Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 2bc05d35

History | View | Annotate | Download (157 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/parseutils.h"
40
#include "libavutil/colorspace.h"
41
#include "libavutil/fifo.h"
42
#include "libavutil/pixdesc.h"
43
#include "libavutil/avstring.h"
44
#include "libavutil/libm.h"
45
#include "libavformat/os_support.h"
46

    
47
#if CONFIG_AVFILTER
48
# include "libavfilter/avfilter.h"
49
# include "libavfilter/avfiltergraph.h"
50
# include "libavfilter/graphparser.h"
51
# include "libavfilter/vsrc_buffer.h"
52
#endif
53

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

    
66
#if HAVE_SYS_SELECT_H
67
#include <sys/select.h>
68
#endif
69

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

    
80
#include "cmdutils.h"
81

    
82
#undef NDEBUG
83
#include <assert.h>
84

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

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

    
96
/**
97
 * select an input file for an output file
98
 */
99
typedef struct AVMetaDataMap {
100
    int out_file;
101
    int in_file;
102
} AVMetaDataMap;
103

    
104
static const OptionDef options[];
105

    
106
#define MAX_FILES 100
107

    
108
static const char *last_asked_format = NULL;
109
static AVFormatContext *input_files[MAX_FILES];
110
static int64_t input_files_ts_offset[MAX_FILES];
111
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
112
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
113
static int nb_input_files = 0;
114
static int nb_icodecs;
115

    
116
static AVFormatContext *output_files[MAX_FILES];
117
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
118
static int nb_output_files = 0;
119
static int nb_ocodecs;
120

    
121
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
122
static int nb_stream_maps;
123

    
124
static AVMetaDataMap meta_data_maps[MAX_FILES];
125
static int nb_meta_data_maps;
126

    
127
/* indexed by output file stream index */
128
static int streamid_map[MAX_STREAMS];
129

    
130
static int frame_width  = 0;
131
static int frame_height = 0;
132
static float frame_aspect_ratio = 0;
133
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
134
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
135
static int frame_topBand  = 0;
136
static int frame_bottomBand = 0;
137
static int frame_leftBand  = 0;
138
static int frame_rightBand = 0;
139
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
140
static AVRational frame_rate;
141
static float video_qscale = 0;
142
static uint16_t *intra_matrix = NULL;
143
static uint16_t *inter_matrix = NULL;
144
static const char *video_rc_override_string=NULL;
145
static int video_disable = 0;
146
static int video_discard = 0;
147
static char *video_codec_name = NULL;
148
static unsigned int video_codec_tag = 0;
149
static char *video_language = NULL;
150
static int same_quality = 0;
151
static int do_deinterlace = 0;
152
static int top_field_first = -1;
153
static int me_threshold = 0;
154
static int intra_dc_precision = 8;
155
static int loop_input = 0;
156
static int loop_output = AVFMT_NOOUTPUTLOOP;
157
static int qp_hist = 0;
158
#if CONFIG_AVFILTER
159
static char *vfilters = NULL;
160
AVFilterGraph *graph = NULL;
161
#endif
162

    
163
static int intra_only = 0;
164
static int audio_sample_rate = 44100;
165
static int64_t channel_layout = 0;
166
#define QSCALE_NONE -99999
167
static float audio_qscale = QSCALE_NONE;
168
static int audio_disable = 0;
169
static int audio_channels = 1;
170
static char  *audio_codec_name = NULL;
171
static unsigned int audio_codec_tag = 0;
172
static char *audio_language = NULL;
173

    
174
static int subtitle_disable = 0;
175
static char *subtitle_codec_name = NULL;
176
static char *subtitle_language = NULL;
177
static unsigned int subtitle_codec_tag = 0;
178

    
179
static float mux_preload= 0.5;
180
static float mux_max_delay= 0.7;
181

    
182
static int64_t recording_time = INT64_MAX;
183
static int64_t start_time = 0;
184
static int64_t recording_timestamp = 0;
185
static int64_t input_ts_offset = 0;
186
static int file_overwrite = 0;
187
static int metadata_count;
188
static AVMetadataTag *metadata;
189
static int do_benchmark = 0;
190
static int do_hex_dump = 0;
191
static int do_pkt_dump = 0;
192
static int do_psnr = 0;
193
static int do_pass = 0;
194
static char *pass_logfilename_prefix = NULL;
195
static int audio_stream_copy = 0;
196
static int video_stream_copy = 0;
197
static int subtitle_stream_copy = 0;
198
static int video_sync_method= -1;
199
static int audio_sync_method= 0;
200
static float audio_drift_threshold= 0.1;
201
static int copy_ts= 0;
202
static int opt_shortest = 0;
203
static int video_global_header = 0;
204
static char *vstats_filename;
205
static FILE *vstats_file;
206
static int opt_programid = 0;
207
static int copy_initial_nonkeyframes = 0;
208

    
209
static int rate_emu = 0;
210

    
211
static int  video_channel = 0;
212
static char *video_standard;
213

    
214
static int audio_volume = 256;
215

    
216
static int exit_on_error = 0;
217
static int using_stdin = 0;
218
static int verbose = 1;
219
static int thread_count= 1;
220
static int q_pressed = 0;
221
static int64_t video_size = 0;
222
static int64_t audio_size = 0;
223
static int64_t extra_size = 0;
224
static int nb_frames_dup = 0;
225
static int nb_frames_drop = 0;
226
static int input_sync;
227
static uint64_t limit_filesize = 0;
228
static int force_fps = 0;
229

    
230
static int pgmyuv_compatibility_hack=0;
231
static float dts_delta_threshold = 10;
232

    
233
static unsigned int sws_flags = SWS_BICUBIC;
234

    
235
static int64_t timer_start;
236

    
237
static uint8_t *audio_buf;
238
static uint8_t *audio_out;
239
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
240

    
241
static short *samples;
242

    
243
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
244
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
245
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
246
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
247

    
248
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
249

    
250
struct AVInputStream;
251

    
252
typedef struct AVOutputStream {
253
    int file_index;          /* file index */
254
    int index;               /* stream index in the output file */
255
    int source_index;        /* AVInputStream index */
256
    AVStream *st;            /* stream in the output file */
257
    int encoding_needed;     /* true if encoding needed for this stream */
258
    int frame_number;
259
    /* input pts and corresponding output pts
260
       for A/V sync */
261
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
262
    struct AVInputStream *sync_ist; /* input stream to sync against */
263
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
264
    /* video only */
265
    int video_resample;
266
    AVFrame pict_tmp;      /* temporary image for resampling */
267
    struct SwsContext *img_resample_ctx; /* for image resampling */
268
    int resample_height;
269
    int resample_width;
270
    int resample_pix_fmt;
271

    
272
    /* full frame size of first frame */
273
    int original_height;
274
    int original_width;
275

    
276
    /* cropping area sizes */
277
    int video_crop;
278
    int topBand;
279
    int bottomBand;
280
    int leftBand;
281
    int rightBand;
282

    
283
    /* cropping area of first frame */
284
    int original_topBand;
285
    int original_bottomBand;
286
    int original_leftBand;
287
    int original_rightBand;
288

    
289
    /* audio only */
290
    int audio_resample;
291
    ReSampleContext *resample; /* for audio resampling */
292
    int reformat_pair;
293
    AVAudioConvert *reformat_ctx;
294
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
295
    FILE *logfile;
296
} AVOutputStream;
297

    
298
typedef struct AVInputStream {
299
    int file_index;
300
    int index;
301
    AVStream *st;
302
    int discard;             /* true if stream data should be discarded */
303
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
304
    int64_t sample_index;      /* current sample */
305

    
306
    int64_t       start;     /* time when read started */
307
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
308
                                is not defined */
309
    int64_t       pts;       /* current pts */
310
    int is_start;            /* is 1 at the start and after a discontinuity */
311
    int showed_multi_packet_warning;
312
    int is_past_recording_time;
313
#if CONFIG_AVFILTER
314
    AVFilterContext *output_video_filter;
315
    AVFilterContext *input_video_filter;
316
    AVFrame *filter_frame;
317
    int has_filter_frame;
318
    AVFilterBufferRef *picref;
319
#endif
320
} AVInputStream;
321

    
322
typedef struct AVInputFile {
323
    int eof_reached;      /* true if eof reached */
324
    int ist_index;        /* index of first stream in ist_table */
325
    int buffer_size;      /* current total buffer size */
326
    int nb_streams;       /* nb streams we are aware of */
327
} AVInputFile;
328

    
329
#if HAVE_TERMIOS_H
330

    
331
/* init terminal so that we can grab keys */
332
static struct termios oldtty;
333
#endif
334

    
335
#if CONFIG_AVFILTER
336
typedef struct {
337
    int pix_fmt;
338
} FilterOutPriv;
339

    
340

    
341
static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
342
{
343
    FilterOutPriv *priv = ctx->priv;
344

    
345
    if(!opaque) return -1;
346

    
347
    priv->pix_fmt = *((int *)opaque);
348

    
349
    return 0;
350
}
351

    
352
static void output_end_frame(AVFilterLink *link)
353
{
354
}
355

    
356
static int output_query_formats(AVFilterContext *ctx)
357
{
358
    FilterOutPriv *priv = ctx->priv;
359
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
360

    
361
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
362
    return 0;
363
}
364

    
365
static int get_filtered_video_pic(AVFilterContext *ctx,
366
                                  AVFilterBufferRef **picref, AVFrame *pic2,
367
                                  uint64_t *pts)
368
{
369
    AVFilterBufferRef *pic;
370

    
371
    if(avfilter_request_frame(ctx->inputs[0]))
372
        return -1;
373
    if(!(pic = ctx->inputs[0]->cur_buf))
374
        return -1;
375
    *picref = pic;
376
    ctx->inputs[0]->cur_buf = NULL;
377

    
378
    *pts          = pic->pts;
379

    
380
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
381
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
382
    pic2->interlaced_frame = pic->video->interlaced;
383
    pic2->top_field_first  = pic->video->top_field_first;
384

    
385
    return 1;
386
}
387

    
388
static AVFilter output_filter =
389
{
390
    .name      = "ffmpeg_output",
391

    
392
    .priv_size = sizeof(FilterOutPriv),
393
    .init      = output_init,
394

    
395
    .query_formats = output_query_formats,
396

    
397
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
398
                                    .type          = AVMEDIA_TYPE_VIDEO,
399
                                    .end_frame     = output_end_frame,
400
                                    .min_perms     = AV_PERM_READ, },
401
                                  { .name = NULL }},
402
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
403
};
404

    
405
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
406
{
407
    AVFilterContext *last_filter, *filter;
408
    /** filter graph containing all filters including input & output */
409
    AVCodecContext *codec = ost->st->codec;
410
    AVCodecContext *icodec = ist->st->codec;
411
    char args[255];
412
    int ret;
413

    
414
    graph = av_mallocz(sizeof(AVFilterGraph));
415

    
416
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
417
        return ret;
418
    if ((ret = avfilter_open(&ist->output_video_filter, &output_filter, "out")) < 0)
419
        return ret;
420

    
421
    snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
422
             ist->st->codec->height, ist->st->codec->pix_fmt);
423
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
424
        return ret;
425
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &codec->pix_fmt)) < 0)
426
        return ret;
427

    
428
    /* add input and output filters to the overall graph */
429
    avfilter_graph_add_filter(graph, ist->input_video_filter);
430
    avfilter_graph_add_filter(graph, ist->output_video_filter);
431

    
432
    last_filter = ist->input_video_filter;
433

    
434
    if (ost->video_crop) {
435
        snprintf(args, 255, "%d:%d:%d:%d",
436
                 codec->width, codec->height,
437
                 ost->leftBand, ost->topBand);
438
        if ((ret = avfilter_open(&filter, avfilter_get_by_name("crop"), NULL)) < 0)
439
            return ret;
440
        if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
441
            return ret;
442
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
443
            return ret;
444
        last_filter = filter;
445
        avfilter_graph_add_filter(graph, last_filter);
446
    }
447

    
448
    if((codec->width !=
449
        icodec->width - (frame_leftBand + frame_rightBand)) ||
450
       (codec->height != icodec->height - (frame_topBand  + frame_bottomBand))) {
451
        snprintf(args, 255, "%d:%d:flags=0x%X",
452
                 codec->width,
453
                 codec->height,
454
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
455
        if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
456
            return ret;
457
        if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
458
            return ret;
459
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
460
            return ret;
461
        last_filter = filter;
462
        avfilter_graph_add_filter(graph, last_filter);
463
    }
464

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

    
468
    if (vfilters) {
469
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
470
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
471

    
472
        outputs->name    = av_strdup("in");
473
        outputs->filter  = last_filter;
474
        outputs->pad_idx = 0;
475
        outputs->next    = NULL;
476

    
477
        inputs->name    = av_strdup("out");
478
        inputs->filter  = ist->output_video_filter;
479
        inputs->pad_idx = 0;
480
        inputs->next    = NULL;
481

    
482
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
483
            return ret;
484
        av_freep(&vfilters);
485
    } else {
486
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
487
            return ret;
488
    }
489

    
490
    /* configure all the filter links */
491
    if ((ret = avfilter_graph_check_validity(graph, NULL)) < 0)
492
        return ret;
493
    if ((ret = avfilter_graph_config_formats(graph, NULL)) < 0)
494
        return ret;
495
    if ((ret = avfilter_graph_config_links(graph, NULL)) < 0)
496
        return ret;
497

    
498
    codec->width  = ist->output_video_filter->inputs[0]->w;
499
    codec->height = ist->output_video_filter->inputs[0]->h;
500

    
501
    return 0;
502
}
503
#endif /* CONFIG_AVFILTER */
504

    
505
static void term_exit(void)
506
{
507
    av_log(NULL, AV_LOG_QUIET, "");
508
#if HAVE_TERMIOS_H
509
    tcsetattr (0, TCSANOW, &oldtty);
510
#endif
511
}
512

    
513
static volatile int received_sigterm = 0;
514

    
515
static void
516
sigterm_handler(int sig)
517
{
518
    received_sigterm = sig;
519
    term_exit();
520
}
521

    
522
static void term_init(void)
523
{
524
#if HAVE_TERMIOS_H
525
    struct termios tty;
526

    
527
    tcgetattr (0, &tty);
528
    oldtty = tty;
529
    atexit(term_exit);
530

    
531
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
532
                          |INLCR|IGNCR|ICRNL|IXON);
533
    tty.c_oflag |= OPOST;
534
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
535
    tty.c_cflag &= ~(CSIZE|PARENB);
536
    tty.c_cflag |= CS8;
537
    tty.c_cc[VMIN] = 1;
538
    tty.c_cc[VTIME] = 0;
539

    
540
    tcsetattr (0, TCSANOW, &tty);
541
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
542
#endif
543

    
544
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
545
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
546
#ifdef SIGXCPU
547
    signal(SIGXCPU, sigterm_handler);
548
#endif
549
}
550

    
551
/* read a key without blocking */
552
static int read_key(void)
553
{
554
#if HAVE_TERMIOS_H
555
    int n = 1;
556
    unsigned char ch;
557
    struct timeval tv;
558
    fd_set rfds;
559

    
560
    FD_ZERO(&rfds);
561
    FD_SET(0, &rfds);
562
    tv.tv_sec = 0;
563
    tv.tv_usec = 0;
564
    n = select(1, &rfds, NULL, NULL, &tv);
565
    if (n > 0) {
566
        n = read(0, &ch, 1);
567
        if (n == 1)
568
            return ch;
569

    
570
        return n;
571
    }
572
#elif HAVE_CONIO_H
573
    if(kbhit())
574
        return(getch());
575
#endif
576
    return -1;
577
}
578

    
579
static int decode_interrupt_cb(void)
580
{
581
    return q_pressed || (q_pressed = read_key() == 'q');
582
}
583

    
584
static int ffmpeg_exit(int ret)
585
{
586
    int i;
587

    
588
    /* close files */
589
    for(i=0;i<nb_output_files;i++) {
590
        /* maybe av_close_output_file ??? */
591
        AVFormatContext *s = output_files[i];
592
        int j;
593
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
594
            url_fclose(s->pb);
595
        for(j=0;j<s->nb_streams;j++) {
596
            av_metadata_free(&s->streams[j]->metadata);
597
            av_free(s->streams[j]->codec);
598
            av_free(s->streams[j]);
599
        }
600
        for(j=0;j<s->nb_programs;j++) {
601
            av_metadata_free(&s->programs[j]->metadata);
602
        }
603
        for(j=0;j<s->nb_chapters;j++) {
604
            av_metadata_free(&s->chapters[j]->metadata);
605
        }
606
        av_metadata_free(&s->metadata);
607
        av_free(s);
608
    }
609
    for(i=0;i<nb_input_files;i++)
610
        av_close_input_file(input_files[i]);
611

    
612
    av_free(intra_matrix);
613
    av_free(inter_matrix);
614

    
615
    if (vstats_file)
616
        fclose(vstats_file);
617
    av_free(vstats_filename);
618

    
619
    av_free(opt_names);
620

    
621
    av_free(video_codec_name);
622
    av_free(audio_codec_name);
623
    av_free(subtitle_codec_name);
624

    
625
    av_free(video_standard);
626

    
627
    for (i=0;i<AVMEDIA_TYPE_NB;i++)
628
        av_free(avcodec_opts[i]);
629
    av_free(avformat_opts);
630
    av_free(sws_opts);
631
    av_free(audio_buf);
632
    av_free(audio_out);
633
    allocated_audio_buf_size= allocated_audio_out_size= 0;
634
    av_free(samples);
635

    
636
#if CONFIG_AVFILTER
637
    avfilter_uninit();
638
#endif
639

    
640
    if (received_sigterm) {
641
        fprintf(stderr,
642
            "Received signal %d: terminating.\n",
643
            (int) received_sigterm);
644
        exit (255);
645
    }
646

    
647
    exit(ret); /* not all OS-es handle main() return value */
648
    return ret;
649
}
650

    
651
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
652
{
653
    if(codec && codec->sample_fmts){
654
        const enum SampleFormat *p= codec->sample_fmts;
655
        for(; *p!=-1; p++){
656
            if(*p == st->codec->sample_fmt)
657
                break;
658
        }
659
        if(*p == -1)
660
            st->codec->sample_fmt = codec->sample_fmts[0];
661
    }
662
}
663

    
664
static void choose_sample_rate(AVStream *st, AVCodec *codec)
665
{
666
    if(codec && codec->supported_samplerates){
667
        const int *p= codec->supported_samplerates;
668
        int best=0;
669
        int best_dist=INT_MAX;
670
        for(; *p; p++){
671
            int dist= abs(st->codec->sample_rate - *p);
672
            if(dist < best_dist){
673
                best_dist= dist;
674
                best= *p;
675
            }
676
        }
677
        if(best_dist){
678
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
679
        }
680
        st->codec->sample_rate= best;
681
    }
682
}
683

    
684
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
685
{
686
    if(codec && codec->pix_fmts){
687
        const enum PixelFormat *p= codec->pix_fmts;
688
        for(; *p!=-1; p++){
689
            if(*p == st->codec->pix_fmt)
690
                break;
691
        }
692
        if(*p == -1
693
           && !(   st->codec->codec_id==CODEC_ID_MJPEG
694
                && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
695
                && (   st->codec->pix_fmt == PIX_FMT_YUV420P
696
                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))
697
            st->codec->pix_fmt = codec->pix_fmts[0];
698
    }
699
}
700

    
701
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
702
{
703
    int i, err;
704
    AVFormatContext *ic;
705
    int nopts = 0;
706

    
707
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
708
    if (err < 0)
709
        return err;
710
    /* copy stream format */
711
    s->nb_streams = ic->nb_streams;
712
    for(i=0;i<ic->nb_streams;i++) {
713
        AVStream *st;
714
        AVCodec *codec;
715

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

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

    
740
        if(!st->codec->thread_count)
741
            st->codec->thread_count = 1;
742
        if(st->codec->thread_count>1)
743
            avcodec_thread_init(st->codec, st->codec->thread_count);
744

    
745
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
746
            nopts = 1;
747
    }
748

    
749
    if (!nopts)
750
        s->timestamp = av_gettime();
751

    
752
    av_close_input_file(ic);
753
    return 0;
754
}
755

    
756
static double
757
get_sync_ipts(const AVOutputStream *ost)
758
{
759
    const AVInputStream *ist = ost->sync_ist;
760
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
761
}
762

    
763
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
764
    int ret;
765

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

    
785
        bsfc= bsfc->next;
786
    }
787

    
788
    ret= av_interleaved_write_frame(s, pkt);
789
    if(ret < 0){
790
        print_error("av_interleaved_write_frame()", ret);
791
        ffmpeg_exit(1);
792
    }
793
}
794

    
795
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
796

    
797
static void do_audio_out(AVFormatContext *s,
798
                         AVOutputStream *ost,
799
                         AVInputStream *ist,
800
                         unsigned char *buf, int size)
801
{
802
    uint8_t *buftmp;
803
    int64_t audio_out_size, audio_buf_size;
804
    int64_t allocated_for_size= size;
805

    
806
    int size_out, frame_bytes, ret;
807
    AVCodecContext *enc= ost->st->codec;
808
    AVCodecContext *dec= ist->st->codec;
809
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
810
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
811
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
812

    
813
need_realloc:
814
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
815
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
816
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
817
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
818
    audio_buf_size*= osize*enc->channels;
819

    
820
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
821
    if(coded_bps > 8*osize)
822
        audio_out_size= audio_out_size * coded_bps / (8*osize);
823
    audio_out_size += FF_MIN_BUFFER_SIZE;
824

    
825
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
826
        fprintf(stderr, "Buffer sizes too large\n");
827
        ffmpeg_exit(1);
828
    }
829

    
830
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
831
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
832
    if (!audio_buf || !audio_out){
833
        fprintf(stderr, "Out of memory in do_audio_out\n");
834
        ffmpeg_exit(1);
835
    }
836

    
837
    if (enc->channels != dec->channels)
838
        ost->audio_resample = 1;
839

    
840
    if (ost->audio_resample && !ost->resample) {
841
        if (dec->sample_fmt != SAMPLE_FMT_S16)
842
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
843
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
844
                                               enc->sample_rate, dec->sample_rate,
845
                                               enc->sample_fmt,  dec->sample_fmt,
846
                                               16, 10, 0, 0.8);
847
        if (!ost->resample) {
848
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
849
                    dec->channels, dec->sample_rate,
850
                    enc->channels, enc->sample_rate);
851
            ffmpeg_exit(1);
852
        }
853
    }
854

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

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

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

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

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

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

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

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

    
955
        frame_bytes = enc->frame_size * osize * enc->channels;
956

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

    
961
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
962

    
963
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
964

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

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

    
986
        ost->sync_opts += size_out / (osize * enc->channels);
987

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

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

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

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

    
1024
    dec = ist->st->codec;
1025

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

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

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

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

    
1051
    if (picture != picture2)
1052
        *picture = *picture2;
1053
    *bufp = buf;
1054
}
1055

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

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

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

    
1078
    enc = ost->st->codec;
1079

    
1080
    if (!subtitle_out) {
1081
        subtitle_out = av_malloc(subtitle_out_max_size);
1082
    }
1083

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

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

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

    
1122
static int bit_buffer_size= 1024*256;
1123
static uint8_t *bit_buffer= NULL;
1124

    
1125
static void do_video_out(AVFormatContext *s,
1126
                         AVOutputStream *ost,
1127
                         AVInputStream *ist,
1128
                         AVFrame *in_picture,
1129
                         int *frame_size)
1130
{
1131
    int nb_frames, i, ret;
1132
#if !CONFIG_AVFILTER
1133
    int64_t topBand, bottomBand, leftBand, rightBand;
1134
#endif
1135
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1136
    AVFrame picture_crop_temp, picture_pad_temp;
1137
    AVCodecContext *enc, *dec;
1138
    double sync_ipts;
1139

    
1140
    avcodec_get_frame_defaults(&picture_crop_temp);
1141
    avcodec_get_frame_defaults(&picture_pad_temp);
1142

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

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

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

    
1151
    *frame_size = 0;
1152

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

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

    
1182
#if CONFIG_AVFILTER
1183
    formatted_picture = in_picture;
1184
#else
1185
    if (ost->video_crop) {
1186
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1187
            fprintf(stderr, "error cropping picture\n");
1188
            if (exit_on_error)
1189
                ffmpeg_exit(1);
1190
            return;
1191
        }
1192
        formatted_picture = &picture_crop_temp;
1193
    } else {
1194
        formatted_picture = in_picture;
1195
    }
1196
#endif
1197

    
1198
    final_picture = formatted_picture;
1199
    padding_src = formatted_picture;
1200
    resampling_dst = &ost->pict_tmp;
1201

    
1202
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1203
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1204
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1205

    
1206
        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));
1207
        if(!ost->video_resample)
1208
            ffmpeg_exit(1);
1209
    }
1210

    
1211
#if !CONFIG_AVFILTER
1212
    if (ost->video_resample) {
1213
        padding_src = NULL;
1214
        final_picture = &ost->pict_tmp;
1215
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1216
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1217
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1218

    
1219
            /* keep bands proportional to the frame size */
1220
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
1221
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1222
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
1223
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
1224

    
1225
            /* sanity check to ensure no bad band sizes sneak in */
1226
            assert(topBand    <= INT_MAX && topBand    >= 0);
1227
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
1228
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
1229
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
1230

    
1231
            ost->topBand    = topBand;
1232
            ost->bottomBand = bottomBand;
1233
            ost->leftBand   = leftBand;
1234
            ost->rightBand  = rightBand;
1235

    
1236
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1237
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1238
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1239

    
1240
            /* initialize a new scaler context */
1241
            sws_freeContext(ost->img_resample_ctx);
1242
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1243
            ost->img_resample_ctx = sws_getContext(
1244
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1245
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1246
                ist->st->codec->pix_fmt,
1247
                ost->st->codec->width,
1248
                ost->st->codec->height,
1249
                ost->st->codec->pix_fmt,
1250
                sws_flags, NULL, NULL, NULL);
1251
            if (ost->img_resample_ctx == NULL) {
1252
                fprintf(stderr, "Cannot get resampling context\n");
1253
                ffmpeg_exit(1);
1254
            }
1255
        }
1256
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1257
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1258
    }
1259
#endif
1260

    
1261
    /* duplicates frame if needed */
1262
    for(i=0;i<nb_frames;i++) {
1263
        AVPacket pkt;
1264
        av_init_packet(&pkt);
1265
        pkt.stream_index= ost->index;
1266

    
1267
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1268
            /* raw pictures are written as AVPicture structure to
1269
               avoid any copies. We support temorarily the older
1270
               method. */
1271
            AVFrame* old_frame = enc->coded_frame;
1272
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1273
            pkt.data= (uint8_t *)final_picture;
1274
            pkt.size=  sizeof(AVPicture);
1275
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1276
            pkt.flags |= AV_PKT_FLAG_KEY;
1277

    
1278
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1279
            enc->coded_frame = old_frame;
1280
        } else {
1281
            AVFrame big_picture;
1282

    
1283
            big_picture= *final_picture;
1284
            /* better than nothing: use input picture interlaced
1285
               settings */
1286
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1287
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1288
                if(top_field_first == -1)
1289
                    big_picture.top_field_first = in_picture->top_field_first;
1290
                else
1291
                    big_picture.top_field_first = top_field_first;
1292
            }
1293

    
1294
            /* handles sameq here. This is not correct because it may
1295
               not be a global option */
1296
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1297
            if(!me_threshold)
1298
                big_picture.pict_type = 0;
1299
//            big_picture.pts = AV_NOPTS_VALUE;
1300
            big_picture.pts= ost->sync_opts;
1301
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1302
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1303
            ret = avcodec_encode_video(enc,
1304
                                       bit_buffer, bit_buffer_size,
1305
                                       &big_picture);
1306
            if (ret < 0) {
1307
                fprintf(stderr, "Video encoding failed\n");
1308
                ffmpeg_exit(1);
1309
            }
1310

    
1311
            if(ret>0){
1312
                pkt.data= bit_buffer;
1313
                pkt.size= ret;
1314
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1315
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1316
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1317
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1318
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1319

    
1320
                if(enc->coded_frame->key_frame)
1321
                    pkt.flags |= AV_PKT_FLAG_KEY;
1322
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1323
                *frame_size = ret;
1324
                video_size += ret;
1325
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1326
                //        enc->frame_number-1, ret, enc->pict_type);
1327
                /* if two pass, output log */
1328
                if (ost->logfile && enc->stats_out) {
1329
                    fprintf(ost->logfile, "%s", enc->stats_out);
1330
                }
1331
            }
1332
        }
1333
        ost->sync_opts++;
1334
        ost->frame_number++;
1335
    }
1336
}
1337

    
1338
static double psnr(double d){
1339
    return -10.0*log(d)/log(10.0);
1340
}
1341

    
1342
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1343
                           int frame_size)
1344
{
1345
    AVCodecContext *enc;
1346
    int frame_number;
1347
    double ti1, bitrate, avg_bitrate;
1348

    
1349
    /* this is executed just the first time do_video_stats is called */
1350
    if (!vstats_file) {
1351
        vstats_file = fopen(vstats_filename, "w");
1352
        if (!vstats_file) {
1353
            perror("fopen");
1354
            ffmpeg_exit(1);
1355
        }
1356
    }
1357

    
1358
    enc = ost->st->codec;
1359
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1360
        frame_number = ost->frame_number;
1361
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1362
        if (enc->flags&CODEC_FLAG_PSNR)
1363
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1364

    
1365
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1366
        /* compute pts value */
1367
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1368
        if (ti1 < 0.01)
1369
            ti1 = 0.01;
1370

    
1371
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1372
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1373
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1374
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1375
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1376
    }
1377
}
1378

    
1379
static void print_report(AVFormatContext **output_files,
1380
                         AVOutputStream **ost_table, int nb_ostreams,
1381
                         int is_last_report)
1382
{
1383
    char buf[1024];
1384
    AVOutputStream *ost;
1385
    AVFormatContext *oc;
1386
    int64_t total_size;
1387
    AVCodecContext *enc;
1388
    int frame_number, vid, i;
1389
    double bitrate, ti1, pts;
1390
    static int64_t last_time = -1;
1391
    static int qp_histogram[52];
1392

    
1393
    if (!is_last_report) {
1394
        int64_t cur_time;
1395
        /* display the report every 0.5 seconds */
1396
        cur_time = av_gettime();
1397
        if (last_time == -1) {
1398
            last_time = cur_time;
1399
            return;
1400
        }
1401
        if ((cur_time - last_time) < 500000)
1402
            return;
1403
        last_time = cur_time;
1404
    }
1405

    
1406

    
1407
    oc = output_files[0];
1408

    
1409
    total_size = url_fsize(oc->pb);
1410
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1411
        total_size= url_ftell(oc->pb);
1412

    
1413
    buf[0] = '\0';
1414
    ti1 = 1e10;
1415
    vid = 0;
1416
    for(i=0;i<nb_ostreams;i++) {
1417
        ost = ost_table[i];
1418
        enc = ost->st->codec;
1419
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1420
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1421
                     !ost->st->stream_copy ?
1422
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1423
        }
1424
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1425
            float t = (av_gettime()-timer_start) / 1000000.0;
1426

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

    
1473
    if (verbose || is_last_report) {
1474
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1475

    
1476
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1477
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1478
            (double)total_size / 1024, ti1, bitrate);
1479

    
1480
        if (nb_frames_dup || nb_frames_drop)
1481
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1482
                  nb_frames_dup, nb_frames_drop);
1483

    
1484
        if (verbose >= 0)
1485
            fprintf(stderr, "%s    \r", buf);
1486

    
1487
        fflush(stderr);
1488
    }
1489

    
1490
    if (is_last_report && verbose >= 0){
1491
        int64_t raw= audio_size + video_size + extra_size;
1492
        fprintf(stderr, "\n");
1493
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1494
                video_size/1024.0,
1495
                audio_size/1024.0,
1496
                extra_size/1024.0,
1497
                100.0*(total_size - raw)/raw
1498
        );
1499
    }
1500
}
1501

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

    
1519
    AVPacket avpkt;
1520
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1521

    
1522
    if(ist->next_pts == AV_NOPTS_VALUE)
1523
        ist->next_pts= ist->pts;
1524

    
1525
    if (pkt == NULL) {
1526
        /* EOF handling */
1527
        av_init_packet(&avpkt);
1528
        avpkt.data = NULL;
1529
        avpkt.size = 0;
1530
        goto handle_eof;
1531
    } else {
1532
        avpkt = *pkt;
1533
    }
1534

    
1535
    if(pkt->dts != AV_NOPTS_VALUE)
1536
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1537

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

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

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

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

    
1640
        buffer_to_free = NULL;
1641
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1642
            pre_process_video_frame(ist, (AVPicture *)&picture,
1643
                                    &buffer_to_free);
1644
        }
1645

    
1646
#if CONFIG_AVFILTER
1647
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1648
            // add it to be filtered
1649
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1650
                                     ist->pts,
1651
                                     ist->st->codec->sample_aspect_ratio);
1652
        }
1653
#endif
1654

    
1655
        // preprocess audio (volume)
1656
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1657
            if (audio_volume != 256) {
1658
                short *volp;
1659
                volp = samples;
1660
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1661
                    int v = ((*volp) * audio_volume + 128) >> 8;
1662
                    if (v < -32768) v = -32768;
1663
                    if (v >  32767) v = 32767;
1664
                    *volp++ = v;
1665
                }
1666
            }
1667
        }
1668

    
1669
        /* frame rate emulation */
1670
        if (rate_emu) {
1671
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1672
            int64_t now = av_gettime() - ist->start;
1673
            if (pts > now)
1674
                usleep(pts - now);
1675
        }
1676
#if CONFIG_AVFILTER
1677
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1678
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1679
#endif
1680
        /* if output time reached then transcode raw format,
1681
           encode packets and output them */
1682
        if (start_time == 0 || ist->pts >= start_time)
1683
#if CONFIG_AVFILTER
1684
        while (frame_available) {
1685
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1686
                get_filtered_video_pic(ist->output_video_filter, &ist->picref, &picture, &ist->pts);
1687
#endif
1688
            for(i=0;i<nb_ostreams;i++) {
1689
                int frame_size;
1690

    
1691
                ost = ost_table[i];
1692
                if (ost->source_index == ist_index) {
1693
                    os = output_files[ost->file_index];
1694

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

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

    
1725
                        av_init_packet(&opkt);
1726

    
1727
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1728
                            continue;
1729

    
1730
                        /* no reencoding needed : output the packet directly */
1731
                        /* force the input stream PTS */
1732

    
1733
                        avcodec_get_frame_defaults(&avframe);
1734
                        ost->st->codec->coded_frame= &avframe;
1735
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1736

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

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

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

    
1756
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1757
                        opkt.flags= pkt->flags;
1758

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

    
1771
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1772
                        ost->st->codec->frame_number++;
1773
                        ost->frame_number++;
1774
                        av_free_packet(&opkt);
1775
                    }
1776
                }
1777
            }
1778

    
1779
#if CONFIG_AVFILTER
1780
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1781
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1782
            if(ist->picref)
1783
                avfilter_unref_buffer(ist->picref);
1784
        }
1785
#endif
1786
        av_free(buffer_to_free);
1787
        /* XXX: allocate the subtitles in the codec ? */
1788
        if (subtitle_to_free) {
1789
            if (subtitle_to_free->rects != NULL) {
1790
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1791
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1792
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1793
                    av_freep(&subtitle_to_free->rects[i]);
1794
                }
1795
                av_freep(&subtitle_to_free->rects);
1796
            }
1797
            subtitle_to_free->num_rects = 0;
1798
            subtitle_to_free = NULL;
1799
        }
1800
    }
1801
 discard_packet:
1802
    if (pkt == NULL) {
1803
        /* EOF handling */
1804

    
1805
        for(i=0;i<nb_ostreams;i++) {
1806
            ost = ost_table[i];
1807
            if (ost->source_index == ist_index) {
1808
                AVCodecContext *enc= ost->st->codec;
1809
                os = output_files[ost->file_index];
1810

    
1811
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1812
                    continue;
1813
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1814
                    continue;
1815

    
1816
                if (ost->encoding_needed) {
1817
                    for(;;) {
1818
                        AVPacket pkt;
1819
                        int fifo_bytes;
1820
                        av_init_packet(&pkt);
1821
                        pkt.stream_index= ost->index;
1822

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

    
1832
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1833
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1834
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1835
                                } else { /* pad */
1836
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1837
                                    if (allocated_audio_buf_size < frame_bytes)
1838
                                        ffmpeg_exit(1);
1839
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1840
                                }
1841

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

    
1874
                        if(ret<=0)
1875
                            break;
1876
                        pkt.data= bit_buffer;
1877
                        pkt.size= ret;
1878
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1879
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1880
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1881
                    }
1882
                }
1883
            }
1884
        }
1885
    }
1886

    
1887
    return 0;
1888
 fail_decode:
1889
    return -1;
1890
}
1891

    
1892
static void print_sdp(AVFormatContext **avc, int n)
1893
{
1894
    char sdp[2048];
1895

    
1896
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1897
    printf("SDP:\n%s\n", sdp);
1898
    fflush(stdout);
1899
}
1900

    
1901
static int copy_chapters(int infile, int outfile)
1902
{
1903
    AVFormatContext *is = input_files[infile];
1904
    AVFormatContext *os = output_files[outfile];
1905
    int i;
1906

    
1907
    for (i = 0; i < is->nb_chapters; i++) {
1908
        AVChapter *in_ch = is->chapters[i], *out_ch;
1909
        AVMetadataTag *t = NULL;
1910
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1911
                                      AV_TIME_BASE_Q, in_ch->time_base);
1912
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1913
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1914

    
1915

    
1916
        if (in_ch->end < ts_off)
1917
            continue;
1918
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1919
            break;
1920

    
1921
        out_ch = av_mallocz(sizeof(AVChapter));
1922
        if (!out_ch)
1923
            return AVERROR(ENOMEM);
1924

    
1925
        out_ch->id        = in_ch->id;
1926
        out_ch->time_base = in_ch->time_base;
1927
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1928
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1929

    
1930
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1931
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1932

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

    
1942
/*
1943
 * The following code is the main loop of the file converter
1944
 */
1945
static int transcode(AVFormatContext **output_files,
1946
                     int nb_output_files,
1947
                     AVFormatContext **input_files,
1948
                     int nb_input_files,
1949
                     AVStreamMap *stream_maps, int nb_stream_maps)
1950
{
1951
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1952
    AVFormatContext *is, *os;
1953
    AVCodecContext *codec, *icodec;
1954
    AVOutputStream *ost, **ost_table = NULL;
1955
    AVInputStream *ist, **ist_table = NULL;
1956
    AVInputFile *file_table;
1957
    char error[1024];
1958
    int key;
1959
    int want_sdp = 1;
1960
    uint8_t no_packet[MAX_FILES]={0};
1961
    int no_packet_count=0;
1962

    
1963
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1964
    if (!file_table)
1965
        goto fail;
1966

    
1967
    /* input stream init */
1968
    j = 0;
1969
    for(i=0;i<nb_input_files;i++) {
1970
        is = input_files[i];
1971
        file_table[i].ist_index = j;
1972
        file_table[i].nb_streams = is->nb_streams;
1973
        j += is->nb_streams;
1974
    }
1975
    nb_istreams = j;
1976

    
1977
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1978
    if (!ist_table)
1979
        goto fail;
1980

    
1981
    for(i=0;i<nb_istreams;i++) {
1982
        ist = av_mallocz(sizeof(AVInputStream));
1983
        if (!ist)
1984
            goto fail;
1985
        ist_table[i] = ist;
1986
    }
1987
    j = 0;
1988
    for(i=0;i<nb_input_files;i++) {
1989
        is = input_files[i];
1990
        for(k=0;k<is->nb_streams;k++) {
1991
            ist = ist_table[j++];
1992
            ist->st = is->streams[k];
1993
            ist->file_index = i;
1994
            ist->index = k;
1995
            ist->discard = 1; /* the stream is discarded by default
1996
                                 (changed later) */
1997

    
1998
            if (rate_emu) {
1999
                ist->start = av_gettime();
2000
            }
2001
        }
2002
    }
2003

    
2004
    /* output stream init */
2005
    nb_ostreams = 0;
2006
    for(i=0;i<nb_output_files;i++) {
2007
        os = output_files[i];
2008
        if (!os->nb_streams) {
2009
            dump_format(output_files[i], i, output_files[i]->filename, 1);
2010
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2011
            ret = AVERROR(EINVAL);
2012
            goto fail;
2013
        }
2014
        nb_ostreams += os->nb_streams;
2015
    }
2016
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2017
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2018
        ret = AVERROR(EINVAL);
2019
        goto fail;
2020
    }
2021

    
2022
    /* Sanity check the mapping args -- do the input files & streams exist? */
2023
    for(i=0;i<nb_stream_maps;i++) {
2024
        int fi = stream_maps[i].file_index;
2025
        int si = stream_maps[i].stream_index;
2026

    
2027
        if (fi < 0 || fi > nb_input_files - 1 ||
2028
            si < 0 || si > file_table[fi].nb_streams - 1) {
2029
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2030
            ret = AVERROR(EINVAL);
2031
            goto fail;
2032
        }
2033
        fi = stream_maps[i].sync_file_index;
2034
        si = stream_maps[i].sync_stream_index;
2035
        if (fi < 0 || fi > nb_input_files - 1 ||
2036
            si < 0 || si > file_table[fi].nb_streams - 1) {
2037
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2038
            ret = AVERROR(EINVAL);
2039
            goto fail;
2040
        }
2041
    }
2042

    
2043
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2044
    if (!ost_table)
2045
        goto fail;
2046
    for(i=0;i<nb_ostreams;i++) {
2047
        ost = av_mallocz(sizeof(AVOutputStream));
2048
        if (!ost)
2049
            goto fail;
2050
        ost_table[i] = ost;
2051
    }
2052

    
2053
    n = 0;
2054
    for(k=0;k<nb_output_files;k++) {
2055
        os = output_files[k];
2056
        for(i=0;i<os->nb_streams;i++,n++) {
2057
            int found;
2058
            ost = ost_table[n];
2059
            ost->file_index = k;
2060
            ost->index = i;
2061
            ost->st = os->streams[i];
2062
            if (nb_stream_maps > 0) {
2063
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2064
                    stream_maps[n].stream_index;
2065

    
2066
                /* Sanity check that the stream types match */
2067
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2068
                    int i= ost->file_index;
2069
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2070
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2071
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2072
                        ost->file_index, ost->index);
2073
                    ffmpeg_exit(1);
2074
                }
2075

    
2076
            } else {
2077
                int best_nb_frames=-1;
2078
                /* get corresponding input stream index : we select the first one with the right type */
2079
                found = 0;
2080
                for(j=0;j<nb_istreams;j++) {
2081
                    int skip=0;
2082
                    ist = ist_table[j];
2083
                    if(opt_programid){
2084
                        int pi,si;
2085
                        AVFormatContext *f= input_files[ ist->file_index ];
2086
                        skip=1;
2087
                        for(pi=0; pi<f->nb_programs; pi++){
2088
                            AVProgram *p= f->programs[pi];
2089
                            if(p->id == opt_programid)
2090
                                for(si=0; si<p->nb_stream_indexes; si++){
2091
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2092
                                        skip=0;
2093
                                }
2094
                        }
2095
                    }
2096
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2097
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2098
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2099
                            best_nb_frames= ist->st->codec_info_nb_frames;
2100
                            ost->source_index = j;
2101
                            found = 1;
2102
                        }
2103
                    }
2104
                }
2105

    
2106
                if (!found) {
2107
                    if(! opt_programid) {
2108
                        /* try again and reuse existing stream */
2109
                        for(j=0;j<nb_istreams;j++) {
2110
                            ist = ist_table[j];
2111
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2112
                                && ist->st->discard != AVDISCARD_ALL) {
2113
                                ost->source_index = j;
2114
                                found = 1;
2115
                            }
2116
                        }
2117
                    }
2118
                    if (!found) {
2119
                        int i= ost->file_index;
2120
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2121
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2122
                                ost->file_index, ost->index);
2123
                        ffmpeg_exit(1);
2124
                    }
2125
                }
2126
            }
2127
            ist = ist_table[ost->source_index];
2128
            ist->discard = 0;
2129
            ost->sync_ist = (nb_stream_maps > 0) ?
2130
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2131
                         stream_maps[n].sync_stream_index] : ist;
2132
        }
2133
    }
2134

    
2135
    /* for each output stream, we compute the right encoding parameters */
2136
    for(i=0;i<nb_ostreams;i++) {
2137
        AVMetadataTag *t = NULL;
2138
        ost = ost_table[i];
2139
        os = output_files[ost->file_index];
2140
        ist = ist_table[ost->source_index];
2141

    
2142
        codec = ost->st->codec;
2143
        icodec = ist->st->codec;
2144

    
2145
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2146
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2147
        }
2148

    
2149
        ost->st->disposition = ist->st->disposition;
2150
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2151
        codec->chroma_sample_location = icodec->chroma_sample_location;
2152

    
2153
        if (ost->st->stream_copy) {
2154
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2155

    
2156
            if (extra_size > INT_MAX)
2157
                goto fail;
2158

    
2159
            /* if stream_copy is selected, no need to decode or encode */
2160
            codec->codec_id = icodec->codec_id;
2161
            codec->codec_type = icodec->codec_type;
2162

    
2163
            if(!codec->codec_tag){
2164
                if(   !os->oformat->codec_tag
2165
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2166
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2167
                    codec->codec_tag = icodec->codec_tag;
2168
            }
2169

    
2170
            codec->bit_rate = icodec->bit_rate;
2171
            codec->extradata= av_mallocz(extra_size);
2172
            if (!codec->extradata)
2173
                goto fail;
2174
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2175
            codec->extradata_size= icodec->extradata_size;
2176
            if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2177
                codec->time_base = icodec->time_base;
2178
                codec->time_base.num *= icodec->ticks_per_frame;
2179
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2180
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2181
            }else
2182
                codec->time_base = ist->st->time_base;
2183
            switch(codec->codec_type) {
2184
            case AVMEDIA_TYPE_AUDIO:
2185
                if(audio_volume != 256) {
2186
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2187
                    ffmpeg_exit(1);
2188
                }
2189
                codec->channel_layout = icodec->channel_layout;
2190
                codec->sample_rate = icodec->sample_rate;
2191
                codec->channels = icodec->channels;
2192
                codec->frame_size = icodec->frame_size;
2193
                codec->block_align= icodec->block_align;
2194
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2195
                    codec->block_align= 0;
2196
                if(codec->codec_id == CODEC_ID_AC3)
2197
                    codec->block_align= 0;
2198
                break;
2199
            case AVMEDIA_TYPE_VIDEO:
2200
                codec->pix_fmt = icodec->pix_fmt;
2201
                codec->width = icodec->width;
2202
                codec->height = icodec->height;
2203
                codec->has_b_frames = icodec->has_b_frames;
2204
                break;
2205
            case AVMEDIA_TYPE_SUBTITLE:
2206
                codec->width = icodec->width;
2207
                codec->height = icodec->height;
2208
                break;
2209
            default:
2210
                abort();
2211
            }
2212
        } else {
2213
            switch(codec->codec_type) {
2214
            case AVMEDIA_TYPE_AUDIO:
2215
                ost->fifo= av_fifo_alloc(1024);
2216
                if(!ost->fifo)
2217
                    goto fail;
2218
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2219
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2220
                icodec->request_channels = codec->channels;
2221
                ist->decoding_needed = 1;
2222
                ost->encoding_needed = 1;
2223
                break;
2224
            case AVMEDIA_TYPE_VIDEO:
2225
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2226
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2227
                    ffmpeg_exit(1);
2228
                }
2229
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2230
                ost->video_resample = ((codec->width != icodec->width -
2231
                                (frame_leftBand + frame_rightBand)) ||
2232
                        (codec->height != icodec->height -
2233
                                (frame_topBand  + frame_bottomBand)) ||
2234
                        (codec->pix_fmt != icodec->pix_fmt));
2235
                if (ost->video_crop) {
2236
                    ost->topBand    = ost->original_topBand    = frame_topBand;
2237
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2238
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
2239
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
2240
                }
2241
                if (ost->video_resample) {
2242
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2243
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2244
                                         codec->width, codec->height)) {
2245
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2246
                        ffmpeg_exit(1);
2247
                    }
2248
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2249
                    ost->img_resample_ctx = sws_getContext(
2250
                            icodec->width - (frame_leftBand + frame_rightBand),
2251
                            icodec->height - (frame_topBand + frame_bottomBand),
2252
                            icodec->pix_fmt,
2253
                            codec->width,
2254
                            codec->height,
2255
                            codec->pix_fmt,
2256
                            sws_flags, NULL, NULL, NULL);
2257
                    if (ost->img_resample_ctx == NULL) {
2258
                        fprintf(stderr, "Cannot get resampling context\n");
2259
                        ffmpeg_exit(1);
2260
                    }
2261

    
2262
#if !CONFIG_AVFILTER
2263
                    ost->original_height = icodec->height;
2264
                    ost->original_width  = icodec->width;
2265
#endif
2266
                    codec->bits_per_raw_sample= 0;
2267
                }
2268
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2269
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2270
                ost->resample_pix_fmt= icodec->pix_fmt;
2271
                ost->encoding_needed = 1;
2272
                ist->decoding_needed = 1;
2273

    
2274
#if CONFIG_AVFILTER
2275
                if (configure_filters(ist, ost)) {
2276
                    fprintf(stderr, "Error opening filters!\n");
2277
                    exit(1);
2278
                }
2279
#endif
2280
                break;
2281
            case AVMEDIA_TYPE_SUBTITLE:
2282
                ost->encoding_needed = 1;
2283
                ist->decoding_needed = 1;
2284
                break;
2285
            default:
2286
                abort();
2287
                break;
2288
            }
2289
            /* two pass mode */
2290
            if (ost->encoding_needed &&
2291
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2292
                char logfilename[1024];
2293
                FILE *f;
2294

    
2295
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2296
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2297
                         i);
2298
                if (codec->flags & CODEC_FLAG_PASS1) {
2299
                    f = fopen(logfilename, "wb");
2300
                    if (!f) {
2301
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2302
                        ffmpeg_exit(1);
2303
                    }
2304
                    ost->logfile = f;
2305
                } else {
2306
                    char  *logbuffer;
2307
                    size_t logbuffer_size;
2308
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2309
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2310
                        ffmpeg_exit(1);
2311
                    }
2312
                    codec->stats_in = logbuffer;
2313
                }
2314
            }
2315
        }
2316
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2317
            int size= codec->width * codec->height;
2318
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2319
        }
2320
    }
2321

    
2322
    if (!bit_buffer)
2323
        bit_buffer = av_malloc(bit_buffer_size);
2324
    if (!bit_buffer) {
2325
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2326
                bit_buffer_size);
2327
        ret = AVERROR(ENOMEM);
2328
        goto fail;
2329
    }
2330

    
2331
    /* open each encoder */
2332
    for(i=0;i<nb_ostreams;i++) {
2333
        ost = ost_table[i];
2334
        if (ost->encoding_needed) {
2335
            AVCodec *codec = output_codecs[i];
2336
            if (!codec)
2337
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2338
            if (!codec) {
2339
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2340
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2341
                ret = AVERROR(EINVAL);
2342
                goto dump_format;
2343
            }
2344
            if (avcodec_open(ost->st->codec, codec) < 0) {
2345
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2346
                        ost->file_index, ost->index);
2347
                ret = AVERROR(EINVAL);
2348
                goto dump_format;
2349
            }
2350
            extra_size += ost->st->codec->extradata_size;
2351
        }
2352
    }
2353

    
2354
    /* open each decoder */
2355
    for(i=0;i<nb_istreams;i++) {
2356
        ist = ist_table[i];
2357
        if (ist->decoding_needed) {
2358
            AVCodec *codec = input_codecs[i];
2359
            if (!codec)
2360
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2361
            if (!codec) {
2362
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2363
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2364
                ret = AVERROR(EINVAL);
2365
                goto dump_format;
2366
            }
2367
            if (avcodec_open(ist->st->codec, codec) < 0) {
2368
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2369
                        ist->file_index, ist->index);
2370
                ret = AVERROR(EINVAL);
2371
                goto dump_format;
2372
            }
2373
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2374
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2375
        }
2376
    }
2377

    
2378
    /* init pts */
2379
    for(i=0;i<nb_istreams;i++) {
2380
        AVStream *st;
2381
        ist = ist_table[i];
2382
        st= ist->st;
2383
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2384
        ist->next_pts = AV_NOPTS_VALUE;
2385
        ist->is_start = 1;
2386
    }
2387

    
2388
    /* set meta data information from input file if required */
2389
    for (i=0;i<nb_meta_data_maps;i++) {
2390
        AVFormatContext *out_file;
2391
        AVFormatContext *in_file;
2392
        AVMetadataTag *mtag;
2393

    
2394
        int out_file_index = meta_data_maps[i].out_file;
2395
        int in_file_index = meta_data_maps[i].in_file;
2396
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2397
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2398
                     out_file_index, out_file_index, in_file_index);
2399
            ret = AVERROR(EINVAL);
2400
            goto dump_format;
2401
        }
2402
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2403
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2404
                     in_file_index, out_file_index, in_file_index);
2405
            ret = AVERROR(EINVAL);
2406
            goto dump_format;
2407
        }
2408

    
2409
        out_file = output_files[out_file_index];
2410
        in_file = input_files[in_file_index];
2411

    
2412

    
2413
        mtag=NULL;
2414
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2415
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2416
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2417
                                    in_file->iformat->metadata_conv);
2418
    }
2419

    
2420
    /* copy chapters from the first input file that has them*/
2421
    for (i = 0; i < nb_input_files; i++) {
2422
        if (!input_files[i]->nb_chapters)
2423
            continue;
2424

    
2425
        for (j = 0; j < nb_output_files; j++)
2426
            if ((ret = copy_chapters(i, j)) < 0)
2427
                goto dump_format;
2428
    }
2429

    
2430
    /* open files and write file headers */
2431
    for(i=0;i<nb_output_files;i++) {
2432
        os = output_files[i];
2433
        if (av_write_header(os) < 0) {
2434
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2435
            ret = AVERROR(EINVAL);
2436
            goto dump_format;
2437
        }
2438
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2439
            want_sdp = 0;
2440
        }
2441
    }
2442

    
2443
 dump_format:
2444
    /* dump the file output parameters - cannot be done before in case
2445
       of stream copy */
2446
    for(i=0;i<nb_output_files;i++) {
2447
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2448
    }
2449

    
2450
    /* dump the stream mapping */
2451
    if (verbose >= 0) {
2452
        fprintf(stderr, "Stream mapping:\n");
2453
        for(i=0;i<nb_ostreams;i++) {
2454
            ost = ost_table[i];
2455
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2456
                    ist_table[ost->source_index]->file_index,
2457
                    ist_table[ost->source_index]->index,
2458
                    ost->file_index,
2459
                    ost->index);
2460
            if (ost->sync_ist != ist_table[ost->source_index])
2461
                fprintf(stderr, " [sync #%d.%d]",
2462
                        ost->sync_ist->file_index,
2463
                        ost->sync_ist->index);
2464
            fprintf(stderr, "\n");
2465
        }
2466
    }
2467

    
2468
    if (ret) {
2469
        fprintf(stderr, "%s\n", error);
2470
        goto fail;
2471
    }
2472

    
2473
    if (want_sdp) {
2474
        print_sdp(output_files, nb_output_files);
2475
    }
2476

    
2477
    if (!using_stdin && verbose >= 0) {
2478
        fprintf(stderr, "Press [q] to stop encoding\n");
2479
        url_set_interrupt_cb(decode_interrupt_cb);
2480
    }
2481
    term_init();
2482

    
2483
    timer_start = av_gettime();
2484

    
2485
    for(; received_sigterm == 0;) {
2486
        int file_index, ist_index;
2487
        AVPacket pkt;
2488
        double ipts_min;
2489
        double opts_min;
2490

    
2491
    redo:
2492
        ipts_min= 1e100;
2493
        opts_min= 1e100;
2494
        /* if 'q' pressed, exits */
2495
        if (!using_stdin) {
2496
            if (q_pressed)
2497
                break;
2498
            /* read_key() returns 0 on EOF */
2499
            key = read_key();
2500
            if (key == 'q')
2501
                break;
2502
        }
2503

    
2504
        /* select the stream that we must read now by looking at the
2505
           smallest output pts */
2506
        file_index = -1;
2507
        for(i=0;i<nb_ostreams;i++) {
2508
            double ipts, opts;
2509
            ost = ost_table[i];
2510
            os = output_files[ost->file_index];
2511
            ist = ist_table[ost->source_index];
2512
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2513
                continue;
2514
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2515
            ipts = (double)ist->pts;
2516
            if (!file_table[ist->file_index].eof_reached){
2517
                if(ipts < ipts_min) {
2518
                    ipts_min = ipts;
2519
                    if(input_sync ) file_index = ist->file_index;
2520
                }
2521
                if(opts < opts_min) {
2522
                    opts_min = opts;
2523
                    if(!input_sync) file_index = ist->file_index;
2524
                }
2525
            }
2526
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2527
                file_index= -1;
2528
                break;
2529
            }
2530
        }
2531
        /* if none, if is finished */
2532
        if (file_index < 0) {
2533
            if(no_packet_count){
2534
                no_packet_count=0;
2535
                memset(no_packet, 0, sizeof(no_packet));
2536
                usleep(10000);
2537
                continue;
2538
            }
2539
            break;
2540
        }
2541

    
2542
        /* finish if limit size exhausted */
2543
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2544
            break;
2545

    
2546
        /* read a frame from it and output it in the fifo */
2547
        is = input_files[file_index];
2548
        ret= av_read_frame(is, &pkt);
2549
        if(ret == AVERROR(EAGAIN)){
2550
            no_packet[file_index]=1;
2551
            no_packet_count++;
2552
            continue;
2553
        }
2554
        if (ret < 0) {
2555
            file_table[file_index].eof_reached = 1;
2556
            if (opt_shortest)
2557
                break;
2558
            else
2559
                continue;
2560
        }
2561

    
2562
        no_packet_count=0;
2563
        memset(no_packet, 0, sizeof(no_packet));
2564

    
2565
        if (do_pkt_dump) {
2566
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2567
        }
2568
        /* the following test is needed in case new streams appear
2569
           dynamically in stream : we ignore them */
2570
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2571
            goto discard_packet;
2572
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2573
        ist = ist_table[ist_index];
2574
        if (ist->discard)
2575
            goto discard_packet;
2576

    
2577
        if (pkt.dts != AV_NOPTS_VALUE)
2578
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2579
        if (pkt.pts != AV_NOPTS_VALUE)
2580
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2581

    
2582
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2583
            if(pkt.pts != AV_NOPTS_VALUE)
2584
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2585
            if(pkt.dts != AV_NOPTS_VALUE)
2586
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2587
        }
2588

    
2589
//        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);
2590
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2591
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2592
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2593
            int64_t delta= pkt_dts - ist->next_pts;
2594
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2595
                input_files_ts_offset[ist->file_index]-= delta;
2596
                if (verbose > 2)
2597
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2598
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2599
                if(pkt.pts != AV_NOPTS_VALUE)
2600
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2601
            }
2602
        }
2603

    
2604
        /* finish if recording time exhausted */
2605
        if (recording_time != INT64_MAX &&
2606
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2607
            ist->is_past_recording_time = 1;
2608
            goto discard_packet;
2609
        }
2610

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

    
2614
            if (verbose >= 0)
2615
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2616
                        ist->file_index, ist->index);
2617
            if (exit_on_error)
2618
                ffmpeg_exit(1);
2619
            av_free_packet(&pkt);
2620
            goto redo;
2621
        }
2622

    
2623
    discard_packet:
2624
        av_free_packet(&pkt);
2625

    
2626
        /* dump report by using the output first video and audio streams */
2627
        print_report(output_files, ost_table, nb_ostreams, 0);
2628
    }
2629

    
2630
    /* at the end of stream, we must flush the decoder buffers */
2631
    for(i=0;i<nb_istreams;i++) {
2632
        ist = ist_table[i];
2633
        if (ist->decoding_needed) {
2634
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2635
        }
2636
    }
2637

    
2638
    term_exit();
2639

    
2640
    /* write the trailer if needed and close file */
2641
    for(i=0;i<nb_output_files;i++) {
2642
        os = output_files[i];
2643
        av_write_trailer(os);
2644
    }
2645

    
2646
    /* dump report by using the first video and audio streams */
2647
    print_report(output_files, ost_table, nb_ostreams, 1);
2648

    
2649
    /* close each encoder */
2650
    for(i=0;i<nb_ostreams;i++) {
2651
        ost = ost_table[i];
2652
        if (ost->encoding_needed) {
2653
            av_freep(&ost->st->codec->stats_in);
2654
            avcodec_close(ost->st->codec);
2655
        }
2656
    }
2657

    
2658
    /* close each decoder */
2659
    for(i=0;i<nb_istreams;i++) {
2660
        ist = ist_table[i];
2661
        if (ist->decoding_needed) {
2662
            avcodec_close(ist->st->codec);
2663
        }
2664
    }
2665
#if CONFIG_AVFILTER
2666
    if (graph) {
2667
        avfilter_graph_destroy(graph);
2668
        av_freep(&graph);
2669
    }
2670
#endif
2671

    
2672
    /* finished ! */
2673
    ret = 0;
2674

    
2675
 fail:
2676
    av_freep(&bit_buffer);
2677
    av_free(file_table);
2678

    
2679
    if (ist_table) {
2680
        for(i=0;i<nb_istreams;i++) {
2681
            ist = ist_table[i];
2682
            av_free(ist);
2683
        }
2684
        av_free(ist_table);
2685
    }
2686
    if (ost_table) {
2687
        for(i=0;i<nb_ostreams;i++) {
2688
            ost = ost_table[i];
2689
            if (ost) {
2690
                if (ost->st->stream_copy)
2691
                    av_freep(&ost->st->codec->extradata);
2692
                if (ost->logfile) {
2693
                    fclose(ost->logfile);
2694
                    ost->logfile = NULL;
2695
                }
2696
                av_fifo_free(ost->fifo); /* works even if fifo is not
2697
                                             initialized but set to zero */
2698
                av_free(ost->pict_tmp.data[0]);
2699
                if (ost->video_resample)
2700
                    sws_freeContext(ost->img_resample_ctx);
2701
                if (ost->resample)
2702
                    audio_resample_close(ost->resample);
2703
                if (ost->reformat_ctx)
2704
                    av_audio_convert_free(ost->reformat_ctx);
2705
                av_free(ost);
2706
            }
2707
        }
2708
        av_free(ost_table);
2709
    }
2710
    return ret;
2711
}
2712

    
2713
static void opt_format(const char *arg)
2714
{
2715
    /* compatibility stuff for pgmyuv */
2716
    if (!strcmp(arg, "pgmyuv")) {
2717
        pgmyuv_compatibility_hack=1;
2718
//        opt_image_format(arg);
2719
        arg = "image2";
2720
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2721
    }
2722

    
2723
    last_asked_format = arg;
2724
}
2725

    
2726
static void opt_video_rc_override_string(const char *arg)
2727
{
2728
    video_rc_override_string = arg;
2729
}
2730

    
2731
static int opt_me_threshold(const char *opt, const char *arg)
2732
{
2733
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2734
    return 0;
2735
}
2736

    
2737
static int opt_verbose(const char *opt, const char *arg)
2738
{
2739
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2740
    return 0;
2741
}
2742

    
2743
static int opt_frame_rate(const char *opt, const char *arg)
2744
{
2745
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2746
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2747
        ffmpeg_exit(1);
2748
    }
2749
    return 0;
2750
}
2751

    
2752
static int opt_bitrate(const char *opt, const char *arg)
2753
{
2754
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2755

    
2756
    opt_default(opt, arg);
2757

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

    
2761
    return 0;
2762
}
2763

    
2764
static void opt_frame_crop_top(const char *arg)
2765
{
2766
    frame_topBand = atoi(arg);
2767
    if (frame_topBand < 0) {
2768
        fprintf(stderr, "Incorrect top crop size\n");
2769
        ffmpeg_exit(1);
2770
    }
2771
    if ((frame_topBand) >= frame_height){
2772
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2773
        ffmpeg_exit(1);
2774
    }
2775
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2776
    frame_height -= frame_topBand;
2777
}
2778

    
2779
static void opt_frame_crop_bottom(const char *arg)
2780
{
2781
    frame_bottomBand = atoi(arg);
2782
    if (frame_bottomBand < 0) {
2783
        fprintf(stderr, "Incorrect bottom crop size\n");
2784
        ffmpeg_exit(1);
2785
    }
2786
    if ((frame_bottomBand) >= frame_height){
2787
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2788
        ffmpeg_exit(1);
2789
    }
2790
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2791
    frame_height -= frame_bottomBand;
2792
}
2793

    
2794
static void opt_frame_crop_left(const char *arg)
2795
{
2796
    frame_leftBand = atoi(arg);
2797
    if (frame_leftBand < 0) {
2798
        fprintf(stderr, "Incorrect left crop size\n");
2799
        ffmpeg_exit(1);
2800
    }
2801
    if ((frame_leftBand) >= frame_width){
2802
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2803
        ffmpeg_exit(1);
2804
    }
2805
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2806
    frame_width -= frame_leftBand;
2807
}
2808

    
2809
static void opt_frame_crop_right(const char *arg)
2810
{
2811
    frame_rightBand = atoi(arg);
2812
    if (frame_rightBand < 0) {
2813
        fprintf(stderr, "Incorrect right crop size\n");
2814
        ffmpeg_exit(1);
2815
    }
2816
    if ((frame_rightBand) >= frame_width){
2817
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2818
        ffmpeg_exit(1);
2819
    }
2820
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2821
    frame_width -= frame_rightBand;
2822
}
2823

    
2824
static void opt_frame_size(const char *arg)
2825
{
2826
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2827
        fprintf(stderr, "Incorrect frame size\n");
2828
        ffmpeg_exit(1);
2829
    }
2830
}
2831

    
2832
static int opt_pad(const char *opt, const char *arg) {
2833
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2834
    return -1;
2835
}
2836

    
2837
static void opt_frame_pix_fmt(const char *arg)
2838
{
2839
    if (strcmp(arg, "list")) {
2840
        frame_pix_fmt = av_get_pix_fmt(arg);
2841
        if (frame_pix_fmt == PIX_FMT_NONE) {
2842
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2843
            ffmpeg_exit(1);
2844
        }
2845
    } else {
2846
        show_pix_fmts();
2847
        ffmpeg_exit(0);
2848
    }
2849
}
2850

    
2851
static void opt_frame_aspect_ratio(const char *arg)
2852
{
2853
    int x = 0, y = 0;
2854
    double ar = 0;
2855
    const char *p;
2856
    char *end;
2857

    
2858
    p = strchr(arg, ':');
2859
    if (p) {
2860
        x = strtol(arg, &end, 10);
2861
        if (end == p)
2862
            y = strtol(end+1, &end, 10);
2863
        if (x > 0 && y > 0)
2864
            ar = (double)x / (double)y;
2865
    } else
2866
        ar = strtod(arg, NULL);
2867

    
2868
    if (!ar) {
2869
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2870
        ffmpeg_exit(1);
2871
    }
2872
    frame_aspect_ratio = ar;
2873
}
2874

    
2875
static int opt_metadata(const char *opt, const char *arg)
2876
{
2877
    char *mid= strchr(arg, '=');
2878

    
2879
    if(!mid){
2880
        fprintf(stderr, "Missing =\n");
2881
        ffmpeg_exit(1);
2882
    }
2883
    *mid++= 0;
2884

    
2885
    metadata_count++;
2886
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2887
    metadata[metadata_count-1].key  = av_strdup(arg);
2888
    metadata[metadata_count-1].value= av_strdup(mid);
2889

    
2890
    return 0;
2891
}
2892

    
2893
static void opt_qscale(const char *arg)
2894
{
2895
    video_qscale = atof(arg);
2896
    if (video_qscale <= 0 ||
2897
        video_qscale > 255) {
2898
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2899
        ffmpeg_exit(1);
2900
    }
2901
}
2902

    
2903
static void opt_top_field_first(const char *arg)
2904
{
2905
    top_field_first= atoi(arg);
2906
}
2907

    
2908
static int opt_thread_count(const char *opt, const char *arg)
2909
{
2910
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2911
#if !HAVE_THREADS
2912
    if (verbose >= 0)
2913
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2914
#endif
2915
    return 0;
2916
}
2917

    
2918
static void opt_audio_sample_fmt(const char *arg)
2919
{
2920
    if (strcmp(arg, "list"))
2921
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2922
    else {
2923
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2924
        ffmpeg_exit(0);
2925
    }
2926
}
2927

    
2928
static int opt_audio_rate(const char *opt, const char *arg)
2929
{
2930
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2931
    return 0;
2932
}
2933

    
2934
static int opt_audio_channels(const char *opt, const char *arg)
2935
{
2936
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2937
    return 0;
2938
}
2939

    
2940
static void opt_video_channel(const char *arg)
2941
{
2942
    video_channel = strtol(arg, NULL, 0);
2943
}
2944

    
2945
static void opt_video_standard(const char *arg)
2946
{
2947
    video_standard = av_strdup(arg);
2948
}
2949

    
2950
static void opt_codec(int *pstream_copy, char **pcodec_name,
2951
                      int codec_type, const char *arg)
2952
{
2953
    av_freep(pcodec_name);
2954
    if (!strcmp(arg, "copy")) {
2955
        *pstream_copy = 1;
2956
    } else {
2957
        *pcodec_name = av_strdup(arg);
2958
    }
2959
}
2960

    
2961
static void opt_audio_codec(const char *arg)
2962
{
2963
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2964
}
2965

    
2966
static void opt_audio_tag(const char *arg)
2967
{
2968
    char *tail;
2969
    audio_codec_tag= strtol(arg, &tail, 0);
2970

    
2971
    if(!tail || *tail)
2972
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2973
}
2974

    
2975
static void opt_video_tag(const char *arg)
2976
{
2977
    char *tail;
2978
    video_codec_tag= strtol(arg, &tail, 0);
2979

    
2980
    if(!tail || *tail)
2981
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2982
}
2983

    
2984
static void opt_video_codec(const char *arg)
2985
{
2986
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2987
}
2988

    
2989
static void opt_subtitle_codec(const char *arg)
2990
{
2991
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2992
}
2993

    
2994
static void opt_subtitle_tag(const char *arg)
2995
{
2996
    char *tail;
2997
    subtitle_codec_tag= strtol(arg, &tail, 0);
2998

    
2999
    if(!tail || *tail)
3000
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3001
}
3002

    
3003
static void opt_map(const char *arg)
3004
{
3005
    AVStreamMap *m;
3006
    char *p;
3007

    
3008
    m = &stream_maps[nb_stream_maps++];
3009

    
3010
    m->file_index = strtol(arg, &p, 0);
3011
    if (*p)
3012
        p++;
3013

    
3014
    m->stream_index = strtol(p, &p, 0);
3015
    if (*p) {
3016
        p++;
3017
        m->sync_file_index = strtol(p, &p, 0);
3018
        if (*p)
3019
            p++;
3020
        m->sync_stream_index = strtol(p, &p, 0);
3021
    } else {
3022
        m->sync_file_index = m->file_index;
3023
        m->sync_stream_index = m->stream_index;
3024
    }
3025
}
3026

    
3027
static void opt_map_meta_data(const char *arg)
3028
{
3029
    AVMetaDataMap *m;
3030
    char *p;
3031

    
3032
    m = &meta_data_maps[nb_meta_data_maps++];
3033

    
3034
    m->out_file = strtol(arg, &p, 0);
3035
    if (*p)
3036
        p++;
3037

    
3038
    m->in_file = strtol(p, &p, 0);
3039
}
3040

    
3041
static void opt_input_ts_scale(const char *arg)
3042
{
3043
    unsigned int stream;
3044
    double scale;
3045
    char *p;
3046

    
3047
    stream = strtol(arg, &p, 0);
3048
    if (*p)
3049
        p++;
3050
    scale= strtod(p, &p);
3051

    
3052
    if(stream >= MAX_STREAMS)
3053
        ffmpeg_exit(1);
3054

    
3055
    input_files_ts_scale[nb_input_files][stream]= scale;
3056
}
3057

    
3058
static int opt_recording_time(const char *opt, const char *arg)
3059
{
3060
    recording_time = parse_time_or_die(opt, arg, 1);
3061
    return 0;
3062
}
3063

    
3064
static int opt_start_time(const char *opt, const char *arg)
3065
{
3066
    start_time = parse_time_or_die(opt, arg, 1);
3067
    return 0;
3068
}
3069

    
3070
static int opt_recording_timestamp(const char *opt, const char *arg)
3071
{
3072
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3073
    return 0;
3074
}
3075

    
3076
static int opt_input_ts_offset(const char *opt, const char *arg)
3077
{
3078
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3079
    return 0;
3080
}
3081

    
3082
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3083
{
3084
    const char *codec_string = encoder ? "encoder" : "decoder";
3085
    AVCodec *codec;
3086

    
3087
    if(!name)
3088
        return CODEC_ID_NONE;
3089
    codec = encoder ?
3090
        avcodec_find_encoder_by_name(name) :
3091
        avcodec_find_decoder_by_name(name);
3092
    if(!codec) {
3093
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3094
        ffmpeg_exit(1);
3095
    }
3096
    if(codec->type != type) {
3097
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3098
        ffmpeg_exit(1);
3099
    }
3100
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3101
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3102
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3103
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3104
                codec_string, codec->name);
3105
        codec = encoder ?
3106
            avcodec_find_encoder(codec->id) :
3107
            avcodec_find_decoder(codec->id);
3108
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3109
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3110
                    codec_string, codec->name);
3111
        ffmpeg_exit(1);
3112
    }
3113
    return codec->id;
3114
}
3115

    
3116
static void opt_input_file(const char *filename)
3117
{
3118
    AVFormatContext *ic;
3119
    AVFormatParameters params, *ap = &params;
3120
    AVInputFormat *file_iformat = NULL;
3121
    int err, i, ret, rfps, rfps_base;
3122
    int64_t timestamp;
3123

    
3124
    if (last_asked_format) {
3125
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3126
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3127
            ffmpeg_exit(1);
3128
        }
3129
        last_asked_format = NULL;
3130
    }
3131

    
3132
    if (!strcmp(filename, "-"))
3133
        filename = "pipe:";
3134

    
3135
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3136
                    !strcmp(filename, "/dev/stdin");
3137

    
3138
    /* get default parameters from command line */
3139
    ic = avformat_alloc_context();
3140
    if (!ic) {
3141
        print_error(filename, AVERROR(ENOMEM));
3142
        ffmpeg_exit(1);
3143
    }
3144

    
3145
    memset(ap, 0, sizeof(*ap));
3146
    ap->prealloced_context = 1;
3147
    ap->sample_rate = audio_sample_rate;
3148
    ap->channels = audio_channels;
3149
    ap->time_base.den = frame_rate.num;
3150
    ap->time_base.num = frame_rate.den;
3151
    ap->width = frame_width;
3152
    ap->height = frame_height;
3153
    ap->pix_fmt = frame_pix_fmt;
3154
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3155
    ap->channel = video_channel;
3156
    ap->standard = video_standard;
3157

    
3158
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3159

    
3160
    ic->video_codec_id   =
3161
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3162
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3163
    ic->audio_codec_id   =
3164
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3165
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3166
    ic->subtitle_codec_id=
3167
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3168
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3169
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3170

    
3171
    if(pgmyuv_compatibility_hack)
3172
        ic->video_codec_id= CODEC_ID_PGMYUV;
3173

    
3174
    /* open the input file with generic libav function */
3175
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3176
    if (err < 0) {
3177
        print_error(filename, err);
3178
        ffmpeg_exit(1);
3179
    }
3180
    if(opt_programid) {
3181
        int i, j;
3182
        int found=0;
3183
        for(i=0; i<ic->nb_streams; i++){
3184
            ic->streams[i]->discard= AVDISCARD_ALL;
3185
        }
3186
        for(i=0; i<ic->nb_programs; i++){
3187
            AVProgram *p= ic->programs[i];
3188
            if(p->id != opt_programid){
3189
                p->discard = AVDISCARD_ALL;
3190
            }else{
3191
                found=1;
3192
                for(j=0; j<p->nb_stream_indexes; j++){
3193
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3194
                }
3195
            }
3196
        }
3197
        if(!found){
3198
            fprintf(stderr, "Specified program id not found\n");
3199
            ffmpeg_exit(1);
3200
        }
3201
        opt_programid=0;
3202
    }
3203

    
3204
    ic->loop_input = loop_input;
3205

    
3206
    /* If not enough info to get the stream parameters, we decode the
3207
       first frames to get it. (used in mpeg case for example) */
3208
    ret = av_find_stream_info(ic);
3209
    if (ret < 0 && verbose >= 0) {
3210
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3211
        av_close_input_file(ic);
3212
        ffmpeg_exit(1);
3213
    }
3214

    
3215
    timestamp = start_time;
3216
    /* add the stream start time */
3217
    if (ic->start_time != AV_NOPTS_VALUE)
3218
        timestamp += ic->start_time;
3219

    
3220
    /* if seeking requested, we execute it */
3221
    if (start_time != 0) {
3222
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3223
        if (ret < 0) {
3224
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3225
                    filename, (double)timestamp / AV_TIME_BASE);
3226
        }
3227
        /* reset seek info */
3228
        start_time = 0;
3229
    }
3230

    
3231
    /* update the current parameters so that they match the one of the input stream */
3232
    for(i=0;i<ic->nb_streams;i++) {
3233
        AVStream *st = ic->streams[i];
3234
        AVCodecContext *dec = st->codec;
3235
        avcodec_thread_init(dec, thread_count);
3236
        switch (dec->codec_type) {
3237
        case AVMEDIA_TYPE_AUDIO:
3238
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3239
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3240
            channel_layout    = dec->channel_layout;
3241
            audio_channels    = dec->channels;
3242
            audio_sample_rate = dec->sample_rate;
3243
            audio_sample_fmt  = dec->sample_fmt;
3244
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3245
            if(audio_disable)
3246
                st->discard= AVDISCARD_ALL;
3247
            /* Note that av_find_stream_info can add more streams, and we
3248
             * currently have no chance of setting up lowres decoding
3249
             * early enough for them. */
3250
            if (dec->lowres)
3251
                audio_sample_rate >>= dec->lowres;
3252
            break;
3253
        case AVMEDIA_TYPE_VIDEO:
3254
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3255
            frame_height = dec->height;
3256
            frame_width  = dec->width;
3257
            if(ic->streams[i]->sample_aspect_ratio.num)
3258
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3259
            else
3260
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3261
            frame_aspect_ratio *= (float) dec->width / dec->height;
3262
            frame_pix_fmt = dec->pix_fmt;
3263
            rfps      = ic->streams[i]->r_frame_rate.num;
3264
            rfps_base = ic->streams[i]->r_frame_rate.den;
3265
            if (dec->lowres) {
3266
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3267
                frame_height >>= dec->lowres;
3268
                frame_width  >>= dec->lowres;
3269
            }
3270
            if(me_threshold)
3271
                dec->debug |= FF_DEBUG_MV;
3272

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

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

    
3279
                    (float)rfps / rfps_base, rfps, rfps_base);
3280
            }
3281
            /* update the current frame rate to match the stream frame rate */
3282
            frame_rate.num = rfps;
3283
            frame_rate.den = rfps_base;
3284

    
3285
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3286
            if(video_disable)
3287
                st->discard= AVDISCARD_ALL;
3288
            else if(video_discard)
3289
                st->discard= video_discard;
3290
            break;
3291
        case AVMEDIA_TYPE_DATA:
3292
            break;
3293
        case AVMEDIA_TYPE_SUBTITLE:
3294
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3295
            if(subtitle_disable)
3296
                st->discard = AVDISCARD_ALL;
3297
            break;
3298
        case AVMEDIA_TYPE_ATTACHMENT:
3299
        case AVMEDIA_TYPE_UNKNOWN:
3300
            nb_icodecs++;
3301
            break;
3302
        default:
3303
            abort();
3304
        }
3305
    }
3306

    
3307
    input_files[nb_input_files] = ic;
3308
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3309
    /* dump the file content */
3310
    if (verbose >= 0)
3311
        dump_format(ic, nb_input_files, filename, 0);
3312

    
3313
    nb_input_files++;
3314

    
3315
    video_channel = 0;
3316

    
3317
    av_freep(&video_codec_name);
3318
    av_freep(&audio_codec_name);
3319
    av_freep(&subtitle_codec_name);
3320
}
3321

    
3322
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3323
                                         int *has_subtitle_ptr)
3324
{
3325
    int has_video, has_audio, has_subtitle, i, j;
3326
    AVFormatContext *ic;
3327

    
3328
    has_video = 0;
3329
    has_audio = 0;
3330
    has_subtitle = 0;
3331
    for(j=0;j<nb_input_files;j++) {
3332
        ic = input_files[j];
3333
        for(i=0;i<ic->nb_streams;i++) {
3334
            AVCodecContext *enc = ic->streams[i]->codec;
3335
            switch(enc->codec_type) {
3336
            case AVMEDIA_TYPE_AUDIO:
3337
                has_audio = 1;
3338
                break;
3339
            case AVMEDIA_TYPE_VIDEO:
3340
                has_video = 1;
3341
                break;
3342
            case AVMEDIA_TYPE_SUBTITLE:
3343
                has_subtitle = 1;
3344
                break;
3345
            case AVMEDIA_TYPE_DATA:
3346
            case AVMEDIA_TYPE_ATTACHMENT:
3347
            case AVMEDIA_TYPE_UNKNOWN:
3348
                break;
3349
            default:
3350
                abort();
3351
            }
3352
        }
3353
    }
3354
    *has_video_ptr = has_video;
3355
    *has_audio_ptr = has_audio;
3356
    *has_subtitle_ptr = has_subtitle;
3357
}
3358

    
3359
static void new_video_stream(AVFormatContext *oc)
3360
{
3361
    AVStream *st;
3362
    AVCodecContext *video_enc;
3363
    enum CodecID codec_id;
3364

    
3365
    st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3366
    if (!st) {
3367
        fprintf(stderr, "Could not alloc stream\n");
3368
        ffmpeg_exit(1);
3369
    }
3370
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3371
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3372
    video_bitstream_filters= NULL;
3373

    
3374
    avcodec_thread_init(st->codec, thread_count);
3375

    
3376
    video_enc = st->codec;
3377

    
3378
    if(video_codec_tag)
3379
        video_enc->codec_tag= video_codec_tag;
3380

    
3381
    if(   (video_global_header&1)
3382
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3383
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3384
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3385
    }
3386
    if(video_global_header&2){
3387
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3388
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3389
    }
3390

    
3391
    if (video_stream_copy) {
3392
        st->stream_copy = 1;
3393
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3394
        video_enc->sample_aspect_ratio =
3395
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3396
    } else {
3397
        const char *p;
3398
        int i;
3399
        AVCodec *codec;
3400
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3401

    
3402
        if (video_codec_name) {
3403
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3404
                                         video_enc->strict_std_compliance);
3405
            codec = avcodec_find_encoder_by_name(video_codec_name);
3406
            output_codecs[nb_ocodecs] = codec;
3407
        } else {
3408
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3409
            codec = avcodec_find_encoder(codec_id);
3410
        }
3411

    
3412
        video_enc->codec_id = codec_id;
3413

    
3414
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3415

    
3416
        if (codec && codec->supported_framerates && !force_fps)
3417
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3418
        video_enc->time_base.den = fps.num;
3419
        video_enc->time_base.num = fps.den;
3420

    
3421
        video_enc->width = frame_width;
3422
        video_enc->height = frame_height;
3423
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3424
        video_enc->pix_fmt = frame_pix_fmt;
3425
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3426

    
3427
        choose_pixel_fmt(st, codec);
3428

    
3429
        if (intra_only)
3430
            video_enc->gop_size = 0;
3431
        if (video_qscale || same_quality) {
3432
            video_enc->flags |= CODEC_FLAG_QSCALE;
3433
            video_enc->global_quality=
3434
                st->quality = FF_QP2LAMBDA * video_qscale;
3435
        }
3436

    
3437
        if(intra_matrix)
3438
            video_enc->intra_matrix = intra_matrix;
3439
        if(inter_matrix)
3440
            video_enc->inter_matrix = inter_matrix;
3441

    
3442
        p= video_rc_override_string;
3443
        for(i=0; p; i++){
3444
            int start, end, q;
3445
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3446
            if(e!=3){
3447
                fprintf(stderr, "error parsing rc_override\n");
3448
                ffmpeg_exit(1);
3449
            }
3450
            video_enc->rc_override=
3451
                av_realloc(video_enc->rc_override,
3452
                           sizeof(RcOverride)*(i+1));
3453
            video_enc->rc_override[i].start_frame= start;
3454
            video_enc->rc_override[i].end_frame  = end;
3455
            if(q>0){
3456
                video_enc->rc_override[i].qscale= q;
3457
                video_enc->rc_override[i].quality_factor= 1.0;
3458
            }
3459
            else{
3460
                video_enc->rc_override[i].qscale= 0;
3461
                video_enc->rc_override[i].quality_factor= -q/100.0;
3462
            }
3463
            p= strchr(p, '/');
3464
            if(p) p++;
3465
        }
3466
        video_enc->rc_override_count=i;
3467
        if (!video_enc->rc_initial_buffer_occupancy)
3468
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3469
        video_enc->me_threshold= me_threshold;
3470
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3471

    
3472
        if (do_psnr)
3473
            video_enc->flags|= CODEC_FLAG_PSNR;
3474

    
3475
        /* two pass mode */
3476
        if (do_pass) {
3477
            if (do_pass == 1) {
3478
                video_enc->flags |= CODEC_FLAG_PASS1;
3479
            } else {
3480
                video_enc->flags |= CODEC_FLAG_PASS2;
3481
            }
3482
        }
3483
    }
3484
    nb_ocodecs++;
3485
    if (video_language) {
3486
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3487
        av_freep(&video_language);
3488
    }
3489

    
3490
    /* reset some key parameters */
3491
    video_disable = 0;
3492
    av_freep(&video_codec_name);
3493
    video_stream_copy = 0;
3494
    frame_pix_fmt = PIX_FMT_NONE;
3495
}
3496

    
3497
static void new_audio_stream(AVFormatContext *oc)
3498
{
3499
    AVStream *st;
3500
    AVCodecContext *audio_enc;
3501
    enum CodecID codec_id;
3502

    
3503
    st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3504
    if (!st) {
3505
        fprintf(stderr, "Could not alloc stream\n");
3506
        ffmpeg_exit(1);
3507
    }
3508
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3509

    
3510
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3511
    audio_bitstream_filters= NULL;
3512

    
3513
    avcodec_thread_init(st->codec, thread_count);
3514

    
3515
    audio_enc = st->codec;
3516
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3517

    
3518
    if(audio_codec_tag)
3519
        audio_enc->codec_tag= audio_codec_tag;
3520

    
3521
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3522
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3523
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3524
    }
3525
    if (audio_stream_copy) {
3526
        st->stream_copy = 1;
3527
        audio_enc->channels = audio_channels;
3528
        audio_enc->sample_rate = audio_sample_rate;
3529
    } else {
3530
        AVCodec *codec;
3531

    
3532
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3533

    
3534
        if (audio_codec_name) {
3535
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3536
                                         audio_enc->strict_std_compliance);
3537
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3538
            output_codecs[nb_ocodecs] = codec;
3539
        } else {
3540
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3541
            codec = avcodec_find_encoder(codec_id);
3542
        }
3543
        audio_enc->codec_id = codec_id;
3544

    
3545
        if (audio_qscale > QSCALE_NONE) {
3546
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3547
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3548
        }
3549
        audio_enc->channels = audio_channels;
3550
        audio_enc->sample_fmt = audio_sample_fmt;
3551
        audio_enc->sample_rate = audio_sample_rate;
3552
        audio_enc->channel_layout = channel_layout;
3553
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3554
            audio_enc->channel_layout = 0;
3555
        choose_sample_fmt(st, codec);
3556
        choose_sample_rate(st, codec);
3557
    }
3558
    nb_ocodecs++;
3559
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3560
    if (audio_language) {
3561
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3562
        av_freep(&audio_language);
3563
    }
3564

    
3565
    /* reset some key parameters */
3566
    audio_disable = 0;
3567
    av_freep(&audio_codec_name);
3568
    audio_stream_copy = 0;
3569
}
3570

    
3571
static void new_subtitle_stream(AVFormatContext *oc)
3572
{
3573
    AVStream *st;
3574
    AVCodecContext *subtitle_enc;
3575

    
3576
    st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3577
    if (!st) {
3578
        fprintf(stderr, "Could not alloc stream\n");
3579
        ffmpeg_exit(1);
3580
    }
3581
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3582

    
3583
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3584
    subtitle_bitstream_filters= NULL;
3585

    
3586
    subtitle_enc = st->codec;
3587
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3588

    
3589
    if(subtitle_codec_tag)
3590
        subtitle_enc->codec_tag= subtitle_codec_tag;
3591

    
3592
    if (subtitle_stream_copy) {
3593
        st->stream_copy = 1;
3594
    } else {
3595
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3596
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3597
                                                   subtitle_enc->strict_std_compliance);
3598
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3599
    }
3600
    nb_ocodecs++;
3601

    
3602
    if (subtitle_language) {
3603
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3604
        av_freep(&subtitle_language);
3605
    }
3606

    
3607
    subtitle_disable = 0;
3608
    av_freep(&subtitle_codec_name);
3609
    subtitle_stream_copy = 0;
3610
}
3611

    
3612
static void opt_new_stream(const char *opt, const char *arg)
3613
{
3614
    AVFormatContext *oc;
3615
    if (nb_output_files <= 0) {
3616
        fprintf(stderr, "At least one output file must be specified\n");
3617
        ffmpeg_exit(1);
3618
    }
3619
    oc = output_files[nb_output_files - 1];
3620

    
3621
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc);
3622
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc);
3623
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc);
3624
    else assert(0);
3625
}
3626

    
3627
/* arg format is "output-stream-index:streamid-value". */
3628
static void opt_streamid(const char *opt, const char *arg)
3629
{
3630
    int idx;
3631
    char *p;
3632
    char idx_str[16];
3633

    
3634
    strncpy(idx_str, arg, sizeof(idx_str));
3635
    idx_str[sizeof(idx_str)-1] = '\0';
3636
    p = strchr(idx_str, ':');
3637
    if (!p) {
3638
        fprintf(stderr,
3639
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3640
                arg, opt);
3641
        ffmpeg_exit(1);
3642
    }
3643
    *p++ = '\0';
3644
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3645
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3646
}
3647

    
3648
static void opt_output_file(const char *filename)
3649
{
3650
    AVFormatContext *oc;
3651
    int err, use_video, use_audio, use_subtitle;
3652
    int input_has_video, input_has_audio, input_has_subtitle;
3653
    AVFormatParameters params, *ap = &params;
3654
    AVOutputFormat *file_oformat;
3655

    
3656
    if (!strcmp(filename, "-"))
3657
        filename = "pipe:";
3658

    
3659
    oc = avformat_alloc_context();
3660
    if (!oc) {
3661
        print_error(filename, AVERROR(ENOMEM));
3662
        ffmpeg_exit(1);
3663
    }
3664

    
3665
    if (last_asked_format) {
3666
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3667
        if (!file_oformat) {
3668
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3669
            ffmpeg_exit(1);
3670
        }
3671
        last_asked_format = NULL;
3672
    } else {
3673
        file_oformat = av_guess_format(NULL, filename, NULL);
3674
        if (!file_oformat) {
3675
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3676
                    filename);
3677
            ffmpeg_exit(1);
3678
        }
3679
    }
3680

    
3681
    oc->oformat = file_oformat;
3682
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3683

    
3684
    if (!strcmp(file_oformat->name, "ffm") &&
3685
        av_strstart(filename, "http:", NULL)) {
3686
        /* special case for files sent to ffserver: we get the stream
3687
           parameters from ffserver */
3688
        int err = read_ffserver_streams(oc, filename);
3689
        if (err < 0) {
3690
            print_error(filename, err);
3691
            ffmpeg_exit(1);
3692
        }
3693
    } else {
3694
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3695
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3696
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3697

    
3698
        /* disable if no corresponding type found and at least one
3699
           input file */
3700
        if (nb_input_files > 0) {
3701
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3702
                                         &input_has_subtitle);
3703
            if (!input_has_video)
3704
                use_video = 0;
3705
            if (!input_has_audio)
3706
                use_audio = 0;
3707
            if (!input_has_subtitle)
3708
                use_subtitle = 0;
3709
        }
3710

    
3711
        /* manual disable */
3712
        if (audio_disable) {
3713
            use_audio = 0;
3714
        }
3715
        if (video_disable) {
3716
            use_video = 0;
3717
        }
3718
        if (subtitle_disable) {
3719
            use_subtitle = 0;
3720
        }
3721

    
3722
        if (use_video) {
3723
            new_video_stream(oc);
3724
        }
3725

    
3726
        if (use_audio) {
3727
            new_audio_stream(oc);
3728
        }
3729

    
3730
        if (use_subtitle) {
3731
            new_subtitle_stream(oc);
3732
        }
3733

    
3734
        oc->timestamp = recording_timestamp;
3735

    
3736
        for(; metadata_count>0; metadata_count--){
3737
            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3738
                                            metadata[metadata_count-1].value, 0);
3739
        }
3740
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3741
    }
3742

    
3743
    output_files[nb_output_files++] = oc;
3744

    
3745
    /* check filename in case of an image number is expected */
3746
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3747
        if (!av_filename_number_test(oc->filename)) {
3748
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3749
            ffmpeg_exit(1);
3750
        }
3751
    }
3752

    
3753
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3754
        /* test if it already exists to avoid loosing precious files */
3755
        if (!file_overwrite &&
3756
            (strchr(filename, ':') == NULL ||
3757
             filename[1] == ':' ||
3758
             av_strstart(filename, "file:", NULL))) {
3759
            if (url_exist(filename)) {
3760
                if (!using_stdin) {
3761
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3762
                    fflush(stderr);
3763
                    if (!read_yesno()) {
3764
                        fprintf(stderr, "Not overwriting - exiting\n");
3765
                        ffmpeg_exit(1);
3766
                    }
3767
                }
3768
                else {
3769
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3770
                    ffmpeg_exit(1);
3771
                }
3772
            }
3773
        }
3774

    
3775
        /* open the file */
3776
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3777
            print_error(filename, err);
3778
            ffmpeg_exit(1);
3779
        }
3780
    }
3781

    
3782
    memset(ap, 0, sizeof(*ap));
3783
    if (av_set_parameters(oc, ap) < 0) {
3784
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3785
                oc->filename);
3786
        ffmpeg_exit(1);
3787
    }
3788

    
3789
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3790
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3791
    oc->loop_output = loop_output;
3792
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3793

    
3794
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3795

    
3796
    memset(streamid_map, 0, sizeof(streamid_map));
3797
}
3798

    
3799
/* same option as mencoder */
3800
static void opt_pass(const char *pass_str)
3801
{
3802
    int pass;
3803
    pass = atoi(pass_str);
3804
    if (pass != 1 && pass != 2) {
3805
        fprintf(stderr, "pass number can be only 1 or 2\n");
3806
        ffmpeg_exit(1);
3807
    }
3808
    do_pass = pass;
3809
}
3810

    
3811
static int64_t getutime(void)
3812
{
3813
#if HAVE_GETRUSAGE
3814
    struct rusage rusage;
3815

    
3816
    getrusage(RUSAGE_SELF, &rusage);
3817
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3818
#elif HAVE_GETPROCESSTIMES
3819
    HANDLE proc;
3820
    FILETIME c, e, k, u;
3821
    proc = GetCurrentProcess();
3822
    GetProcessTimes(proc, &c, &e, &k, &u);
3823
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3824
#else
3825
    return av_gettime();
3826
#endif
3827
}
3828

    
3829
static int64_t getmaxrss(void)
3830
{
3831
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3832
    struct rusage rusage;
3833
    getrusage(RUSAGE_SELF, &rusage);
3834
    return (int64_t)rusage.ru_maxrss * 1024;
3835
#elif HAVE_GETPROCESSMEMORYINFO
3836
    HANDLE proc;
3837
    PROCESS_MEMORY_COUNTERS memcounters;
3838
    proc = GetCurrentProcess();
3839
    memcounters.cb = sizeof(memcounters);
3840
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3841
    return memcounters.PeakPagefileUsage;
3842
#else
3843
    return 0;
3844
#endif
3845
}
3846

    
3847
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3848
{
3849
    int i;
3850
    const char *p = str;
3851
    for(i = 0;; i++) {
3852
        dest[i] = atoi(p);
3853
        if(i == 63)
3854
            break;
3855
        p = strchr(p, ',');
3856
        if(!p) {
3857
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3858
            ffmpeg_exit(1);
3859
        }
3860
        p++;
3861
    }
3862
}
3863

    
3864
static void opt_inter_matrix(const char *arg)
3865
{
3866
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3867
    parse_matrix_coeffs(inter_matrix, arg);
3868
}
3869

    
3870
static void opt_intra_matrix(const char *arg)
3871
{
3872
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3873
    parse_matrix_coeffs(intra_matrix, arg);
3874
}
3875

    
3876
static void show_usage(void)
3877
{
3878
    printf("Hyper fast Audio and Video encoder\n");
3879
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3880
    printf("\n");
3881
}
3882

    
3883
static void show_help(void)
3884
{
3885
    av_log_set_callback(log_callback_help);
3886
    show_usage();
3887
    show_help_options(options, "Main options:\n",
3888
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3889
    show_help_options(options, "\nAdvanced options:\n",
3890
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3891
                      OPT_EXPERT);
3892
    show_help_options(options, "\nVideo options:\n",
3893
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3894
                      OPT_VIDEO);
3895
    show_help_options(options, "\nAdvanced Video options:\n",
3896
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3897
                      OPT_VIDEO | OPT_EXPERT);
3898
    show_help_options(options, "\nAudio options:\n",
3899
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3900
                      OPT_AUDIO);
3901
    show_help_options(options, "\nAdvanced Audio options:\n",
3902
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3903
                      OPT_AUDIO | OPT_EXPERT);
3904
    show_help_options(options, "\nSubtitle options:\n",
3905
                      OPT_SUBTITLE | OPT_GRAB,
3906
                      OPT_SUBTITLE);
3907
    show_help_options(options, "\nAudio/Video grab options:\n",
3908
                      OPT_GRAB,
3909
                      OPT_GRAB);
3910
    printf("\n");
3911
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3912
    printf("\n");
3913
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3914
    printf("\n");
3915
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3916
}
3917

    
3918
static void opt_target(const char *arg)
3919
{
3920
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3921
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3922

    
3923
    if(!strncmp(arg, "pal-", 4)) {
3924
        norm = PAL;
3925
        arg += 4;
3926
    } else if(!strncmp(arg, "ntsc-", 5)) {
3927
        norm = NTSC;
3928
        arg += 5;
3929
    } else if(!strncmp(arg, "film-", 5)) {
3930
        norm = FILM;
3931
        arg += 5;
3932
    } else {
3933
        int fr;
3934
        /* Calculate FR via float to avoid int overflow */
3935
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3936
        if(fr == 25000) {
3937
            norm = PAL;
3938
        } else if((fr == 29970) || (fr == 23976)) {
3939
            norm = NTSC;
3940
        } else {
3941
            /* Try to determine PAL/NTSC by peeking in the input files */
3942
            if(nb_input_files) {
3943
                int i, j;
3944
                for(j = 0; j < nb_input_files; j++) {
3945
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3946
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3947
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3948
                            continue;
3949
                        fr = c->time_base.den * 1000 / c->time_base.num;
3950
                        if(fr == 25000) {
3951
                            norm = PAL;
3952
                            break;
3953
                        } else if((fr == 29970) || (fr == 23976)) {
3954
                            norm = NTSC;
3955
                            break;
3956
                        }
3957
                    }
3958
                    if(norm != UNKNOWN)
3959
                        break;
3960
                }
3961
            }
3962
        }
3963
        if(verbose && norm != UNKNOWN)
3964
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3965
    }
3966

    
3967
    if(norm == UNKNOWN) {
3968
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3969
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3970
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3971
        ffmpeg_exit(1);
3972
    }
3973

    
3974
    if(!strcmp(arg, "vcd")) {
3975

    
3976
        opt_video_codec("mpeg1video");
3977
        opt_audio_codec("mp2");
3978
        opt_format("vcd");
3979

    
3980
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3981
        opt_frame_rate(NULL, frame_rates[norm]);
3982
        opt_default("g", norm == PAL ? "15" : "18");
3983

    
3984
        opt_default("b", "1150000");
3985
        opt_default("maxrate", "1150000");
3986
        opt_default("minrate", "1150000");
3987
        opt_default("bufsize", "327680"); // 40*1024*8;
3988

    
3989
        opt_default("ab", "224000");
3990
        audio_sample_rate = 44100;
3991
        audio_channels = 2;
3992

    
3993
        opt_default("packetsize", "2324");
3994
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3995

    
3996
        /* We have to offset the PTS, so that it is consistent with the SCR.
3997
           SCR starts at 36000, but the first two packs contain only padding
3998
           and the first pack from the other stream, respectively, may also have
3999
           been written before.
4000
           So the real data starts at SCR 36000+3*1200. */
4001
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4002
    } else if(!strcmp(arg, "svcd")) {
4003

    
4004
        opt_video_codec("mpeg2video");
4005
        opt_audio_codec("mp2");
4006
        opt_format("svcd");
4007

    
4008
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4009
        opt_frame_rate(NULL, frame_rates[norm]);
4010
        opt_default("g", norm == PAL ? "15" : "18");
4011

    
4012
        opt_default("b", "2040000");
4013
        opt_default("maxrate", "2516000");
4014
        opt_default("minrate", "0"); //1145000;
4015
        opt_default("bufsize", "1835008"); //224*1024*8;
4016
        opt_default("flags", "+scan_offset");
4017

    
4018

    
4019
        opt_default("ab", "224000");
4020
        audio_sample_rate = 44100;
4021

    
4022
        opt_default("packetsize", "2324");
4023

    
4024
    } else if(!strcmp(arg, "dvd")) {
4025

    
4026
        opt_video_codec("mpeg2video");
4027
        opt_audio_codec("ac3");
4028
        opt_format("dvd");
4029

    
4030
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4031
        opt_frame_rate(NULL, frame_rates[norm]);
4032
        opt_default("g", norm == PAL ? "15" : "18");
4033

    
4034
        opt_default("b", "6000000");
4035
        opt_default("maxrate", "9000000");
4036
        opt_default("minrate", "0"); //1500000;
4037
        opt_default("bufsize", "1835008"); //224*1024*8;
4038

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

    
4042
        opt_default("ab", "448000");
4043
        audio_sample_rate = 48000;
4044

    
4045
    } else if(!strncmp(arg, "dv", 2)) {
4046

    
4047
        opt_format("dv");
4048

    
4049
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4050
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4051
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4052
        opt_frame_rate(NULL, frame_rates[norm]);
4053

    
4054
        audio_sample_rate = 48000;
4055
        audio_channels = 2;
4056

    
4057
    } else {
4058
        fprintf(stderr, "Unknown target: %s\n", arg);
4059
        ffmpeg_exit(1);
4060
    }
4061
}
4062

    
4063
static void opt_vstats_file (const char *arg)
4064
{
4065
    av_free (vstats_filename);
4066
    vstats_filename=av_strdup (arg);
4067
}
4068

    
4069
static void opt_vstats (void)
4070
{
4071
    char filename[40];
4072
    time_t today2 = time(NULL);
4073
    struct tm *today = localtime(&today2);
4074

    
4075
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4076
             today->tm_sec);
4077
    opt_vstats_file(filename);
4078
}
4079

    
4080
static int opt_bsf(const char *opt, const char *arg)
4081
{
4082
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4083
    AVBitStreamFilterContext **bsfp;
4084

    
4085
    if(!bsfc){
4086
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4087
        ffmpeg_exit(1);
4088
    }
4089

    
4090
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4091
          *opt == 'a' ? &audio_bitstream_filters :
4092
                        &subtitle_bitstream_filters;
4093
    while(*bsfp)
4094
        bsfp= &(*bsfp)->next;
4095

    
4096
    *bsfp= bsfc;
4097

    
4098
    return 0;
4099
}
4100

    
4101
static int opt_preset(const char *opt, const char *arg)
4102
{
4103
    FILE *f=NULL;
4104
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4105
    int i;
4106
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
4107
                           getenv("HOME"),
4108
                           FFMPEG_DATADIR,
4109
                         };
4110

    
4111
    if (*opt != 'f') {
4112
        for(i=0; i<3 && !f; i++){
4113
            if(!base[i])
4114
                continue;
4115
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4116
            f= fopen(filename, "r");
4117
            if(!f){
4118
                char *codec_name= *opt == 'v' ? video_codec_name :
4119
                                  *opt == 'a' ? audio_codec_name :
4120
                                                subtitle_codec_name;
4121
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4122
                f= fopen(filename, "r");
4123
            }
4124
        }
4125
    } else {
4126
        av_strlcpy(filename, arg, sizeof(filename));
4127
        f= fopen(filename, "r");
4128
    }
4129

    
4130
    if(!f){
4131
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4132
        ffmpeg_exit(1);
4133
    }
4134

    
4135
    while(!feof(f)){
4136
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4137
        if(line[0] == '#' && !e)
4138
            continue;
4139
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4140
        if(e){
4141
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4142
            ffmpeg_exit(1);
4143
        }
4144
        if(!strcmp(tmp, "acodec")){
4145
            opt_audio_codec(tmp2);
4146
        }else if(!strcmp(tmp, "vcodec")){
4147
            opt_video_codec(tmp2);
4148
        }else if(!strcmp(tmp, "scodec")){
4149
            opt_subtitle_codec(tmp2);
4150
        }else if(opt_default(tmp, tmp2) < 0){
4151
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4152
            ffmpeg_exit(1);
4153
        }
4154
    }
4155

    
4156
    fclose(f);
4157

    
4158
    return 0;
4159
}
4160

    
4161
static const OptionDef options[] = {
4162
    /* main options */
4163
#include "cmdutils_common_opts.h"
4164
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4165
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4166
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4167
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4168
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4169
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4170
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4171
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4172
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4173
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4174
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4175
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4176
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4177
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4178
      "add timings for benchmarking" },
4179
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4180
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4181
      "dump each input packet" },
4182
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4183
      "when dumping packets, also dump the payload" },
4184
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4185
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4186
    { "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)", "" },
4187
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4188
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4189
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4190
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4191
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4192
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4193
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4194
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4195
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4196
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4197
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4198
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4199
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4200

    
4201
    /* video options */
4202
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4203
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4204
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4205
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4206
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4207
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4208
    { "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" },
4209
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "Deprecated, please use the crop avfilter", "size" },
4210
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "Deprecated, please use the crop avfilter", "size" },
4211
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "Deprecated, please use the crop avfilter", "size" },
4212
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "Deprecated, please use the crop avfilter", "size" },
4213
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4214
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4215
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4216
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4217
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4218
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4219
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4220
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4221
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4222
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4223
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4224
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4225
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4226
      "use same video quality as source (implies VBR)" },
4227
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4228
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4229
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4230
      "deinterlace pictures" },
4231
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4232
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4233
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4234
#if CONFIG_AVFILTER
4235
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4236
#endif
4237
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4238
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4239
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4240
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4241
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4242
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4243
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4244
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4245
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4246
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4247

    
4248
    /* audio options */
4249
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4250
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4251
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4252
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4253
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4254
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4255
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4256
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4257
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4258
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4259
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4260
    { "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" },
4261

    
4262
    /* subtitle options */
4263
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4264
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4265
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4266
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4267
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4268

    
4269
    /* grab options */
4270
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4271
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4272
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4273

    
4274
    /* muxer options */
4275
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4276
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4277

    
4278
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4279
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4280
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4281

    
4282
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4283
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4284
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4285
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4286

    
4287
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4288
    { NULL, },
4289
};
4290

    
4291
int main(int argc, char **argv)
4292
{
4293
    int i;
4294
    int64_t ti;
4295

    
4296
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4297

    
4298
    avcodec_register_all();
4299
#if CONFIG_AVDEVICE
4300
    avdevice_register_all();
4301
#endif
4302
#if CONFIG_AVFILTER
4303
    avfilter_register_all();
4304
#endif
4305
    av_register_all();
4306

    
4307
#if HAVE_ISATTY
4308
    if(isatty(STDIN_FILENO))
4309
        url_set_interrupt_cb(decode_interrupt_cb);
4310
#endif
4311

    
4312
    for(i=0; i<AVMEDIA_TYPE_NB; i++){
4313
        avcodec_opts[i]= avcodec_alloc_context2(i);
4314
    }
4315
    avformat_opts = avformat_alloc_context();
4316
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4317

    
4318
    show_banner();
4319

    
4320
    /* parse options */
4321
    parse_options(argc, argv, options, opt_output_file);
4322

    
4323
    if(nb_output_files <= 0 && nb_input_files == 0) {
4324
        show_usage();
4325
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4326
        ffmpeg_exit(1);
4327
    }
4328

    
4329
    /* file converter / grab */
4330
    if (nb_output_files <= 0) {
4331
        fprintf(stderr, "At least one output file must be specified\n");
4332
        ffmpeg_exit(1);
4333
    }
4334

    
4335
    if (nb_input_files == 0) {
4336
        fprintf(stderr, "At least one input file must be specified\n");
4337
        ffmpeg_exit(1);
4338
    }
4339

    
4340
    ti = getutime();
4341
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4342
                  stream_maps, nb_stream_maps) < 0)
4343
        ffmpeg_exit(1);
4344
    ti = getutime() - ti;
4345
    if (do_benchmark) {
4346
        int maxrss = getmaxrss() / 1024;
4347
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4348
    }
4349

    
4350
    return ffmpeg_exit(0);
4351
}