Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ bdf3d3bf

History | View | Annotate | Download (163 KB)

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

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

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "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/avfilter.h"
54
# include "libavfilter/avfiltergraph.h"
55
# include "libavfilter/vsrc_buffer.h"
56
#endif
57

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

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

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

    
84
#include "cmdutils.h"
85

    
86
#include "libavutil/avassert.h"
87

    
88
const char program_name[] = "FFmpeg";
89
const int program_birth_year = 2000;
90

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

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

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

    
113
static const OptionDef options[];
114

    
115
#define MAX_FILES 100
116
#if !FF_API_MAX_STREAMS
117
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
118
#endif
119

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

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

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

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

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

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

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

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

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

    
199
static float mux_preload= 0.5;
200
static float mux_max_delay= 0.7;
201

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

    
229
static int rate_emu = 0;
230

    
231
static int  video_channel = 0;
232
static char *video_standard;
233

    
234
static int audio_volume = 256;
235

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

    
251
static float dts_delta_threshold = 10;
252

    
253
static int64_t timer_start;
254

    
255
static uint8_t *audio_buf;
256
static uint8_t *audio_out;
257
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
258

    
259
static short *samples;
260

    
261
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
262
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
263
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
264

    
265
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
266

    
267
struct AVInputStream;
268

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

    
290
    /* full frame size of first frame */
291
    int original_height;
292
    int original_width;
293

    
294
    /* forced key frames */
295
    int64_t *forced_kf_pts;
296
    int forced_kf_count;
297
    int forced_kf_index;
298

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

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

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

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

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

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

    
350
#if HAVE_TERMIOS_H
351

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

    
356
#if CONFIG_AVFILTER
357

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

    
369
    ost->graph = avfilter_graph_alloc();
370

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

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

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

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

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

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

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

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

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

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

    
431
    codec->width  = ost->output_video_filter->inputs[0]->w;
432
    codec->height = ost->output_video_filter->inputs[0]->h;
433
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
434
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
435

    
436
    return 0;
437
}
438
#endif /* CONFIG_AVFILTER */
439

    
440
static void term_exit(void)
441
{
442
    av_log(NULL, AV_LOG_QUIET, "");
443
#if HAVE_TERMIOS_H
444
    tcsetattr (0, TCSANOW, &oldtty);
445
#endif
446
}
447

    
448
static volatile int received_sigterm = 0;
449

    
450
static void
451
sigterm_handler(int sig)
452
{
453
    received_sigterm = sig;
454
    q_pressed++;
455
    term_exit();
456
}
457

    
458
static void term_init(void)
459
{
460
#if HAVE_TERMIOS_H
461
    struct termios tty;
462

    
463
    tcgetattr (0, &tty);
464
    oldtty = tty;
465
    atexit(term_exit);
466

    
467
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
468
                          |INLCR|IGNCR|ICRNL|IXON);
469
    tty.c_oflag |= OPOST;
470
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
471
    tty.c_cflag &= ~(CSIZE|PARENB);
472
    tty.c_cflag |= CS8;
473
    tty.c_cc[VMIN] = 1;
474
    tty.c_cc[VTIME] = 0;
475

    
476
    tcsetattr (0, TCSANOW, &tty);
477
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
478
#endif
479

    
480
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
481
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
482
#ifdef SIGXCPU
483
    signal(SIGXCPU, sigterm_handler);
484
#endif
485
}
486

    
487
/* read a key without blocking */
488
static int read_key(void)
489
{
490
#if HAVE_TERMIOS_H
491
    int n = 1;
492
    unsigned char ch;
493
    struct timeval tv;
494
    fd_set rfds;
495

    
496
    FD_ZERO(&rfds);
497
    FD_SET(0, &rfds);
498
    tv.tv_sec = 0;
499
    tv.tv_usec = 0;
500
    n = select(1, &rfds, NULL, NULL, &tv);
501
    if (n > 0) {
502
        n = read(0, &ch, 1);
503
        if (n == 1)
504
            return ch;
505

    
506
        return n;
507
    }
508
#elif HAVE_KBHIT
509
    if(kbhit())
510
        return(getch());
511
#endif
512
    return -1;
513
}
514

    
515
static int decode_interrupt_cb(void)
516
{
517
    q_pressed += read_key() == 'q';
518
    return q_pressed > 1;
519
}
520

    
521
static int ffmpeg_exit(int ret)
522
{
523
    int i;
524

    
525
    /* close files */
526
    for(i=0;i<nb_output_files;i++) {
527
        AVFormatContext *s = output_files[i];
528
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
529
            avio_close(s->pb);
530
        avformat_free_context(s);
531
        av_free(output_streams_for_file[i]);
532
    }
533
    for(i=0;i<nb_input_files;i++) {
534
        av_close_input_file(input_files[i]);
535
        av_free(input_files_ts_scale[i]);
536
    }
537

    
538
    av_free(intra_matrix);
539
    av_free(inter_matrix);
540

    
541
    if (vstats_file)
542
        fclose(vstats_file);
543
    av_free(vstats_filename);
544

    
545
    av_free(streamid_map);
546
    av_free(input_codecs);
547
    av_free(output_codecs);
548
    av_free(stream_maps);
549
    av_free(meta_data_maps);
550

    
551
    av_free(video_codec_name);
552
    av_free(audio_codec_name);
553
    av_free(subtitle_codec_name);
554

    
555
    av_free(video_standard);
556

    
557
    uninit_opts();
558
    av_free(audio_buf);
559
    av_free(audio_out);
560
    allocated_audio_buf_size= allocated_audio_out_size= 0;
561
    av_free(samples);
562

    
563
#if CONFIG_AVFILTER
564
    avfilter_uninit();
565
#endif
566

    
567
    if (received_sigterm) {
568
        fprintf(stderr,
569
            "Received signal %d: terminating.\n",
570
            (int) received_sigterm);
571
        exit (255);
572
    }
573

    
574
    exit(ret); /* not all OS-es handle main() return value */
575
    return ret;
576
}
577

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

    
598
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
599
{
600
    if(codec && codec->sample_fmts){
601
        const enum AVSampleFormat *p= codec->sample_fmts;
602
        for(; *p!=-1; p++){
603
            if(*p == st->codec->sample_fmt)
604
                break;
605
        }
606
        if (*p == -1) {
607
            av_log(NULL, AV_LOG_WARNING,
608
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
609
                   av_get_sample_fmt_name(st->codec->sample_fmt),
610
                   codec->name,
611
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
612
            st->codec->sample_fmt = codec->sample_fmts[0];
613
        }
614
    }
615
}
616

    
617
static void choose_sample_rate(AVStream *st, AVCodec *codec)
618
{
619
    if(codec && codec->supported_samplerates){
620
        const int *p= codec->supported_samplerates;
621
        int best=0;
622
        int best_dist=INT_MAX;
623
        for(; *p; p++){
624
            int dist= abs(st->codec->sample_rate - *p);
625
            if(dist < best_dist){
626
                best_dist= dist;
627
                best= *p;
628
            }
629
        }
630
        if(best_dist){
631
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
632
        }
633
        st->codec->sample_rate= best;
634
    }
635
}
636

    
637
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
638
{
639
    if(codec && codec->pix_fmts){
640
        const enum PixelFormat *p= codec->pix_fmts;
641
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
642
            if(st->codec->codec_id==CODEC_ID_MJPEG){
643
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
644
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
645
                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};
646
            }
647
        }
648
        for(; *p!=-1; p++){
649
            if(*p == st->codec->pix_fmt)
650
                break;
651
        }
652
        if (*p == -1) {
653
            if(st->codec->pix_fmt != PIX_FMT_NONE)
654
            av_log(NULL, AV_LOG_WARNING,
655
                   "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
656
                   av_pix_fmt_descriptors[st->codec->pix_fmt].name,
657
                   codec->name,
658
                   av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
659
            st->codec->pix_fmt = codec->pix_fmts[0];
660
        }
661
    }
662
}
663

    
664
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
665
{
666
    int idx = oc->nb_streams - 1;
667
    AVOutputStream *ost;
668

    
669
    output_streams_for_file[file_idx] =
670
        grow_array(output_streams_for_file[file_idx],
671
                   sizeof(*output_streams_for_file[file_idx]),
672
                   &nb_output_streams_for_file[file_idx],
673
                   oc->nb_streams);
674
    ost = output_streams_for_file[file_idx][idx] =
675
        av_mallocz(sizeof(AVOutputStream));
676
    if (!ost) {
677
        fprintf(stderr, "Could not alloc output stream\n");
678
        ffmpeg_exit(1);
679
    }
680
    ost->file_index = file_idx;
681
    ost->index = idx;
682
    return ost;
683
}
684

    
685
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
686
{
687
    int i, err;
688
    AVFormatContext *ic;
689
    int nopts = 0;
690

    
691
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
692
    if (err < 0)
693
        return err;
694
    /* copy stream format */
695
    s->nb_streams = 0;
696
    for(i=0;i<ic->nb_streams;i++) {
697
        AVStream *st;
698
        AVCodec *codec;
699

    
700
        s->nb_streams++;
701

    
702
        // FIXME: a more elegant solution is needed
703
        st = av_mallocz(sizeof(AVStream));
704
        memcpy(st, ic->streams[i], sizeof(AVStream));
705
        st->codec = avcodec_alloc_context();
706
        if (!st->codec) {
707
            print_error(filename, AVERROR(ENOMEM));
708
            ffmpeg_exit(1);
709
        }
710
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
711
        s->streams[i] = st;
712

    
713
        codec = avcodec_find_encoder(st->codec->codec_id);
714
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
715
            if (audio_stream_copy) {
716
                st->stream_copy = 1;
717
            } else
718
                choose_sample_fmt(st, codec);
719
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
720
            if (video_stream_copy) {
721
                st->stream_copy = 1;
722
            } else
723
                choose_pixel_fmt(st, codec);
724
        }
725

    
726
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
727
            nopts = 1;
728

    
729
        new_output_stream(s, nb_output_files);
730
    }
731

    
732
    if (!nopts)
733
        s->timestamp = av_gettime();
734

    
735
    av_close_input_file(ic);
736
    return 0;
737
}
738

    
739
static double
740
get_sync_ipts(const AVOutputStream *ost)
741
{
742
    const AVInputStream *ist = ost->sync_ist;
743
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
744
}
745

    
746
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
747
    int ret;
748

    
749
    while(bsfc){
750
        AVPacket new_pkt= *pkt;
751
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
752
                                          &new_pkt.data, &new_pkt.size,
753
                                          pkt->data, pkt->size,
754
                                          pkt->flags & AV_PKT_FLAG_KEY);
755
        if(a>0){
756
            av_free_packet(pkt);
757
            new_pkt.destruct= av_destruct_packet;
758
        } else if(a<0){
759
            fprintf(stderr, "%s failed for stream %d, codec %s",
760
                    bsfc->filter->name, pkt->stream_index,
761
                    avctx->codec ? avctx->codec->name : "copy");
762
            print_error("", a);
763
            if (exit_on_error)
764
                ffmpeg_exit(1);
765
        }
766
        *pkt= new_pkt;
767

    
768
        bsfc= bsfc->next;
769
    }
770

    
771
    ret= av_interleaved_write_frame(s, pkt);
772
    if(ret < 0){
773
        print_error("av_interleaved_write_frame()", ret);
774
        ffmpeg_exit(1);
775
    }
776
}
777

    
778
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
779

    
780
static void do_audio_out(AVFormatContext *s,
781
                         AVOutputStream *ost,
782
                         AVInputStream *ist,
783
                         unsigned char *buf, int size)
784
{
785
    uint8_t *buftmp;
786
    int64_t audio_out_size, audio_buf_size;
787
    int64_t allocated_for_size= size;
788

    
789
    int size_out, frame_bytes, ret, resample_changed;
790
    AVCodecContext *enc= ost->st->codec;
791
    AVCodecContext *dec= ist->st->codec;
792
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
793
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
794
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
795

    
796
need_realloc:
797
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
798
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
799
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
800
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
801
    audio_buf_size*= osize*enc->channels;
802

    
803
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
804
    if(coded_bps > 8*osize)
805
        audio_out_size= audio_out_size * coded_bps / (8*osize);
806
    audio_out_size += FF_MIN_BUFFER_SIZE;
807

    
808
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
809
        fprintf(stderr, "Buffer sizes too large\n");
810
        ffmpeg_exit(1);
811
    }
812

    
813
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
814
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
815
    if (!audio_buf || !audio_out){
816
        fprintf(stderr, "Out of memory in do_audio_out\n");
817
        ffmpeg_exit(1);
818
    }
819

    
820
    if (enc->channels != dec->channels)
821
        ost->audio_resample = 1;
822

    
823
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
824
                       ost->resample_channels    != dec->channels   ||
825
                       ost->resample_sample_rate != dec->sample_rate;
826

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

    
862
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
863
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
864
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
865
        if (ost->reformat_ctx)
866
            av_audio_convert_free(ost->reformat_ctx);
867
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
868
                                                   dec->sample_fmt, 1, NULL, 0);
869
        if (!ost->reformat_ctx) {
870
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
871
                av_get_sample_fmt_name(dec->sample_fmt),
872
                av_get_sample_fmt_name(enc->sample_fmt));
873
            ffmpeg_exit(1);
874
        }
875
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
876
    }
877

    
878
    if(audio_sync_method){
879
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
880
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
881
        double idelta= delta*dec->sample_rate / enc->sample_rate;
882
        int byte_delta= ((int)idelta)*2*dec->channels;
883

    
884
        //FIXME resample delay
885
        if(fabs(delta) > 50){
886
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
887
                if(byte_delta < 0){
888
                    byte_delta= FFMAX(byte_delta, -size);
889
                    size += byte_delta;
890
                    buf  -= byte_delta;
891
                    if(verbose > 2)
892
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
893
                    if(!size)
894
                        return;
895
                    ist->is_start=0;
896
                }else{
897
                    static uint8_t *input_tmp= NULL;
898
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
899

    
900
                    if(byte_delta > allocated_for_size - size){
901
                        allocated_for_size= byte_delta + (int64_t)size;
902
                        goto need_realloc;
903
                    }
904
                    ist->is_start=0;
905

    
906
                    memset(input_tmp, 0, byte_delta);
907
                    memcpy(input_tmp + byte_delta, buf, size);
908
                    buf= input_tmp;
909
                    size += byte_delta;
910
                    if(verbose > 2)
911
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
912
                }
913
            }else if(audio_sync_method>1){
914
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
915
                av_assert0(ost->audio_resample);
916
                if(verbose > 2)
917
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
918
//                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));
919
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
920
            }
921
        }
922
    }else
923
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
924
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
925

    
926
    if (ost->audio_resample) {
927
        buftmp = audio_buf;
928
        size_out = audio_resample(ost->resample,
929
                                  (short *)buftmp, (short *)buf,
930
                                  size / (dec->channels * isize));
931
        size_out = size_out * enc->channels * osize;
932
    } else {
933
        buftmp = buf;
934
        size_out = size;
935
    }
936

    
937
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
938
        const void *ibuf[6]= {buftmp};
939
        void *obuf[6]= {audio_buf};
940
        int istride[6]= {isize};
941
        int ostride[6]= {osize};
942
        int len= size_out/istride[0];
943
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
944
            printf("av_audio_convert() failed\n");
945
            if (exit_on_error)
946
                ffmpeg_exit(1);
947
            return;
948
        }
949
        buftmp = audio_buf;
950
        size_out = len*osize;
951
    }
952

    
953
    /* now encode as many frames as possible */
954
    if (enc->frame_size > 1) {
955
        /* output resampled raw samples */
956
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
957
            fprintf(stderr, "av_fifo_realloc2() failed\n");
958
            ffmpeg_exit(1);
959
        }
960
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
961

    
962
        frame_bytes = enc->frame_size * osize * enc->channels;
963

    
964
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
965
            AVPacket pkt;
966
            av_init_packet(&pkt);
967

    
968
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
969

    
970
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
971

    
972
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
973
                                       (short *)audio_buf);
974
            if (ret < 0) {
975
                fprintf(stderr, "Audio encoding failed\n");
976
                ffmpeg_exit(1);
977
            }
978
            audio_size += ret;
979
            pkt.stream_index= ost->index;
980
            pkt.data= audio_out;
981
            pkt.size= ret;
982
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
983
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
984
            pkt.flags |= AV_PKT_FLAG_KEY;
985
            write_frame(s, &pkt, enc, ost->bitstream_filters);
986

    
987
            ost->sync_opts += enc->frame_size;
988
        }
989
    } else {
990
        AVPacket pkt;
991
        av_init_packet(&pkt);
992

    
993
        ost->sync_opts += size_out / (osize * enc->channels);
994

    
995
        /* output a pcm frame */
996
        /* determine the size of the coded buffer */
997
        size_out /= osize;
998
        if (coded_bps)
999
            size_out = size_out*coded_bps/8;
1000

    
1001
        if(size_out > audio_out_size){
1002
            fprintf(stderr, "Internal error, buffer size too small\n");
1003
            ffmpeg_exit(1);
1004
        }
1005

    
1006
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1007
        ret = avcodec_encode_audio(enc, audio_out, size_out,
1008
                                   (short *)buftmp);
1009
        if (ret < 0) {
1010
            fprintf(stderr, "Audio encoding failed\n");
1011
            ffmpeg_exit(1);
1012
        }
1013
        audio_size += ret;
1014
        pkt.stream_index= ost->index;
1015
        pkt.data= audio_out;
1016
        pkt.size= ret;
1017
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1018
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1019
        pkt.flags |= AV_PKT_FLAG_KEY;
1020
        write_frame(s, &pkt, enc, ost->bitstream_filters);
1021
    }
1022
}
1023

    
1024
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1025
{
1026
    AVCodecContext *dec;
1027
    AVPicture *picture2;
1028
    AVPicture picture_tmp;
1029
    uint8_t *buf = 0;
1030

    
1031
    dec = ist->st->codec;
1032

    
1033
    /* deinterlace : must be done before any resize */
1034
    if (do_deinterlace) {
1035
        int size;
1036

    
1037
        /* create temporary picture */
1038
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1039
        buf = av_malloc(size);
1040
        if (!buf)
1041
            return;
1042

    
1043
        picture2 = &picture_tmp;
1044
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1045

    
1046
        if(avpicture_deinterlace(picture2, picture,
1047
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1048
            /* if error, do not deinterlace */
1049
            fprintf(stderr, "Deinterlacing failed\n");
1050
            av_free(buf);
1051
            buf = NULL;
1052
            picture2 = picture;
1053
        }
1054
    } else {
1055
        picture2 = picture;
1056
    }
1057

    
1058
    if (picture != picture2)
1059
        *picture = *picture2;
1060
    *bufp = buf;
1061
}
1062

    
1063
/* we begin to correct av delay at this threshold */
1064
#define AV_DELAY_MAX 0.100
1065

    
1066
static void do_subtitle_out(AVFormatContext *s,
1067
                            AVOutputStream *ost,
1068
                            AVInputStream *ist,
1069
                            AVSubtitle *sub,
1070
                            int64_t pts)
1071
{
1072
    static uint8_t *subtitle_out = NULL;
1073
    int subtitle_out_max_size = 1024 * 1024;
1074
    int subtitle_out_size, nb, i;
1075
    AVCodecContext *enc;
1076
    AVPacket pkt;
1077

    
1078
    if (pts == AV_NOPTS_VALUE) {
1079
        fprintf(stderr, "Subtitle packets must have a pts\n");
1080
        if (exit_on_error)
1081
            ffmpeg_exit(1);
1082
        return;
1083
    }
1084

    
1085
    enc = ost->st->codec;
1086

    
1087
    if (!subtitle_out) {
1088
        subtitle_out = av_malloc(subtitle_out_max_size);
1089
    }
1090

    
1091
    /* Note: DVB subtitle need one packet to draw them and one other
1092
       packet to clear them */
1093
    /* XXX: signal it in the codec context ? */
1094
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1095
        nb = 2;
1096
    else
1097
        nb = 1;
1098

    
1099
    for(i = 0; i < nb; i++) {
1100
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1101
        // start_display_time is required to be 0
1102
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1103
        sub->end_display_time -= sub->start_display_time;
1104
        sub->start_display_time = 0;
1105
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1106
                                                    subtitle_out_max_size, sub);
1107
        if (subtitle_out_size < 0) {
1108
            fprintf(stderr, "Subtitle encoding failed\n");
1109
            ffmpeg_exit(1);
1110
        }
1111

    
1112
        av_init_packet(&pkt);
1113
        pkt.stream_index = ost->index;
1114
        pkt.data = subtitle_out;
1115
        pkt.size = subtitle_out_size;
1116
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1117
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1118
            /* XXX: the pts correction is handled here. Maybe handling
1119
               it in the codec would be better */
1120
            if (i == 0)
1121
                pkt.pts += 90 * sub->start_display_time;
1122
            else
1123
                pkt.pts += 90 * sub->end_display_time;
1124
        }
1125
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1126
    }
1127
}
1128

    
1129
static int bit_buffer_size= 1024*256;
1130
static uint8_t *bit_buffer= NULL;
1131

    
1132
static void do_video_out(AVFormatContext *s,
1133
                         AVOutputStream *ost,
1134
                         AVInputStream *ist,
1135
                         AVFrame *in_picture,
1136
                         int *frame_size)
1137
{
1138
    int nb_frames, i, ret;
1139
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1140
    AVCodecContext *enc, *dec;
1141
    double sync_ipts;
1142

    
1143
    enc = ost->st->codec;
1144
    dec = ist->st->codec;
1145

    
1146
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1147

    
1148
    /* by default, we output a single frame */
1149
    nb_frames = 1;
1150

    
1151
    *frame_size = 0;
1152

    
1153
    if(video_sync_method){
1154
        double vdelta = sync_ipts - ost->sync_opts;
1155
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1156
        if (vdelta < -1.1)
1157
            nb_frames = 0;
1158
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1159
            if(vdelta<=-0.6){
1160
                nb_frames=0;
1161
            }else if(vdelta>0.6)
1162
                ost->sync_opts= lrintf(sync_ipts);
1163
        }else if (vdelta > 1.1)
1164
            nb_frames = lrintf(vdelta);
1165
//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);
1166
        if (nb_frames == 0){
1167
            ++nb_frames_drop;
1168
            if (verbose>2)
1169
                fprintf(stderr, "*** drop!\n");
1170
        }else if (nb_frames > 1) {
1171
            nb_frames_dup += nb_frames - 1;
1172
            if (verbose>2)
1173
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1174
        }
1175
    }else
1176
        ost->sync_opts= lrintf(sync_ipts);
1177

    
1178
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1179
    if (nb_frames <= 0)
1180
        return;
1181

    
1182
    formatted_picture = in_picture;
1183
    final_picture = formatted_picture;
1184
    padding_src = formatted_picture;
1185
    resampling_dst = &ost->pict_tmp;
1186

    
1187
    if (   ost->resample_height != ist->st->codec->height
1188
        || ost->resample_width  != ist->st->codec->width
1189
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1190

    
1191
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1192
        if(!ost->video_resample)
1193
            ffmpeg_exit(1);
1194
    }
1195

    
1196
#if !CONFIG_AVFILTER
1197
    if (ost->video_resample) {
1198
        padding_src = NULL;
1199
        final_picture = &ost->pict_tmp;
1200
        if(  ost->resample_height != ist->st->codec->height
1201
          || ost->resample_width  != ist->st->codec->width
1202
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1203

    
1204
            /* initialize a new scaler context */
1205
            sws_freeContext(ost->img_resample_ctx);
1206
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1207
            ost->img_resample_ctx = sws_getContext(
1208
                ist->st->codec->width,
1209
                ist->st->codec->height,
1210
                ist->st->codec->pix_fmt,
1211
                ost->st->codec->width,
1212
                ost->st->codec->height,
1213
                ost->st->codec->pix_fmt,
1214
                sws_flags, NULL, NULL, NULL);
1215
            if (ost->img_resample_ctx == NULL) {
1216
                fprintf(stderr, "Cannot get resampling context\n");
1217
                ffmpeg_exit(1);
1218
            }
1219
        }
1220
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1221
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1222
    }
1223
#endif
1224

    
1225
    /* duplicates frame if needed */
1226
    for(i=0;i<nb_frames;i++) {
1227
        AVPacket pkt;
1228
        av_init_packet(&pkt);
1229
        pkt.stream_index= ost->index;
1230

    
1231
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1232
            /* raw pictures are written as AVPicture structure to
1233
               avoid any copies. We support temorarily the older
1234
               method. */
1235
            AVFrame* old_frame = enc->coded_frame;
1236
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1237
            pkt.data= (uint8_t *)final_picture;
1238
            pkt.size=  sizeof(AVPicture);
1239
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1240
            pkt.flags |= AV_PKT_FLAG_KEY;
1241

    
1242
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1243
            enc->coded_frame = old_frame;
1244
        } else {
1245
            AVFrame big_picture;
1246

    
1247
            big_picture= *final_picture;
1248
            /* better than nothing: use input picture interlaced
1249
               settings */
1250
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1251
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1252
                if(top_field_first == -1)
1253
                    big_picture.top_field_first = in_picture->top_field_first;
1254
                else
1255
                    big_picture.top_field_first = top_field_first;
1256
            }
1257

    
1258
            /* handles sameq here. This is not correct because it may
1259
               not be a global option */
1260
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1261
            if(!me_threshold)
1262
                big_picture.pict_type = 0;
1263
//            big_picture.pts = AV_NOPTS_VALUE;
1264
            big_picture.pts= ost->sync_opts;
1265
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1266
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1267
            if (ost->forced_kf_index < ost->forced_kf_count &&
1268
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1269
                big_picture.pict_type = FF_I_TYPE;
1270
                ost->forced_kf_index++;
1271
            }
1272
            ret = avcodec_encode_video(enc,
1273
                                       bit_buffer, bit_buffer_size,
1274
                                       &big_picture);
1275
            if (ret < 0) {
1276
                fprintf(stderr, "Video encoding failed\n");
1277
                ffmpeg_exit(1);
1278
            }
1279

    
1280
            if(ret>0){
1281
                pkt.data= bit_buffer;
1282
                pkt.size= ret;
1283
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1284
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1285
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1286
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1287
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1288

    
1289
                if(enc->coded_frame->key_frame)
1290
                    pkt.flags |= AV_PKT_FLAG_KEY;
1291
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1292
                *frame_size = ret;
1293
                video_size += ret;
1294
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1295
                //        enc->frame_number-1, ret, enc->pict_type);
1296
                /* if two pass, output log */
1297
                if (ost->logfile && enc->stats_out) {
1298
                    fprintf(ost->logfile, "%s", enc->stats_out);
1299
                }
1300
            }
1301
        }
1302
        ost->sync_opts++;
1303
        ost->frame_number++;
1304
    }
1305
}
1306

    
1307
static double psnr(double d){
1308
    return -10.0*log(d)/log(10.0);
1309
}
1310

    
1311
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1312
                           int frame_size)
1313
{
1314
    AVCodecContext *enc;
1315
    int frame_number;
1316
    double ti1, bitrate, avg_bitrate;
1317

    
1318
    /* this is executed just the first time do_video_stats is called */
1319
    if (!vstats_file) {
1320
        vstats_file = fopen(vstats_filename, "w");
1321
        if (!vstats_file) {
1322
            perror("fopen");
1323
            ffmpeg_exit(1);
1324
        }
1325
    }
1326

    
1327
    enc = ost->st->codec;
1328
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1329
        frame_number = ost->frame_number;
1330
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1331
        if (enc->flags&CODEC_FLAG_PSNR)
1332
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1333

    
1334
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1335
        /* compute pts value */
1336
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1337
        if (ti1 < 0.01)
1338
            ti1 = 0.01;
1339

    
1340
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1341
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1342
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1343
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1344
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1345
    }
1346
}
1347

    
1348
static void print_report(AVFormatContext **output_files,
1349
                         AVOutputStream **ost_table, int nb_ostreams,
1350
                         int is_last_report)
1351
{
1352
    char buf[1024];
1353
    AVOutputStream *ost;
1354
    AVFormatContext *oc;
1355
    int64_t total_size;
1356
    AVCodecContext *enc;
1357
    int frame_number, vid, i;
1358
    double bitrate, ti1, pts;
1359
    static int64_t last_time = -1;
1360
    static int qp_histogram[52];
1361

    
1362
    if (!is_last_report) {
1363
        int64_t cur_time;
1364
        /* display the report every 0.5 seconds */
1365
        cur_time = av_gettime();
1366
        if (last_time == -1) {
1367
            last_time = cur_time;
1368
            return;
1369
        }
1370
        if ((cur_time - last_time) < 500000)
1371
            return;
1372
        last_time = cur_time;
1373
    }
1374

    
1375

    
1376
    oc = output_files[0];
1377

    
1378
    total_size = avio_size(oc->pb);
1379
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1380
        total_size= avio_tell(oc->pb);
1381

    
1382
    buf[0] = '\0';
1383
    ti1 = 1e10;
1384
    vid = 0;
1385
    for(i=0;i<nb_ostreams;i++) {
1386
        float q= -1;
1387
        ost = ost_table[i];
1388
        enc = ost->st->codec;
1389
        if(!ost->st->stream_copy && enc->coded_frame)
1390
            q= enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1391
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1392
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1393
        }
1394
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1395
            float t = (av_gettime()-timer_start) / 1000000.0;
1396

    
1397
            frame_number = ost->frame_number;
1398
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1399
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1400
            if(is_last_report)
1401
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1402
            if(qp_hist){
1403
                int j;
1404
                int qp= lrintf(q);
1405
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1406
                    qp_histogram[qp]++;
1407
                for(j=0; j<32; j++)
1408
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1409
            }
1410
            if (enc->flags&CODEC_FLAG_PSNR){
1411
                int j;
1412
                double error, error_sum=0;
1413
                double scale, scale_sum=0;
1414
                char type[3]= {'Y','U','V'};
1415
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1416
                for(j=0; j<3; j++){
1417
                    if(is_last_report){
1418
                        error= enc->error[j];
1419
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1420
                    }else{
1421
                        error= enc->coded_frame->error[j];
1422
                        scale= enc->width*enc->height*255.0*255.0;
1423
                    }
1424
                    if(j) scale/=4;
1425
                    error_sum += error;
1426
                    scale_sum += scale;
1427
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1428
                }
1429
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1430
            }
1431
            vid = 1;
1432
        }
1433
        /* compute min output value */
1434
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1435
        if ((pts < ti1) && (pts > 0))
1436
            ti1 = pts;
1437
    }
1438
    if (ti1 < 0.01)
1439
        ti1 = 0.01;
1440

    
1441
    if (verbose || is_last_report) {
1442
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1443

    
1444
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1445
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1446
            (double)total_size / 1024, ti1, bitrate);
1447

    
1448
        if (nb_frames_dup || nb_frames_drop)
1449
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1450
                  nb_frames_dup, nb_frames_drop);
1451

    
1452
        if (verbose >= 0)
1453
            fprintf(stderr, "%s    \r", buf);
1454

    
1455
        fflush(stderr);
1456
    }
1457

    
1458
    if (is_last_report && verbose >= 0){
1459
        int64_t raw= audio_size + video_size + extra_size;
1460
        fprintf(stderr, "\n");
1461
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1462
                video_size/1024.0,
1463
                audio_size/1024.0,
1464
                extra_size/1024.0,
1465
                100.0*(total_size - raw)/raw
1466
        );
1467
    }
1468
}
1469

    
1470
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1471
{
1472
    int fill_char = 0x00;
1473
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1474
        fill_char = 0x80;
1475
    memset(buf, fill_char, size);
1476
}
1477

    
1478
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1479
static int output_packet(AVInputStream *ist, int ist_index,
1480
                         AVOutputStream **ost_table, int nb_ostreams,
1481
                         const AVPacket *pkt)
1482
{
1483
    AVFormatContext *os;
1484
    AVOutputStream *ost;
1485
    int ret, i;
1486
    int got_picture;
1487
    AVFrame picture;
1488
    void *buffer_to_free;
1489
    static unsigned int samples_size= 0;
1490
    AVSubtitle subtitle, *subtitle_to_free;
1491
    int64_t pkt_pts = AV_NOPTS_VALUE;
1492
#if CONFIG_AVFILTER
1493
    int frame_available;
1494
#endif
1495

    
1496
    AVPacket avpkt;
1497
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1498

    
1499
    if(ist->next_pts == AV_NOPTS_VALUE)
1500
        ist->next_pts= ist->pts;
1501

    
1502
    if (pkt == NULL) {
1503
        /* EOF handling */
1504
        av_init_packet(&avpkt);
1505
        avpkt.data = NULL;
1506
        avpkt.size = 0;
1507
        goto handle_eof;
1508
    } else {
1509
        avpkt = *pkt;
1510
    }
1511

    
1512
    if(pkt->dts != AV_NOPTS_VALUE)
1513
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1514
    if(pkt->pts != AV_NOPTS_VALUE)
1515
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1516

    
1517
    //while we have more to decode or while the decoder did output something on EOF
1518
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1519
        uint8_t *data_buf, *decoded_data_buf;
1520
        int data_size, decoded_data_size;
1521
    handle_eof:
1522
        ist->pts= ist->next_pts;
1523

    
1524
        if(avpkt.size && avpkt.size != pkt->size &&
1525
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1526
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1527
            ist->showed_multi_packet_warning=1;
1528
        }
1529

    
1530
        /* decode the packet if needed */
1531
        decoded_data_buf = NULL; /* fail safe */
1532
        decoded_data_size= 0;
1533
        data_buf  = avpkt.data;
1534
        data_size = avpkt.size;
1535
        subtitle_to_free = NULL;
1536
        if (ist->decoding_needed) {
1537
            switch(ist->st->codec->codec_type) {
1538
            case AVMEDIA_TYPE_AUDIO:{
1539
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1540
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1541
                    av_free(samples);
1542
                    samples= av_malloc(samples_size);
1543
                }
1544
                decoded_data_size= samples_size;
1545
                    /* XXX: could avoid copy if PCM 16 bits with same
1546
                       endianness as CPU */
1547
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1548
                                            &avpkt);
1549
                if (ret < 0)
1550
                    goto fail_decode;
1551
                avpkt.data += ret;
1552
                avpkt.size -= ret;
1553
                data_size   = ret;
1554
                /* Some bug in mpeg audio decoder gives */
1555
                /* decoded_data_size < 0, it seems they are overflows */
1556
                if (decoded_data_size <= 0) {
1557
                    /* no audio frame */
1558
                    continue;
1559
                }
1560
                decoded_data_buf = (uint8_t *)samples;
1561
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1562
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1563
                break;}
1564
            case AVMEDIA_TYPE_VIDEO:
1565
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1566
                    /* XXX: allocate picture correctly */
1567
                    avcodec_get_frame_defaults(&picture);
1568
                    avpkt.pts = pkt_pts;
1569
                    avpkt.dts = ist->pts;
1570
                    pkt_pts = AV_NOPTS_VALUE;
1571

    
1572
                    ret = avcodec_decode_video2(ist->st->codec,
1573
                                                &picture, &got_picture, &avpkt);
1574
                    ist->st->quality= picture.quality;
1575
                    if (ret < 0)
1576
                        goto fail_decode;
1577
                    if (!got_picture) {
1578
                        /* no picture yet */
1579
                        goto discard_packet;
1580
                    }
1581
                    ist->next_pts = ist->pts = picture.best_effort_timestamp;
1582
                    if (ist->st->codec->time_base.num != 0) {
1583
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1584
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1585
                                          ist->st->codec->time_base.num * ticks) /
1586
                            ist->st->codec->time_base.den;
1587
                    }
1588
                    avpkt.size = 0;
1589
                    break;
1590
            case AVMEDIA_TYPE_SUBTITLE:
1591
                ret = avcodec_decode_subtitle2(ist->st->codec,
1592
                                               &subtitle, &got_picture, &avpkt);
1593
                if (ret < 0)
1594
                    goto fail_decode;
1595
                if (!got_picture) {
1596
                    goto discard_packet;
1597
                }
1598
                subtitle_to_free = &subtitle;
1599
                avpkt.size = 0;
1600
                break;
1601
            default:
1602
                goto fail_decode;
1603
            }
1604
        } else {
1605
            switch(ist->st->codec->codec_type) {
1606
            case AVMEDIA_TYPE_AUDIO:
1607
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1608
                    ist->st->codec->sample_rate;
1609
                break;
1610
            case AVMEDIA_TYPE_VIDEO:
1611
                if (ist->st->codec->time_base.num != 0) {
1612
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1613
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1614
                                      ist->st->codec->time_base.num * ticks) /
1615
                        ist->st->codec->time_base.den;
1616
                }
1617
                break;
1618
            }
1619
            ret = avpkt.size;
1620
            avpkt.size = 0;
1621
        }
1622

    
1623
        buffer_to_free = NULL;
1624
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1625
            pre_process_video_frame(ist, (AVPicture *)&picture,
1626
                                    &buffer_to_free);
1627
        }
1628

    
1629
#if CONFIG_AVFILTER
1630
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1631
            for(i=0;i<nb_ostreams;i++) {
1632
                ost = ost_table[i];
1633
                if (ost->input_video_filter && ost->source_index == ist_index) {
1634
                    AVRational sar;
1635
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1636
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1637
                    // add it to be filtered
1638
                    av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1639
                                             ist->pts,
1640
                                             sar, ist->st->codec->width, ist->st->codec->height,
1641
                                             ist->st->codec->pix_fmt, "0:0"); //TODO user setable params
1642
                }
1643
            }
1644
        }
1645
#endif
1646

    
1647
        // preprocess audio (volume)
1648
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1649
            if (audio_volume != 256) {
1650
                short *volp;
1651
                volp = samples;
1652
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1653
                    int v = ((*volp) * audio_volume + 128) >> 8;
1654
                    if (v < -32768) v = -32768;
1655
                    if (v >  32767) v = 32767;
1656
                    *volp++ = v;
1657
                }
1658
            }
1659
        }
1660

    
1661
        /* frame rate emulation */
1662
        if (rate_emu) {
1663
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1664
            int64_t now = av_gettime() - ist->start;
1665
            if (pts > now)
1666
                usleep(pts - now);
1667
        }
1668
        /* if output time reached then transcode raw format,
1669
           encode packets and output them */
1670
        if (start_time == 0 || ist->pts >= start_time)
1671
            for(i=0;i<nb_ostreams;i++) {
1672
                int frame_size;
1673

    
1674
                ost = ost_table[i];
1675
                if (ost->source_index == ist_index) {
1676
#if CONFIG_AVFILTER
1677
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1678
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1679
                while (frame_available) {
1680
                    AVRational ist_pts_tb;
1681
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1682
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1683
                    if (ost->picref)
1684
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1685
#endif
1686
                    os = output_files[ost->file_index];
1687

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

    
1691
                    if (ost->encoding_needed) {
1692
                        av_assert0(ist->decoding_needed);
1693
                        switch(ost->st->codec->codec_type) {
1694
                        case AVMEDIA_TYPE_AUDIO:
1695
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1696
                            break;
1697
                        case AVMEDIA_TYPE_VIDEO:
1698
#if CONFIG_AVFILTER
1699
                            if (ost->picref->video)
1700
                                ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1701
#endif
1702
                            do_video_out(os, ost, ist, &picture, &frame_size);
1703
                            if (vstats_filename && frame_size)
1704
                                do_video_stats(os, ost, frame_size);
1705
                            break;
1706
                        case AVMEDIA_TYPE_SUBTITLE:
1707
                            do_subtitle_out(os, ost, ist, &subtitle,
1708
                                            pkt->pts);
1709
                            break;
1710
                        default:
1711
                            abort();
1712
                        }
1713
                    } else {
1714
                        AVFrame avframe; //FIXME/XXX remove this
1715
                        AVPacket opkt;
1716
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1717

    
1718
                        av_init_packet(&opkt);
1719

    
1720
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1721
#if !CONFIG_AVFILTER
1722
                            continue;
1723
#else
1724
                            goto cont;
1725
#endif
1726

    
1727
                        /* no reencoding needed : output the packet directly */
1728
                        /* force the input stream PTS */
1729

    
1730
                        avcodec_get_frame_defaults(&avframe);
1731
                        ost->st->codec->coded_frame= &avframe;
1732
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1733

    
1734
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1735
                            audio_size += data_size;
1736
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1737
                            video_size += data_size;
1738
                            ost->sync_opts++;
1739
                        }
1740

    
1741
                        opkt.stream_index= ost->index;
1742
                        if(pkt->pts != AV_NOPTS_VALUE)
1743
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1744
                        else
1745
                            opkt.pts= AV_NOPTS_VALUE;
1746

    
1747
                        if (pkt->dts == AV_NOPTS_VALUE)
1748
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1749
                        else
1750
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1751
                        opkt.dts -= ost_tb_start_time;
1752

    
1753
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1754
                        opkt.flags= pkt->flags;
1755

    
1756
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1757
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1758
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1759
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1760
                           ) {
1761
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1762
                                opkt.destruct= av_destruct_packet;
1763
                        } else {
1764
                            opkt.data = data_buf;
1765
                            opkt.size = data_size;
1766
                        }
1767

    
1768
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1769
                        ost->st->codec->frame_number++;
1770
                        ost->frame_number++;
1771
                        av_free_packet(&opkt);
1772
                    }
1773
#if CONFIG_AVFILTER
1774
                    cont:
1775
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1776
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1777
                    if(ost->picref)
1778
                        avfilter_unref_buffer(ost->picref);
1779
                }
1780
#endif
1781
                }
1782
            }
1783

    
1784
        av_free(buffer_to_free);
1785
        /* XXX: allocate the subtitles in the codec ? */
1786
        if (subtitle_to_free) {
1787
            avsubtitle_free(subtitle_to_free);
1788
            subtitle_to_free = NULL;
1789
        }
1790
    }
1791
 discard_packet:
1792
    if (pkt == NULL) {
1793
        /* EOF handling */
1794

    
1795
        for(i=0;i<nb_ostreams;i++) {
1796
            ost = ost_table[i];
1797
            if (ost->source_index == ist_index) {
1798
                AVCodecContext *enc= ost->st->codec;
1799
                os = output_files[ost->file_index];
1800

    
1801
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1802
                    continue;
1803
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1804
                    continue;
1805

    
1806
                if (ost->encoding_needed) {
1807
                    for(;;) {
1808
                        AVPacket pkt;
1809
                        int fifo_bytes;
1810
                        av_init_packet(&pkt);
1811
                        pkt.stream_index= ost->index;
1812

    
1813
                        switch(ost->st->codec->codec_type) {
1814
                        case AVMEDIA_TYPE_AUDIO:
1815
                            fifo_bytes = av_fifo_size(ost->fifo);
1816
                            ret = 0;
1817
                            /* encode any samples remaining in fifo */
1818
                            if (fifo_bytes > 0) {
1819
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1820
                                int fs_tmp = enc->frame_size;
1821

    
1822
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1823
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1824
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1825
                                } else { /* pad */
1826
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1827
                                    if (allocated_audio_buf_size < frame_bytes)
1828
                                        ffmpeg_exit(1);
1829
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1830
                                }
1831

    
1832
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1833
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1834
                                                          ost->st->time_base.num, enc->sample_rate);
1835
                                enc->frame_size = fs_tmp;
1836
                            }
1837
                            if(ret <= 0) {
1838
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1839
                            }
1840
                            if (ret < 0) {
1841
                                fprintf(stderr, "Audio encoding failed\n");
1842
                                ffmpeg_exit(1);
1843
                            }
1844
                            audio_size += ret;
1845
                            pkt.flags |= AV_PKT_FLAG_KEY;
1846
                            break;
1847
                        case AVMEDIA_TYPE_VIDEO:
1848
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1849
                            if (ret < 0) {
1850
                                fprintf(stderr, "Video encoding failed\n");
1851
                                ffmpeg_exit(1);
1852
                            }
1853
                            video_size += ret;
1854
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1855
                                pkt.flags |= AV_PKT_FLAG_KEY;
1856
                            if (ost->logfile && enc->stats_out) {
1857
                                fprintf(ost->logfile, "%s", enc->stats_out);
1858
                            }
1859
                            break;
1860
                        default:
1861
                            ret=-1;
1862
                        }
1863

    
1864
                        if(ret<=0)
1865
                            break;
1866
                        pkt.data= bit_buffer;
1867
                        pkt.size= ret;
1868
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1869
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1870
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1871
                    }
1872
                }
1873
            }
1874
        }
1875
    }
1876

    
1877
    return 0;
1878
 fail_decode:
1879
    return -1;
1880
}
1881

    
1882
static void print_sdp(AVFormatContext **avc, int n)
1883
{
1884
    char sdp[2048];
1885

    
1886
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1887
    printf("SDP:\n%s\n", sdp);
1888
    fflush(stdout);
1889
}
1890

    
1891
static int copy_chapters(int infile, int outfile)
1892
{
1893
    AVFormatContext *is = input_files[infile];
1894
    AVFormatContext *os = output_files[outfile];
1895
    int i;
1896

    
1897
    for (i = 0; i < is->nb_chapters; i++) {
1898
        AVChapter *in_ch = is->chapters[i], *out_ch;
1899
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1900
                                      AV_TIME_BASE_Q, in_ch->time_base);
1901
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1902
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1903

    
1904

    
1905
        if (in_ch->end < ts_off)
1906
            continue;
1907
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1908
            break;
1909

    
1910
        out_ch = av_mallocz(sizeof(AVChapter));
1911
        if (!out_ch)
1912
            return AVERROR(ENOMEM);
1913

    
1914
        out_ch->id        = in_ch->id;
1915
        out_ch->time_base = in_ch->time_base;
1916
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1917
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1918

    
1919
        if (metadata_chapters_autocopy)
1920
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1921

    
1922
        os->nb_chapters++;
1923
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1924
        if (!os->chapters)
1925
            return AVERROR(ENOMEM);
1926
        os->chapters[os->nb_chapters - 1] = out_ch;
1927
    }
1928
    return 0;
1929
}
1930

    
1931
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1932
                                    AVCodecContext *avctx)
1933
{
1934
    char *p;
1935
    int n = 1, i;
1936
    int64_t t;
1937

    
1938
    for (p = kf; *p; p++)
1939
        if (*p == ',')
1940
            n++;
1941
    ost->forced_kf_count = n;
1942
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1943
    if (!ost->forced_kf_pts) {
1944
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1945
        ffmpeg_exit(1);
1946
    }
1947
    for (i = 0; i < n; i++) {
1948
        p = i ? strchr(p, ',') + 1 : kf;
1949
        t = parse_time_or_die("force_key_frames", p, 1);
1950
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1951
    }
1952
}
1953

    
1954
/*
1955
 * The following code is the main loop of the file converter
1956
 */
1957
static int transcode(AVFormatContext **output_files,
1958
                     int nb_output_files,
1959
                     AVFormatContext **input_files,
1960
                     int nb_input_files,
1961
                     AVStreamMap *stream_maps, int nb_stream_maps)
1962
{
1963
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1964
    AVFormatContext *is, *os;
1965
    AVCodecContext *codec, *icodec;
1966
    AVOutputStream *ost, **ost_table = NULL;
1967
    AVInputStream *ist, **ist_table = NULL;
1968
    AVInputFile *file_table;
1969
    char error[1024];
1970
    int key;
1971
    int want_sdp = 1;
1972
    uint8_t no_packet[MAX_FILES]={0};
1973
    int no_packet_count=0;
1974
    int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1975
    int nb_streams[AVMEDIA_TYPE_NB]={0};
1976

    
1977
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1978
    if (!file_table)
1979
        goto fail;
1980

    
1981
    /* input stream init */
1982
    j = 0;
1983
    for(i=0;i<nb_input_files;i++) {
1984
        is = input_files[i];
1985
        file_table[i].ist_index = j;
1986
        file_table[i].nb_streams = is->nb_streams;
1987
        j += is->nb_streams;
1988
    }
1989
    nb_istreams = j;
1990

    
1991
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1992
    if (!ist_table)
1993
        goto fail;
1994

    
1995
    for(i=0;i<nb_istreams;i++) {
1996
        ist = av_mallocz(sizeof(AVInputStream));
1997
        if (!ist)
1998
            goto fail;
1999
        ist_table[i] = ist;
2000
    }
2001
    j = 0;
2002
    for(i=0;i<nb_input_files;i++) {
2003
        is = input_files[i];
2004
        for(k=0;k<is->nb_streams;k++) {
2005
            ist = ist_table[j++];
2006
            ist->st = is->streams[k];
2007
            ist->file_index = i;
2008
            ist->index = k;
2009
            ist->discard = 1; /* the stream is discarded by default
2010
                                 (changed later) */
2011

    
2012
            if (rate_emu) {
2013
                ist->start = av_gettime();
2014
            }
2015
        }
2016
    }
2017

    
2018
    /* output stream init */
2019
    nb_ostreams = 0;
2020
    for(i=0;i<nb_output_files;i++) {
2021
        os = output_files[i];
2022
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2023
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2024
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2025
            ret = AVERROR(EINVAL);
2026
            goto fail;
2027
        }
2028
        nb_ostreams += os->nb_streams;
2029
    }
2030
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2031
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2032
        ret = AVERROR(EINVAL);
2033
        goto fail;
2034
    }
2035

    
2036
    /* Sanity check the mapping args -- do the input files & streams exist? */
2037
    for(i=0;i<nb_stream_maps;i++) {
2038
        int fi = stream_maps[i].file_index;
2039
        int si = stream_maps[i].stream_index;
2040

    
2041
        if (fi < 0 || fi > nb_input_files - 1 ||
2042
            si < 0 || si > file_table[fi].nb_streams - 1) {
2043
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2044
            ret = AVERROR(EINVAL);
2045
            goto fail;
2046
        }
2047
        fi = stream_maps[i].sync_file_index;
2048
        si = stream_maps[i].sync_stream_index;
2049
        if (fi < 0 || fi > nb_input_files - 1 ||
2050
            si < 0 || si > file_table[fi].nb_streams - 1) {
2051
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2052
            ret = AVERROR(EINVAL);
2053
            goto fail;
2054
        }
2055
    }
2056

    
2057
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2058
    if (!ost_table)
2059
        goto fail;
2060

    
2061
    for(k=0;k<nb_output_files;k++) {
2062
        os = output_files[k];
2063
        for(i=0;i<os->nb_streams;i++,n++) {
2064
            nb_streams[os->streams[i]->codec->codec_type]++;
2065
        }
2066
    }
2067
    for(step=1<<30; step; step>>=1){
2068
        int found_streams[AVMEDIA_TYPE_NB]={0};
2069
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2070
            nb_frame_threshold[j] += step;
2071

    
2072
        for(j=0; j<nb_istreams; j++) {
2073
            int skip=0;
2074
            ist = ist_table[j];
2075
            if(opt_programid){
2076
                int pi,si;
2077
                AVFormatContext *f= input_files[ ist->file_index ];
2078
                skip=1;
2079
                for(pi=0; pi<f->nb_programs; pi++){
2080
                    AVProgram *p= f->programs[pi];
2081
                    if(p->id == opt_programid)
2082
                        for(si=0; si<p->nb_stream_indexes; si++){
2083
                            if(f->streams[ p->stream_index[si] ] == ist->st)
2084
                                skip=0;
2085
                        }
2086
                }
2087
            }
2088
            if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2089
                && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2090
                found_streams[ist->st->codec->codec_type]++;
2091
            }
2092
        }
2093
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2094
            if(found_streams[j] < nb_streams[j])
2095
                nb_frame_threshold[j] -= step;
2096
    }
2097
    n = 0;
2098
    for(k=0;k<nb_output_files;k++) {
2099
        os = output_files[k];
2100
        for(i=0;i<os->nb_streams;i++,n++) {
2101
            int found;
2102
            ost = ost_table[n] = output_streams_for_file[k][i];
2103
            ost->st = os->streams[i];
2104
            if (nb_stream_maps > 0) {
2105
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2106
                    stream_maps[n].stream_index;
2107

    
2108
                /* Sanity check that the stream types match */
2109
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2110
                    int i= ost->file_index;
2111
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2112
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2113
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2114
                        ost->file_index, ost->index);
2115
                    ffmpeg_exit(1);
2116
                }
2117

    
2118
            } else {
2119
                /* get corresponding input stream index : we select the first one with the right type */
2120
                found = 0;
2121
                for(j=0;j<nb_istreams;j++) {
2122
                    int skip=0;
2123
                    ist = ist_table[j];
2124
                    if(opt_programid){
2125
                        int pi,si;
2126
                        AVFormatContext *f= input_files[ ist->file_index ];
2127
                        skip=1;
2128
                        for(pi=0; pi<f->nb_programs; pi++){
2129
                            AVProgram *p= f->programs[pi];
2130
                            if(p->id == opt_programid)
2131
                                for(si=0; si<p->nb_stream_indexes; si++){
2132
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2133
                                        skip=0;
2134
                                }
2135
                        }
2136
                    }
2137
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2138
                        ist->st->codec->codec_type == ost->st->codec->codec_type &&
2139
                        nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2140
                            ost->source_index = j;
2141
                            found = 1;
2142
                            break;
2143
                    }
2144
                }
2145

    
2146
                if (!found) {
2147
                    if(! opt_programid) {
2148
                        /* try again and reuse existing stream */
2149
                        for(j=0;j<nb_istreams;j++) {
2150
                            ist = ist_table[j];
2151
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2152
                                && ist->st->discard != AVDISCARD_ALL) {
2153
                                ost->source_index = j;
2154
                                found = 1;
2155
                            }
2156
                        }
2157
                    }
2158
                    if (!found) {
2159
                        int i= ost->file_index;
2160
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2161
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2162
                                ost->file_index, ost->index);
2163
                        ffmpeg_exit(1);
2164
                    }
2165
                }
2166
            }
2167
            ist = ist_table[ost->source_index];
2168
            ist->discard = 0;
2169
            ost->sync_ist = (nb_stream_maps > 0) ?
2170
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2171
                         stream_maps[n].sync_stream_index] : ist;
2172
        }
2173
    }
2174

    
2175
    /* for each output stream, we compute the right encoding parameters */
2176
    for(i=0;i<nb_ostreams;i++) {
2177
        ost = ost_table[i];
2178
        os = output_files[ost->file_index];
2179
        ist = ist_table[ost->source_index];
2180

    
2181
        codec = ost->st->codec;
2182
        icodec = ist->st->codec;
2183

    
2184
        if (metadata_streams_autocopy)
2185
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2186
                             AV_METADATA_DONT_OVERWRITE);
2187

    
2188
        ost->st->disposition = ist->st->disposition;
2189
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2190
        codec->chroma_sample_location = icodec->chroma_sample_location;
2191

    
2192
        if (ost->st->stream_copy) {
2193
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2194

    
2195
            if (extra_size > INT_MAX)
2196
                goto fail;
2197

    
2198
            /* if stream_copy is selected, no need to decode or encode */
2199
            codec->codec_id = icodec->codec_id;
2200
            codec->codec_type = icodec->codec_type;
2201

    
2202
            if(!codec->codec_tag){
2203
                if(   !os->oformat->codec_tag
2204
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2205
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2206
                    codec->codec_tag = icodec->codec_tag;
2207
            }
2208

    
2209
            codec->bit_rate = icodec->bit_rate;
2210
            codec->rc_max_rate    = icodec->rc_max_rate;
2211
            codec->rc_buffer_size = icodec->rc_buffer_size;
2212
            codec->extradata= av_mallocz(extra_size);
2213
            if (!codec->extradata)
2214
                goto fail;
2215
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2216
            codec->extradata_size= icodec->extradata_size;
2217
            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){
2218
                codec->time_base = icodec->time_base;
2219
                codec->time_base.num *= icodec->ticks_per_frame;
2220
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2221
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2222
            }else
2223
                codec->time_base = ist->st->time_base;
2224
            switch(codec->codec_type) {
2225
            case AVMEDIA_TYPE_AUDIO:
2226
                if(audio_volume != 256) {
2227
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2228
                    ffmpeg_exit(1);
2229
                }
2230
                codec->channel_layout = icodec->channel_layout;
2231
                codec->sample_rate = icodec->sample_rate;
2232
                codec->channels = icodec->channels;
2233
                codec->frame_size = icodec->frame_size;
2234
                codec->audio_service_type = icodec->audio_service_type;
2235
                codec->block_align= icodec->block_align;
2236
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2237
                    codec->block_align= 0;
2238
                if(codec->codec_id == CODEC_ID_AC3)
2239
                    codec->block_align= 0;
2240
                break;
2241
            case AVMEDIA_TYPE_VIDEO:
2242
                codec->pix_fmt = icodec->pix_fmt;
2243
                codec->width = icodec->width;
2244
                codec->height = icodec->height;
2245
                codec->has_b_frames = icodec->has_b_frames;
2246
                break;
2247
            case AVMEDIA_TYPE_SUBTITLE:
2248
                codec->width = icodec->width;
2249
                codec->height = icodec->height;
2250
                break;
2251
            default:
2252
                abort();
2253
            }
2254
        } else {
2255
            switch(codec->codec_type) {
2256
            case AVMEDIA_TYPE_AUDIO:
2257
                ost->fifo= av_fifo_alloc(1024);
2258
                if(!ost->fifo)
2259
                    goto fail;
2260
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2261
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2262
                icodec->request_channels = codec->channels;
2263
                ist->decoding_needed = 1;
2264
                ost->encoding_needed = 1;
2265
                ost->resample_sample_fmt  = icodec->sample_fmt;
2266
                ost->resample_sample_rate = icodec->sample_rate;
2267
                ost->resample_channels    = icodec->channels;
2268
                break;
2269
            case AVMEDIA_TYPE_VIDEO:
2270
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2271
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2272
                    ffmpeg_exit(1);
2273
                }
2274
                ost->video_resample = (codec->width != icodec->width   ||
2275
                                       codec->height != icodec->height ||
2276
                        (codec->pix_fmt != icodec->pix_fmt));
2277
                if (ost->video_resample) {
2278
#if !CONFIG_AVFILTER
2279
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2280
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2281
                                         codec->width, codec->height)) {
2282
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2283
                        ffmpeg_exit(1);
2284
                    }
2285
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2286
                    ost->img_resample_ctx = sws_getContext(
2287
                        icodec->width,
2288
                        icodec->height,
2289
                            icodec->pix_fmt,
2290
                            codec->width,
2291
                            codec->height,
2292
                            codec->pix_fmt,
2293
                            sws_flags, NULL, NULL, NULL);
2294
                    if (ost->img_resample_ctx == NULL) {
2295
                        fprintf(stderr, "Cannot get resampling context\n");
2296
                        ffmpeg_exit(1);
2297
                    }
2298

    
2299
                    ost->original_height = icodec->height;
2300
                    ost->original_width  = icodec->width;
2301
#endif
2302
                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2303
                }
2304
                ost->resample_height = icodec->height;
2305
                ost->resample_width  = icodec->width;
2306
                ost->resample_pix_fmt= icodec->pix_fmt;
2307
                ost->encoding_needed = 1;
2308
                ist->decoding_needed = 1;
2309

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2578
    timer_start = av_gettime();
2579

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2720
    discard_packet:
2721
        av_free_packet(&pkt);
2722

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

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

    
2735
    term_exit();
2736

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2844
    opt_default(opt, arg);
2845

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

    
2849
    return 0;
2850
}
2851

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

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

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

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

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

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

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

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

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

    
2920
    av_metadata_set2(&metadata, arg, mid, 0);
2921

    
2922
    return 0;
2923
}
2924

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

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

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

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

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

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

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

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

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

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

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

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

    
3017
static int opt_codec_tag(const char *opt, const char *arg)
3018
{
3019
    char *tail;
3020
    uint32_t *codec_tag;
3021

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

    
3028
    *codec_tag = strtol(arg, &tail, 0);
3029
    if (!tail || *tail)
3030
        *codec_tag = AV_RL32(arg);
3031

    
3032
    return 0;
3033
}
3034

    
3035
static void opt_map(const char *arg)
3036
{
3037
    AVStreamMap *m;
3038
    char *p;
3039

    
3040
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3041
    m = &stream_maps[nb_stream_maps-1];
3042

    
3043
    m->file_index = strtol(arg, &p, 0);
3044
    if (*p)
3045
        p++;
3046

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

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

    
3081
static void opt_map_metadata(const char *arg)
3082
{
3083
    AVMetaDataMap *m, *m1;
3084
    char *p;
3085

    
3086
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3087
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3088

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

    
3095
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3096
    m1->file = strtol(p, &p, 0);
3097
    parse_meta_type(p, &m1->type, &m1->index, &p);
3098

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

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

    
3114
static void opt_map_chapters(const char *arg)
3115
{
3116
    AVChapterMap *c;
3117
    char *p;
3118

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

    
3126
    c->in_file = strtol(p, &p, 0);
3127
}
3128

    
3129
static void opt_input_ts_scale(const char *arg)
3130
{
3131
    unsigned int stream;
3132
    double scale;
3133
    char *p;
3134

    
3135
    stream = strtol(arg, &p, 0);
3136
    if (*p)
3137
        p++;
3138
    scale= strtod(p, &p);
3139

    
3140
    if(stream >= MAX_STREAMS)
3141
        ffmpeg_exit(1);
3142

    
3143
    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);
3144
    input_files_ts_scale[nb_input_files][stream]= scale;
3145
}
3146

    
3147
static int opt_recording_time(const char *opt, const char *arg)
3148
{
3149
    recording_time = parse_time_or_die(opt, arg, 1);
3150
    return 0;
3151
}
3152

    
3153
static int opt_start_time(const char *opt, const char *arg)
3154
{
3155
    start_time = parse_time_or_die(opt, arg, 1);
3156
    return 0;
3157
}
3158

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

    
3165
static int opt_input_ts_offset(const char *opt, const char *arg)
3166
{
3167
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3168
    return 0;
3169
}
3170

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

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

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

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

    
3221
    if (!strcmp(filename, "-"))
3222
        filename = "pipe:";
3223

    
3224
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3225
                    !strcmp(filename, "/dev/stdin");
3226

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

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

    
3247
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3248

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

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

    
3290
    ic->loop_input = loop_input;
3291

    
3292
    /* If not enough info to get the stream parameters, we decode the
3293
       first frames to get it. (used in mpeg case for example) */
3294
    ret = av_find_stream_info(ic);
3295
    if (ret < 0 && verbose >= 0) {
3296
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3297
        av_close_input_file(ic);
3298
        ffmpeg_exit(1);
3299
    }
3300

    
3301
    timestamp = start_time;
3302
    /* add the stream start time */
3303
    if (ic->start_time != AV_NOPTS_VALUE)
3304
        timestamp += ic->start_time;
3305

    
3306
    /* if seeking requested, we execute it */
3307
    if (start_time != 0) {
3308
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3309
        if (ret < 0) {
3310
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3311
                    filename, (double)timestamp / AV_TIME_BASE);
3312
        }
3313
        /* reset seek info */
3314
        start_time = 0;
3315
    }
3316

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

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

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

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

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

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

    
3402
    nb_input_files++;
3403

    
3404
    video_channel = 0;
3405

    
3406
    av_freep(&video_codec_name);
3407
    av_freep(&audio_codec_name);
3408
    av_freep(&subtitle_codec_name);
3409
}
3410

    
3411
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3412
                                         int *has_subtitle_ptr)
3413
{
3414
    int has_video, has_audio, has_subtitle, i, j;
3415
    AVFormatContext *ic;
3416

    
3417
    has_video = 0;
3418
    has_audio = 0;
3419
    has_subtitle = 0;
3420
    for(j=0;j<nb_input_files;j++) {
3421
        ic = input_files[j];
3422
        for(i=0;i<ic->nb_streams;i++) {
3423
            AVCodecContext *enc = ic->streams[i]->codec;
3424
            switch(enc->codec_type) {
3425
            case AVMEDIA_TYPE_AUDIO:
3426
                has_audio = 1;
3427
                break;
3428
            case AVMEDIA_TYPE_VIDEO:
3429
                has_video = 1;
3430
                break;
3431
            case AVMEDIA_TYPE_SUBTITLE:
3432
                has_subtitle = 1;
3433
                break;
3434
            case AVMEDIA_TYPE_DATA:
3435
            case AVMEDIA_TYPE_ATTACHMENT:
3436
            case AVMEDIA_TYPE_UNKNOWN:
3437
                break;
3438
            default:
3439
                abort();
3440
            }
3441
        }
3442
    }
3443
    *has_video_ptr = has_video;
3444
    *has_audio_ptr = has_audio;
3445
    *has_subtitle_ptr = has_subtitle;
3446
}
3447

    
3448
static void new_video_stream(AVFormatContext *oc, int file_idx)
3449
{
3450
    AVStream *st;
3451
    AVOutputStream *ost;
3452
    AVCodecContext *video_enc;
3453
    enum CodecID codec_id = CODEC_ID_NONE;
3454
    AVCodec *codec= NULL;
3455
    int i;
3456

    
3457
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3458
    if (!st) {
3459
        fprintf(stderr, "Could not alloc stream\n");
3460
        ffmpeg_exit(1);
3461
    }
3462
    ost = new_output_stream(oc, file_idx);
3463

    
3464
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3465
    if(!video_stream_copy){
3466
        if (video_codec_name) {
3467
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3468
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3469
            codec = avcodec_find_encoder_by_name(video_codec_name);
3470
            output_codecs[nb_output_codecs-1] = codec;
3471
        } else {
3472
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3473
            codec = avcodec_find_encoder(codec_id);
3474
        }
3475
#if CONFIG_AVFILTER
3476
        if(frame_aspect_ratio_override){
3477
            i = vfilters ? strlen(vfilters) : 0;
3478
            vfilters = av_realloc(vfilters, i+100);
3479
            snprintf(vfilters+i, 100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3480
            frame_aspect_ratio=0;
3481
            frame_aspect_ratio_override=0;
3482
        }
3483

    
3484
        ost->avfilter= vfilters;
3485
        vfilters= NULL;
3486
#endif
3487
    }
3488

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

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

    
3495
    video_enc = st->codec;
3496

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

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

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

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

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

    
3528
        video_enc->width = frame_width;
3529
        video_enc->height = frame_height;
3530
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
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_subtitle_stream(AVFormatContext *oc, int file_idx)
3687
{
3688
    AVStream *st;
3689
    AVOutputStream *ost;
3690
    AVCodec *codec=NULL;
3691
    AVCodecContext *subtitle_enc;
3692
    enum CodecID codec_id = CODEC_ID_NONE;
3693

    
3694
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3695
    if (!st) {
3696
        fprintf(stderr, "Could not alloc stream\n");
3697
        ffmpeg_exit(1);
3698
    }
3699
    ost = new_output_stream(oc, file_idx);
3700
    subtitle_enc = st->codec;
3701
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3702
    if(!subtitle_stream_copy){
3703
        if (subtitle_codec_name) {
3704
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3705
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3706
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3707
        } else {
3708
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3709
            codec = avcodec_find_encoder(codec_id);
3710
        }
3711
    }
3712
    avcodec_get_context_defaults3(st->codec, codec);
3713

    
3714
    ost->bitstream_filters = subtitle_bitstream_filters;
3715
    subtitle_bitstream_filters= NULL;
3716

    
3717
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3718

    
3719
    if(subtitle_codec_tag)
3720
        subtitle_enc->codec_tag= subtitle_codec_tag;
3721

    
3722
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3723
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3724
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3725
    }
3726
    if (subtitle_stream_copy) {
3727
        st->stream_copy = 1;
3728
    } else {
3729
        subtitle_enc->codec_id = codec_id;
3730
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3731
    }
3732

    
3733
    if (subtitle_language) {
3734
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3735
        av_freep(&subtitle_language);
3736
    }
3737

    
3738
    subtitle_disable = 0;
3739
    av_freep(&subtitle_codec_name);
3740
    subtitle_stream_copy = 0;
3741
}
3742

    
3743
static int opt_new_stream(const char *opt, const char *arg)
3744
{
3745
    AVFormatContext *oc;
3746
    int file_idx = nb_output_files - 1;
3747
    if (nb_output_files <= 0) {
3748
        fprintf(stderr, "At least one output file must be specified\n");
3749
        ffmpeg_exit(1);
3750
    }
3751
    oc = output_files[file_idx];
3752

    
3753
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3754
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3755
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3756
    else av_assert0(0);
3757
    return 0;
3758
}
3759

    
3760
/* arg format is "output-stream-index:streamid-value". */
3761
static int opt_streamid(const char *opt, const char *arg)
3762
{
3763
    int idx;
3764
    char *p;
3765
    char idx_str[16];
3766

    
3767
    strncpy(idx_str, arg, sizeof(idx_str));
3768
    idx_str[sizeof(idx_str)-1] = '\0';
3769
    p = strchr(idx_str, ':');
3770
    if (!p) {
3771
        fprintf(stderr,
3772
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3773
                arg, opt);
3774
        ffmpeg_exit(1);
3775
    }
3776
    *p++ = '\0';
3777
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3778
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3779
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3780
    return 0;
3781
}
3782

    
3783
static void opt_output_file(const char *filename)
3784
{
3785
    AVFormatContext *oc;
3786
    int err, use_video, use_audio, use_subtitle;
3787
    int input_has_video, input_has_audio, input_has_subtitle;
3788
    AVFormatParameters params, *ap = &params;
3789
    AVOutputFormat *file_oformat;
3790

    
3791
    if (!strcmp(filename, "-"))
3792
        filename = "pipe:";
3793

    
3794
    oc = avformat_alloc_context();
3795
    if (!oc) {
3796
        print_error(filename, AVERROR(ENOMEM));
3797
        ffmpeg_exit(1);
3798
    }
3799

    
3800
    if (last_asked_format) {
3801
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3802
        if (!file_oformat) {
3803
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3804
            ffmpeg_exit(1);
3805
        }
3806
        last_asked_format = NULL;
3807
    } else {
3808
        file_oformat = av_guess_format(NULL, filename, NULL);
3809
        if (!file_oformat) {
3810
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3811
                    filename);
3812
            ffmpeg_exit(1);
3813
        }
3814
    }
3815

    
3816
    oc->oformat = file_oformat;
3817
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3818

    
3819
    if (!strcmp(file_oformat->name, "ffm") &&
3820
        av_strstart(filename, "http:", NULL)) {
3821
        /* special case for files sent to ffserver: we get the stream
3822
           parameters from ffserver */
3823
        int err = read_ffserver_streams(oc, filename);
3824
        if (err < 0) {
3825
            print_error(filename, err);
3826
            ffmpeg_exit(1);
3827
        }
3828
    } else {
3829
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3830
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3831
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3832

    
3833
        /* disable if no corresponding type found and at least one
3834
           input file */
3835
        if (nb_input_files > 0) {
3836
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3837
                                         &input_has_subtitle);
3838
            if (!input_has_video)
3839
                use_video = 0;
3840
            if (!input_has_audio)
3841
                use_audio = 0;
3842
            if (!input_has_subtitle)
3843
                use_subtitle = 0;
3844
        }
3845

    
3846
        /* manual disable */
3847
        if (audio_disable)    use_audio    = 0;
3848
        if (video_disable)    use_video    = 0;
3849
        if (subtitle_disable) use_subtitle = 0;
3850

    
3851
        if (use_video)    new_video_stream(oc, nb_output_files);
3852
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3853
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3854

    
3855
        oc->timestamp = recording_timestamp;
3856

    
3857
        av_metadata_copy(&oc->metadata, metadata, 0);
3858
        av_metadata_free(&metadata);
3859
    }
3860

    
3861
    output_files[nb_output_files++] = oc;
3862

    
3863
    /* check filename in case of an image number is expected */
3864
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3865
        if (!av_filename_number_test(oc->filename)) {
3866
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3867
            ffmpeg_exit(1);
3868
        }
3869
    }
3870

    
3871
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3872
        /* test if it already exists to avoid loosing precious files */
3873
        if (!file_overwrite &&
3874
            (strchr(filename, ':') == NULL ||
3875
             filename[1] == ':' ||
3876
             av_strstart(filename, "file:", NULL))) {
3877
            if (url_exist(filename)) {
3878
                if (!using_stdin) {
3879
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3880
                    fflush(stderr);
3881
                    if (!read_yesno()) {
3882
                        fprintf(stderr, "Not overwriting - exiting\n");
3883
                        ffmpeg_exit(1);
3884
                    }
3885
                }
3886
                else {
3887
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3888
                    ffmpeg_exit(1);
3889
                }
3890
            }
3891
        }
3892

    
3893
        /* open the file */
3894
        if ((err = avio_open(&oc->pb, filename, AVIO_WRONLY)) < 0) {
3895
            print_error(filename, err);
3896
            ffmpeg_exit(1);
3897
        }
3898
    }
3899

    
3900
    memset(ap, 0, sizeof(*ap));
3901
    if (av_set_parameters(oc, ap) < 0) {
3902
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3903
                oc->filename);
3904
        ffmpeg_exit(1);
3905
    }
3906

    
3907
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3908
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3909
    oc->loop_output = loop_output;
3910

    
3911
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3912

    
3913
    av_freep(&forced_key_frames);
3914
}
3915

    
3916
/* same option as mencoder */
3917
static int opt_pass(const char *opt, const char *arg)
3918
{
3919
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3920
    return 0;
3921
}
3922

    
3923
static int64_t getutime(void)
3924
{
3925
#if HAVE_GETRUSAGE
3926
    struct rusage rusage;
3927

    
3928
    getrusage(RUSAGE_SELF, &rusage);
3929
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3930
#elif HAVE_GETPROCESSTIMES
3931
    HANDLE proc;
3932
    FILETIME c, e, k, u;
3933
    proc = GetCurrentProcess();
3934
    GetProcessTimes(proc, &c, &e, &k, &u);
3935
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3936
#else
3937
    return av_gettime();
3938
#endif
3939
}
3940

    
3941
static int64_t getmaxrss(void)
3942
{
3943
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3944
    struct rusage rusage;
3945
    getrusage(RUSAGE_SELF, &rusage);
3946
    return (int64_t)rusage.ru_maxrss * 1024;
3947
#elif HAVE_GETPROCESSMEMORYINFO
3948
    HANDLE proc;
3949
    PROCESS_MEMORY_COUNTERS memcounters;
3950
    proc = GetCurrentProcess();
3951
    memcounters.cb = sizeof(memcounters);
3952
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3953
    return memcounters.PeakPagefileUsage;
3954
#else
3955
    return 0;
3956
#endif
3957
}
3958

    
3959
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3960
{
3961
    int i;
3962
    const char *p = str;
3963
    for(i = 0;; i++) {
3964
        dest[i] = atoi(p);
3965
        if(i == 63)
3966
            break;
3967
        p = strchr(p, ',');
3968
        if(!p) {
3969
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3970
            ffmpeg_exit(1);
3971
        }
3972
        p++;
3973
    }
3974
}
3975

    
3976
static void opt_inter_matrix(const char *arg)
3977
{
3978
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3979
    parse_matrix_coeffs(inter_matrix, arg);
3980
}
3981

    
3982
static void opt_intra_matrix(const char *arg)
3983
{
3984
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3985
    parse_matrix_coeffs(intra_matrix, arg);
3986
}
3987

    
3988
static void show_usage(void)
3989
{
3990
    printf("Hyper fast Audio and Video encoder\n");
3991
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3992
    printf("\n");
3993
}
3994

    
3995
static void show_help(void)
3996
{
3997
    AVCodec *c;
3998
    AVOutputFormat *oformat = NULL;
3999

    
4000
    av_log_set_callback(log_callback_help);
4001
    show_usage();
4002
    show_help_options(options, "Main options:\n",
4003
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4004
    show_help_options(options, "\nAdvanced options:\n",
4005
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4006
                      OPT_EXPERT);
4007
    show_help_options(options, "\nVideo options:\n",
4008
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4009
                      OPT_VIDEO);
4010
    show_help_options(options, "\nAdvanced Video options:\n",
4011
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4012
                      OPT_VIDEO | OPT_EXPERT);
4013
    show_help_options(options, "\nAudio options:\n",
4014
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4015
                      OPT_AUDIO);
4016
    show_help_options(options, "\nAdvanced Audio options:\n",
4017
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4018
                      OPT_AUDIO | OPT_EXPERT);
4019
    show_help_options(options, "\nSubtitle options:\n",
4020
                      OPT_SUBTITLE | OPT_GRAB,
4021
                      OPT_SUBTITLE);
4022
    show_help_options(options, "\nAudio/Video grab options:\n",
4023
                      OPT_GRAB,
4024
                      OPT_GRAB);
4025
    printf("\n");
4026
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4027
    printf("\n");
4028

    
4029
    /* individual codec options */
4030
    c = NULL;
4031
    while ((c = av_codec_next(c))) {
4032
        if (c->priv_class) {
4033
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4034
            printf("\n");
4035
        }
4036
    }
4037

    
4038
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4039
    printf("\n");
4040

    
4041
    /* individual muxer options */
4042
    while ((oformat = av_oformat_next(oformat))) {
4043
        if (oformat->priv_class) {
4044
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4045
            printf("\n");
4046
        }
4047
    }
4048

    
4049
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4050
}
4051

    
4052
static void opt_target(const char *arg)
4053
{
4054
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4055
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4056

    
4057
    if(!strncmp(arg, "pal-", 4)) {
4058
        norm = PAL;
4059
        arg += 4;
4060
    } else if(!strncmp(arg, "ntsc-", 5)) {
4061
        norm = NTSC;
4062
        arg += 5;
4063
    } else if(!strncmp(arg, "film-", 5)) {
4064
        norm = FILM;
4065
        arg += 5;
4066
    } else {
4067
        int fr;
4068
        /* Calculate FR via float to avoid int overflow */
4069
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4070
        if(fr == 25000) {
4071
            norm = PAL;
4072
        } else if((fr == 29970) || (fr == 23976)) {
4073
            norm = NTSC;
4074
        } else {
4075
            /* Try to determine PAL/NTSC by peeking in the input files */
4076
            if(nb_input_files) {
4077
                int i, j;
4078
                for(j = 0; j < nb_input_files; j++) {
4079
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4080
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4081
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4082
                            continue;
4083
                        fr = c->time_base.den * 1000 / c->time_base.num;
4084
                        if(fr == 25000) {
4085
                            norm = PAL;
4086
                            break;
4087
                        } else if((fr == 29970) || (fr == 23976)) {
4088
                            norm = NTSC;
4089
                            break;
4090
                        }
4091
                    }
4092
                    if(norm != UNKNOWN)
4093
                        break;
4094
                }
4095
            }
4096
        }
4097
        if(verbose && norm != UNKNOWN)
4098
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4099
    }
4100

    
4101
    if(norm == UNKNOWN) {
4102
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4103
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4104
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4105
        ffmpeg_exit(1);
4106
    }
4107

    
4108
    if(!strcmp(arg, "vcd")) {
4109

    
4110
        opt_video_codec("mpeg1video");
4111
        opt_audio_codec("mp2");
4112
        opt_format("vcd");
4113

    
4114
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4115
        opt_frame_rate(NULL, frame_rates[norm]);
4116
        opt_default("g", norm == PAL ? "15" : "18");
4117

    
4118
        opt_default("b", "1150000");
4119
        opt_default("maxrate", "1150000");
4120
        opt_default("minrate", "1150000");
4121
        opt_default("bufsize", "327680"); // 40*1024*8;
4122

    
4123
        opt_default("ab", "224000");
4124
        audio_sample_rate = 44100;
4125
        audio_channels = 2;
4126

    
4127
        opt_default("packetsize", "2324");
4128
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4129

    
4130
        /* We have to offset the PTS, so that it is consistent with the SCR.
4131
           SCR starts at 36000, but the first two packs contain only padding
4132
           and the first pack from the other stream, respectively, may also have
4133
           been written before.
4134
           So the real data starts at SCR 36000+3*1200. */
4135
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4136
    } else if(!strcmp(arg, "svcd")) {
4137

    
4138
        opt_video_codec("mpeg2video");
4139
        opt_audio_codec("mp2");
4140
        opt_format("svcd");
4141

    
4142
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4143
        opt_frame_rate(NULL, frame_rates[norm]);
4144
        opt_default("g", norm == PAL ? "15" : "18");
4145

    
4146
        opt_default("b", "2040000");
4147
        opt_default("maxrate", "2516000");
4148
        opt_default("minrate", "0"); //1145000;
4149
        opt_default("bufsize", "1835008"); //224*1024*8;
4150
        opt_default("flags", "+scan_offset");
4151

    
4152

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

    
4156
        opt_default("packetsize", "2324");
4157

    
4158
    } else if(!strcmp(arg, "dvd")) {
4159

    
4160
        opt_video_codec("mpeg2video");
4161
        opt_audio_codec("ac3");
4162
        opt_format("dvd");
4163

    
4164
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4165
        opt_frame_rate(NULL, frame_rates[norm]);
4166
        opt_default("g", norm == PAL ? "15" : "18");
4167

    
4168
        opt_default("b", "6000000");
4169
        opt_default("maxrate", "9000000");
4170
        opt_default("minrate", "0"); //1500000;
4171
        opt_default("bufsize", "1835008"); //224*1024*8;
4172

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

    
4176
        opt_default("ab", "448000");
4177
        audio_sample_rate = 48000;
4178

    
4179
    } else if(!strncmp(arg, "dv", 2)) {
4180

    
4181
        opt_format("dv");
4182

    
4183
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4184
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4185
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4186
        opt_frame_rate(NULL, frame_rates[norm]);
4187

    
4188
        audio_sample_rate = 48000;
4189
        audio_channels = 2;
4190

    
4191
    } else {
4192
        fprintf(stderr, "Unknown target: %s\n", arg);
4193
        ffmpeg_exit(1);
4194
    }
4195
}
4196

    
4197
static void opt_vstats_file (const char *arg)
4198
{
4199
    av_free (vstats_filename);
4200
    vstats_filename=av_strdup (arg);
4201
}
4202

    
4203
static void opt_vstats (void)
4204
{
4205
    char filename[40];
4206
    time_t today2 = time(NULL);
4207
    struct tm *today = localtime(&today2);
4208

    
4209
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4210
             today->tm_sec);
4211
    opt_vstats_file(filename);
4212
}
4213

    
4214
static int opt_bsf(const char *opt, const char *arg)
4215
{
4216
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4217
    AVBitStreamFilterContext **bsfp;
4218

    
4219
    if(!bsfc){
4220
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4221
        ffmpeg_exit(1);
4222
    }
4223

    
4224
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4225
          *opt == 'a' ? &audio_bitstream_filters :
4226
                        &subtitle_bitstream_filters;
4227
    while(*bsfp)
4228
        bsfp= &(*bsfp)->next;
4229

    
4230
    *bsfp= bsfc;
4231

    
4232
    return 0;
4233
}
4234

    
4235
static int opt_preset(const char *opt, const char *arg)
4236
{
4237
    FILE *f=NULL;
4238
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4239
    char *codec_name = *opt == 'v' ? video_codec_name :
4240
                       *opt == 'a' ? audio_codec_name :
4241
                                     subtitle_codec_name;
4242

    
4243
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4244
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4245
        ffmpeg_exit(1);
4246
    }
4247

    
4248
    while(!feof(f)){
4249
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4250
        if(line[0] == '#' && !e)
4251
            continue;
4252
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4253
        if(e){
4254
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4255
            ffmpeg_exit(1);
4256
        }
4257
        if(!strcmp(tmp, "acodec")){
4258
            opt_audio_codec(tmp2);
4259
        }else if(!strcmp(tmp, "vcodec")){
4260
            opt_video_codec(tmp2);
4261
        }else if(!strcmp(tmp, "scodec")){
4262
            opt_subtitle_codec(tmp2);
4263
        }else if(opt_default(tmp, tmp2) < 0){
4264
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4265
            ffmpeg_exit(1);
4266
        }
4267
    }
4268

    
4269
    fclose(f);
4270

    
4271
    return 0;
4272
}
4273

    
4274
static const OptionDef options[] = {
4275
    /* main options */
4276
#include "cmdutils_common_opts.h"
4277
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4278
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4279
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4280
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4281
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4282
      "outfile[,metadata]:infile[,metadata]" },
4283
    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4284
      "outfile[,metadata]:infile[,metadata]" },
4285
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4286
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4287
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4288
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4289
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4290
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4291
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4292
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4293
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4294
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4295
      "add timings for benchmarking" },
4296
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4297
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4298
      "dump each input packet" },
4299
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4300
      "when dumping packets, also dump the payload" },
4301
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4302
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4303
    { "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)", "" },
4304
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4305
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4306
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4307
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4308
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4309
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4310
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4311
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4312
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4313
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4314
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4315
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4316
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4317
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4318

    
4319
    /* video options */
4320
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4321
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4322
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4323
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4324
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4325
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4326
    { "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" },
4327
    { "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" },
4328
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4329
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4330
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4331
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4332
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4333
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4334
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4335
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4336
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4337
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4338
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4339
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4340
    { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4341
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4342
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4343
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4344
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4345
      "use same quantizer as source (implies VBR)" },
4346
    { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4347
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4348
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4349
      "deinterlace pictures" },
4350
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4351
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4352
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4353
#if CONFIG_AVFILTER
4354
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4355
#endif
4356
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4357
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4358
    { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4359
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4360
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4361
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4362
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4363
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4364
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4365
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4366
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4367

    
4368
    /* audio options */
4369
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4370
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4371
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4372
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4373
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4374
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4375
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4376
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4377
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4378
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4379
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4380
    { "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" },
4381

    
4382
    /* subtitle options */
4383
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4384
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4385
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4386
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4387
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4388

    
4389
    /* grab options */
4390
    { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4391
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4392
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4393

    
4394
    /* muxer options */
4395
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4396
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4397

    
4398
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4399
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4400
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4401

    
4402
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4403
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4404
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4405
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4406

    
4407
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4408
    { NULL, },
4409
};
4410

    
4411
int main(int argc, char **argv)
4412
{
4413
    int64_t ti;
4414

    
4415
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4416

    
4417
    avcodec_register_all();
4418
#if CONFIG_AVDEVICE
4419
    avdevice_register_all();
4420
#endif
4421
#if CONFIG_AVFILTER
4422
    avfilter_register_all();
4423
#endif
4424
    av_register_all();
4425

    
4426
#if HAVE_ISATTY
4427
    if(isatty(STDIN_FILENO))
4428
        avio_set_interrupt_cb(decode_interrupt_cb);
4429
#endif
4430

    
4431
    init_opts();
4432

    
4433
    show_banner();
4434

    
4435
    /* parse options */
4436
    parse_options(argc, argv, options, opt_output_file);
4437

    
4438
    if(nb_output_files <= 0 && nb_input_files == 0) {
4439
        show_usage();
4440
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4441
        ffmpeg_exit(1);
4442
    }
4443

    
4444
    /* file converter / grab */
4445
    if (nb_output_files <= 0) {
4446
        fprintf(stderr, "At least one output file must be specified\n");
4447
        ffmpeg_exit(1);
4448
    }
4449

    
4450
    if (nb_input_files == 0) {
4451
        fprintf(stderr, "At least one input file must be specified\n");
4452
        ffmpeg_exit(1);
4453
    }
4454

    
4455
    ti = getutime();
4456
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4457
                  stream_maps, nb_stream_maps) < 0)
4458
        ffmpeg_exit(1);
4459
    ti = getutime() - ti;
4460
    if (do_benchmark) {
4461
        int maxrss = getmaxrss() / 1024;
4462
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4463
    }
4464

    
4465
    return ffmpeg_exit(0);
4466
}