Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0ebf4754

History | View | Annotate | Download (160 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
#if CONFIG_AVFILTER
51
# include "libavfilter/avfilter.h"
52
# include "libavfilter/avfiltergraph.h"
53
# include "libavfilter/vsrc_buffer.h"
54
#endif
55

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

    
68
#if HAVE_SYS_SELECT_H
69
#include <sys/select.h>
70
#endif
71

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

    
86
const char program_name[] = "FFmpeg";
87
const int program_birth_year = 2000;
88

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

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

    
106
typedef struct AVChapterMap {
107
    int in_file;
108
    int out_file;
109
} AVChapterMap;
110

    
111
static const OptionDef options[];
112

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

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

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

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

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

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

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

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

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

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

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

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

    
223
static int rate_emu = 0;
224

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

    
228
static int audio_volume = 256;
229

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

    
245
static float dts_delta_threshold = 10;
246

    
247
static unsigned int sws_flags = SWS_BICUBIC;
248

    
249
static int64_t timer_start;
250

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

    
255
static short *samples;
256

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

    
261
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
262

    
263
struct AVInputStream;
264

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

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

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

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

    
306
#if CONFIG_AVFILTER
307
    AVFilterContext *output_video_filter;
308
    AVFilterContext *input_video_filter;
309
    AVFilterBufferRef *picref;
310
    char *avfilter;
311
    AVFilterGraph *graph;
312
#endif
313
} AVOutputStream;
314

    
315
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
316
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
317

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

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

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

    
346
#if HAVE_TERMIOS_H
347

    
348
/* init terminal so that we can grab keys */
349
static struct termios oldtty;
350
#endif
351

    
352
#if CONFIG_AVFILTER
353

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

    
365
    ost->graph = avfilter_graph_alloc();
366

    
367
    if (ist->st->sample_aspect_ratio.num){
368
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
369
    }else
370
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
371

    
372
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
373
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
374
             sample_aspect_ratio.num, sample_aspect_ratio.den);
375

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

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

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

    
402
    if (ost->avfilter) {
403
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
404
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
405

    
406
        outputs->name    = av_strdup("in");
407
        outputs->filter_ctx = last_filter;
408
        outputs->pad_idx = 0;
409
        outputs->next    = NULL;
410

    
411
        inputs->name    = av_strdup("out");
412
        inputs->filter_ctx = ost->output_video_filter;
413
        inputs->pad_idx = 0;
414
        inputs->next    = NULL;
415

    
416
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
417
            return ret;
418
        av_freep(&ost->avfilter);
419
    } else {
420
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
421
            return ret;
422
    }
423

    
424
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
425
        return ret;
426

    
427
    codec->width  = ost->output_video_filter->inputs[0]->w;
428
    codec->height = ost->output_video_filter->inputs[0]->h;
429
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
430
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
431

    
432
    return 0;
433
}
434
#endif /* CONFIG_AVFILTER */
435

    
436
static void term_exit(void)
437
{
438
    av_log(NULL, AV_LOG_QUIET, "");
439
#if HAVE_TERMIOS_H
440
    tcsetattr (0, TCSANOW, &oldtty);
441
#endif
442
}
443

    
444
static volatile int received_sigterm = 0;
445

    
446
static void
447
sigterm_handler(int sig)
448
{
449
    received_sigterm = sig;
450
    term_exit();
451
}
452

    
453
static void term_init(void)
454
{
455
#if HAVE_TERMIOS_H
456
    struct termios tty;
457

    
458
    tcgetattr (0, &tty);
459
    oldtty = tty;
460
    atexit(term_exit);
461

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

    
471
    tcsetattr (0, TCSANOW, &tty);
472
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
473
#endif
474

    
475
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
476
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
477
#ifdef SIGXCPU
478
    signal(SIGXCPU, sigterm_handler);
479
#endif
480
}
481

    
482
/* read a key without blocking */
483
static int read_key(void)
484
{
485
#if HAVE_TERMIOS_H
486
    int n = 1;
487
    unsigned char ch;
488
    struct timeval tv;
489
    fd_set rfds;
490

    
491
    FD_ZERO(&rfds);
492
    FD_SET(0, &rfds);
493
    tv.tv_sec = 0;
494
    tv.tv_usec = 0;
495
    n = select(1, &rfds, NULL, NULL, &tv);
496
    if (n > 0) {
497
        n = read(0, &ch, 1);
498
        if (n == 1)
499
            return ch;
500

    
501
        return n;
502
    }
503
#elif HAVE_CONIO_H
504
    if(kbhit())
505
        return(getch());
506
#endif
507
    return -1;
508
}
509

    
510
static int decode_interrupt_cb(void)
511
{
512
    return q_pressed || (q_pressed = read_key() == 'q');
513
}
514

    
515
static int ffmpeg_exit(int ret)
516
{
517
    int i;
518

    
519
    /* close files */
520
    for(i=0;i<nb_output_files;i++) {
521
        AVFormatContext *s = output_files[i];
522
        int j;
523
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
524
            url_fclose(s->pb);
525
        avformat_free_context(s);
526
        av_free(output_streams_for_file[i]);
527
    }
528
    for(i=0;i<nb_input_files;i++) {
529
        av_close_input_file(input_files[i]);
530
        av_free(input_files_ts_scale[i]);
531
    }
532

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

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

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

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

    
550
    av_free(video_standard);
551

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

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

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

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

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

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

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

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

    
652
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
653
{
654
    int idx = oc->nb_streams - 1;
655
    AVOutputStream *ost;
656

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

    
673
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
674
{
675
    int i, err;
676
    AVFormatContext *ic;
677
    int nopts = 0;
678

    
679
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
680
    if (err < 0)
681
        return err;
682
    /* copy stream format */
683
    s->nb_streams = 0;
684
    for(i=0;i<ic->nb_streams;i++) {
685
        AVStream *st;
686
        AVCodec *codec;
687

    
688
        s->nb_streams++;
689

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

    
701
        codec = avcodec_find_encoder(st->codec->codec_id);
702
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
703
            if (audio_stream_copy) {
704
                st->stream_copy = 1;
705
            } else
706
                choose_sample_fmt(st, codec);
707
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
708
            if (video_stream_copy) {
709
                st->stream_copy = 1;
710
            } else
711
                choose_pixel_fmt(st, codec);
712
        }
713

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

    
717
        new_output_stream(s, nb_output_files);
718
    }
719

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

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

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

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

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

    
756
        bsfc= bsfc->next;
757
    }
758

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

    
766
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
767

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

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

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

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

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

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

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

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

    
815
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
816
        if (resample_changed) {
817
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
818
                   ist->file_index, ist->index,
819
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
820
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
821
            ost->resample_sample_fmt  = dec->sample_fmt;
822
            ost->resample_channels    = dec->channels;
823
            ost->resample_sample_rate = dec->sample_rate;
824
            if (ost->resample)
825
                audio_resample_close(ost->resample);
826
        }
827
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
828
        if (audio_sync_method <= 1 &&
829
            ost->resample_sample_fmt  == enc->sample_fmt &&
830
            ost->resample_channels    == enc->channels   &&
831
            ost->resample_sample_rate == enc->sample_rate) {
832
            ost->resample = NULL;
833
            ost->audio_resample = 0;
834
        } else {
835
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
836
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
837
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
838
                                                   enc->sample_rate, dec->sample_rate,
839
                                                   enc->sample_fmt,  dec->sample_fmt,
840
                                                   16, 10, 0, 0.8);
841
            if (!ost->resample) {
842
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
843
                        dec->channels, dec->sample_rate,
844
                        enc->channels, enc->sample_rate);
845
                ffmpeg_exit(1);
846
            }
847
        }
848
    }
849

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

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

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

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

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

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

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

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

    
950
        frame_bytes = enc->frame_size * osize * enc->channels;
951

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

    
956
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
957

    
958
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
959

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

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

    
981
        ost->sync_opts += size_out / (osize * enc->channels);
982

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

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

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

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

    
1019
    dec = ist->st->codec;
1020

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

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

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

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

    
1046
    if (picture != picture2)
1047
        *picture = *picture2;
1048
    *bufp = buf;
1049
}
1050

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

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

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

    
1073
    enc = ost->st->codec;
1074

    
1075
    if (!subtitle_out) {
1076
        subtitle_out = av_malloc(subtitle_out_max_size);
1077
    }
1078

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

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

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

    
1117
static int bit_buffer_size= 1024*256;
1118
static uint8_t *bit_buffer= NULL;
1119

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

    
1131
    enc = ost->st->codec;
1132
    dec = ist->st->codec;
1133

    
1134
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1135

    
1136
    /* by default, we output a single frame */
1137
    nb_frames = 1;
1138

    
1139
    *frame_size = 0;
1140

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

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

    
1170
    formatted_picture = in_picture;
1171
    final_picture = formatted_picture;
1172
    padding_src = formatted_picture;
1173
    resampling_dst = &ost->pict_tmp;
1174

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1363

    
1364
    oc = output_files[0];
1365

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

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

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

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

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

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

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

    
1444
        fflush(stderr);
1445
    }
1446

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

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

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

    
1480
    if(ist->next_pts == AV_NOPTS_VALUE)
1481
        ist->next_pts= ist->pts;
1482

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

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

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

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

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

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

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

    
1610
#if CONFIG_AVFILTER
1611
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1612
            for(i=0;i<nb_ostreams;i++) {
1613
                ost = ost_table[i];
1614
                if (ost->input_video_filter && ost->source_index == ist_index) {
1615
                    AVRational sar;
1616
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1617
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1618
                    // add it to be filtered
1619
                    av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1620
                                             ist->pts,
1621
                                             sar);
1622
                }
1623
            }
1624
        }
1625
#endif
1626

    
1627
        // preprocess audio (volume)
1628
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1629
            if (audio_volume != 256) {
1630
                short *volp;
1631
                volp = samples;
1632
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1633
                    int v = ((*volp) * audio_volume + 128) >> 8;
1634
                    if (v < -32768) v = -32768;
1635
                    if (v >  32767) v = 32767;
1636
                    *volp++ = v;
1637
                }
1638
            }
1639
        }
1640

    
1641
        /* frame rate emulation */
1642
        if (rate_emu) {
1643
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1644
            int64_t now = av_gettime() - ist->start;
1645
            if (pts > now)
1646
                usleep(pts - now);
1647
        }
1648
        /* if output time reached then transcode raw format,
1649
           encode packets and output them */
1650
        if (start_time == 0 || ist->pts >= start_time)
1651
            for(i=0;i<nb_ostreams;i++) {
1652
                int frame_size;
1653

    
1654
                ost = ost_table[i];
1655
                if (ost->source_index == ist_index) {
1656
#if CONFIG_AVFILTER
1657
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1658
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1659
                while (frame_available) {
1660
                    AVRational ist_pts_tb;
1661
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1662
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1663
                    if (ost->picref)
1664
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1665
#endif
1666
                    os = output_files[ost->file_index];
1667

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

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

    
1698
                        av_init_packet(&opkt);
1699

    
1700
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1701
                            continue;
1702

    
1703
                        /* no reencoding needed : output the packet directly */
1704
                        /* force the input stream PTS */
1705

    
1706
                        avcodec_get_frame_defaults(&avframe);
1707
                        ost->st->codec->coded_frame= &avframe;
1708
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1709

    
1710
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1711
                            audio_size += data_size;
1712
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1713
                            video_size += data_size;
1714
                            ost->sync_opts++;
1715
                        }
1716

    
1717
                        opkt.stream_index= ost->index;
1718
                        if(pkt->pts != AV_NOPTS_VALUE)
1719
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1720
                        else
1721
                            opkt.pts= AV_NOPTS_VALUE;
1722

    
1723
                        if (pkt->dts == AV_NOPTS_VALUE)
1724
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1725
                        else
1726
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1727
                        opkt.dts -= ost_tb_start_time;
1728

    
1729
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1730
                        opkt.flags= pkt->flags;
1731

    
1732
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1733
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1734
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1735
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1736
                           ) {
1737
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1738
                                opkt.destruct= av_destruct_packet;
1739
                        } else {
1740
                            opkt.data = data_buf;
1741
                            opkt.size = data_size;
1742
                        }
1743

    
1744
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1745
                        ost->st->codec->frame_number++;
1746
                        ost->frame_number++;
1747
                        av_free_packet(&opkt);
1748
                    }
1749
#if CONFIG_AVFILTER
1750
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1751
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1752
                    if(ost->picref)
1753
                        avfilter_unref_buffer(ost->picref);
1754
                }
1755
#endif
1756
                }
1757
            }
1758

    
1759
        av_free(buffer_to_free);
1760
        /* XXX: allocate the subtitles in the codec ? */
1761
        if (subtitle_to_free) {
1762
            avsubtitle_free(subtitle_to_free);
1763
            subtitle_to_free = NULL;
1764
        }
1765
    }
1766
 discard_packet:
1767
    if (pkt == NULL) {
1768
        /* EOF handling */
1769

    
1770
        for(i=0;i<nb_ostreams;i++) {
1771
            ost = ost_table[i];
1772
            if (ost->source_index == ist_index) {
1773
                AVCodecContext *enc= ost->st->codec;
1774
                os = output_files[ost->file_index];
1775

    
1776
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1777
                    continue;
1778
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1779
                    continue;
1780

    
1781
                if (ost->encoding_needed) {
1782
                    for(;;) {
1783
                        AVPacket pkt;
1784
                        int fifo_bytes;
1785
                        av_init_packet(&pkt);
1786
                        pkt.stream_index= ost->index;
1787

    
1788
                        switch(ost->st->codec->codec_type) {
1789
                        case AVMEDIA_TYPE_AUDIO:
1790
                            fifo_bytes = av_fifo_size(ost->fifo);
1791
                            ret = 0;
1792
                            /* encode any samples remaining in fifo */
1793
                            if (fifo_bytes > 0) {
1794
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1795
                                int fs_tmp = enc->frame_size;
1796

    
1797
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1798
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1799
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1800
                                } else { /* pad */
1801
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1802
                                    if (allocated_audio_buf_size < frame_bytes)
1803
                                        ffmpeg_exit(1);
1804
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1805
                                }
1806

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

    
1839
                        if(ret<=0)
1840
                            break;
1841
                        pkt.data= bit_buffer;
1842
                        pkt.size= ret;
1843
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1844
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1845
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1846
                    }
1847
                }
1848
            }
1849
        }
1850
    }
1851

    
1852
    return 0;
1853
 fail_decode:
1854
    return -1;
1855
}
1856

    
1857
static void print_sdp(AVFormatContext **avc, int n)
1858
{
1859
    char sdp[2048];
1860

    
1861
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1862
    printf("SDP:\n%s\n", sdp);
1863
    fflush(stdout);
1864
}
1865

    
1866
static int copy_chapters(int infile, int outfile)
1867
{
1868
    AVFormatContext *is = input_files[infile];
1869
    AVFormatContext *os = output_files[outfile];
1870
    int i;
1871

    
1872
    for (i = 0; i < is->nb_chapters; i++) {
1873
        AVChapter *in_ch = is->chapters[i], *out_ch;
1874
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1875
                                      AV_TIME_BASE_Q, in_ch->time_base);
1876
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1877
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1878

    
1879

    
1880
        if (in_ch->end < ts_off)
1881
            continue;
1882
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1883
            break;
1884

    
1885
        out_ch = av_mallocz(sizeof(AVChapter));
1886
        if (!out_ch)
1887
            return AVERROR(ENOMEM);
1888

    
1889
        out_ch->id        = in_ch->id;
1890
        out_ch->time_base = in_ch->time_base;
1891
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1892
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1893

    
1894
        if (metadata_chapters_autocopy)
1895
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1896

    
1897
        os->nb_chapters++;
1898
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1899
        if (!os->chapters)
1900
            return AVERROR(ENOMEM);
1901
        os->chapters[os->nb_chapters - 1] = out_ch;
1902
    }
1903
    return 0;
1904
}
1905

    
1906
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1907
                                    AVCodecContext *avctx)
1908
{
1909
    char *p;
1910
    int n = 1, i;
1911
    int64_t t;
1912

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

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

    
1950
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1951
    if (!file_table)
1952
        goto fail;
1953

    
1954
    /* input stream init */
1955
    j = 0;
1956
    for(i=0;i<nb_input_files;i++) {
1957
        is = input_files[i];
1958
        file_table[i].ist_index = j;
1959
        file_table[i].nb_streams = is->nb_streams;
1960
        j += is->nb_streams;
1961
    }
1962
    nb_istreams = j;
1963

    
1964
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1965
    if (!ist_table)
1966
        goto fail;
1967

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

    
1985
            if (rate_emu) {
1986
                ist->start = av_gettime();
1987
            }
1988
        }
1989
    }
1990

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

    
2009
    /* Sanity check the mapping args -- do the input files & streams exist? */
2010
    for(i=0;i<nb_stream_maps;i++) {
2011
        int fi = stream_maps[i].file_index;
2012
        int si = stream_maps[i].stream_index;
2013

    
2014
        if (fi < 0 || fi > nb_input_files - 1 ||
2015
            si < 0 || si > file_table[fi].nb_streams - 1) {
2016
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2017
            ret = AVERROR(EINVAL);
2018
            goto fail;
2019
        }
2020
        fi = stream_maps[i].sync_file_index;
2021
        si = stream_maps[i].sync_stream_index;
2022
        if (fi < 0 || fi > nb_input_files - 1 ||
2023
            si < 0 || si > file_table[fi].nb_streams - 1) {
2024
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2025
            ret = AVERROR(EINVAL);
2026
            goto fail;
2027
        }
2028
    }
2029

    
2030
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2031
    if (!ost_table)
2032
        goto fail;
2033
    n = 0;
2034
    for(k=0;k<nb_output_files;k++) {
2035
        os = output_files[k];
2036
        for(i=0;i<os->nb_streams;i++,n++) {
2037
            int found;
2038
            ost = ost_table[n] = output_streams_for_file[k][i];
2039
            ost->st = os->streams[i];
2040
            if (nb_stream_maps > 0) {
2041
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2042
                    stream_maps[n].stream_index;
2043

    
2044
                /* Sanity check that the stream types match */
2045
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2046
                    int i= ost->file_index;
2047
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2048
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2049
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2050
                        ost->file_index, ost->index);
2051
                    ffmpeg_exit(1);
2052
                }
2053

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

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

    
2113
    /* for each output stream, we compute the right encoding parameters */
2114
    for(i=0;i<nb_ostreams;i++) {
2115
        ost = ost_table[i];
2116
        os = output_files[ost->file_index];
2117
        ist = ist_table[ost->source_index];
2118

    
2119
        codec = ost->st->codec;
2120
        icodec = ist->st->codec;
2121

    
2122
        if (metadata_streams_autocopy)
2123
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2124
                             AV_METADATA_DONT_OVERWRITE);
2125

    
2126
        ost->st->disposition = ist->st->disposition;
2127
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2128
        codec->chroma_sample_location = icodec->chroma_sample_location;
2129

    
2130
        if (ost->st->stream_copy) {
2131
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2132

    
2133
            if (extra_size > INT_MAX)
2134
                goto fail;
2135

    
2136
            /* if stream_copy is selected, no need to decode or encode */
2137
            codec->codec_id = icodec->codec_id;
2138
            codec->codec_type = icodec->codec_type;
2139

    
2140
            if(!codec->codec_tag){
2141
                if(   !os->oformat->codec_tag
2142
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2143
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2144
                    codec->codec_tag = icodec->codec_tag;
2145
            }
2146

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

    
2236
                    ost->original_height = icodec->height;
2237
                    ost->original_width  = icodec->width;
2238
#endif
2239
                    codec->bits_per_raw_sample= 0;
2240
                }
2241
                ost->resample_height = icodec->height;
2242
                ost->resample_width  = icodec->width;
2243
                ost->resample_pix_fmt= icodec->pix_fmt;
2244
                ost->encoding_needed = 1;
2245
                ist->decoding_needed = 1;
2246

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

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

    
2295
    if (!bit_buffer)
2296
        bit_buffer = av_malloc(bit_buffer_size);
2297
    if (!bit_buffer) {
2298
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2299
                bit_buffer_size);
2300
        ret = AVERROR(ENOMEM);
2301
        goto fail;
2302
    }
2303

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

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

    
2361
    /* init pts */
2362
    for(i=0;i<nb_istreams;i++) {
2363
        AVStream *st;
2364
        ist = ist_table[i];
2365
        st= ist->st;
2366
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2367
        ist->next_pts = AV_NOPTS_VALUE;
2368
        ist->is_start = 1;
2369
    }
2370

    
2371
    /* set meta data information from input file if required */
2372
    for (i=0;i<nb_meta_data_maps;i++) {
2373
        AVFormatContext *files[2];
2374
        AVMetadata      **meta[2];
2375
        int j;
2376

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

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

    
2392
        files[0] = output_files[out_file_index];
2393
        files[1] = input_files[in_file_index];
2394

    
2395
        for (j = 0; j < 2; j++) {
2396
            AVMetaDataMap *map = &meta_data_maps[i][j];
2397

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

    
2417
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2418
    }
2419

    
2420
    /* copy global metadata by default */
2421
    if (metadata_global_autocopy) {
2422

    
2423
        for (i = 0; i < nb_output_files; i++)
2424
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2425
                             AV_METADATA_DONT_OVERWRITE);
2426
    }
2427

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

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

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

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

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

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

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

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

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

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

    
2513
    timer_start = av_gettime();
2514

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2654
    discard_packet:
2655
        av_free_packet(&pkt);
2656

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

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

    
2669
    term_exit();
2670

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

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

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

    
2692
    /* close each decoder */
2693
    for(i=0;i<nb_istreams;i++) {
2694
        ist = ist_table[i];
2695
        if (ist->decoding_needed) {
2696
            avcodec_close(ist->st->codec);
2697
        }
2698
    }
2699

    
2700
    /* finished ! */
2701
    ret = 0;
2702

    
2703
 fail:
2704
    av_freep(&bit_buffer);
2705
    av_free(file_table);
2706

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

    
2743
static void opt_format(const char *arg)
2744
{
2745
    last_asked_format = arg;
2746
}
2747

    
2748
static void opt_video_rc_override_string(const char *arg)
2749
{
2750
    video_rc_override_string = arg;
2751
}
2752

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

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

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

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

    
2778
    opt_default(opt, arg);
2779

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

    
2783
    return 0;
2784
}
2785

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

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

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

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

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

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

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

    
2843
static int opt_metadata(const char *opt, const char *arg)
2844
{
2845
    char *mid= strchr(arg, '=');
2846

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

    
2853
    av_metadata_set2(&metadata, arg, mid, 0);
2854

    
2855
    return 0;
2856
}
2857

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

    
2868
static void opt_top_field_first(const char *arg)
2869
{
2870
    top_field_first= atoi(arg);
2871
}
2872

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

    
2883
static void opt_audio_sample_fmt(const char *arg)
2884
{
2885
    if (strcmp(arg, "list")) {
2886
        audio_sample_fmt = av_get_sample_fmt(arg);
2887
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2888
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2889
            ffmpeg_exit(1);
2890
        }
2891
    } else {
2892
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2893
        ffmpeg_exit(0);
2894
    }
2895
}
2896

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

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

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

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

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

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

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

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

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

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

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

    
2960
    return 0;
2961
}
2962

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

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

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

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

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

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

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

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

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

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

    
3035
static void opt_map_meta_data(const char *arg)
3036
{
3037
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3038
                    "Use -map_metadata instead.\n");
3039
    opt_map_metadata(arg);
3040
}
3041

    
3042
static void opt_map_chapters(const char *arg)
3043
{
3044
    AVChapterMap *c;
3045
    char *p;
3046

    
3047
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3048
                              nb_chapter_maps + 1);
3049
    c = &chapter_maps[nb_chapter_maps - 1];
3050
    c->out_file = strtol(arg, &p, 0);
3051
    if (*p)
3052
        p++;
3053

    
3054
    c->in_file = strtol(p, &p, 0);
3055
}
3056

    
3057
static void opt_input_ts_scale(const char *arg)
3058
{
3059
    unsigned int stream;
3060
    double scale;
3061
    char *p;
3062

    
3063
    stream = strtol(arg, &p, 0);
3064
    if (*p)
3065
        p++;
3066
    scale= strtod(p, &p);
3067

    
3068
    if(stream >= MAX_STREAMS)
3069
        ffmpeg_exit(1);
3070

    
3071
    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);
3072
    input_files_ts_scale[nb_input_files][stream]= scale;
3073
}
3074

    
3075
static int opt_recording_time(const char *opt, const char *arg)
3076
{
3077
    recording_time = parse_time_or_die(opt, arg, 1);
3078
    return 0;
3079
}
3080

    
3081
static int opt_start_time(const char *opt, const char *arg)
3082
{
3083
    start_time = parse_time_or_die(opt, arg, 1);
3084
    return 0;
3085
}
3086

    
3087
static int opt_recording_timestamp(const char *opt, const char *arg)
3088
{
3089
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3090
    return 0;
3091
}
3092

    
3093
static int opt_input_ts_offset(const char *opt, const char *arg)
3094
{
3095
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3096
    return 0;
3097
}
3098

    
3099
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3100
{
3101
    const char *codec_string = encoder ? "encoder" : "decoder";
3102
    AVCodec *codec;
3103

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

    
3133
static void opt_input_file(const char *filename)
3134
{
3135
    AVFormatContext *ic;
3136
    AVFormatParameters params, *ap = &params;
3137
    AVInputFormat *file_iformat = NULL;
3138
    int err, i, ret, rfps, rfps_base;
3139
    int64_t timestamp;
3140

    
3141
    if (last_asked_format) {
3142
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3143
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3144
            ffmpeg_exit(1);
3145
        }
3146
        last_asked_format = NULL;
3147
    }
3148

    
3149
    if (!strcmp(filename, "-"))
3150
        filename = "pipe:";
3151

    
3152
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3153
                    !strcmp(filename, "/dev/stdin");
3154

    
3155
    /* get default parameters from command line */
3156
    ic = avformat_alloc_context();
3157
    if (!ic) {
3158
        print_error(filename, AVERROR(ENOMEM));
3159
        ffmpeg_exit(1);
3160
    }
3161

    
3162
    memset(ap, 0, sizeof(*ap));
3163
    ap->prealloced_context = 1;
3164
    ap->sample_rate = audio_sample_rate;
3165
    ap->channels = audio_channels;
3166
    ap->time_base.den = frame_rate.num;
3167
    ap->time_base.num = frame_rate.den;
3168
    ap->width = frame_width;
3169
    ap->height = frame_height;
3170
    ap->pix_fmt = frame_pix_fmt;
3171
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3172
    ap->channel = video_channel;
3173
    ap->standard = video_standard;
3174

    
3175
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3176

    
3177
    ic->video_codec_id   =
3178
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3179
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3180
    ic->audio_codec_id   =
3181
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3182
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3183
    ic->subtitle_codec_id=
3184
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3185
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3186
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3187

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

    
3218
    ic->loop_input = loop_input;
3219

    
3220
    /* If not enough info to get the stream parameters, we decode the
3221
       first frames to get it. (used in mpeg case for example) */
3222
    ret = av_find_stream_info(ic);
3223
    if (ret < 0 && verbose >= 0) {
3224
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3225
        av_close_input_file(ic);
3226
        ffmpeg_exit(1);
3227
    }
3228

    
3229
    timestamp = start_time;
3230
    /* add the stream start time */
3231
    if (ic->start_time != AV_NOPTS_VALUE)
3232
        timestamp += ic->start_time;
3233

    
3234
    /* if seeking requested, we execute it */
3235
    if (start_time != 0) {
3236
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3237
        if (ret < 0) {
3238
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3239
                    filename, (double)timestamp / AV_TIME_BASE);
3240
        }
3241
        /* reset seek info */
3242
        start_time = 0;
3243
    }
3244

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

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

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

    
3297
                    (float)rfps / rfps_base, rfps, rfps_base);
3298
            }
3299
            /* update the current frame rate to match the stream frame rate */
3300
            frame_rate.num = rfps;
3301
            frame_rate.den = rfps_base;
3302

    
3303
            if(video_disable)
3304
                st->discard= AVDISCARD_ALL;
3305
            else if(video_discard)
3306
                st->discard= video_discard;
3307
            break;
3308
        case AVMEDIA_TYPE_DATA:
3309
            break;
3310
        case AVMEDIA_TYPE_SUBTITLE:
3311
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3312
            if(subtitle_disable)
3313
                st->discard = AVDISCARD_ALL;
3314
            break;
3315
        case AVMEDIA_TYPE_ATTACHMENT:
3316
        case AVMEDIA_TYPE_UNKNOWN:
3317
            break;
3318
        default:
3319
            abort();
3320
        }
3321
    }
3322

    
3323
    input_files[nb_input_files] = ic;
3324
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3325
    /* dump the file content */
3326
    if (verbose >= 0)
3327
        av_dump_format(ic, nb_input_files, filename, 0);
3328

    
3329
    nb_input_files++;
3330

    
3331
    video_channel = 0;
3332

    
3333
    av_freep(&video_codec_name);
3334
    av_freep(&audio_codec_name);
3335
    av_freep(&subtitle_codec_name);
3336
}
3337

    
3338
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3339
                                         int *has_subtitle_ptr)
3340
{
3341
    int has_video, has_audio, has_subtitle, i, j;
3342
    AVFormatContext *ic;
3343

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

    
3375
static void new_video_stream(AVFormatContext *oc, int file_idx)
3376
{
3377
    AVStream *st;
3378
    AVOutputStream *ost;
3379
    AVCodecContext *video_enc;
3380
    enum CodecID codec_id = CODEC_ID_NONE;
3381
    AVCodec *codec= NULL;
3382
    int i;
3383

    
3384
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3385
    if (!st) {
3386
        fprintf(stderr, "Could not alloc stream\n");
3387
        ffmpeg_exit(1);
3388
    }
3389
    ost = new_output_stream(oc, file_idx);
3390

    
3391
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3392
    if(!video_stream_copy){
3393
        if (video_codec_name) {
3394
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3395
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3396
            codec = avcodec_find_encoder_by_name(video_codec_name);
3397
            output_codecs[nb_output_codecs-1] = codec;
3398
        } else {
3399
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3400
            codec = avcodec_find_encoder(codec_id);
3401
        }
3402

    
3403
        if(frame_aspect_ratio > 0){
3404
            i = vfilters ? strlen(vfilters) : 0;
3405
            vfilters = av_realloc(vfilters, i+100);
3406
            snprintf(vfilters+i, i+100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3407
            frame_aspect_ratio=0;
3408
        }
3409

    
3410
        ost->avfilter= vfilters;
3411
        vfilters= NULL;
3412
    }
3413

    
3414
    avcodec_get_context_defaults3(st->codec, codec);
3415
    ost->bitstream_filters = video_bitstream_filters;
3416
    video_bitstream_filters= NULL;
3417

    
3418
    st->codec->thread_count= thread_count;
3419

    
3420
    video_enc = st->codec;
3421

    
3422
    if(video_codec_tag)
3423
        video_enc->codec_tag= video_codec_tag;
3424

    
3425
    if(   (video_global_header&1)
3426
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3427
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3428
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3429
    }
3430
    if(video_global_header&2){
3431
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3432
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3433
    }
3434

    
3435
    if (video_stream_copy) {
3436
        st->stream_copy = 1;
3437
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3438
        video_enc->sample_aspect_ratio =
3439
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3440
    } else {
3441
        const char *p;
3442
        int i;
3443
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3444

    
3445
        video_enc->codec_id = codec_id;
3446
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3447

    
3448
        if (codec && codec->supported_framerates && !force_fps)
3449
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3450
        video_enc->time_base.den = fps.num;
3451
        video_enc->time_base.num = fps.den;
3452

    
3453
        video_enc->width = frame_width;
3454
        video_enc->height = frame_height;
3455
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3456
        video_enc->pix_fmt = frame_pix_fmt;
3457
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3458

    
3459
        choose_pixel_fmt(st, codec);
3460

    
3461
        if (intra_only)
3462
            video_enc->gop_size = 0;
3463
        if (video_qscale || same_quality) {
3464
            video_enc->flags |= CODEC_FLAG_QSCALE;
3465
            video_enc->global_quality=
3466
                st->quality = FF_QP2LAMBDA * video_qscale;
3467
        }
3468

    
3469
        if(intra_matrix)
3470
            video_enc->intra_matrix = intra_matrix;
3471
        if(inter_matrix)
3472
            video_enc->inter_matrix = inter_matrix;
3473

    
3474
        p= video_rc_override_string;
3475
        for(i=0; p; i++){
3476
            int start, end, q;
3477
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3478
            if(e!=3){
3479
                fprintf(stderr, "error parsing rc_override\n");
3480
                ffmpeg_exit(1);
3481
            }
3482
            video_enc->rc_override=
3483
                av_realloc(video_enc->rc_override,
3484
                           sizeof(RcOverride)*(i+1));
3485
            video_enc->rc_override[i].start_frame= start;
3486
            video_enc->rc_override[i].end_frame  = end;
3487
            if(q>0){
3488
                video_enc->rc_override[i].qscale= q;
3489
                video_enc->rc_override[i].quality_factor= 1.0;
3490
            }
3491
            else{
3492
                video_enc->rc_override[i].qscale= 0;
3493
                video_enc->rc_override[i].quality_factor= -q/100.0;
3494
            }
3495
            p= strchr(p, '/');
3496
            if(p) p++;
3497
        }
3498
        video_enc->rc_override_count=i;
3499
        if (!video_enc->rc_initial_buffer_occupancy)
3500
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3501
        video_enc->me_threshold= me_threshold;
3502
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3503

    
3504
        if (do_psnr)
3505
            video_enc->flags|= CODEC_FLAG_PSNR;
3506

    
3507
        /* two pass mode */
3508
        if (do_pass) {
3509
            if (do_pass == 1) {
3510
                video_enc->flags |= CODEC_FLAG_PASS1;
3511
            } else {
3512
                video_enc->flags |= CODEC_FLAG_PASS2;
3513
            }
3514
        }
3515

    
3516
        if (forced_key_frames)
3517
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3518
    }
3519
    if (video_language) {
3520
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3521
        av_freep(&video_language);
3522
    }
3523

    
3524
    /* reset some key parameters */
3525
    video_disable = 0;
3526
    av_freep(&video_codec_name);
3527
    av_freep(&forced_key_frames);
3528
    video_stream_copy = 0;
3529
    frame_pix_fmt = PIX_FMT_NONE;
3530
}
3531

    
3532
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3533
{
3534
    AVStream *st;
3535
    AVOutputStream *ost;
3536
    AVCodec *codec= NULL;
3537
    AVCodecContext *audio_enc;
3538
    enum CodecID codec_id = CODEC_ID_NONE;
3539

    
3540
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3541
    if (!st) {
3542
        fprintf(stderr, "Could not alloc stream\n");
3543
        ffmpeg_exit(1);
3544
    }
3545
    ost = new_output_stream(oc, file_idx);
3546

    
3547
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3548
    if(!audio_stream_copy){
3549
        if (audio_codec_name) {
3550
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3551
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3552
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3553
            output_codecs[nb_output_codecs-1] = codec;
3554
        } else {
3555
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3556
            codec = avcodec_find_encoder(codec_id);
3557
        }
3558
    }
3559

    
3560
    avcodec_get_context_defaults3(st->codec, codec);
3561

    
3562
    ost->bitstream_filters = audio_bitstream_filters;
3563
    audio_bitstream_filters= NULL;
3564

    
3565
    st->codec->thread_count= thread_count;
3566

    
3567
    audio_enc = st->codec;
3568
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3569

    
3570
    if(audio_codec_tag)
3571
        audio_enc->codec_tag= audio_codec_tag;
3572

    
3573
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3574
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3576
    }
3577
    if (audio_stream_copy) {
3578
        st->stream_copy = 1;
3579
        audio_enc->channels = audio_channels;
3580
        audio_enc->sample_rate = audio_sample_rate;
3581
    } else {
3582
        audio_enc->codec_id = codec_id;
3583
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3584

    
3585
        if (audio_qscale > QSCALE_NONE) {
3586
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3587
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3588
        }
3589
        audio_enc->channels = audio_channels;
3590
        audio_enc->sample_fmt = audio_sample_fmt;
3591
        audio_enc->sample_rate = audio_sample_rate;
3592
        audio_enc->channel_layout = channel_layout;
3593
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3594
            audio_enc->channel_layout = 0;
3595
        choose_sample_fmt(st, codec);
3596
        choose_sample_rate(st, codec);
3597
    }
3598
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3599
    if (audio_language) {
3600
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3601
        av_freep(&audio_language);
3602
    }
3603

    
3604
    /* reset some key parameters */
3605
    audio_disable = 0;
3606
    av_freep(&audio_codec_name);
3607
    audio_stream_copy = 0;
3608
}
3609

    
3610
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3611
{
3612
    AVStream *st;
3613
    AVOutputStream *ost;
3614
    AVCodec *codec=NULL;
3615
    AVCodecContext *subtitle_enc;
3616
    enum CodecID codec_id = CODEC_ID_NONE;
3617

    
3618
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3619
    if (!st) {
3620
        fprintf(stderr, "Could not alloc stream\n");
3621
        ffmpeg_exit(1);
3622
    }
3623
    ost = new_output_stream(oc, file_idx);
3624
    subtitle_enc = st->codec;
3625
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3626
    if(!subtitle_stream_copy){
3627
        if (subtitle_codec_name) {
3628
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3629
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3630
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3631
        } else {
3632
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3633
            codec = avcodec_find_encoder(codec_id);
3634
        }
3635
    }
3636
    avcodec_get_context_defaults3(st->codec, codec);
3637

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

    
3641
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3642

    
3643
    if(subtitle_codec_tag)
3644
        subtitle_enc->codec_tag= subtitle_codec_tag;
3645

    
3646
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3647
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3648
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3649
    }
3650
    if (subtitle_stream_copy) {
3651
        st->stream_copy = 1;
3652
    } else {
3653
        subtitle_enc->codec_id = codec_id;
3654
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3655
    }
3656

    
3657
    if (subtitle_language) {
3658
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3659
        av_freep(&subtitle_language);
3660
    }
3661

    
3662
    subtitle_disable = 0;
3663
    av_freep(&subtitle_codec_name);
3664
    subtitle_stream_copy = 0;
3665
}
3666

    
3667
static int opt_new_stream(const char *opt, const char *arg)
3668
{
3669
    AVFormatContext *oc;
3670
    int file_idx = nb_output_files - 1;
3671
    if (nb_output_files <= 0) {
3672
        fprintf(stderr, "At least one output file must be specified\n");
3673
        ffmpeg_exit(1);
3674
    }
3675
    oc = output_files[file_idx];
3676

    
3677
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3678
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3679
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3680
    else av_assert0(0);
3681
    return 0;
3682
}
3683

    
3684
/* arg format is "output-stream-index:streamid-value". */
3685
static int opt_streamid(const char *opt, const char *arg)
3686
{
3687
    int idx;
3688
    char *p;
3689
    char idx_str[16];
3690

    
3691
    strncpy(idx_str, arg, sizeof(idx_str));
3692
    idx_str[sizeof(idx_str)-1] = '\0';
3693
    p = strchr(idx_str, ':');
3694
    if (!p) {
3695
        fprintf(stderr,
3696
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3697
                arg, opt);
3698
        ffmpeg_exit(1);
3699
    }
3700
    *p++ = '\0';
3701
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3702
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3703
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3704
    return 0;
3705
}
3706

    
3707
static void opt_output_file(const char *filename)
3708
{
3709
    AVFormatContext *oc;
3710
    int err, use_video, use_audio, use_subtitle;
3711
    int input_has_video, input_has_audio, input_has_subtitle;
3712
    AVFormatParameters params, *ap = &params;
3713
    AVOutputFormat *file_oformat;
3714

    
3715
    if (!strcmp(filename, "-"))
3716
        filename = "pipe:";
3717

    
3718
    oc = avformat_alloc_context();
3719
    if (!oc) {
3720
        print_error(filename, AVERROR(ENOMEM));
3721
        ffmpeg_exit(1);
3722
    }
3723

    
3724
    if (last_asked_format) {
3725
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3726
        if (!file_oformat) {
3727
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3728
            ffmpeg_exit(1);
3729
        }
3730
        last_asked_format = NULL;
3731
    } else {
3732
        file_oformat = av_guess_format(NULL, filename, NULL);
3733
        if (!file_oformat) {
3734
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3735
                    filename);
3736
            ffmpeg_exit(1);
3737
        }
3738
    }
3739

    
3740
    oc->oformat = file_oformat;
3741
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3742

    
3743
    if (!strcmp(file_oformat->name, "ffm") &&
3744
        av_strstart(filename, "http:", NULL)) {
3745
        /* special case for files sent to ffserver: we get the stream
3746
           parameters from ffserver */
3747
        int err = read_ffserver_streams(oc, filename);
3748
        if (err < 0) {
3749
            print_error(filename, err);
3750
            ffmpeg_exit(1);
3751
        }
3752
    } else {
3753
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3754
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3755
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3756

    
3757
        /* disable if no corresponding type found and at least one
3758
           input file */
3759
        if (nb_input_files > 0) {
3760
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3761
                                         &input_has_subtitle);
3762
            if (!input_has_video)
3763
                use_video = 0;
3764
            if (!input_has_audio)
3765
                use_audio = 0;
3766
            if (!input_has_subtitle)
3767
                use_subtitle = 0;
3768
        }
3769

    
3770
        /* manual disable */
3771
        if (audio_disable)    use_audio    = 0;
3772
        if (video_disable)    use_video    = 0;
3773
        if (subtitle_disable) use_subtitle = 0;
3774

    
3775
        if (use_video)    new_video_stream(oc, nb_output_files);
3776
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3777
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3778

    
3779
        oc->timestamp = recording_timestamp;
3780

    
3781
        av_metadata_copy(&oc->metadata, metadata, 0);
3782
        av_metadata_free(&metadata);
3783
    }
3784

    
3785
    output_files[nb_output_files++] = oc;
3786

    
3787
    /* check filename in case of an image number is expected */
3788
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3789
        if (!av_filename_number_test(oc->filename)) {
3790
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3791
            ffmpeg_exit(1);
3792
        }
3793
    }
3794

    
3795
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3796
        /* test if it already exists to avoid loosing precious files */
3797
        if (!file_overwrite &&
3798
            (strchr(filename, ':') == NULL ||
3799
             filename[1] == ':' ||
3800
             av_strstart(filename, "file:", NULL))) {
3801
            if (url_exist(filename)) {
3802
                if (!using_stdin) {
3803
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3804
                    fflush(stderr);
3805
                    if (!read_yesno()) {
3806
                        fprintf(stderr, "Not overwriting - exiting\n");
3807
                        ffmpeg_exit(1);
3808
                    }
3809
                }
3810
                else {
3811
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3812
                    ffmpeg_exit(1);
3813
                }
3814
            }
3815
        }
3816

    
3817
        /* open the file */
3818
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3819
            print_error(filename, err);
3820
            ffmpeg_exit(1);
3821
        }
3822
    }
3823

    
3824
    memset(ap, 0, sizeof(*ap));
3825
    if (av_set_parameters(oc, ap) < 0) {
3826
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3827
                oc->filename);
3828
        ffmpeg_exit(1);
3829
    }
3830

    
3831
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3832
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3833
    oc->loop_output = loop_output;
3834
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3835

    
3836
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3837

    
3838
    av_freep(&forced_key_frames);
3839
}
3840

    
3841
/* same option as mencoder */
3842
static void opt_pass(const char *pass_str)
3843
{
3844
    int pass;
3845
    pass = atoi(pass_str);
3846
    if (pass != 1 && pass != 2) {
3847
        fprintf(stderr, "pass number can be only 1 or 2\n");
3848
        ffmpeg_exit(1);
3849
    }
3850
    do_pass = pass;
3851
}
3852

    
3853
static int64_t getutime(void)
3854
{
3855
#if HAVE_GETRUSAGE
3856
    struct rusage rusage;
3857

    
3858
    getrusage(RUSAGE_SELF, &rusage);
3859
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3860
#elif HAVE_GETPROCESSTIMES
3861
    HANDLE proc;
3862
    FILETIME c, e, k, u;
3863
    proc = GetCurrentProcess();
3864
    GetProcessTimes(proc, &c, &e, &k, &u);
3865
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3866
#else
3867
    return av_gettime();
3868
#endif
3869
}
3870

    
3871
static int64_t getmaxrss(void)
3872
{
3873
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3874
    struct rusage rusage;
3875
    getrusage(RUSAGE_SELF, &rusage);
3876
    return (int64_t)rusage.ru_maxrss * 1024;
3877
#elif HAVE_GETPROCESSMEMORYINFO
3878
    HANDLE proc;
3879
    PROCESS_MEMORY_COUNTERS memcounters;
3880
    proc = GetCurrentProcess();
3881
    memcounters.cb = sizeof(memcounters);
3882
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3883
    return memcounters.PeakPagefileUsage;
3884
#else
3885
    return 0;
3886
#endif
3887
}
3888

    
3889
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3890
{
3891
    int i;
3892
    const char *p = str;
3893
    for(i = 0;; i++) {
3894
        dest[i] = atoi(p);
3895
        if(i == 63)
3896
            break;
3897
        p = strchr(p, ',');
3898
        if(!p) {
3899
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3900
            ffmpeg_exit(1);
3901
        }
3902
        p++;
3903
    }
3904
}
3905

    
3906
static void opt_inter_matrix(const char *arg)
3907
{
3908
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3909
    parse_matrix_coeffs(inter_matrix, arg);
3910
}
3911

    
3912
static void opt_intra_matrix(const char *arg)
3913
{
3914
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3915
    parse_matrix_coeffs(intra_matrix, arg);
3916
}
3917

    
3918
static void show_usage(void)
3919
{
3920
    printf("Hyper fast Audio and Video encoder\n");
3921
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3922
    printf("\n");
3923
}
3924

    
3925
static void show_help(void)
3926
{
3927
    AVCodec *c;
3928
    AVOutputFormat *oformat = NULL;
3929

    
3930
    av_log_set_callback(log_callback_help);
3931
    show_usage();
3932
    show_help_options(options, "Main options:\n",
3933
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3934
    show_help_options(options, "\nAdvanced options:\n",
3935
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3936
                      OPT_EXPERT);
3937
    show_help_options(options, "\nVideo options:\n",
3938
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3939
                      OPT_VIDEO);
3940
    show_help_options(options, "\nAdvanced Video options:\n",
3941
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3942
                      OPT_VIDEO | OPT_EXPERT);
3943
    show_help_options(options, "\nAudio options:\n",
3944
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3945
                      OPT_AUDIO);
3946
    show_help_options(options, "\nAdvanced Audio options:\n",
3947
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3948
                      OPT_AUDIO | OPT_EXPERT);
3949
    show_help_options(options, "\nSubtitle options:\n",
3950
                      OPT_SUBTITLE | OPT_GRAB,
3951
                      OPT_SUBTITLE);
3952
    show_help_options(options, "\nAudio/Video grab options:\n",
3953
                      OPT_GRAB,
3954
                      OPT_GRAB);
3955
    printf("\n");
3956
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3957
    printf("\n");
3958

    
3959
    /* individual codec options */
3960
    c = NULL;
3961
    while ((c = av_codec_next(c))) {
3962
        if (c->priv_class) {
3963
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3964
            printf("\n");
3965
        }
3966
    }
3967

    
3968
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3969
    printf("\n");
3970

    
3971
    /* individual muxer options */
3972
    while ((oformat = av_oformat_next(oformat))) {
3973
        if (oformat->priv_class) {
3974
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3975
            printf("\n");
3976
        }
3977
    }
3978

    
3979
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3980
}
3981

    
3982
static void opt_target(const char *arg)
3983
{
3984
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3985
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3986

    
3987
    if(!strncmp(arg, "pal-", 4)) {
3988
        norm = PAL;
3989
        arg += 4;
3990
    } else if(!strncmp(arg, "ntsc-", 5)) {
3991
        norm = NTSC;
3992
        arg += 5;
3993
    } else if(!strncmp(arg, "film-", 5)) {
3994
        norm = FILM;
3995
        arg += 5;
3996
    } else {
3997
        int fr;
3998
        /* Calculate FR via float to avoid int overflow */
3999
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4000
        if(fr == 25000) {
4001
            norm = PAL;
4002
        } else if((fr == 29970) || (fr == 23976)) {
4003
            norm = NTSC;
4004
        } else {
4005
            /* Try to determine PAL/NTSC by peeking in the input files */
4006
            if(nb_input_files) {
4007
                int i, j;
4008
                for(j = 0; j < nb_input_files; j++) {
4009
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4010
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4011
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4012
                            continue;
4013
                        fr = c->time_base.den * 1000 / c->time_base.num;
4014
                        if(fr == 25000) {
4015
                            norm = PAL;
4016
                            break;
4017
                        } else if((fr == 29970) || (fr == 23976)) {
4018
                            norm = NTSC;
4019
                            break;
4020
                        }
4021
                    }
4022
                    if(norm != UNKNOWN)
4023
                        break;
4024
                }
4025
            }
4026
        }
4027
        if(verbose && norm != UNKNOWN)
4028
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4029
    }
4030

    
4031
    if(norm == UNKNOWN) {
4032
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4033
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4034
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4035
        ffmpeg_exit(1);
4036
    }
4037

    
4038
    if(!strcmp(arg, "vcd")) {
4039

    
4040
        opt_video_codec("mpeg1video");
4041
        opt_audio_codec("mp2");
4042
        opt_format("vcd");
4043

    
4044
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4045
        opt_frame_rate(NULL, frame_rates[norm]);
4046
        opt_default("g", norm == PAL ? "15" : "18");
4047

    
4048
        opt_default("b", "1150000");
4049
        opt_default("maxrate", "1150000");
4050
        opt_default("minrate", "1150000");
4051
        opt_default("bufsize", "327680"); // 40*1024*8;
4052

    
4053
        opt_default("ab", "224000");
4054
        audio_sample_rate = 44100;
4055
        audio_channels = 2;
4056

    
4057
        opt_default("packetsize", "2324");
4058
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4059

    
4060
        /* We have to offset the PTS, so that it is consistent with the SCR.
4061
           SCR starts at 36000, but the first two packs contain only padding
4062
           and the first pack from the other stream, respectively, may also have
4063
           been written before.
4064
           So the real data starts at SCR 36000+3*1200. */
4065
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4066
    } else if(!strcmp(arg, "svcd")) {
4067

    
4068
        opt_video_codec("mpeg2video");
4069
        opt_audio_codec("mp2");
4070
        opt_format("svcd");
4071

    
4072
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4073
        opt_frame_rate(NULL, frame_rates[norm]);
4074
        opt_default("g", norm == PAL ? "15" : "18");
4075

    
4076
        opt_default("b", "2040000");
4077
        opt_default("maxrate", "2516000");
4078
        opt_default("minrate", "0"); //1145000;
4079
        opt_default("bufsize", "1835008"); //224*1024*8;
4080
        opt_default("flags", "+scan_offset");
4081

    
4082

    
4083
        opt_default("ab", "224000");
4084
        audio_sample_rate = 44100;
4085

    
4086
        opt_default("packetsize", "2324");
4087

    
4088
    } else if(!strcmp(arg, "dvd")) {
4089

    
4090
        opt_video_codec("mpeg2video");
4091
        opt_audio_codec("ac3");
4092
        opt_format("dvd");
4093

    
4094
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4095
        opt_frame_rate(NULL, frame_rates[norm]);
4096
        opt_default("g", norm == PAL ? "15" : "18");
4097

    
4098
        opt_default("b", "6000000");
4099
        opt_default("maxrate", "9000000");
4100
        opt_default("minrate", "0"); //1500000;
4101
        opt_default("bufsize", "1835008"); //224*1024*8;
4102

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

    
4106
        opt_default("ab", "448000");
4107
        audio_sample_rate = 48000;
4108

    
4109
    } else if(!strncmp(arg, "dv", 2)) {
4110

    
4111
        opt_format("dv");
4112

    
4113
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4114
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4115
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4116
        opt_frame_rate(NULL, frame_rates[norm]);
4117

    
4118
        audio_sample_rate = 48000;
4119
        audio_channels = 2;
4120

    
4121
    } else {
4122
        fprintf(stderr, "Unknown target: %s\n", arg);
4123
        ffmpeg_exit(1);
4124
    }
4125
}
4126

    
4127
static void opt_vstats_file (const char *arg)
4128
{
4129
    av_free (vstats_filename);
4130
    vstats_filename=av_strdup (arg);
4131
}
4132

    
4133
static void opt_vstats (void)
4134
{
4135
    char filename[40];
4136
    time_t today2 = time(NULL);
4137
    struct tm *today = localtime(&today2);
4138

    
4139
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4140
             today->tm_sec);
4141
    opt_vstats_file(filename);
4142
}
4143

    
4144
static int opt_bsf(const char *opt, const char *arg)
4145
{
4146
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4147
    AVBitStreamFilterContext **bsfp;
4148

    
4149
    if(!bsfc){
4150
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4151
        ffmpeg_exit(1);
4152
    }
4153

    
4154
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4155
          *opt == 'a' ? &audio_bitstream_filters :
4156
                        &subtitle_bitstream_filters;
4157
    while(*bsfp)
4158
        bsfp= &(*bsfp)->next;
4159

    
4160
    *bsfp= bsfc;
4161

    
4162
    return 0;
4163
}
4164

    
4165
static int opt_preset(const char *opt, const char *arg)
4166
{
4167
    FILE *f=NULL;
4168
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4169
    char *codec_name = *opt == 'v' ? video_codec_name :
4170
                       *opt == 'a' ? audio_codec_name :
4171
                                     subtitle_codec_name;
4172

    
4173
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4174
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4175
        ffmpeg_exit(1);
4176
    }
4177

    
4178
    while(!feof(f)){
4179
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4180
        if(line[0] == '#' && !e)
4181
            continue;
4182
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4183
        if(e){
4184
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4185
            ffmpeg_exit(1);
4186
        }
4187
        if(!strcmp(tmp, "acodec")){
4188
            opt_audio_codec(tmp2);
4189
        }else if(!strcmp(tmp, "vcodec")){
4190
            opt_video_codec(tmp2);
4191
        }else if(!strcmp(tmp, "scodec")){
4192
            opt_subtitle_codec(tmp2);
4193
        }else if(opt_default(tmp, tmp2) < 0){
4194
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4195
            ffmpeg_exit(1);
4196
        }
4197
    }
4198

    
4199
    fclose(f);
4200

    
4201
    return 0;
4202
}
4203

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

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

    
4297
    /* audio options */
4298
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4299
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4300
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4301
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4302
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4303
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4304
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4305
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4306
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4307
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4308
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4309
    { "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" },
4310

    
4311
    /* subtitle options */
4312
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4313
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4314
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4315
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4316
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4317

    
4318
    /* grab options */
4319
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4320
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4321
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4322

    
4323
    /* muxer options */
4324
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4325
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4326

    
4327
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4328
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4329
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4330

    
4331
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4332
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4333
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4334
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4335

    
4336
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4337
    { NULL, },
4338
};
4339

    
4340
int main(int argc, char **argv)
4341
{
4342
    int64_t ti;
4343

    
4344
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4345

    
4346
    avcodec_register_all();
4347
#if CONFIG_AVDEVICE
4348
    avdevice_register_all();
4349
#endif
4350
#if CONFIG_AVFILTER
4351
    avfilter_register_all();
4352
#endif
4353
    av_register_all();
4354

    
4355
#if HAVE_ISATTY
4356
    if(isatty(STDIN_FILENO))
4357
        url_set_interrupt_cb(decode_interrupt_cb);
4358
#endif
4359

    
4360
    init_opts();
4361

    
4362
    show_banner();
4363

    
4364
    /* parse options */
4365
    parse_options(argc, argv, options, opt_output_file);
4366

    
4367
    if(nb_output_files <= 0 && nb_input_files == 0) {
4368
        show_usage();
4369
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4370
        ffmpeg_exit(1);
4371
    }
4372

    
4373
    /* file converter / grab */
4374
    if (nb_output_files <= 0) {
4375
        fprintf(stderr, "At least one output file must be specified\n");
4376
        ffmpeg_exit(1);
4377
    }
4378

    
4379
    if (nb_input_files == 0) {
4380
        fprintf(stderr, "At least one input file must be specified\n");
4381
        ffmpeg_exit(1);
4382
    }
4383

    
4384
    ti = getutime();
4385
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4386
                  stream_maps, nb_stream_maps) < 0)
4387
        ffmpeg_exit(1);
4388
    ti = getutime() - ti;
4389
    if (do_benchmark) {
4390
        int maxrss = getmaxrss() / 1024;
4391
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4392
    }
4393

    
4394
    return ffmpeg_exit(0);
4395
}