Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 87e4d9b2

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
    char args[255];
359
    int ret;
360

    
361
    graph = avfilter_graph_alloc();
362

    
363
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
364
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
365
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
366
                                       "src", args, NULL, graph);
367
    if (ret < 0)
368
        return ret;
369
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
370
                                       "out", NULL, &ffsink_ctx, graph);
371
    if (ret < 0)
372
        return ret;
373
    last_filter = ist->input_video_filter;
374

    
375
    if (codec->width  != icodec->width || codec->height != icodec->height) {
376
        snprintf(args, 255, "%d:%d:flags=0x%X",
377
                 codec->width,
378
                 codec->height,
379
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
380
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
381
                                                NULL, args, NULL, graph)) < 0)
382
            return ret;
383
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
384
            return ret;
385
        last_filter = filter;
386
    }
387

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

    
391
    if (vfilters) {
392
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
394

    
395
        outputs->name    = av_strdup("in");
396
        outputs->filter_ctx = last_filter;
397
        outputs->pad_idx = 0;
398
        outputs->next    = NULL;
399

    
400
        inputs->name    = av_strdup("out");
401
        inputs->filter_ctx = ist->output_video_filter;
402
        inputs->pad_idx = 0;
403
        inputs->next    = NULL;
404

    
405
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
406
            return ret;
407
        av_freep(&vfilters);
408
    } else {
409
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
410
            return ret;
411
    }
412

    
413
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
414
        return ret;
415

    
416
    codec->width  = ist->output_video_filter->inputs[0]->w;
417
    codec->height = ist->output_video_filter->inputs[0]->h;
418

    
419
    return 0;
420
}
421
#endif /* CONFIG_AVFILTER */
422

    
423
static void term_exit(void)
424
{
425
    av_log(NULL, AV_LOG_QUIET, "");
426
#if HAVE_TERMIOS_H
427
    tcsetattr (0, TCSANOW, &oldtty);
428
#endif
429
}
430

    
431
static volatile int received_sigterm = 0;
432

    
433
static void
434
sigterm_handler(int sig)
435
{
436
    received_sigterm = sig;
437
    term_exit();
438
}
439

    
440
static void term_init(void)
441
{
442
#if HAVE_TERMIOS_H
443
    struct termios tty;
444

    
445
    tcgetattr (0, &tty);
446
    oldtty = tty;
447
    atexit(term_exit);
448

    
449
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
450
                          |INLCR|IGNCR|ICRNL|IXON);
451
    tty.c_oflag |= OPOST;
452
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
453
    tty.c_cflag &= ~(CSIZE|PARENB);
454
    tty.c_cflag |= CS8;
455
    tty.c_cc[VMIN] = 1;
456
    tty.c_cc[VTIME] = 0;
457

    
458
    tcsetattr (0, TCSANOW, &tty);
459
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
460
#endif
461

    
462
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
463
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
464
#ifdef SIGXCPU
465
    signal(SIGXCPU, sigterm_handler);
466
#endif
467
}
468

    
469
/* read a key without blocking */
470
static int read_key(void)
471
{
472
#if HAVE_TERMIOS_H
473
    int n = 1;
474
    unsigned char ch;
475
    struct timeval tv;
476
    fd_set rfds;
477

    
478
    FD_ZERO(&rfds);
479
    FD_SET(0, &rfds);
480
    tv.tv_sec = 0;
481
    tv.tv_usec = 0;
482
    n = select(1, &rfds, NULL, NULL, &tv);
483
    if (n > 0) {
484
        n = read(0, &ch, 1);
485
        if (n == 1)
486
            return ch;
487

    
488
        return n;
489
    }
490
#elif HAVE_CONIO_H
491
    if(kbhit())
492
        return(getch());
493
#endif
494
    return -1;
495
}
496

    
497
static int decode_interrupt_cb(void)
498
{
499
    return q_pressed || (q_pressed = read_key() == 'q');
500
}
501

    
502
static int ffmpeg_exit(int ret)
503
{
504
    int i;
505

    
506
    /* close files */
507
    for(i=0;i<nb_output_files;i++) {
508
        /* maybe av_close_output_file ??? */
509
        AVFormatContext *s = output_files[i];
510
        int j;
511
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
512
            url_fclose(s->pb);
513
        for(j=0;j<s->nb_streams;j++) {
514
            av_metadata_free(&s->streams[j]->metadata);
515
            av_free(s->streams[j]->codec);
516
            av_free(s->streams[j]->info);
517
            av_free(s->streams[j]);
518
        }
519
        for(j=0;j<s->nb_programs;j++) {
520
            av_metadata_free(&s->programs[j]->metadata);
521
        }
522
        for(j=0;j<s->nb_chapters;j++) {
523
            av_metadata_free(&s->chapters[j]->metadata);
524
        }
525
        av_metadata_free(&s->metadata);
526
        av_free(s);
527
        av_free(output_streams_for_file[i]);
528
    }
529
    for(i=0;i<nb_input_files;i++) {
530
        av_close_input_file(input_files[i]);
531
        av_free(input_files_ts_scale[i]);
532
    }
533

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

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

    
541
    av_free(opt_names);
542
    av_free(streamid_map);
543
    av_free(input_codecs);
544
    av_free(output_codecs);
545
    av_free(stream_maps);
546
    av_free(meta_data_maps);
547

    
548
    av_free(video_codec_name);
549
    av_free(audio_codec_name);
550
    av_free(subtitle_codec_name);
551

    
552
    av_free(video_standard);
553

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

    
560
#if CONFIG_AVFILTER
561
    avfilter_uninit();
562
#endif
563

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

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

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

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

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

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

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

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

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

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

    
690
        s->nb_streams++;
691

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

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

    
716
        if(!st->codec->thread_count)
717
            st->codec->thread_count = 1;
718
        if(st->codec->thread_count>1)
719
            avcodec_thread_init(st->codec, st->codec->thread_count);
720

    
721
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
722
            nopts = 1;
723

    
724
        new_output_stream(s, nb_output_files);
725
    }
726

    
727
    if (!nopts)
728
        s->timestamp = av_gettime();
729

    
730
    av_close_input_file(ic);
731
    return 0;
732
}
733

    
734
static double
735
get_sync_ipts(const AVOutputStream *ost)
736
{
737
    const AVInputStream *ist = ost->sync_ist;
738
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
739
}
740

    
741
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
742
    int ret;
743

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

    
763
        bsfc= bsfc->next;
764
    }
765

    
766
    ret= av_interleaved_write_frame(s, pkt);
767
    if(ret < 0){
768
        print_error("av_interleaved_write_frame()", ret);
769
        ffmpeg_exit(1);
770
    }
771
}
772

    
773
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
774

    
775
static void do_audio_out(AVFormatContext *s,
776
                         AVOutputStream *ost,
777
                         AVInputStream *ist,
778
                         unsigned char *buf, int size)
779
{
780
    uint8_t *buftmp;
781
    int64_t audio_out_size, audio_buf_size;
782
    int64_t allocated_for_size= size;
783

    
784
    int size_out, frame_bytes, ret, resample_changed;
785
    AVCodecContext *enc= ost->st->codec;
786
    AVCodecContext *dec= ist->st->codec;
787
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
788
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
789
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
790

    
791
need_realloc:
792
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
793
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
794
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
795
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
796
    audio_buf_size*= osize*enc->channels;
797

    
798
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
799
    if(coded_bps > 8*osize)
800
        audio_out_size= audio_out_size * coded_bps / (8*osize);
801
    audio_out_size += FF_MIN_BUFFER_SIZE;
802

    
803
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
804
        fprintf(stderr, "Buffer sizes too large\n");
805
        ffmpeg_exit(1);
806
    }
807

    
808
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
809
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
810
    if (!audio_buf || !audio_out){
811
        fprintf(stderr, "Out of memory in do_audio_out\n");
812
        ffmpeg_exit(1);
813
    }
814

    
815
    if (enc->channels != dec->channels)
816
        ost->audio_resample = 1;
817

    
818
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
819
                       ost->resample_channels    != dec->channels   ||
820
                       ost->resample_sample_rate != dec->sample_rate;
821

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

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

    
873
    if(audio_sync_method){
874
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
875
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
876
        double idelta= delta*dec->sample_rate / enc->sample_rate;
877
        int byte_delta= ((int)idelta)*2*dec->channels;
878

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

    
895
                    if(byte_delta > allocated_for_size - size){
896
                        allocated_for_size= byte_delta + (int64_t)size;
897
                        goto need_realloc;
898
                    }
899
                    ist->is_start=0;
900

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

    
921
    if (ost->audio_resample) {
922
        buftmp = audio_buf;
923
        size_out = audio_resample(ost->resample,
924
                                  (short *)buftmp, (short *)buf,
925
                                  size / (dec->channels * isize));
926
        size_out = size_out * enc->channels * osize;
927
    } else {
928
        buftmp = buf;
929
        size_out = size;
930
    }
931

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

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

    
957
        frame_bytes = enc->frame_size * osize * enc->channels;
958

    
959
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
960
            AVPacket pkt;
961
            av_init_packet(&pkt);
962

    
963
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
964

    
965
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
966

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

    
982
            ost->sync_opts += enc->frame_size;
983
        }
984
    } else {
985
        AVPacket pkt;
986
        av_init_packet(&pkt);
987

    
988
        ost->sync_opts += size_out / (osize * enc->channels);
989

    
990
        /* output a pcm frame */
991
        /* determine the size of the coded buffer */
992
        size_out /= osize;
993
        if (coded_bps)
994
            size_out = size_out*coded_bps/8;
995

    
996
        if(size_out > audio_out_size){
997
            fprintf(stderr, "Internal error, buffer size too small\n");
998
            ffmpeg_exit(1);
999
        }
1000

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

    
1019
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1020
{
1021
    AVCodecContext *dec;
1022
    AVPicture *picture2;
1023
    AVPicture picture_tmp;
1024
    uint8_t *buf = 0;
1025

    
1026
    dec = ist->st->codec;
1027

    
1028
    /* deinterlace : must be done before any resize */
1029
    if (do_deinterlace) {
1030
        int size;
1031

    
1032
        /* create temporary picture */
1033
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1034
        buf = av_malloc(size);
1035
        if (!buf)
1036
            return;
1037

    
1038
        picture2 = &picture_tmp;
1039
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1040

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

    
1053
    if (picture != picture2)
1054
        *picture = *picture2;
1055
    *bufp = buf;
1056
}
1057

    
1058
/* we begin to correct av delay at this threshold */
1059
#define AV_DELAY_MAX 0.100
1060

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

    
1073
    if (pts == AV_NOPTS_VALUE) {
1074
        fprintf(stderr, "Subtitle packets must have a pts\n");
1075
        if (exit_on_error)
1076
            ffmpeg_exit(1);
1077
        return;
1078
    }
1079

    
1080
    enc = ost->st->codec;
1081

    
1082
    if (!subtitle_out) {
1083
        subtitle_out = av_malloc(subtitle_out_max_size);
1084
    }
1085

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

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

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

    
1124
static int bit_buffer_size= 1024*256;
1125
static uint8_t *bit_buffer= NULL;
1126

    
1127
static void do_video_out(AVFormatContext *s,
1128
                         AVOutputStream *ost,
1129
                         AVInputStream *ist,
1130
                         AVFrame *in_picture,
1131
                         int *frame_size)
1132
{
1133
    int nb_frames, i, ret;
1134
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1135
    AVCodecContext *enc, *dec;
1136
    double sync_ipts;
1137

    
1138
    enc = ost->st->codec;
1139
    dec = ist->st->codec;
1140

    
1141
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1142

    
1143
    /* by default, we output a single frame */
1144
    nb_frames = 1;
1145

    
1146
    *frame_size = 0;
1147

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

    
1173
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1174
    if (nb_frames <= 0)
1175
        return;
1176

    
1177
    formatted_picture = in_picture;
1178
    final_picture = formatted_picture;
1179
    padding_src = formatted_picture;
1180
    resampling_dst = &ost->pict_tmp;
1181

    
1182
    if (   ost->resample_height != ist->st->codec->height
1183
        || ost->resample_width  != ist->st->codec->width
1184
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1185

    
1186
        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));
1187
        if(!ost->video_resample)
1188
            ffmpeg_exit(1);
1189
    }
1190

    
1191
#if !CONFIG_AVFILTER
1192
    if (ost->video_resample) {
1193
        padding_src = NULL;
1194
        final_picture = &ost->pict_tmp;
1195
        if(  ost->resample_height != ist->st->codec->height
1196
          || ost->resample_width  != ist->st->codec->width
1197
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1198

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

    
1220
    /* duplicates frame if needed */
1221
    for(i=0;i<nb_frames;i++) {
1222
        AVPacket pkt;
1223
        av_init_packet(&pkt);
1224
        pkt.stream_index= ost->index;
1225

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

    
1237
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1238
            enc->coded_frame = old_frame;
1239
        } else {
1240
            AVFrame big_picture;
1241

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

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

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

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

    
1302
static double psnr(double d){
1303
    return -10.0*log(d)/log(10.0);
1304
}
1305

    
1306
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1307
                           int frame_size)
1308
{
1309
    AVCodecContext *enc;
1310
    int frame_number;
1311
    double ti1, bitrate, avg_bitrate;
1312

    
1313
    /* this is executed just the first time do_video_stats is called */
1314
    if (!vstats_file) {
1315
        vstats_file = fopen(vstats_filename, "w");
1316
        if (!vstats_file) {
1317
            perror("fopen");
1318
            ffmpeg_exit(1);
1319
        }
1320
    }
1321

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

    
1329
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1330
        /* compute pts value */
1331
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1332
        if (ti1 < 0.01)
1333
            ti1 = 0.01;
1334

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

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

    
1357
    if (!is_last_report) {
1358
        int64_t cur_time;
1359
        /* display the report every 0.5 seconds */
1360
        cur_time = av_gettime();
1361
        if (last_time == -1) {
1362
            last_time = cur_time;
1363
            return;
1364
        }
1365
        if ((cur_time - last_time) < 500000)
1366
            return;
1367
        last_time = cur_time;
1368
    }
1369

    
1370

    
1371
    oc = output_files[0];
1372

    
1373
    total_size = url_fsize(oc->pb);
1374
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1375
        total_size= url_ftell(oc->pb);
1376

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

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

    
1437
    if (verbose || is_last_report) {
1438
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1439

    
1440
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1441
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1442
            (double)total_size / 1024, ti1, bitrate);
1443

    
1444
        if (nb_frames_dup || nb_frames_drop)
1445
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1446
                  nb_frames_dup, nb_frames_drop);
1447

    
1448
        if (verbose >= 0)
1449
            fprintf(stderr, "%s    \r", buf);
1450

    
1451
        fflush(stderr);
1452
    }
1453

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

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

    
1484
    AVPacket avpkt;
1485
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1486

    
1487
    if(ist->next_pts == AV_NOPTS_VALUE)
1488
        ist->next_pts= ist->pts;
1489

    
1490
    if (pkt == NULL) {
1491
        /* EOF handling */
1492
        av_init_packet(&avpkt);
1493
        avpkt.data = NULL;
1494
        avpkt.size = 0;
1495
        goto handle_eof;
1496
    } else {
1497
        avpkt = *pkt;
1498
    }
1499

    
1500
    if(pkt->dts != AV_NOPTS_VALUE)
1501
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1502
    if(pkt->pts != AV_NOPTS_VALUE)
1503
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1504

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

    
1512
        if(avpkt.size && avpkt.size != pkt->size &&
1513
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1514
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1515
            ist->showed_multi_packet_warning=1;
1516
        }
1517

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

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

    
1610
        buffer_to_free = NULL;
1611
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1612
            pre_process_video_frame(ist, (AVPicture *)&picture,
1613
                                    &buffer_to_free);
1614
        }
1615

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

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

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

    
1667
                ost = ost_table[i];
1668
                if (ost->source_index == ist_index) {
1669
                    os = output_files[ost->file_index];
1670

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

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

    
1701
                        av_init_packet(&opkt);
1702

    
1703
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1704
                            continue;
1705

    
1706
                        /* no reencoding needed : output the packet directly */
1707
                        /* force the input stream PTS */
1708

    
1709
                        avcodec_get_frame_defaults(&avframe);
1710
                        ost->st->codec->coded_frame= &avframe;
1711
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1712

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

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

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

    
1732
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1733
                        opkt.flags= pkt->flags;
1734

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

    
1747
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1748
                        ost->st->codec->frame_number++;
1749
                        ost->frame_number++;
1750
                        av_free_packet(&opkt);
1751
                    }
1752
                }
1753
            }
1754

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

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

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

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

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

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

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

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

    
1855
    return 0;
1856
 fail_decode:
1857
    return -1;
1858
}
1859

    
1860
static void print_sdp(AVFormatContext **avc, int n)
1861
{
1862
    char sdp[2048];
1863

    
1864
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1865
    printf("SDP:\n%s\n", sdp);
1866
    fflush(stdout);
1867
}
1868

    
1869
static int copy_chapters(int infile, int outfile)
1870
{
1871
    AVFormatContext *is = input_files[infile];
1872
    AVFormatContext *os = output_files[outfile];
1873
    int i;
1874

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

    
1882

    
1883
        if (in_ch->end < ts_off)
1884
            continue;
1885
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1886
            break;
1887

    
1888
        out_ch = av_mallocz(sizeof(AVChapter));
1889
        if (!out_ch)
1890
            return AVERROR(ENOMEM);
1891

    
1892
        out_ch->id        = in_ch->id;
1893
        out_ch->time_base = in_ch->time_base;
1894
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1895
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1896

    
1897
        if (metadata_chapters_autocopy)
1898
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1899

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

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

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

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

    
1953
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1954
    if (!file_table)
1955
        goto fail;
1956

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

    
1967
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1968
    if (!ist_table)
1969
        goto fail;
1970

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

    
1988
            if (rate_emu) {
1989
                ist->start = av_gettime();
1990
            }
1991
        }
1992
    }
1993

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

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

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

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

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

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

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

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

    
2122
        codec = ost->st->codec;
2123
        icodec = ist->st->codec;
2124

    
2125
        if (metadata_streams_autocopy)
2126
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2127
                             AV_METADATA_DONT_OVERWRITE);
2128

    
2129
        ost->st->disposition = ist->st->disposition;
2130
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2131
        codec->chroma_sample_location = icodec->chroma_sample_location;
2132

    
2133
        if (ost->st->stream_copy) {
2134
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2135

    
2136
            if (extra_size > INT_MAX)
2137
                goto fail;
2138

    
2139
            /* if stream_copy is selected, no need to decode or encode */
2140
            codec->codec_id = icodec->codec_id;
2141
            codec->codec_type = icodec->codec_type;
2142

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

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

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

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

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

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

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

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

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

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

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

    
2389
        int out_file_index = meta_data_maps[i][0].file;
2390
        int in_file_index = meta_data_maps[i][1].file;
2391
        if (in_file_index < 0 || out_file_index < 0)
2392
            continue;
2393
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2394
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2395

    
2396
        files[0] = output_files[out_file_index];
2397
        files[1] = input_files[in_file_index];
2398

    
2399
        for (j = 0; j < 2; j++) {
2400
            AVMetaDataMap *map = &meta_data_maps[i][j];
2401

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

    
2421
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2422
    }
2423

    
2424
    /* copy global metadata by default */
2425
    if (metadata_global_autocopy) {
2426

    
2427
        for (i = 0; i < nb_output_files; i++)
2428
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2429
                             AV_METADATA_DONT_OVERWRITE);
2430
    }
2431

    
2432
    /* copy chapters according to chapter maps */
2433
    for (i = 0; i < nb_chapter_maps; i++) {
2434
        int infile  = chapter_maps[i].in_file;
2435
        int outfile = chapter_maps[i].out_file;
2436

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

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

    
2458
            for (j = 0; j < nb_output_files; j++)
2459
                if ((ret = copy_chapters(i, j)) < 0)
2460
                    goto dump_format;
2461
            break;
2462
        }
2463

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

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

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

    
2502
    if (ret) {
2503
        fprintf(stderr, "%s\n", error);
2504
        goto fail;
2505
    }
2506

    
2507
    if (want_sdp) {
2508
        print_sdp(output_files, nb_output_files);
2509
    }
2510

    
2511
    if (!using_stdin && verbose >= 0) {
2512
        fprintf(stderr, "Press [q] to stop encoding\n");
2513
        url_set_interrupt_cb(decode_interrupt_cb);
2514
    }
2515
    term_init();
2516

    
2517
    timer_start = av_gettime();
2518

    
2519
    for(; received_sigterm == 0;) {
2520
        int file_index, ist_index;
2521
        AVPacket pkt;
2522
        double ipts_min;
2523
        double opts_min;
2524

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

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

    
2576
        /* finish if limit size exhausted */
2577
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2578
            break;
2579

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

    
2596
        no_packet_count=0;
2597
        memset(no_packet, 0, sizeof(no_packet));
2598

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

    
2611
        if (pkt.dts != AV_NOPTS_VALUE)
2612
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2613
        if (pkt.pts != AV_NOPTS_VALUE)
2614
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2615

    
2616
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2617
            && input_files_ts_scale[file_index][pkt.stream_index]){
2618
            if(pkt.pts != AV_NOPTS_VALUE)
2619
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2620
            if(pkt.dts != AV_NOPTS_VALUE)
2621
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2622
        }
2623

    
2624
//        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);
2625
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2626
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2627
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2628
            int64_t delta= pkt_dts - ist->next_pts;
2629
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2630
                input_files_ts_offset[ist->file_index]-= delta;
2631
                if (verbose > 2)
2632
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2633
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2634
                if(pkt.pts != AV_NOPTS_VALUE)
2635
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2636
            }
2637
        }
2638

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

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

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

    
2658
    discard_packet:
2659
        av_free_packet(&pkt);
2660

    
2661
        /* dump report by using the output first video and audio streams */
2662
        print_report(output_files, ost_table, nb_ostreams, 0);
2663
    }
2664

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

    
2673
    term_exit();
2674

    
2675
    /* write the trailer if needed and close file */
2676
    for(i=0;i<nb_output_files;i++) {
2677
        os = output_files[i];
2678
        av_write_trailer(os);
2679
    }
2680

    
2681
    /* dump report by using the first video and audio streams */
2682
    print_report(output_files, ost_table, nb_ostreams, 1);
2683

    
2684
    /* close each encoder */
2685
    for(i=0;i<nb_ostreams;i++) {
2686
        ost = ost_table[i];
2687
        if (ost->encoding_needed) {
2688
            av_freep(&ost->st->codec->stats_in);
2689
            avcodec_close(ost->st->codec);
2690
        }
2691
    }
2692

    
2693
    /* close each decoder */
2694
    for(i=0;i<nb_istreams;i++) {
2695
        ist = ist_table[i];
2696
        if (ist->decoding_needed) {
2697
            avcodec_close(ist->st->codec);
2698
        }
2699
    }
2700
#if CONFIG_AVFILTER
2701
    if (graph) {
2702
        avfilter_graph_free(graph);
2703
        av_freep(&graph);
2704
    }
2705
#endif
2706

    
2707
    /* finished ! */
2708
    ret = 0;
2709

    
2710
 fail:
2711
    av_freep(&bit_buffer);
2712
    av_free(file_table);
2713

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

    
2750
static void opt_format(const char *arg)
2751
{
2752
    last_asked_format = arg;
2753
}
2754

    
2755
static void opt_video_rc_override_string(const char *arg)
2756
{
2757
    video_rc_override_string = arg;
2758
}
2759

    
2760
static int opt_me_threshold(const char *opt, const char *arg)
2761
{
2762
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2763
    return 0;
2764
}
2765

    
2766
static int opt_verbose(const char *opt, const char *arg)
2767
{
2768
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2769
    return 0;
2770
}
2771

    
2772
static int opt_frame_rate(const char *opt, const char *arg)
2773
{
2774
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2775
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2776
        ffmpeg_exit(1);
2777
    }
2778
    return 0;
2779
}
2780

    
2781
static int opt_bitrate(const char *opt, const char *arg)
2782
{
2783
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2784

    
2785
    opt_default(opt, arg);
2786

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

    
2790
    return 0;
2791
}
2792

    
2793
static int opt_frame_crop(const char *opt, const char *arg)
2794
{
2795
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2796
    return AVERROR(EINVAL);
2797
}
2798

    
2799
static void opt_frame_size(const char *arg)
2800
{
2801
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2802
        fprintf(stderr, "Incorrect frame size\n");
2803
        ffmpeg_exit(1);
2804
    }
2805
}
2806

    
2807
static int opt_pad(const char *opt, const char *arg) {
2808
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2809
    return -1;
2810
}
2811

    
2812
static void opt_frame_pix_fmt(const char *arg)
2813
{
2814
    if (strcmp(arg, "list")) {
2815
        frame_pix_fmt = av_get_pix_fmt(arg);
2816
        if (frame_pix_fmt == PIX_FMT_NONE) {
2817
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2818
            ffmpeg_exit(1);
2819
        }
2820
    } else {
2821
        show_pix_fmts();
2822
        ffmpeg_exit(0);
2823
    }
2824
}
2825

    
2826
static void opt_frame_aspect_ratio(const char *arg)
2827
{
2828
    int x = 0, y = 0;
2829
    double ar = 0;
2830
    const char *p;
2831
    char *end;
2832

    
2833
    p = strchr(arg, ':');
2834
    if (p) {
2835
        x = strtol(arg, &end, 10);
2836
        if (end == p)
2837
            y = strtol(end+1, &end, 10);
2838
        if (x > 0 && y > 0)
2839
            ar = (double)x / (double)y;
2840
    } else
2841
        ar = strtod(arg, NULL);
2842

    
2843
    if (!ar) {
2844
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2845
        ffmpeg_exit(1);
2846
    }
2847
    frame_aspect_ratio = ar;
2848
}
2849

    
2850
static int opt_metadata(const char *opt, const char *arg)
2851
{
2852
    char *mid= strchr(arg, '=');
2853

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

    
2860
    av_metadata_set2(&metadata, arg, mid, 0);
2861

    
2862
    return 0;
2863
}
2864

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

    
2875
static void opt_top_field_first(const char *arg)
2876
{
2877
    top_field_first= atoi(arg);
2878
}
2879

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

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

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

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

    
2916
static void opt_video_channel(const char *arg)
2917
{
2918
    video_channel = strtol(arg, NULL, 0);
2919
}
2920

    
2921
static void opt_video_standard(const char *arg)
2922
{
2923
    video_standard = av_strdup(arg);
2924
}
2925

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

    
2937
static void opt_audio_codec(const char *arg)
2938
{
2939
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2940
}
2941

    
2942
static void opt_video_codec(const char *arg)
2943
{
2944
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2945
}
2946

    
2947
static void opt_subtitle_codec(const char *arg)
2948
{
2949
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2950
}
2951

    
2952
static int opt_codec_tag(const char *opt, const char *arg)
2953
{
2954
    char *tail;
2955
    uint32_t *codec_tag;
2956

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

    
2963
    *codec_tag = strtol(arg, &tail, 0);
2964
    if (!tail || *tail)
2965
        *codec_tag = AV_RL32(arg);
2966

    
2967
    return 0;
2968
}
2969

    
2970
static void opt_map(const char *arg)
2971
{
2972
    AVStreamMap *m;
2973
    char *p;
2974

    
2975
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2976
    m = &stream_maps[nb_stream_maps-1];
2977

    
2978
    m->file_index = strtol(arg, &p, 0);
2979
    if (*p)
2980
        p++;
2981

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

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

    
3016
static void opt_map_metadata(const char *arg)
3017
{
3018
    AVMetaDataMap *m, *m1;
3019
    char *p;
3020

    
3021
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3022
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3023

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

    
3030
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3031
    m1->file = strtol(p, &p, 0);
3032
    parse_meta_type(p, &m1->type, &m1->index, &p);
3033

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

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

    
3049
static void opt_map_chapters(const char *arg)
3050
{
3051
    AVChapterMap *c;
3052
    char *p;
3053

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

    
3061
    c->in_file = strtol(p, &p, 0);
3062
}
3063

    
3064
static void opt_input_ts_scale(const char *arg)
3065
{
3066
    unsigned int stream;
3067
    double scale;
3068
    char *p;
3069

    
3070
    stream = strtol(arg, &p, 0);
3071
    if (*p)
3072
        p++;
3073
    scale= strtod(p, &p);
3074

    
3075
    if(stream >= MAX_STREAMS)
3076
        ffmpeg_exit(1);
3077

    
3078
    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);
3079
    input_files_ts_scale[nb_input_files][stream]= scale;
3080
}
3081

    
3082
static int opt_recording_time(const char *opt, const char *arg)
3083
{
3084
    recording_time = parse_time_or_die(opt, arg, 1);
3085
    return 0;
3086
}
3087

    
3088
static int opt_start_time(const char *opt, const char *arg)
3089
{
3090
    start_time = parse_time_or_die(opt, arg, 1);
3091
    return 0;
3092
}
3093

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

    
3100
static int opt_input_ts_offset(const char *opt, const char *arg)
3101
{
3102
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3103
    return 0;
3104
}
3105

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

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

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

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

    
3156
    if (!strcmp(filename, "-"))
3157
        filename = "pipe:";
3158

    
3159
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3160
                    !strcmp(filename, "/dev/stdin");
3161

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

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

    
3182
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3183

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

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

    
3225
    ic->loop_input = loop_input;
3226

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

    
3236
    timestamp = start_time;
3237
    /* add the stream start time */
3238
    if (ic->start_time != AV_NOPTS_VALUE)
3239
        timestamp += ic->start_time;
3240

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

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

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

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

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

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

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

    
3336
    nb_input_files++;
3337

    
3338
    video_channel = 0;
3339

    
3340
    av_freep(&video_codec_name);
3341
    av_freep(&audio_codec_name);
3342
    av_freep(&subtitle_codec_name);
3343
}
3344

    
3345
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3346
                                         int *has_subtitle_ptr)
3347
{
3348
    int has_video, has_audio, has_subtitle, i, j;
3349
    AVFormatContext *ic;
3350

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

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

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

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

    
3410
    avcodec_get_context_defaults3(st->codec, codec);
3411
    ost->bitstream_filters = video_bitstream_filters;
3412
    video_bitstream_filters= NULL;
3413

    
3414
    avcodec_thread_init(st->codec, thread_count);
3415

    
3416
    video_enc = st->codec;
3417

    
3418
    if(video_codec_tag)
3419
        video_enc->codec_tag= video_codec_tag;
3420

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

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

    
3441
        video_enc->codec_id = codec_id;
3442
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3443

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

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

    
3455
        choose_pixel_fmt(st, codec);
3456

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

    
3465
        if(intra_matrix)
3466
            video_enc->intra_matrix = intra_matrix;
3467
        if(inter_matrix)
3468
            video_enc->inter_matrix = inter_matrix;
3469

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

    
3500
        if (do_psnr)
3501
            video_enc->flags|= CODEC_FLAG_PSNR;
3502

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

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

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

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

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

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

    
3556
    avcodec_get_context_defaults3(st->codec, codec);
3557

    
3558
    ost->bitstream_filters = audio_bitstream_filters;
3559
    audio_bitstream_filters= NULL;
3560

    
3561
    avcodec_thread_init(st->codec, thread_count);
3562

    
3563
    audio_enc = st->codec;
3564
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3565

    
3566
    if(audio_codec_tag)
3567
        audio_enc->codec_tag= audio_codec_tag;
3568

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

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

    
3600
    /* reset some key parameters */
3601
    audio_disable = 0;
3602
    av_freep(&audio_codec_name);
3603
    audio_stream_copy = 0;
3604
}
3605

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

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

    
3634
    ost->bitstream_filters = subtitle_bitstream_filters;
3635
    subtitle_bitstream_filters= NULL;
3636

    
3637
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3638

    
3639
    if(subtitle_codec_tag)
3640
        subtitle_enc->codec_tag= subtitle_codec_tag;
3641

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

    
3653
    if (subtitle_language) {
3654
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3655
        av_freep(&subtitle_language);
3656
    }
3657

    
3658
    subtitle_disable = 0;
3659
    av_freep(&subtitle_codec_name);
3660
    subtitle_stream_copy = 0;
3661
}
3662

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

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

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

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

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

    
3711
    if (!strcmp(filename, "-"))
3712
        filename = "pipe:";
3713

    
3714
    oc = avformat_alloc_context();
3715
    if (!oc) {
3716
        print_error(filename, AVERROR(ENOMEM));
3717
        ffmpeg_exit(1);
3718
    }
3719

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

    
3736
    oc->oformat = file_oformat;
3737
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3738

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

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

    
3766
        /* manual disable */
3767
        if (audio_disable)    use_audio    = 0;
3768
        if (video_disable)    use_video    = 0;
3769
        if (subtitle_disable) use_subtitle = 0;
3770

    
3771
        if (use_video)    new_video_stream(oc, nb_output_files);
3772
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3773
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3774

    
3775
        oc->timestamp = recording_timestamp;
3776

    
3777
        av_metadata_copy(&oc->metadata, metadata, 0);
3778
        av_metadata_free(&metadata);
3779
    }
3780

    
3781
    output_files[nb_output_files++] = oc;
3782

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

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

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

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

    
3827
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3828
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3829
    oc->loop_output = loop_output;
3830
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3831

    
3832
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3833

    
3834
    av_freep(&forced_key_frames);
3835
}
3836

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

    
3849
static int64_t getutime(void)
3850
{
3851
#if HAVE_GETRUSAGE
3852
    struct rusage rusage;
3853

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

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

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

    
3902
static void opt_inter_matrix(const char *arg)
3903
{
3904
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3905
    parse_matrix_coeffs(inter_matrix, arg);
3906
}
3907

    
3908
static void opt_intra_matrix(const char *arg)
3909
{
3910
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3911
    parse_matrix_coeffs(intra_matrix, arg);
3912
}
3913

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

    
3921
static void show_help(void)
3922
{
3923
    AVCodec *c;
3924
    AVOutputFormat *oformat = NULL;
3925

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

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

    
3964
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3965
    printf("\n");
3966

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

    
3975
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3976
}
3977

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

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

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

    
4034
    if(!strcmp(arg, "vcd")) {
4035

    
4036
        opt_video_codec("mpeg1video");
4037
        opt_audio_codec("mp2");
4038
        opt_format("vcd");
4039

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

    
4044
        opt_default("b", "1150000");
4045
        opt_default("maxrate", "1150000");
4046
        opt_default("minrate", "1150000");
4047
        opt_default("bufsize", "327680"); // 40*1024*8;
4048

    
4049
        opt_default("ab", "224000");
4050
        audio_sample_rate = 44100;
4051
        audio_channels = 2;
4052

    
4053
        opt_default("packetsize", "2324");
4054
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4055

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

    
4064
        opt_video_codec("mpeg2video");
4065
        opt_audio_codec("mp2");
4066
        opt_format("svcd");
4067

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

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

    
4078

    
4079
        opt_default("ab", "224000");
4080
        audio_sample_rate = 44100;
4081

    
4082
        opt_default("packetsize", "2324");
4083

    
4084
    } else if(!strcmp(arg, "dvd")) {
4085

    
4086
        opt_video_codec("mpeg2video");
4087
        opt_audio_codec("ac3");
4088
        opt_format("dvd");
4089

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

    
4094
        opt_default("b", "6000000");
4095
        opt_default("maxrate", "9000000");
4096
        opt_default("minrate", "0"); //1500000;
4097
        opt_default("bufsize", "1835008"); //224*1024*8;
4098

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

    
4102
        opt_default("ab", "448000");
4103
        audio_sample_rate = 48000;
4104

    
4105
    } else if(!strncmp(arg, "dv", 2)) {
4106

    
4107
        opt_format("dv");
4108

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

    
4114
        audio_sample_rate = 48000;
4115
        audio_channels = 2;
4116

    
4117
    } else {
4118
        fprintf(stderr, "Unknown target: %s\n", arg);
4119
        ffmpeg_exit(1);
4120
    }
4121
}
4122

    
4123
static void opt_vstats_file (const char *arg)
4124
{
4125
    av_free (vstats_filename);
4126
    vstats_filename=av_strdup (arg);
4127
}
4128

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

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

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

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

    
4150
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4151
          *opt == 'a' ? &audio_bitstream_filters :
4152
                        &subtitle_bitstream_filters;
4153
    while(*bsfp)
4154
        bsfp= &(*bsfp)->next;
4155

    
4156
    *bsfp= bsfc;
4157

    
4158
    return 0;
4159
}
4160

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

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

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

    
4195
    fclose(f);
4196

    
4197
    return 0;
4198
}
4199

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

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

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

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

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

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

    
4323
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4324
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4325
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4326

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

    
4332
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4333
    { NULL, },
4334
};
4335

    
4336
int main(int argc, char **argv)
4337
{
4338
    int64_t ti;
4339

    
4340
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4341

    
4342
    avcodec_register_all();
4343
#if CONFIG_AVDEVICE
4344
    avdevice_register_all();
4345
#endif
4346
#if CONFIG_AVFILTER
4347
    avfilter_register_all();
4348
#endif
4349
    av_register_all();
4350

    
4351
#if HAVE_ISATTY
4352
    if(isatty(STDIN_FILENO))
4353
        url_set_interrupt_cb(decode_interrupt_cb);
4354
#endif
4355

    
4356
    init_opts();
4357

    
4358
    show_banner();
4359

    
4360
    /* parse options */
4361
    parse_options(argc, argv, options, opt_output_file);
4362

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

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

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

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

    
4390
    return ffmpeg_exit(0);
4391
}