Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ba3517aa

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 "libavcore/audioconvert.h"
40
#include "libavcore/parseutils.h"
41
#include "libavcore/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
static AVFilterGraph *graph = NULL;
176
#endif
177

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

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

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

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

    
224
static int rate_emu = 0;
225

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

    
229
static int audio_volume = 256;
230

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

    
246
static float dts_delta_threshold = 10;
247

    
248
static unsigned int sws_flags = SWS_BICUBIC;
249

    
250
static int64_t timer_start;
251

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

    
256
static short *samples;
257

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

    
262
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263

    
264
struct AVInputStream;
265

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

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

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

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

    
308
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
310

    
311
typedef struct AVInputStream {
312
    int file_index;
313
    int index;
314
    AVStream *st;
315
    int discard;             /* true if stream data should be discarded */
316
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
317
    int64_t sample_index;      /* current sample */
318

    
319
    int64_t       start;     /* time when read started */
320
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
321
                                is not defined */
322
    int64_t       pts;       /* current pts */
323
    PtsCorrectionContext pts_ctx;
324
    int is_start;            /* is 1 at the start and after a discontinuity */
325
    int showed_multi_packet_warning;
326
    int is_past_recording_time;
327
#if CONFIG_AVFILTER
328
    AVFilterContext *output_video_filter;
329
    AVFilterContext *input_video_filter;
330
    AVFrame *filter_frame;
331
    int has_filter_frame;
332
    AVFilterBufferRef *picref;
333
#endif
334
} AVInputStream;
335

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

    
343
#if HAVE_TERMIOS_H
344

    
345
/* init terminal so that we can grab keys */
346
static struct termios oldtty;
347
#endif
348

    
349
#if CONFIG_AVFILTER
350

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

    
362
    graph = avfilter_graph_alloc();
363

    
364
    if (ist->st->sample_aspect_ratio.num){
365
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
366
    }else
367
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
368

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

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

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

    
396
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
397
    graph->scale_sws_opts = av_strdup(args);
398

    
399
    if (vfilters) {
400
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
401
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
402

    
403
        outputs->name    = av_strdup("in");
404
        outputs->filter_ctx = last_filter;
405
        outputs->pad_idx = 0;
406
        outputs->next    = NULL;
407

    
408
        inputs->name    = av_strdup("out");
409
        inputs->filter_ctx = ist->output_video_filter;
410
        inputs->pad_idx = 0;
411
        inputs->next    = NULL;
412

    
413
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
414
            return ret;
415
        av_freep(&vfilters);
416
    } else {
417
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
418
            return ret;
419
    }
420

    
421
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
422
        return ret;
423

    
424
    codec->width  = ist->output_video_filter->inputs[0]->w;
425
    codec->height = ist->output_video_filter->inputs[0]->h;
426
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
427
        ist->output_video_filter->inputs[0]->sample_aspect_ratio;
428

    
429
    return 0;
430
}
431
#endif /* CONFIG_AVFILTER */
432

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

    
441
static volatile int received_sigterm = 0;
442

    
443
static void
444
sigterm_handler(int sig)
445
{
446
    received_sigterm = sig;
447
    term_exit();
448
}
449

    
450
static void term_init(void)
451
{
452
#if HAVE_TERMIOS_H
453
    struct termios tty;
454

    
455
    tcgetattr (0, &tty);
456
    oldtty = tty;
457
    atexit(term_exit);
458

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

    
468
    tcsetattr (0, TCSANOW, &tty);
469
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
470
#endif
471

    
472
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
473
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
474
#ifdef SIGXCPU
475
    signal(SIGXCPU, sigterm_handler);
476
#endif
477
}
478

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

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

    
498
        return n;
499
    }
500
#elif HAVE_CONIO_H
501
    if(kbhit())
502
        return(getch());
503
#endif
504
    return -1;
505
}
506

    
507
static int decode_interrupt_cb(void)
508
{
509
    return q_pressed || (q_pressed = read_key() == 'q');
510
}
511

    
512
static int ffmpeg_exit(int ret)
513
{
514
    int i;
515

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

    
530
    av_free(intra_matrix);
531
    av_free(inter_matrix);
532

    
533
    if (vstats_file)
534
        fclose(vstats_file);
535
    av_free(vstats_filename);
536

    
537
    av_free(streamid_map);
538
    av_free(input_codecs);
539
    av_free(output_codecs);
540
    av_free(stream_maps);
541
    av_free(meta_data_maps);
542

    
543
    av_free(video_codec_name);
544
    av_free(audio_codec_name);
545
    av_free(subtitle_codec_name);
546

    
547
    av_free(video_standard);
548

    
549
    uninit_opts();
550
    av_free(audio_buf);
551
    av_free(audio_out);
552
    allocated_audio_buf_size= allocated_audio_out_size= 0;
553
    av_free(samples);
554

    
555
#if CONFIG_AVFILTER
556
    avfilter_uninit();
557
#endif
558

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

    
566
    exit(ret); /* not all OS-es handle main() return value */
567
    return ret;
568
}
569

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

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

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

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

    
649
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
650
{
651
    int idx = oc->nb_streams - 1;
652
    AVOutputStream *ost;
653

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

    
670
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
671
{
672
    int i, err;
673
    AVFormatContext *ic;
674
    int nopts = 0;
675

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

    
685
        s->nb_streams++;
686

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

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

    
711
        if(!st->codec->thread_count)
712
            st->codec->thread_count = 1;
713
        if(st->codec->thread_count>1)
714
            avcodec_thread_init(st->codec, st->codec->thread_count);
715

    
716
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
717
            nopts = 1;
718

    
719
        new_output_stream(s, nb_output_files);
720
    }
721

    
722
    if (!nopts)
723
        s->timestamp = av_gettime();
724

    
725
    av_close_input_file(ic);
726
    return 0;
727
}
728

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

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

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

    
758
        bsfc= bsfc->next;
759
    }
760

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

    
768
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
769

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

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

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

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

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

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

    
810
    if (enc->channels != dec->channels)
811
        ost->audio_resample = 1;
812

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

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

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

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

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

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

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

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

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

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

    
952
        frame_bytes = enc->frame_size * osize * enc->channels;
953

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

    
958
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
959

    
960
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
961

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

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

    
983
        ost->sync_opts += size_out / (osize * enc->channels);
984

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

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

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

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

    
1021
    dec = ist->st->codec;
1022

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

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

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

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

    
1048
    if (picture != picture2)
1049
        *picture = *picture2;
1050
    *bufp = buf;
1051
}
1052

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

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

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

    
1075
    enc = ost->st->codec;
1076

    
1077
    if (!subtitle_out) {
1078
        subtitle_out = av_malloc(subtitle_out_max_size);
1079
    }
1080

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

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

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

    
1119
static int bit_buffer_size= 1024*256;
1120
static uint8_t *bit_buffer= NULL;
1121

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

    
1133
    enc = ost->st->codec;
1134
    dec = ist->st->codec;
1135

    
1136
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1137

    
1138
    /* by default, we output a single frame */
1139
    nb_frames = 1;
1140

    
1141
    *frame_size = 0;
1142

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

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

    
1172
    formatted_picture = in_picture;
1173
    final_picture = formatted_picture;
1174
    padding_src = formatted_picture;
1175
    resampling_dst = &ost->pict_tmp;
1176

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1365

    
1366
    oc = output_files[0];
1367

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

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

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

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

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

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

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

    
1446
        fflush(stderr);
1447
    }
1448

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

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

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

    
1482
    if(ist->next_pts == AV_NOPTS_VALUE)
1483
        ist->next_pts= ist->pts;
1484

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

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

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

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

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

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

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

    
1612
#if CONFIG_AVFILTER
1613
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1614
            AVRational sar;
1615
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1616
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1617
            // add it to be filtered
1618
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1619
                                     ist->pts,
1620
                                     sar);
1621
        }
1622
#endif
1623

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

    
1638
        /* frame rate emulation */
1639
        if (rate_emu) {
1640
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1641
            int64_t now = av_gettime() - ist->start;
1642
            if (pts > now)
1643
                usleep(pts - now);
1644
        }
1645
#if CONFIG_AVFILTER
1646
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1647
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1648
#endif
1649
        /* if output time reached then transcode raw format,
1650
           encode packets and output them */
1651
        if (start_time == 0 || ist->pts >= start_time)
1652
#if CONFIG_AVFILTER
1653
        while (frame_available) {
1654
            AVRational ist_pts_tb;
1655
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1656
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1657
            if (ist->picref)
1658
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1659
#endif
1660
            for(i=0;i<nb_ostreams;i++) {
1661
                int frame_size;
1662

    
1663
                ost = ost_table[i];
1664
                if (ost->source_index == ist_index) {
1665
                    os = output_files[ost->file_index];
1666

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

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

    
1697
                        av_init_packet(&opkt);
1698

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

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

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

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

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

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

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

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

    
1743
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1744
                        ost->st->codec->frame_number++;
1745
                        ost->frame_number++;
1746
                        av_free_packet(&opkt);
1747
                    }
1748
                }
1749
            }
1750

    
1751
#if CONFIG_AVFILTER
1752
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1753
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1754
            if(ist->picref)
1755
                avfilter_unref_buffer(ist->picref);
1756
        }
1757
#endif
1758
        av_free(buffer_to_free);
1759
        /* XXX: allocate the subtitles in the codec ? */
1760
        if (subtitle_to_free) {
1761
            avsubtitle_free(subtitle_to_free);
1762
            subtitle_to_free = NULL;
1763
        }
1764
    }
1765
 discard_packet:
1766
    if (pkt == NULL) {
1767
        /* EOF handling */
1768

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

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

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

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

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

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

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

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

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

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

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

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

    
1878

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2360
    /* init pts */
2361
    for(i=0;i<nb_istreams;i++) {
2362
        AVStream *st;
2363
        ist = ist_table[i];
2364
        st= ist->st;
2365
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2366
        ist->next_pts = AV_NOPTS_VALUE;
2367
        init_pts_correction(&ist->pts_ctx);
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
        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
    }
2688

    
2689
    /* close each decoder */
2690
    for(i=0;i<nb_istreams;i++) {
2691
        ist = ist_table[i];
2692
        if (ist->decoding_needed) {
2693
            avcodec_close(ist->st->codec);
2694
        }
2695
    }
2696
#if CONFIG_AVFILTER
2697
    avfilter_graph_free(&graph);
2698
#endif
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
    x = vfilters ? strlen(vfilters) : 0;
2843
    vfilters = av_realloc(vfilters, x+100);
2844
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2845
}
2846

    
2847
static int opt_metadata(const char *opt, const char *arg)
2848
{
2849
    char *mid= strchr(arg, '=');
2850

    
2851
    if(!mid){
2852
        fprintf(stderr, "Missing =\n");
2853
        ffmpeg_exit(1);
2854
    }
2855
    *mid++= 0;
2856

    
2857
    av_metadata_set2(&metadata, arg, mid, 0);
2858

    
2859
    return 0;
2860
}
2861

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

    
2872
static void opt_top_field_first(const char *arg)
2873
{
2874
    top_field_first= atoi(arg);
2875
}
2876

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

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

    
2901
static int opt_audio_rate(const char *opt, const char *arg)
2902
{
2903
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2904
    return 0;
2905
}
2906

    
2907
static int opt_audio_channels(const char *opt, const char *arg)
2908
{
2909
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2910
    return 0;
2911
}
2912

    
2913
static void opt_video_channel(const char *arg)
2914
{
2915
    video_channel = strtol(arg, NULL, 0);
2916
}
2917

    
2918
static void opt_video_standard(const char *arg)
2919
{
2920
    video_standard = av_strdup(arg);
2921
}
2922

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

    
2934
static void opt_audio_codec(const char *arg)
2935
{
2936
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2937
}
2938

    
2939
static void opt_video_codec(const char *arg)
2940
{
2941
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2942
}
2943

    
2944
static void opt_subtitle_codec(const char *arg)
2945
{
2946
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2947
}
2948

    
2949
static int opt_codec_tag(const char *opt, const char *arg)
2950
{
2951
    char *tail;
2952
    uint32_t *codec_tag;
2953

    
2954
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2955
                !strcmp(opt, "vtag") ? &video_codec_tag :
2956
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2957
    if (!codec_tag)
2958
        return -1;
2959

    
2960
    *codec_tag = strtol(arg, &tail, 0);
2961
    if (!tail || *tail)
2962
        *codec_tag = AV_RL32(arg);
2963

    
2964
    return 0;
2965
}
2966

    
2967
static void opt_map(const char *arg)
2968
{
2969
    AVStreamMap *m;
2970
    char *p;
2971

    
2972
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2973
    m = &stream_maps[nb_stream_maps-1];
2974

    
2975
    m->file_index = strtol(arg, &p, 0);
2976
    if (*p)
2977
        p++;
2978

    
2979
    m->stream_index = strtol(p, &p, 0);
2980
    if (*p) {
2981
        p++;
2982
        m->sync_file_index = strtol(p, &p, 0);
2983
        if (*p)
2984
            p++;
2985
        m->sync_stream_index = strtol(p, &p, 0);
2986
    } else {
2987
        m->sync_file_index = m->file_index;
2988
        m->sync_stream_index = m->stream_index;
2989
    }
2990
}
2991

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

    
3013
static void opt_map_metadata(const char *arg)
3014
{
3015
    AVMetaDataMap *m, *m1;
3016
    char *p;
3017

    
3018
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3019
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3020

    
3021
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3022
    m->file = strtol(arg, &p, 0);
3023
    parse_meta_type(p, &m->type, &m->index, &p);
3024
    if (*p)
3025
        p++;
3026

    
3027
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3028
    m1->file = strtol(p, &p, 0);
3029
    parse_meta_type(p, &m1->type, &m1->index, &p);
3030

    
3031
    if (m->type == 'g' || m1->type == 'g')
3032
        metadata_global_autocopy = 0;
3033
    if (m->type == 's' || m1->type == 's')
3034
        metadata_streams_autocopy = 0;
3035
    if (m->type == 'c' || m1->type == 'c')
3036
        metadata_chapters_autocopy = 0;
3037
}
3038

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

    
3046
static void opt_map_chapters(const char *arg)
3047
{
3048
    AVChapterMap *c;
3049
    char *p;
3050

    
3051
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3052
                              nb_chapter_maps + 1);
3053
    c = &chapter_maps[nb_chapter_maps - 1];
3054
    c->out_file = strtol(arg, &p, 0);
3055
    if (*p)
3056
        p++;
3057

    
3058
    c->in_file = strtol(p, &p, 0);
3059
}
3060

    
3061
static void opt_input_ts_scale(const char *arg)
3062
{
3063
    unsigned int stream;
3064
    double scale;
3065
    char *p;
3066

    
3067
    stream = strtol(arg, &p, 0);
3068
    if (*p)
3069
        p++;
3070
    scale= strtod(p, &p);
3071

    
3072
    if(stream >= MAX_STREAMS)
3073
        ffmpeg_exit(1);
3074

    
3075
    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);
3076
    input_files_ts_scale[nb_input_files][stream]= scale;
3077
}
3078

    
3079
static int opt_recording_time(const char *opt, const char *arg)
3080
{
3081
    recording_time = parse_time_or_die(opt, arg, 1);
3082
    return 0;
3083
}
3084

    
3085
static int opt_start_time(const char *opt, const char *arg)
3086
{
3087
    start_time = parse_time_or_die(opt, arg, 1);
3088
    return 0;
3089
}
3090

    
3091
static int opt_recording_timestamp(const char *opt, const char *arg)
3092
{
3093
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3094
    return 0;
3095
}
3096

    
3097
static int opt_input_ts_offset(const char *opt, const char *arg)
3098
{
3099
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3100
    return 0;
3101
}
3102

    
3103
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3104
{
3105
    const char *codec_string = encoder ? "encoder" : "decoder";
3106
    AVCodec *codec;
3107

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

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

    
3145
    if (last_asked_format) {
3146
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3147
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3148
            ffmpeg_exit(1);
3149
        }
3150
        last_asked_format = NULL;
3151
    }
3152

    
3153
    if (!strcmp(filename, "-"))
3154
        filename = "pipe:";
3155

    
3156
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3157
                    !strcmp(filename, "/dev/stdin");
3158

    
3159
    /* get default parameters from command line */
3160
    ic = avformat_alloc_context();
3161
    if (!ic) {
3162
        print_error(filename, AVERROR(ENOMEM));
3163
        ffmpeg_exit(1);
3164
    }
3165

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

    
3179
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3180

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

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

    
3222
    ic->loop_input = loop_input;
3223

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

    
3233
    timestamp = start_time;
3234
    /* add the stream start time */
3235
    if (ic->start_time != AV_NOPTS_VALUE)
3236
        timestamp += ic->start_time;
3237

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

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

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

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

    
3301
                    (float)rfps / rfps_base, rfps, rfps_base);
3302
            }
3303
            /* update the current frame rate to match the stream frame rate */
3304
            frame_rate.num = rfps;
3305
            frame_rate.den = rfps_base;
3306

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

    
3327
    input_files[nb_input_files] = ic;
3328
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3329
    /* dump the file content */
3330
    if (verbose >= 0)
3331
        dump_format(ic, nb_input_files, filename, 0);
3332

    
3333
    nb_input_files++;
3334

    
3335
    video_channel = 0;
3336

    
3337
    av_freep(&video_codec_name);
3338
    av_freep(&audio_codec_name);
3339
    av_freep(&subtitle_codec_name);
3340
}
3341

    
3342
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3343
                                         int *has_subtitle_ptr)
3344
{
3345
    int has_video, has_audio, has_subtitle, i, j;
3346
    AVFormatContext *ic;
3347

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

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

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

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

    
3407
    avcodec_get_context_defaults3(st->codec, codec);
3408
    ost->bitstream_filters = video_bitstream_filters;
3409
    video_bitstream_filters= NULL;
3410

    
3411
    avcodec_thread_init(st->codec, thread_count);
3412

    
3413
    video_enc = st->codec;
3414

    
3415
    if(video_codec_tag)
3416
        video_enc->codec_tag= video_codec_tag;
3417

    
3418
    if(   (video_global_header&1)
3419
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3420
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3421
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3422
    }
3423
    if(video_global_header&2){
3424
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3425
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3426
    }
3427

    
3428
    if (video_stream_copy) {
3429
        st->stream_copy = 1;
3430
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3431
        video_enc->sample_aspect_ratio =
3432
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3433
    } else {
3434
        const char *p;
3435
        int i;
3436
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3437

    
3438
        video_enc->codec_id = codec_id;
3439
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3440

    
3441
        if (codec && codec->supported_framerates && !force_fps)
3442
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3443
        video_enc->time_base.den = fps.num;
3444
        video_enc->time_base.num = fps.den;
3445

    
3446
        video_enc->width = frame_width;
3447
        video_enc->height = frame_height;
3448
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3449
        video_enc->pix_fmt = frame_pix_fmt;
3450
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3451

    
3452
        choose_pixel_fmt(st, codec);
3453

    
3454
        if (intra_only)
3455
            video_enc->gop_size = 0;
3456
        if (video_qscale || same_quality) {
3457
            video_enc->flags |= CODEC_FLAG_QSCALE;
3458
            video_enc->global_quality=
3459
                st->quality = FF_QP2LAMBDA * video_qscale;
3460
        }
3461

    
3462
        if(intra_matrix)
3463
            video_enc->intra_matrix = intra_matrix;
3464
        if(inter_matrix)
3465
            video_enc->inter_matrix = inter_matrix;
3466

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

    
3497
        if (do_psnr)
3498
            video_enc->flags|= CODEC_FLAG_PSNR;
3499

    
3500
        /* two pass mode */
3501
        if (do_pass) {
3502
            if (do_pass == 1) {
3503
                video_enc->flags |= CODEC_FLAG_PASS1;
3504
            } else {
3505
                video_enc->flags |= CODEC_FLAG_PASS2;
3506
            }
3507
        }
3508

    
3509
        if (forced_key_frames)
3510
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3511
    }
3512
    if (video_language) {
3513
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3514
        av_freep(&video_language);
3515
    }
3516

    
3517
    /* reset some key parameters */
3518
    video_disable = 0;
3519
    av_freep(&video_codec_name);
3520
    av_freep(&forced_key_frames);
3521
    video_stream_copy = 0;
3522
    frame_pix_fmt = PIX_FMT_NONE;
3523
}
3524

    
3525
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3526
{
3527
    AVStream *st;
3528
    AVOutputStream *ost;
3529
    AVCodec *codec= NULL;
3530
    AVCodecContext *audio_enc;
3531
    enum CodecID codec_id = CODEC_ID_NONE;
3532

    
3533
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3534
    if (!st) {
3535
        fprintf(stderr, "Could not alloc stream\n");
3536
        ffmpeg_exit(1);
3537
    }
3538
    ost = new_output_stream(oc, file_idx);
3539

    
3540
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3541
    if(!audio_stream_copy){
3542
        if (audio_codec_name) {
3543
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3544
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3545
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3546
            output_codecs[nb_output_codecs-1] = codec;
3547
        } else {
3548
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3549
            codec = avcodec_find_encoder(codec_id);
3550
        }
3551
    }
3552

    
3553
    avcodec_get_context_defaults3(st->codec, codec);
3554

    
3555
    ost->bitstream_filters = audio_bitstream_filters;
3556
    audio_bitstream_filters= NULL;
3557

    
3558
    avcodec_thread_init(st->codec, thread_count);
3559

    
3560
    audio_enc = st->codec;
3561
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3562

    
3563
    if(audio_codec_tag)
3564
        audio_enc->codec_tag= audio_codec_tag;
3565

    
3566
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3567
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3568
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3569
    }
3570
    if (audio_stream_copy) {
3571
        st->stream_copy = 1;
3572
        audio_enc->channels = audio_channels;
3573
        audio_enc->sample_rate = audio_sample_rate;
3574
    } else {
3575
        audio_enc->codec_id = codec_id;
3576
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3577

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

    
3597
    /* reset some key parameters */
3598
    audio_disable = 0;
3599
    av_freep(&audio_codec_name);
3600
    audio_stream_copy = 0;
3601
}
3602

    
3603
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3604
{
3605
    AVStream *st;
3606
    AVOutputStream *ost;
3607
    AVCodec *codec=NULL;
3608
    AVCodecContext *subtitle_enc;
3609
    enum CodecID codec_id = CODEC_ID_NONE;
3610

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

    
3631
    ost->bitstream_filters = subtitle_bitstream_filters;
3632
    subtitle_bitstream_filters= NULL;
3633

    
3634
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3635

    
3636
    if(subtitle_codec_tag)
3637
        subtitle_enc->codec_tag= subtitle_codec_tag;
3638

    
3639
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3640
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3641
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3642
    }
3643
    if (subtitle_stream_copy) {
3644
        st->stream_copy = 1;
3645
    } else {
3646
        subtitle_enc->codec_id = codec_id;
3647
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3648
    }
3649

    
3650
    if (subtitle_language) {
3651
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3652
        av_freep(&subtitle_language);
3653
    }
3654

    
3655
    subtitle_disable = 0;
3656
    av_freep(&subtitle_codec_name);
3657
    subtitle_stream_copy = 0;
3658
}
3659

    
3660
static int opt_new_stream(const char *opt, const char *arg)
3661
{
3662
    AVFormatContext *oc;
3663
    int file_idx = nb_output_files - 1;
3664
    if (nb_output_files <= 0) {
3665
        fprintf(stderr, "At least one output file must be specified\n");
3666
        ffmpeg_exit(1);
3667
    }
3668
    oc = output_files[file_idx];
3669

    
3670
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3671
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3672
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3673
    else av_assert0(0);
3674
    return 0;
3675
}
3676

    
3677
/* arg format is "output-stream-index:streamid-value". */
3678
static int opt_streamid(const char *opt, const char *arg)
3679
{
3680
    int idx;
3681
    char *p;
3682
    char idx_str[16];
3683

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

    
3700
static void opt_output_file(const char *filename)
3701
{
3702
    AVFormatContext *oc;
3703
    int err, use_video, use_audio, use_subtitle;
3704
    int input_has_video, input_has_audio, input_has_subtitle;
3705
    AVFormatParameters params, *ap = &params;
3706
    AVOutputFormat *file_oformat;
3707

    
3708
    if (!strcmp(filename, "-"))
3709
        filename = "pipe:";
3710

    
3711
    oc = avformat_alloc_context();
3712
    if (!oc) {
3713
        print_error(filename, AVERROR(ENOMEM));
3714
        ffmpeg_exit(1);
3715
    }
3716

    
3717
    if (last_asked_format) {
3718
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3719
        if (!file_oformat) {
3720
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3721
            ffmpeg_exit(1);
3722
        }
3723
        last_asked_format = NULL;
3724
    } else {
3725
        file_oformat = av_guess_format(NULL, filename, NULL);
3726
        if (!file_oformat) {
3727
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3728
                    filename);
3729
            ffmpeg_exit(1);
3730
        }
3731
    }
3732

    
3733
    oc->oformat = file_oformat;
3734
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3735

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

    
3750
        /* disable if no corresponding type found and at least one
3751
           input file */
3752
        if (nb_input_files > 0) {
3753
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3754
                                         &input_has_subtitle);
3755
            if (!input_has_video)
3756
                use_video = 0;
3757
            if (!input_has_audio)
3758
                use_audio = 0;
3759
            if (!input_has_subtitle)
3760
                use_subtitle = 0;
3761
        }
3762

    
3763
        /* manual disable */
3764
        if (audio_disable)    use_audio    = 0;
3765
        if (video_disable)    use_video    = 0;
3766
        if (subtitle_disable) use_subtitle = 0;
3767

    
3768
        if (use_video)    new_video_stream(oc, nb_output_files);
3769
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3770
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3771

    
3772
        oc->timestamp = recording_timestamp;
3773

    
3774
        av_metadata_copy(&oc->metadata, metadata, 0);
3775
        av_metadata_free(&metadata);
3776
    }
3777

    
3778
    output_files[nb_output_files++] = oc;
3779

    
3780
    /* check filename in case of an image number is expected */
3781
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3782
        if (!av_filename_number_test(oc->filename)) {
3783
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3784
            ffmpeg_exit(1);
3785
        }
3786
    }
3787

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

    
3810
        /* open the file */
3811
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3812
            print_error(filename, err);
3813
            ffmpeg_exit(1);
3814
        }
3815
    }
3816

    
3817
    memset(ap, 0, sizeof(*ap));
3818
    if (av_set_parameters(oc, ap) < 0) {
3819
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3820
                oc->filename);
3821
        ffmpeg_exit(1);
3822
    }
3823

    
3824
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3825
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3826
    oc->loop_output = loop_output;
3827
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3828

    
3829
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3830

    
3831
    av_freep(&forced_key_frames);
3832
}
3833

    
3834
/* same option as mencoder */
3835
static void opt_pass(const char *pass_str)
3836
{
3837
    int pass;
3838
    pass = atoi(pass_str);
3839
    if (pass != 1 && pass != 2) {
3840
        fprintf(stderr, "pass number can be only 1 or 2\n");
3841
        ffmpeg_exit(1);
3842
    }
3843
    do_pass = pass;
3844
}
3845

    
3846
static int64_t getutime(void)
3847
{
3848
#if HAVE_GETRUSAGE
3849
    struct rusage rusage;
3850

    
3851
    getrusage(RUSAGE_SELF, &rusage);
3852
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3853
#elif HAVE_GETPROCESSTIMES
3854
    HANDLE proc;
3855
    FILETIME c, e, k, u;
3856
    proc = GetCurrentProcess();
3857
    GetProcessTimes(proc, &c, &e, &k, &u);
3858
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3859
#else
3860
    return av_gettime();
3861
#endif
3862
}
3863

    
3864
static int64_t getmaxrss(void)
3865
{
3866
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3867
    struct rusage rusage;
3868
    getrusage(RUSAGE_SELF, &rusage);
3869
    return (int64_t)rusage.ru_maxrss * 1024;
3870
#elif HAVE_GETPROCESSMEMORYINFO
3871
    HANDLE proc;
3872
    PROCESS_MEMORY_COUNTERS memcounters;
3873
    proc = GetCurrentProcess();
3874
    memcounters.cb = sizeof(memcounters);
3875
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3876
    return memcounters.PeakPagefileUsage;
3877
#else
3878
    return 0;
3879
#endif
3880
}
3881

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

    
3899
static void opt_inter_matrix(const char *arg)
3900
{
3901
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3902
    parse_matrix_coeffs(inter_matrix, arg);
3903
}
3904

    
3905
static void opt_intra_matrix(const char *arg)
3906
{
3907
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3908
    parse_matrix_coeffs(intra_matrix, arg);
3909
}
3910

    
3911
static void show_usage(void)
3912
{
3913
    printf("Hyper fast Audio and Video encoder\n");
3914
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3915
    printf("\n");
3916
}
3917

    
3918
static void show_help(void)
3919
{
3920
    AVCodec *c;
3921
    AVOutputFormat *oformat = NULL;
3922

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

    
3952
    /* individual codec options */
3953
    c = NULL;
3954
    while ((c = av_codec_next(c))) {
3955
        if (c->priv_class) {
3956
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3957
            printf("\n");
3958
        }
3959
    }
3960

    
3961
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3962
    printf("\n");
3963

    
3964
    /* individual muxer options */
3965
    while ((oformat = av_oformat_next(oformat))) {
3966
        if (oformat->priv_class) {
3967
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3968
            printf("\n");
3969
        }
3970
    }
3971

    
3972
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3973
}
3974

    
3975
static void opt_target(const char *arg)
3976
{
3977
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3978
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3979

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

    
4024
    if(norm == UNKNOWN) {
4025
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4026
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4027
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4028
        ffmpeg_exit(1);
4029
    }
4030

    
4031
    if(!strcmp(arg, "vcd")) {
4032

    
4033
        opt_video_codec("mpeg1video");
4034
        opt_audio_codec("mp2");
4035
        opt_format("vcd");
4036

    
4037
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4038
        opt_frame_rate(NULL, frame_rates[norm]);
4039
        opt_default("g", norm == PAL ? "15" : "18");
4040

    
4041
        opt_default("b", "1150000");
4042
        opt_default("maxrate", "1150000");
4043
        opt_default("minrate", "1150000");
4044
        opt_default("bufsize", "327680"); // 40*1024*8;
4045

    
4046
        opt_default("ab", "224000");
4047
        audio_sample_rate = 44100;
4048
        audio_channels = 2;
4049

    
4050
        opt_default("packetsize", "2324");
4051
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4052

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

    
4061
        opt_video_codec("mpeg2video");
4062
        opt_audio_codec("mp2");
4063
        opt_format("svcd");
4064

    
4065
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4066
        opt_frame_rate(NULL, frame_rates[norm]);
4067
        opt_default("g", norm == PAL ? "15" : "18");
4068

    
4069
        opt_default("b", "2040000");
4070
        opt_default("maxrate", "2516000");
4071
        opt_default("minrate", "0"); //1145000;
4072
        opt_default("bufsize", "1835008"); //224*1024*8;
4073
        opt_default("flags", "+scan_offset");
4074

    
4075

    
4076
        opt_default("ab", "224000");
4077
        audio_sample_rate = 44100;
4078

    
4079
        opt_default("packetsize", "2324");
4080

    
4081
    } else if(!strcmp(arg, "dvd")) {
4082

    
4083
        opt_video_codec("mpeg2video");
4084
        opt_audio_codec("ac3");
4085
        opt_format("dvd");
4086

    
4087
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4088
        opt_frame_rate(NULL, frame_rates[norm]);
4089
        opt_default("g", norm == PAL ? "15" : "18");
4090

    
4091
        opt_default("b", "6000000");
4092
        opt_default("maxrate", "9000000");
4093
        opt_default("minrate", "0"); //1500000;
4094
        opt_default("bufsize", "1835008"); //224*1024*8;
4095

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

    
4099
        opt_default("ab", "448000");
4100
        audio_sample_rate = 48000;
4101

    
4102
    } else if(!strncmp(arg, "dv", 2)) {
4103

    
4104
        opt_format("dv");
4105

    
4106
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4107
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4108
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4109
        opt_frame_rate(NULL, frame_rates[norm]);
4110

    
4111
        audio_sample_rate = 48000;
4112
        audio_channels = 2;
4113

    
4114
    } else {
4115
        fprintf(stderr, "Unknown target: %s\n", arg);
4116
        ffmpeg_exit(1);
4117
    }
4118
}
4119

    
4120
static void opt_vstats_file (const char *arg)
4121
{
4122
    av_free (vstats_filename);
4123
    vstats_filename=av_strdup (arg);
4124
}
4125

    
4126
static void opt_vstats (void)
4127
{
4128
    char filename[40];
4129
    time_t today2 = time(NULL);
4130
    struct tm *today = localtime(&today2);
4131

    
4132
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4133
             today->tm_sec);
4134
    opt_vstats_file(filename);
4135
}
4136

    
4137
static int opt_bsf(const char *opt, const char *arg)
4138
{
4139
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4140
    AVBitStreamFilterContext **bsfp;
4141

    
4142
    if(!bsfc){
4143
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4144
        ffmpeg_exit(1);
4145
    }
4146

    
4147
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4148
          *opt == 'a' ? &audio_bitstream_filters :
4149
                        &subtitle_bitstream_filters;
4150
    while(*bsfp)
4151
        bsfp= &(*bsfp)->next;
4152

    
4153
    *bsfp= bsfc;
4154

    
4155
    return 0;
4156
}
4157

    
4158
static int opt_preset(const char *opt, const char *arg)
4159
{
4160
    FILE *f=NULL;
4161
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4162
    char *codec_name = *opt == 'v' ? video_codec_name :
4163
                       *opt == 'a' ? audio_codec_name :
4164
                                     subtitle_codec_name;
4165

    
4166
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4167
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4168
        ffmpeg_exit(1);
4169
    }
4170

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

    
4192
    fclose(f);
4193

    
4194
    return 0;
4195
}
4196

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

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

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

    
4304
    /* subtitle options */
4305
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4306
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4307
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4308
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4309
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4310

    
4311
    /* grab options */
4312
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4313
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4314
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4315

    
4316
    /* muxer options */
4317
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4318
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4319

    
4320
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4321
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4322
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4323

    
4324
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4325
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4326
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4327
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4328

    
4329
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4330
    { NULL, },
4331
};
4332

    
4333
int main(int argc, char **argv)
4334
{
4335
    int64_t ti;
4336

    
4337
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4338

    
4339
    avcodec_register_all();
4340
#if CONFIG_AVDEVICE
4341
    avdevice_register_all();
4342
#endif
4343
#if CONFIG_AVFILTER
4344
    avfilter_register_all();
4345
#endif
4346
    av_register_all();
4347

    
4348
#if HAVE_ISATTY
4349
    if(isatty(STDIN_FILENO))
4350
        url_set_interrupt_cb(decode_interrupt_cb);
4351
#endif
4352

    
4353
    init_opts();
4354

    
4355
    show_banner();
4356

    
4357
    /* parse options */
4358
    parse_options(argc, argv, options, opt_output_file);
4359

    
4360
    if(nb_output_files <= 0 && nb_input_files == 0) {
4361
        show_usage();
4362
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4363
        ffmpeg_exit(1);
4364
    }
4365

    
4366
    /* file converter / grab */
4367
    if (nb_output_files <= 0) {
4368
        fprintf(stderr, "At least one output file must be specified\n");
4369
        ffmpeg_exit(1);
4370
    }
4371

    
4372
    if (nb_input_files == 0) {
4373
        fprintf(stderr, "At least one input file must be specified\n");
4374
        ffmpeg_exit(1);
4375
    }
4376

    
4377
    ti = getutime();
4378
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4379
                  stream_maps, nb_stream_maps) < 0)
4380
        ffmpeg_exit(1);
4381
    ti = getutime() - ti;
4382
    if (do_benchmark) {
4383
        int maxrss = getmaxrss() / 1024;
4384
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4385
    }
4386

    
4387
    return ffmpeg_exit(0);
4388
}