Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 74dc99f2

History | View | Annotate | Download (156 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/pixdesc.h"
42
#include "libavutil/avstring.h"
43
#include "libavutil/libm.h"
44
#include "libavformat/os_support.h"
45

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

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

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

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

    
79
#include "cmdutils.h"
80

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

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

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

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

    
101
static const OptionDef options[];
102

    
103
#define MAX_FILES 100
104

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

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

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

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

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

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

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

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

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

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

    
206
static int rate_emu = 0;
207

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

    
211
static int audio_volume = 256;
212

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

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

    
230
static unsigned int sws_flags = SWS_BICUBIC;
231

    
232
static int64_t timer_start;
233

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

    
238
static short *samples;
239

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

    
245
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
246

    
247
struct AVInputStream;
248

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

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

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

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

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

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

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

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

    
326
#if HAVE_TERMIOS_H
327

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

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

    
337

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

    
342
    if(!opaque) return -1;
343

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

    
346
    return 0;
347
}
348

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

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

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

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

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

    
375
    *pts          = pic->pts;
376

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

    
382
    return 1;
383
}
384

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

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

    
392
    .query_formats = output_query_formats,
393

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

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

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

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

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

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

    
428
    last_filter = ist->input_video_filter;
429

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

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

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

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

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

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

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

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

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

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

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

    
510
static volatile int received_sigterm = 0;
511

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

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

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

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

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

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

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

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

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

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

    
581
static int av_exit(int ret)
582
{
583
    int i;
584

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

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

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

    
616
    av_free(opt_names);
617

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

    
622
    av_free(video_standard);
623

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
782
        bsfc= bsfc->next;
783
    }
784

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

    
792
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
793

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1148
    *frame_size = 0;
1149

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1406

    
1407
    oc = output_files[0];
1408

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

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

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

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

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

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

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

    
1487
        fflush(stderr);
1488
    }
1489

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1724
                        av_init_packet(&opkt);
1725

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

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

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

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

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

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

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

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

    
1770
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1771
                        ost->st->codec->frame_number++;
1772
                        ost->frame_number++;
1773
                        av_free_packet(&opkt);
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
#endif
1780
            }
1781

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1916

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2026
        if (fi < 0 || fi > nb_input_files - 1 ||
2027
            si < 0 || si > file_table[fi].nb_streams - 1) {
2028
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2029
            av_exit(1);
2030
        }
2031
        fi = stream_maps[i].sync_file_index;
2032
        si = stream_maps[i].sync_stream_index;
2033
        if (fi < 0 || fi > nb_input_files - 1 ||
2034
            si < 0 || si > file_table[fi].nb_streams - 1) {
2035
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2036
            av_exit(1);
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
                    av_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
                        av_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
                    av_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
                    av_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
                        av_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
                        av_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
                        av_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
                        av_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
                av_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_frame_rate(&frame_rate, arg) < 0) {
2743
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2744
        av_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
        av_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
        av_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
        av_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
        av_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
        av_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
        av_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
        av_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
        av_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_frame_size(&frame_width, &frame_height, arg) < 0) {
2824
        fprintf(stderr, "Incorrect frame size\n");
2825
        av_exit(1);
2826
    }
2827
}
2828

    
2829
static void opt_pad(const char *arg) {
2830
    fprintf(stderr, "Please use vf=pad\n");
2831
    av_exit(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
            av_exit(1);
2841
        }
2842
    } else {
2843
        show_pix_fmts();
2844
        av_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
        av_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
        av_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
        av_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
        av_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
        av_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
        av_exit(1);
3092
    }
3093
    if(codec->type != type) {
3094
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3095
        av_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
        av_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
            av_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
        av_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
        av_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
            av_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_exit(1);
3209
    }
3210

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

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

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

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

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

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

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

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

    
3304
    nb_input_files++;
3305

    
3306
    video_channel = 0;
3307

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

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

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

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

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

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

    
3367
    video_enc = st->codec;
3368

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

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

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

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

    
3403
        video_enc->codec_id = codec_id;
3404

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

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

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

    
3418
        choose_pixel_fmt(st, codec);
3419

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3743
        oc->timestamp = recording_timestamp;
3744

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

    
3752
    output_files[nb_output_files++] = oc;
3753

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

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

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

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

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

    
3803
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3804

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4036

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

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

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

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

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

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

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

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

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

    
4065
        opt_format("dv");
4066

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

    
4072
        audio_sample_rate = 48000;
4073
        audio_channels = 2;
4074

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

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

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

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

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

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

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

    
4114
    *bsfp= bsfc;
4115

    
4116
    return 0;
4117
}
4118

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

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

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

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

    
4174
    fclose(f);
4175

    
4176
    return 0;
4177
}
4178

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4334
    show_banner();
4335

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

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

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

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

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

    
4366
    return av_exit(0);
4367
}