Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 5d4890d7

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
/** select an input file for an output file */
97
typedef struct AVMetaDataMap {
98
    int out_file;
99
    int in_file;
100
} AVMetaDataMap;
101

    
102
static const OptionDef options[];
103

    
104
#define MAX_FILES 100
105

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

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

    
119
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
120
static int nb_stream_maps;
121

    
122
static AVMetaDataMap meta_data_maps[MAX_FILES];
123
static int nb_meta_data_maps;
124

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

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

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

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

    
177
static float mux_preload= 0.5;
178
static float mux_max_delay= 0.7;
179

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

    
207
static int rate_emu = 0;
208

    
209
static int  video_channel = 0;
210
static char *video_standard;
211

    
212
static int audio_volume = 256;
213

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

    
228
static int pgmyuv_compatibility_hack=0;
229
static float dts_delta_threshold = 10;
230

    
231
static unsigned int sws_flags = SWS_BICUBIC;
232

    
233
static int64_t timer_start;
234

    
235
static uint8_t *audio_buf;
236
static uint8_t *audio_out;
237
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
238

    
239
static short *samples;
240

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

    
246
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
247

    
248
struct AVInputStream;
249

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

    
270
    /* full frame size of first frame */
271
    int original_height;
272
    int original_width;
273

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

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

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

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

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

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

    
327
#if HAVE_TERMIOS_H
328

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

    
333
#if CONFIG_AVFILTER
334
typedef struct {
335
    int pix_fmt;
336
} FilterOutPriv;
337

    
338

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

    
343
    if(!opaque) return -1;
344

    
345
    priv->pix_fmt = *((int *)opaque);
346

    
347
    return 0;
348
}
349

    
350
static void output_end_frame(AVFilterLink *link)
351
{
352
}
353

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

    
359
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
360
    return 0;
361
}
362

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

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

    
376
    *pts          = pic->pts;
377

    
378
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
379
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
380
    pic2->interlaced_frame = pic->interlaced;
381
    pic2->top_field_first  = pic->top_field_first;
382

    
383
    return 1;
384
}
385

    
386
static AVFilter output_filter =
387
{
388
    .name      = "ffmpeg_output",
389

    
390
    .priv_size = sizeof(FilterOutPriv),
391
    .init      = output_init,
392

    
393
    .query_formats = output_query_formats,
394

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

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

    
411
    graph = av_mallocz(sizeof(AVFilterGraph));
412

    
413
    if (!(ist->input_video_filter = avfilter_open(avfilter_get_by_name("buffer"), "src")))
414
        return -1;
415
    if (!(ist->out_video_filter = avfilter_open(&output_filter, "out")))
416
        return -1;
417

    
418
    snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
419
             ist->st->codec->height, ist->st->codec->pix_fmt);
420
    if (avfilter_init_filter(ist->input_video_filter, args, NULL))
421
        return -1;
422
    if (avfilter_init_filter(ist->out_video_filter, NULL, &codec->pix_fmt))
423
        return -1;
424

    
425
    /* add input and output filters to the overall graph */
426
    avfilter_graph_add_filter(graph, ist->input_video_filter);
427
    avfilter_graph_add_filter(graph, ist->out_video_filter);
428

    
429
    last_filter = ist->input_video_filter;
430

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

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

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

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

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

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

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

    
489
    /* configure all the filter links */
490
    if (avfilter_graph_check_validity(graph, NULL))
491
        return -1;
492
    if (avfilter_graph_config_formats(graph, NULL))
493
        return -1;
494
    if (avfilter_graph_config_links(graph, NULL))
495
        return -1;
496

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

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

    
504
static void term_exit(void)
505
{
506
#if HAVE_TERMIOS_H
507
    tcsetattr (0, TCSANOW, &oldtty);
508
#endif
509
}
510

    
511
static volatile int received_sigterm = 0;
512

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

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

    
525
    tcgetattr (0, &tty);
526
    oldtty = tty;
527
    atexit(term_exit);
528

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

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

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

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

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

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

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

    
582
static int ffmpeg_exit(int ret)
583
{
584
    int i;
585

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

    
610
    av_free(intra_matrix);
611
    av_free(inter_matrix);
612

    
613
    if (vstats_file)
614
        fclose(vstats_file);
615
    av_free(vstats_filename);
616

    
617
    av_free(opt_names);
618

    
619
    av_free(video_codec_name);
620
    av_free(audio_codec_name);
621
    av_free(subtitle_codec_name);
622

    
623
    av_free(video_standard);
624

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

    
634
#if CONFIG_AVFILTER
635
    avfilter_uninit();
636
#endif
637

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

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

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

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

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

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

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

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

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

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

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

    
747
    if (!nopts)
748
        s->timestamp = av_gettime();
749

    
750
    av_close_input_file(ic);
751
    return 0;
752
}
753

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

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

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

    
783
        bsfc= bsfc->next;
784
    }
785

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

    
793
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
794

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

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

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

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

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

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

    
835
    if (enc->channels != dec->channels)
836
        ost->audio_resample = 1;
837

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1138
    avcodec_get_frame_defaults(&picture_crop_temp);
1139
    avcodec_get_frame_defaults(&picture_pad_temp);
1140

    
1141
    enc = ost->st->codec;
1142
    dec = ist->st->codec;
1143

    
1144
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1145

    
1146
    /* by default, we output a single frame */
1147
    nb_frames = 1;
1148

    
1149
    *frame_size = 0;
1150

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

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

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

    
1196
    final_picture = formatted_picture;
1197
    padding_src = formatted_picture;
1198
    resampling_dst = &ost->pict_tmp;
1199

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

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

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

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

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

    
1229
            ost->topBand    = topBand;
1230
            ost->bottomBand = bottomBand;
1231
            ost->leftBand   = leftBand;
1232
            ost->rightBand  = rightBand;
1233

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1404

    
1405
    oc = output_files[0];
1406

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

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

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

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

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

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

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

    
1485
        fflush(stderr);
1486
    }
1487

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

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

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

    
1520
    if(ist->next_pts == AV_NOPTS_VALUE)
1521
        ist->next_pts= ist->pts;
1522

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1722
                        av_init_packet(&opkt);
1723

    
1724
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1725
                            continue;
1726

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1884
    return 0;
1885
 fail_decode:
1886
    return -1;
1887
}
1888

    
1889
static void print_sdp(AVFormatContext **avc, int n)
1890
{
1891
    char sdp[2048];
1892

    
1893
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1894
    printf("SDP:\n%s\n", sdp);
1895
    fflush(stdout);
1896
}
1897

    
1898
static int copy_chapters(int infile, int outfile)
1899
{
1900
    AVFormatContext *is = input_files[infile];
1901
    AVFormatContext *os = output_files[outfile];
1902
    int i;
1903

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

    
1912

    
1913
        if (in_ch->end < ts_off)
1914
            continue;
1915
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1916
            break;
1917

    
1918
        out_ch = av_mallocz(sizeof(AVChapter));
1919
        if (!out_ch)
1920
            return AVERROR(ENOMEM);
1921

    
1922
        out_ch->id        = in_ch->id;
1923
        out_ch->time_base = in_ch->time_base;
1924
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1925
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1926

    
1927
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1928
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1929

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

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

    
1960
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1961
    if (!file_table)
1962
        goto fail;
1963

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

    
1974
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1975
    if (!ist_table)
1976
        goto fail;
1977

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

    
1995
            if (rate_emu) {
1996
                ist->start = av_gettime();
1997
            }
1998
        }
1999
    }
2000

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

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

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

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

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

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

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

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

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

    
2139
        codec = ost->st->codec;
2140
        icodec = ist->st->codec;
2141

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

    
2146
        ost->st->disposition = ist->st->disposition;
2147
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2148
        codec->chroma_sample_location = icodec->chroma_sample_location;
2149

    
2150
        if (ost->st->stream_copy) {
2151
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2152

    
2153
            if (extra_size > INT_MAX)
2154
                goto fail;
2155

    
2156
            /* if stream_copy is selected, no need to decode or encode */
2157
            codec->codec_id = icodec->codec_id;
2158
            codec->codec_type = icodec->codec_type;
2159

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

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

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

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

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

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

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

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

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

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

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

    
2406
        out_file = output_files[out_file_index];
2407
        in_file = input_files[in_file_index];
2408

    
2409

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

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

    
2422
        for (j = 0; j < nb_output_files; j++)
2423
            if ((ret = copy_chapters(i, j)) < 0)
2424
                goto dump_format;
2425
    }
2426

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

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

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

    
2465
    if (ret) {
2466
        fprintf(stderr, "%s\n", error);
2467
        goto fail;
2468
    }
2469

    
2470
    if (want_sdp) {
2471
        print_sdp(output_files, nb_output_files);
2472
    }
2473

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

    
2480
    timer_start = av_gettime();
2481

    
2482
    for(; received_sigterm == 0;) {
2483
        int file_index, ist_index;
2484
        AVPacket pkt;
2485
        double ipts_min;
2486
        double opts_min;
2487

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

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

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

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

    
2559
        no_packet_count=0;
2560
        memset(no_packet, 0, sizeof(no_packet));
2561

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

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

    
2579
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2580
            if(pkt.pts != AV_NOPTS_VALUE)
2581
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2582
            if(pkt.dts != AV_NOPTS_VALUE)
2583
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2584
        }
2585

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

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

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

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

    
2620
    discard_packet:
2621
        av_free_packet(&pkt);
2622

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

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

    
2635
    term_exit();
2636

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

    
2643
    /* dump report by using the first video and audio streams */
2644
    print_report(output_files, ost_table, nb_ostreams, 1);
2645

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

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

    
2669
    /* finished ! */
2670
    ret = 0;
2671

    
2672
 fail:
2673
    av_freep(&bit_buffer);
2674
    av_free(file_table);
2675

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

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

    
2720
    last_asked_format = arg;
2721
}
2722

    
2723
static void opt_video_rc_override_string(const char *arg)
2724
{
2725
    video_rc_override_string = arg;
2726
}
2727

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

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

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

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

    
2753
    opt_default(opt, arg);
2754

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

    
2758
    return 0;
2759
}
2760

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

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

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

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

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

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

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

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

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

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

    
2872
static int opt_metadata(const char *opt, const char *arg)
2873
{
2874
    char *mid= strchr(arg, '=');
2875

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

    
2882
    metadata_count++;
2883
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2884
    metadata[metadata_count-1].key  = av_strdup(arg);
2885
    metadata[metadata_count-1].value= av_strdup(mid);
2886

    
2887
    return 0;
2888
}
2889

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

    
2900
static void opt_top_field_first(const char *arg)
2901
{
2902
    top_field_first= atoi(arg);
2903
}
2904

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

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

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

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

    
2937
static void opt_video_channel(const char *arg)
2938
{
2939
    video_channel = strtol(arg, NULL, 0);
2940
}
2941

    
2942
static void opt_video_standard(const char *arg)
2943
{
2944
    video_standard = av_strdup(arg);
2945
}
2946

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

    
2958
static void opt_audio_codec(const char *arg)
2959
{
2960
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2961
}
2962

    
2963
static void opt_audio_tag(const char *arg)
2964
{
2965
    char *tail;
2966
    audio_codec_tag= strtol(arg, &tail, 0);
2967

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

    
2972
static void opt_video_tag(const char *arg)
2973
{
2974
    char *tail;
2975
    video_codec_tag= strtol(arg, &tail, 0);
2976

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

    
2981
static void opt_video_codec(const char *arg)
2982
{
2983
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2984
}
2985

    
2986
static void opt_subtitle_codec(const char *arg)
2987
{
2988
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2989
}
2990

    
2991
static void opt_subtitle_tag(const char *arg)
2992
{
2993
    char *tail;
2994
    subtitle_codec_tag= strtol(arg, &tail, 0);
2995

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

    
3000
static void opt_map(const char *arg)
3001
{
3002
    AVStreamMap *m;
3003
    char *p;
3004

    
3005
    m = &stream_maps[nb_stream_maps++];
3006

    
3007
    m->file_index = strtol(arg, &p, 0);
3008
    if (*p)
3009
        p++;
3010

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

    
3024
static void opt_map_meta_data(const char *arg)
3025
{
3026
    AVMetaDataMap *m;
3027
    char *p;
3028

    
3029
    m = &meta_data_maps[nb_meta_data_maps++];
3030

    
3031
    m->out_file = strtol(arg, &p, 0);
3032
    if (*p)
3033
        p++;
3034

    
3035
    m->in_file = strtol(p, &p, 0);
3036
}
3037

    
3038
static void opt_input_ts_scale(const char *arg)
3039
{
3040
    unsigned int stream;
3041
    double scale;
3042
    char *p;
3043

    
3044
    stream = strtol(arg, &p, 0);
3045
    if (*p)
3046
        p++;
3047
    scale= strtod(p, &p);
3048

    
3049
    if(stream >= MAX_STREAMS)
3050
        ffmpeg_exit(1);
3051

    
3052
    input_files_ts_scale[nb_input_files][stream]= scale;
3053
}
3054

    
3055
static int opt_recording_time(const char *opt, const char *arg)
3056
{
3057
    recording_time = parse_time_or_die(opt, arg, 1);
3058
    return 0;
3059
}
3060

    
3061
static int opt_start_time(const char *opt, const char *arg)
3062
{
3063
    start_time = parse_time_or_die(opt, arg, 1);
3064
    return 0;
3065
}
3066

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

    
3073
static int opt_input_ts_offset(const char *opt, const char *arg)
3074
{
3075
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3076
    return 0;
3077
}
3078

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

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

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

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

    
3129
    if (!strcmp(filename, "-"))
3130
        filename = "pipe:";
3131

    
3132
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3133
                    !strcmp(filename, "/dev/stdin");
3134

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

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

    
3155
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3156

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

    
3168
    if(pgmyuv_compatibility_hack)
3169
        ic->video_codec_id= CODEC_ID_PGMYUV;
3170

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

    
3201
    ic->loop_input = loop_input;
3202

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

    
3212
    timestamp = start_time;
3213
    /* add the stream start time */
3214
    if (ic->start_time != AV_NOPTS_VALUE)
3215
        timestamp += ic->start_time;
3216

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

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

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

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

    
3271
                    (float)rfps / rfps_base, rfps, rfps_base);
3272
            }
3273
            /* update the current frame rate to match the stream frame rate */
3274
            frame_rate.num = rfps;
3275
            frame_rate.den = rfps_base;
3276

    
3277
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3278
            if(video_disable)
3279
                st->discard= AVDISCARD_ALL;
3280
            else if(video_discard)
3281
                st->discard= video_discard;
3282
            break;
3283
        case AVMEDIA_TYPE_DATA:
3284
            break;
3285
        case AVMEDIA_TYPE_SUBTITLE:
3286
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3287
            if(subtitle_disable)
3288
                st->discard = AVDISCARD_ALL;
3289
            break;
3290
        case AVMEDIA_TYPE_ATTACHMENT:
3291
        case AVMEDIA_TYPE_UNKNOWN:
3292
            nb_icodecs++;
3293
            break;
3294
        default:
3295
            abort();
3296
        }
3297
    }
3298

    
3299
    input_files[nb_input_files] = ic;
3300
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3301
    /* dump the file content */
3302
    if (verbose >= 0)
3303
        dump_format(ic, nb_input_files, filename, 0);
3304

    
3305
    nb_input_files++;
3306

    
3307
    video_channel = 0;
3308

    
3309
    av_freep(&video_codec_name);
3310
    av_freep(&audio_codec_name);
3311
    av_freep(&subtitle_codec_name);
3312
}
3313

    
3314
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3315
                                         int *has_subtitle_ptr)
3316
{
3317
    int has_video, has_audio, has_subtitle, i, j;
3318
    AVFormatContext *ic;
3319

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

    
3351
static void new_video_stream(AVFormatContext *oc)
3352
{
3353
    AVStream *st;
3354
    AVCodecContext *video_enc;
3355
    enum CodecID codec_id;
3356

    
3357
    st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3358
    if (!st) {
3359
        fprintf(stderr, "Could not alloc stream\n");
3360
        ffmpeg_exit(1);
3361
    }
3362
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3363
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3364
    video_bitstream_filters= NULL;
3365

    
3366
    avcodec_thread_init(st->codec, thread_count);
3367

    
3368
    video_enc = st->codec;
3369

    
3370
    if(video_codec_tag)
3371
        video_enc->codec_tag= video_codec_tag;
3372

    
3373
    if(   (video_global_header&1)
3374
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3375
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3376
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3377
    }
3378
    if(video_global_header&2){
3379
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3380
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3381
    }
3382

    
3383
    if (video_stream_copy) {
3384
        st->stream_copy = 1;
3385
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3386
        video_enc->sample_aspect_ratio =
3387
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3388
    } else {
3389
        const char *p;
3390
        int i;
3391
        AVCodec *codec;
3392
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3393

    
3394
        if (video_codec_name) {
3395
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3396
                                         video_enc->strict_std_compliance);
3397
            codec = avcodec_find_encoder_by_name(video_codec_name);
3398
            output_codecs[nb_ocodecs] = codec;
3399
        } else {
3400
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3401
            codec = avcodec_find_encoder(codec_id);
3402
        }
3403

    
3404
        video_enc->codec_id = codec_id;
3405

    
3406
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3407

    
3408
        if (codec && codec->supported_framerates && !force_fps)
3409
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3410
        video_enc->time_base.den = fps.num;
3411
        video_enc->time_base.num = fps.den;
3412

    
3413
        video_enc->width = frame_width;
3414
        video_enc->height = frame_height;
3415
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3416
        video_enc->pix_fmt = frame_pix_fmt;
3417
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3418

    
3419
        choose_pixel_fmt(st, codec);
3420

    
3421
        if (intra_only)
3422
            video_enc->gop_size = 0;
3423
        if (video_qscale || same_quality) {
3424
            video_enc->flags |= CODEC_FLAG_QSCALE;
3425
            video_enc->global_quality=
3426
                st->quality = FF_QP2LAMBDA * video_qscale;
3427
        }
3428

    
3429
        if(intra_matrix)
3430
            video_enc->intra_matrix = intra_matrix;
3431
        if(inter_matrix)
3432
            video_enc->inter_matrix = inter_matrix;
3433

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

    
3464
        if (do_psnr)
3465
            video_enc->flags|= CODEC_FLAG_PSNR;
3466

    
3467
        /* two pass mode */
3468
        if (do_pass) {
3469
            if (do_pass == 1) {
3470
                video_enc->flags |= CODEC_FLAG_PASS1;
3471
            } else {
3472
                video_enc->flags |= CODEC_FLAG_PASS2;
3473
            }
3474
        }
3475
    }
3476
    nb_ocodecs++;
3477
    if (video_language) {
3478
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3479
        av_freep(&video_language);
3480
    }
3481

    
3482
    /* reset some key parameters */
3483
    video_disable = 0;
3484
    av_freep(&video_codec_name);
3485
    video_stream_copy = 0;
3486
    frame_pix_fmt = PIX_FMT_NONE;
3487
}
3488

    
3489
static void new_audio_stream(AVFormatContext *oc)
3490
{
3491
    AVStream *st;
3492
    AVCodecContext *audio_enc;
3493
    enum CodecID codec_id;
3494

    
3495
    st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3496
    if (!st) {
3497
        fprintf(stderr, "Could not alloc stream\n");
3498
        ffmpeg_exit(1);
3499
    }
3500
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3501

    
3502
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3503
    audio_bitstream_filters= NULL;
3504

    
3505
    avcodec_thread_init(st->codec, thread_count);
3506

    
3507
    audio_enc = st->codec;
3508
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3509

    
3510
    if(audio_codec_tag)
3511
        audio_enc->codec_tag= audio_codec_tag;
3512

    
3513
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3514
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3515
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3516
    }
3517
    if (audio_stream_copy) {
3518
        st->stream_copy = 1;
3519
        audio_enc->channels = audio_channels;
3520
        audio_enc->sample_rate = audio_sample_rate;
3521
    } else {
3522
        AVCodec *codec;
3523

    
3524
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3525

    
3526
        if (audio_codec_name) {
3527
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3528
                                         audio_enc->strict_std_compliance);
3529
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3530
            output_codecs[nb_ocodecs] = codec;
3531
        } else {
3532
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3533
            codec = avcodec_find_encoder(codec_id);
3534
        }
3535
        audio_enc->codec_id = codec_id;
3536

    
3537
        if (audio_qscale > QSCALE_NONE) {
3538
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3539
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3540
        }
3541
        audio_enc->channels = audio_channels;
3542
        audio_enc->sample_fmt = audio_sample_fmt;
3543
        audio_enc->sample_rate = audio_sample_rate;
3544
        audio_enc->channel_layout = channel_layout;
3545
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3546
            audio_enc->channel_layout = 0;
3547
        choose_sample_fmt(st, codec);
3548
        choose_sample_rate(st, codec);
3549
    }
3550
    nb_ocodecs++;
3551
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3552
    if (audio_language) {
3553
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3554
        av_freep(&audio_language);
3555
    }
3556

    
3557
    /* reset some key parameters */
3558
    audio_disable = 0;
3559
    av_freep(&audio_codec_name);
3560
    audio_stream_copy = 0;
3561
}
3562

    
3563
static void new_subtitle_stream(AVFormatContext *oc)
3564
{
3565
    AVStream *st;
3566
    AVCodecContext *subtitle_enc;
3567

    
3568
    st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3569
    if (!st) {
3570
        fprintf(stderr, "Could not alloc stream\n");
3571
        ffmpeg_exit(1);
3572
    }
3573
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3574

    
3575
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3576
    subtitle_bitstream_filters= NULL;
3577

    
3578
    subtitle_enc = st->codec;
3579
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3580

    
3581
    if(subtitle_codec_tag)
3582
        subtitle_enc->codec_tag= subtitle_codec_tag;
3583

    
3584
    if (subtitle_stream_copy) {
3585
        st->stream_copy = 1;
3586
    } else {
3587
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3588
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3589
                                                   subtitle_enc->strict_std_compliance);
3590
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3591
    }
3592
    nb_ocodecs++;
3593

    
3594
    if (subtitle_language) {
3595
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3596
        av_freep(&subtitle_language);
3597
    }
3598

    
3599
    subtitle_disable = 0;
3600
    av_freep(&subtitle_codec_name);
3601
    subtitle_stream_copy = 0;
3602
}
3603

    
3604
static void opt_new_audio_stream(void)
3605
{
3606
    AVFormatContext *oc;
3607
    if (nb_output_files <= 0) {
3608
        fprintf(stderr, "At least one output file must be specified\n");
3609
        ffmpeg_exit(1);
3610
    }
3611
    oc = output_files[nb_output_files - 1];
3612
    new_audio_stream(oc);
3613
}
3614

    
3615
static void opt_new_video_stream(void)
3616
{
3617
    AVFormatContext *oc;
3618
    if (nb_output_files <= 0) {
3619
        fprintf(stderr, "At least one output file must be specified\n");
3620
        ffmpeg_exit(1);
3621
    }
3622
    oc = output_files[nb_output_files - 1];
3623
    new_video_stream(oc);
3624
}
3625

    
3626
static void opt_new_subtitle_stream(void)
3627
{
3628
    AVFormatContext *oc;
3629
    if (nb_output_files <= 0) {
3630
        fprintf(stderr, "At least one output file must be specified\n");
3631
        ffmpeg_exit(1);
3632
    }
3633
    oc = output_files[nb_output_files - 1];
3634
    new_subtitle_stream(oc);
3635
}
3636

    
3637
/* arg format is "output-stream-index:streamid-value". */
3638
static void opt_streamid(const char *opt, const char *arg)
3639
{
3640
    int idx;
3641
    char *p;
3642
    char idx_str[16];
3643

    
3644
    strncpy(idx_str, arg, sizeof(idx_str));
3645
    idx_str[sizeof(idx_str)-1] = '\0';
3646
    p = strchr(idx_str, ':');
3647
    if (!p) {
3648
        fprintf(stderr,
3649
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3650
                arg, opt);
3651
        ffmpeg_exit(1);
3652
    }
3653
    *p++ = '\0';
3654
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3655
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3656
}
3657

    
3658
static void opt_output_file(const char *filename)
3659
{
3660
    AVFormatContext *oc;
3661
    int err, use_video, use_audio, use_subtitle;
3662
    int input_has_video, input_has_audio, input_has_subtitle;
3663
    AVFormatParameters params, *ap = &params;
3664
    AVOutputFormat *file_oformat;
3665

    
3666
    if (!strcmp(filename, "-"))
3667
        filename = "pipe:";
3668

    
3669
    oc = avformat_alloc_context();
3670
    if (!oc) {
3671
        print_error(filename, AVERROR(ENOMEM));
3672
        ffmpeg_exit(1);
3673
    }
3674

    
3675
    if (last_asked_format) {
3676
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3677
        if (!file_oformat) {
3678
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3679
            ffmpeg_exit(1);
3680
        }
3681
        last_asked_format = NULL;
3682
    } else {
3683
        file_oformat = av_guess_format(NULL, filename, NULL);
3684
        if (!file_oformat) {
3685
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3686
                    filename);
3687
            ffmpeg_exit(1);
3688
        }
3689
    }
3690

    
3691
    oc->oformat = file_oformat;
3692
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3693

    
3694
    if (!strcmp(file_oformat->name, "ffm") &&
3695
        av_strstart(filename, "http:", NULL)) {
3696
        /* special case for files sent to ffserver: we get the stream
3697
           parameters from ffserver */
3698
        int err = read_ffserver_streams(oc, filename);
3699
        if (err < 0) {
3700
            print_error(filename, err);
3701
            ffmpeg_exit(1);
3702
        }
3703
    } else {
3704
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3705
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3706
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3707

    
3708
        /* disable if no corresponding type found and at least one
3709
           input file */
3710
        if (nb_input_files > 0) {
3711
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3712
                                         &input_has_subtitle);
3713
            if (!input_has_video)
3714
                use_video = 0;
3715
            if (!input_has_audio)
3716
                use_audio = 0;
3717
            if (!input_has_subtitle)
3718
                use_subtitle = 0;
3719
        }
3720

    
3721
        /* manual disable */
3722
        if (audio_disable) {
3723
            use_audio = 0;
3724
        }
3725
        if (video_disable) {
3726
            use_video = 0;
3727
        }
3728
        if (subtitle_disable) {
3729
            use_subtitle = 0;
3730
        }
3731

    
3732
        if (use_video) {
3733
            new_video_stream(oc);
3734
        }
3735

    
3736
        if (use_audio) {
3737
            new_audio_stream(oc);
3738
        }
3739

    
3740
        if (use_subtitle) {
3741
            new_subtitle_stream(oc);
3742
        }
3743

    
3744
        oc->timestamp = recording_timestamp;
3745

    
3746
        for(; metadata_count>0; metadata_count--){
3747
            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3748
                                            metadata[metadata_count-1].value, 0);
3749
        }
3750
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3751
    }
3752

    
3753
    output_files[nb_output_files++] = oc;
3754

    
3755
    /* check filename in case of an image number is expected */
3756
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3757
        if (!av_filename_number_test(oc->filename)) {
3758
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3759
            ffmpeg_exit(1);
3760
        }
3761
    }
3762

    
3763
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3764
        /* test if it already exists to avoid loosing precious files */
3765
        if (!file_overwrite &&
3766
            (strchr(filename, ':') == NULL ||
3767
             filename[1] == ':' ||
3768
             av_strstart(filename, "file:", NULL))) {
3769
            if (url_exist(filename)) {
3770
                if (!using_stdin) {
3771
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3772
                    fflush(stderr);
3773
                    if (!read_yesno()) {
3774
                        fprintf(stderr, "Not overwriting - exiting\n");
3775
                        ffmpeg_exit(1);
3776
                    }
3777
                }
3778
                else {
3779
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3780
                    ffmpeg_exit(1);
3781
                }
3782
            }
3783
        }
3784

    
3785
        /* open the file */
3786
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3787
            print_error(filename, err);
3788
            ffmpeg_exit(1);
3789
        }
3790
    }
3791

    
3792
    memset(ap, 0, sizeof(*ap));
3793
    if (av_set_parameters(oc, ap) < 0) {
3794
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3795
                oc->filename);
3796
        ffmpeg_exit(1);
3797
    }
3798

    
3799
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3800
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3801
    oc->loop_output = loop_output;
3802
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3803

    
3804
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3805

    
3806
    memset(streamid_map, 0, sizeof(streamid_map));
3807
}
3808

    
3809
/* same option as mencoder */
3810
static void opt_pass(const char *pass_str)
3811
{
3812
    int pass;
3813
    pass = atoi(pass_str);
3814
    if (pass != 1 && pass != 2) {
3815
        fprintf(stderr, "pass number can be only 1 or 2\n");
3816
        ffmpeg_exit(1);
3817
    }
3818
    do_pass = pass;
3819
}
3820

    
3821
static int64_t getutime(void)
3822
{
3823
#if HAVE_GETRUSAGE
3824
    struct rusage rusage;
3825

    
3826
    getrusage(RUSAGE_SELF, &rusage);
3827
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3828
#elif HAVE_GETPROCESSTIMES
3829
    HANDLE proc;
3830
    FILETIME c, e, k, u;
3831
    proc = GetCurrentProcess();
3832
    GetProcessTimes(proc, &c, &e, &k, &u);
3833
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3834
#else
3835
    return av_gettime();
3836
#endif
3837
}
3838

    
3839
static int64_t getmaxrss(void)
3840
{
3841
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3842
    struct rusage rusage;
3843
    getrusage(RUSAGE_SELF, &rusage);
3844
    return (int64_t)rusage.ru_maxrss * 1024;
3845
#elif HAVE_GETPROCESSMEMORYINFO
3846
    HANDLE proc;
3847
    PROCESS_MEMORY_COUNTERS memcounters;
3848
    proc = GetCurrentProcess();
3849
    memcounters.cb = sizeof(memcounters);
3850
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3851
    return memcounters.PeakPagefileUsage;
3852
#else
3853
    return 0;
3854
#endif
3855
}
3856

    
3857
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3858
{
3859
    int i;
3860
    const char *p = str;
3861
    for(i = 0;; i++) {
3862
        dest[i] = atoi(p);
3863
        if(i == 63)
3864
            break;
3865
        p = strchr(p, ',');
3866
        if(!p) {
3867
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3868
            ffmpeg_exit(1);
3869
        }
3870
        p++;
3871
    }
3872
}
3873

    
3874
static void opt_inter_matrix(const char *arg)
3875
{
3876
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3877
    parse_matrix_coeffs(inter_matrix, arg);
3878
}
3879

    
3880
static void opt_intra_matrix(const char *arg)
3881
{
3882
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3883
    parse_matrix_coeffs(intra_matrix, arg);
3884
}
3885

    
3886
/**
3887
 * Trivial log callback.
3888
 * Only suitable for show_help and similar since it lacks prefix handling.
3889
 */
3890
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3891
{
3892
    vfprintf(stdout, fmt, vl);
3893
}
3894

    
3895
static void show_usage(void)
3896
{
3897
    printf("Hyper fast Audio and Video encoder\n");
3898
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3899
    printf("\n");
3900
}
3901

    
3902
static void show_help(void)
3903
{
3904
    av_log_set_callback(log_callback_help);
3905
    show_usage();
3906
    show_help_options(options, "Main options:\n",
3907
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3908
    show_help_options(options, "\nAdvanced options:\n",
3909
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3910
                      OPT_EXPERT);
3911
    show_help_options(options, "\nVideo options:\n",
3912
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3913
                      OPT_VIDEO);
3914
    show_help_options(options, "\nAdvanced Video options:\n",
3915
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3916
                      OPT_VIDEO | OPT_EXPERT);
3917
    show_help_options(options, "\nAudio options:\n",
3918
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3919
                      OPT_AUDIO);
3920
    show_help_options(options, "\nAdvanced Audio options:\n",
3921
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3922
                      OPT_AUDIO | OPT_EXPERT);
3923
    show_help_options(options, "\nSubtitle options:\n",
3924
                      OPT_SUBTITLE | OPT_GRAB,
3925
                      OPT_SUBTITLE);
3926
    show_help_options(options, "\nAudio/Video grab options:\n",
3927
                      OPT_GRAB,
3928
                      OPT_GRAB);
3929
    printf("\n");
3930
    av_opt_show(avcodec_opts[0], NULL);
3931
    printf("\n");
3932
    av_opt_show(avformat_opts, NULL);
3933
    printf("\n");
3934
    av_opt_show(sws_opts, NULL);
3935
}
3936

    
3937
static void opt_target(const char *arg)
3938
{
3939
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3940
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3941

    
3942
    if(!strncmp(arg, "pal-", 4)) {
3943
        norm = PAL;
3944
        arg += 4;
3945
    } else if(!strncmp(arg, "ntsc-", 5)) {
3946
        norm = NTSC;
3947
        arg += 5;
3948
    } else if(!strncmp(arg, "film-", 5)) {
3949
        norm = FILM;
3950
        arg += 5;
3951
    } else {
3952
        int fr;
3953
        /* Calculate FR via float to avoid int overflow */
3954
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3955
        if(fr == 25000) {
3956
            norm = PAL;
3957
        } else if((fr == 29970) || (fr == 23976)) {
3958
            norm = NTSC;
3959
        } else {
3960
            /* Try to determine PAL/NTSC by peeking in the input files */
3961
            if(nb_input_files) {
3962
                int i, j;
3963
                for(j = 0; j < nb_input_files; j++) {
3964
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3965
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3966
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3967
                            continue;
3968
                        fr = c->time_base.den * 1000 / c->time_base.num;
3969
                        if(fr == 25000) {
3970
                            norm = PAL;
3971
                            break;
3972
                        } else if((fr == 29970) || (fr == 23976)) {
3973
                            norm = NTSC;
3974
                            break;
3975
                        }
3976
                    }
3977
                    if(norm != UNKNOWN)
3978
                        break;
3979
                }
3980
            }
3981
        }
3982
        if(verbose && norm != UNKNOWN)
3983
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3984
    }
3985

    
3986
    if(norm == UNKNOWN) {
3987
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3988
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3989
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3990
        ffmpeg_exit(1);
3991
    }
3992

    
3993
    if(!strcmp(arg, "vcd")) {
3994

    
3995
        opt_video_codec("mpeg1video");
3996
        opt_audio_codec("mp2");
3997
        opt_format("vcd");
3998

    
3999
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4000
        opt_frame_rate(NULL, frame_rates[norm]);
4001
        opt_default("g", norm == PAL ? "15" : "18");
4002

    
4003
        opt_default("b", "1150000");
4004
        opt_default("maxrate", "1150000");
4005
        opt_default("minrate", "1150000");
4006
        opt_default("bufsize", "327680"); // 40*1024*8;
4007

    
4008
        opt_default("ab", "224000");
4009
        audio_sample_rate = 44100;
4010
        audio_channels = 2;
4011

    
4012
        opt_default("packetsize", "2324");
4013
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4014

    
4015
        /* We have to offset the PTS, so that it is consistent with the SCR.
4016
           SCR starts at 36000, but the first two packs contain only padding
4017
           and the first pack from the other stream, respectively, may also have
4018
           been written before.
4019
           So the real data starts at SCR 36000+3*1200. */
4020
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4021
    } else if(!strcmp(arg, "svcd")) {
4022

    
4023
        opt_video_codec("mpeg2video");
4024
        opt_audio_codec("mp2");
4025
        opt_format("svcd");
4026

    
4027
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4028
        opt_frame_rate(NULL, frame_rates[norm]);
4029
        opt_default("g", norm == PAL ? "15" : "18");
4030

    
4031
        opt_default("b", "2040000");
4032
        opt_default("maxrate", "2516000");
4033
        opt_default("minrate", "0"); //1145000;
4034
        opt_default("bufsize", "1835008"); //224*1024*8;
4035
        opt_default("flags", "+scan_offset");
4036

    
4037

    
4038
        opt_default("ab", "224000");
4039
        audio_sample_rate = 44100;
4040

    
4041
        opt_default("packetsize", "2324");
4042

    
4043
    } else if(!strcmp(arg, "dvd")) {
4044

    
4045
        opt_video_codec("mpeg2video");
4046
        opt_audio_codec("ac3");
4047
        opt_format("dvd");
4048

    
4049
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4050
        opt_frame_rate(NULL, frame_rates[norm]);
4051
        opt_default("g", norm == PAL ? "15" : "18");
4052

    
4053
        opt_default("b", "6000000");
4054
        opt_default("maxrate", "9000000");
4055
        opt_default("minrate", "0"); //1500000;
4056
        opt_default("bufsize", "1835008"); //224*1024*8;
4057

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

    
4061
        opt_default("ab", "448000");
4062
        audio_sample_rate = 48000;
4063

    
4064
    } else if(!strncmp(arg, "dv", 2)) {
4065

    
4066
        opt_format("dv");
4067

    
4068
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4069
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4070
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4071
        opt_frame_rate(NULL, frame_rates[norm]);
4072

    
4073
        audio_sample_rate = 48000;
4074
        audio_channels = 2;
4075

    
4076
    } else {
4077
        fprintf(stderr, "Unknown target: %s\n", arg);
4078
        ffmpeg_exit(1);
4079
    }
4080
}
4081

    
4082
static void opt_vstats_file (const char *arg)
4083
{
4084
    av_free (vstats_filename);
4085
    vstats_filename=av_strdup (arg);
4086
}
4087

    
4088
static void opt_vstats (void)
4089
{
4090
    char filename[40];
4091
    time_t today2 = time(NULL);
4092
    struct tm *today = localtime(&today2);
4093

    
4094
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4095
             today->tm_sec);
4096
    opt_vstats_file(filename);
4097
}
4098

    
4099
static int opt_bsf(const char *opt, const char *arg)
4100
{
4101
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4102
    AVBitStreamFilterContext **bsfp;
4103

    
4104
    if(!bsfc){
4105
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4106
        ffmpeg_exit(1);
4107
    }
4108

    
4109
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4110
          *opt == 'a' ? &audio_bitstream_filters :
4111
                        &subtitle_bitstream_filters;
4112
    while(*bsfp)
4113
        bsfp= &(*bsfp)->next;
4114

    
4115
    *bsfp= bsfc;
4116

    
4117
    return 0;
4118
}
4119

    
4120
static int opt_preset(const char *opt, const char *arg)
4121
{
4122
    FILE *f=NULL;
4123
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4124
    int i;
4125
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
4126
                           getenv("HOME"),
4127
                           FFMPEG_DATADIR,
4128
                         };
4129

    
4130
    if (*opt != 'f') {
4131
        for(i=0; i<3 && !f; i++){
4132
            if(!base[i])
4133
                continue;
4134
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4135
            f= fopen(filename, "r");
4136
            if(!f){
4137
                char *codec_name= *opt == 'v' ? video_codec_name :
4138
                                  *opt == 'a' ? audio_codec_name :
4139
                                                subtitle_codec_name;
4140
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4141
                f= fopen(filename, "r");
4142
            }
4143
        }
4144
    } else {
4145
        av_strlcpy(filename, arg, sizeof(filename));
4146
        f= fopen(filename, "r");
4147
    }
4148

    
4149
    if(!f){
4150
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4151
        ffmpeg_exit(1);
4152
    }
4153

    
4154
    while(!feof(f)){
4155
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4156
        if(line[0] == '#' && !e)
4157
            continue;
4158
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4159
        if(e){
4160
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4161
            ffmpeg_exit(1);
4162
        }
4163
        if(!strcmp(tmp, "acodec")){
4164
            opt_audio_codec(tmp2);
4165
        }else if(!strcmp(tmp, "vcodec")){
4166
            opt_video_codec(tmp2);
4167
        }else if(!strcmp(tmp, "scodec")){
4168
            opt_subtitle_codec(tmp2);
4169
        }else if(opt_default(tmp, tmp2) < 0){
4170
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4171
            ffmpeg_exit(1);
4172
        }
4173
    }
4174

    
4175
    fclose(f);
4176

    
4177
    return 0;
4178
}
4179

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

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

    
4267
    /* audio options */
4268
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4269
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4270
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4271
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4272
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4273
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4274
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4275
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4276
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4277
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4278
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4279
    { "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" },
4280

    
4281
    /* subtitle options */
4282
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4283
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4284
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4285
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4286
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4287

    
4288
    /* grab options */
4289
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4290
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4291
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4292

    
4293
    /* muxer options */
4294
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4295
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4296

    
4297
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4298
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4299
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4300

    
4301
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4302
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4303
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4304
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4305

    
4306
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4307
    { NULL, },
4308
};
4309

    
4310
int main(int argc, char **argv)
4311
{
4312
    int i;
4313
    int64_t ti;
4314

    
4315
    avcodec_register_all();
4316
#if CONFIG_AVDEVICE
4317
    avdevice_register_all();
4318
#endif
4319
#if CONFIG_AVFILTER
4320
    avfilter_register_all();
4321
#endif
4322
    av_register_all();
4323

    
4324
#if HAVE_ISATTY
4325
    if(isatty(STDIN_FILENO))
4326
        url_set_interrupt_cb(decode_interrupt_cb);
4327
#endif
4328

    
4329
    for(i=0; i<AVMEDIA_TYPE_NB; i++){
4330
        avcodec_opts[i]= avcodec_alloc_context2(i);
4331
    }
4332
    avformat_opts = avformat_alloc_context();
4333
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4334

    
4335
    show_banner();
4336

    
4337
    /* parse options */
4338
    parse_options(argc, argv, options, opt_output_file);
4339

    
4340
    if(nb_output_files <= 0 && nb_input_files == 0) {
4341
        show_usage();
4342
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4343
        ffmpeg_exit(1);
4344
    }
4345

    
4346
    /* file converter / grab */
4347
    if (nb_output_files <= 0) {
4348
        fprintf(stderr, "At least one output file must be specified\n");
4349
        ffmpeg_exit(1);
4350
    }
4351

    
4352
    if (nb_input_files == 0) {
4353
        fprintf(stderr, "At least one input file must be specified\n");
4354
        ffmpeg_exit(1);
4355
    }
4356

    
4357
    ti = getutime();
4358
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4359
                  stream_maps, nb_stream_maps) < 0)
4360
        ffmpeg_exit(1);
4361
    ti = getutime() - ti;
4362
    if (do_benchmark) {
4363
        int maxrss = getmaxrss() / 1024;
4364
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4365
    }
4366

    
4367
    return ffmpeg_exit(0);
4368
}