Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 9a191b3a

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

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

    
168
static int subtitle_disable = 0;
169
static char *subtitle_codec_name = NULL;
170
static char *subtitle_language = NULL;
171
static unsigned int subtitle_codec_tag = 0;
172

    
173
static float mux_preload= 0.5;
174
static float mux_max_delay= 0.7;
175

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

    
203
static int rate_emu = 0;
204

    
205
static int  video_channel = 0;
206
static char *video_standard;
207

    
208
static int audio_volume = 256;
209

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

    
224
static int pgmyuv_compatibility_hack=0;
225
static float dts_delta_threshold = 10;
226

    
227
static unsigned int sws_flags = SWS_BICUBIC;
228

    
229
static int64_t timer_start;
230

    
231
static uint8_t *audio_buf;
232
static uint8_t *audio_out;
233
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
234

    
235
static short *samples;
236

    
237
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
238
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
239
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
240
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
241

    
242
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
243

    
244
struct AVInputStream;
245

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

    
266
    /* full frame size of first frame */
267
    int original_height;
268
    int original_width;
269

    
270
    /* cropping area sizes */
271
    int video_crop;
272
    int topBand;
273
    int bottomBand;
274
    int leftBand;
275
    int rightBand;
276

    
277
    /* cropping area of first frame */
278
    int original_topBand;
279
    int original_bottomBand;
280
    int original_leftBand;
281
    int original_rightBand;
282

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

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

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

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

    
323
#if HAVE_TERMIOS_H
324

    
325
/* init terminal so that we can grab keys */
326
static struct termios oldtty;
327
#endif
328

    
329
#if CONFIG_AVFILTER
330
typedef struct {
331
    int pix_fmt;
332
} FilterOutPriv;
333

    
334

    
335
static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
336
{
337
    FilterOutPriv *priv = ctx->priv;
338

    
339
    if(!opaque) return -1;
340

    
341
    priv->pix_fmt = *((int *)opaque);
342

    
343
    return 0;
344
}
345

    
346
static void output_end_frame(AVFilterLink *link)
347
{
348
}
349

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

    
355
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
356
    return 0;
357
}
358

    
359
static int get_filtered_video_pic(AVFilterContext *ctx,
360
                                  AVFilterPicRef **picref, AVFrame *pic2,
361
                                  uint64_t *pts)
362
{
363
    AVFilterPicRef *pic;
364

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

    
372
    *pts          = pic->pts;
373

    
374
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
375
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
376
    pic2->interlaced_frame = pic->interlaced;
377
    pic2->top_field_first  = pic->top_field_first;
378

    
379
    return 1;
380
}
381

    
382
static AVFilter output_filter =
383
{
384
    .name      = "ffmpeg_output",
385

    
386
    .priv_size = sizeof(FilterOutPriv),
387
    .init      = output_init,
388

    
389
    .query_formats = output_query_formats,
390

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

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

    
407
    graph = av_mallocz(sizeof(AVFilterGraph));
408

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

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

    
421
    /* add input and output filters to the overall graph */
422
    avfilter_graph_add_filter(graph, ist->input_video_filter);
423
    avfilter_graph_add_filter(graph, ist->out_video_filter);
424

    
425
    last_filter = ist->input_video_filter;
426

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

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

    
460
    if (vfilters) {
461
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
462
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
463

    
464
        outputs->name    = av_strdup("in");
465
        outputs->filter  = last_filter;
466
        outputs->pad_idx = 0;
467
        outputs->next    = NULL;
468

    
469
        inputs->name    = av_strdup("out");
470
        inputs->filter  = ist->out_video_filter;
471
        inputs->pad_idx = 0;
472
        inputs->next    = NULL;
473

    
474
        if (avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL) < 0)
475
            return -1;
476
        av_freep(&vfilters);
477
    } else {
478
        if (avfilter_link(last_filter, 0, ist->out_video_filter, 0) < 0)
479
            return -1;
480
    }
481

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

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

    
493
    codec->width = ist->out_video_filter->inputs[0]->w;
494
    codec->height = ist->out_video_filter->inputs[0]->h;
495

    
496
    return 0;
497
}
498
#endif /* CONFIG_AVFILTER */
499

    
500
static void term_exit(void)
501
{
502
#if HAVE_TERMIOS_H
503
    tcsetattr (0, TCSANOW, &oldtty);
504
#endif
505
}
506

    
507
static volatile int received_sigterm = 0;
508

    
509
static void
510
sigterm_handler(int sig)
511
{
512
    received_sigterm = sig;
513
    term_exit();
514
}
515

    
516
static void term_init(void)
517
{
518
#if HAVE_TERMIOS_H
519
    struct termios tty;
520

    
521
    tcgetattr (0, &tty);
522
    oldtty = tty;
523
    atexit(term_exit);
524

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

    
534
    tcsetattr (0, TCSANOW, &tty);
535
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
536
#endif
537

    
538
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
539
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
540
#ifdef SIGXCPU
541
    signal(SIGXCPU, sigterm_handler);
542
#endif
543
}
544

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

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

    
564
        return n;
565
    }
566
#elif HAVE_CONIO_H
567
    if(kbhit())
568
        return(getch());
569
#endif
570
    return -1;
571
}
572

    
573
static int decode_interrupt_cb(void)
574
{
575
    return q_pressed || (q_pressed = read_key() == 'q');
576
}
577

    
578
static int av_exit(int ret)
579
{
580
    int i;
581

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

    
606
    av_free(intra_matrix);
607
    av_free(inter_matrix);
608

    
609
    if (vstats_file)
610
        fclose(vstats_file);
611
    av_free(vstats_filename);
612

    
613
    av_free(opt_names);
614

    
615
    av_free(video_codec_name);
616
    av_free(audio_codec_name);
617
    av_free(subtitle_codec_name);
618

    
619
    av_free(video_standard);
620

    
621
#if CONFIG_POWERPC_PERF
622
    void powerpc_display_perf_report(void);
623
    powerpc_display_perf_report();
624
#endif /* CONFIG_POWERPC_PERF */
625

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
784
        bsfc= bsfc->next;
785
    }
786

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

    
794
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
795

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1150
    *frame_size = 0;
1151

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1408

    
1409
    oc = output_files[0];
1410

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

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

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

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

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

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

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

    
1489
        fflush(stderr);
1490
    }
1491

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

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

    
1522
    AVPacket avpkt;
1523
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1524

    
1525
    if(ist->next_pts == AV_NOPTS_VALUE)
1526
        ist->next_pts= ist->pts;
1527

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

    
1538
    if(pkt->dts != AV_NOPTS_VALUE)
1539
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1540

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

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

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

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

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

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

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

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

    
1694
                ost = ost_table[i];
1695
                if (ost->source_index == ist_index) {
1696
                    os = output_files[ost->file_index];
1697

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

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

    
1727
                        av_init_packet(&opkt);
1728

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

    
1732
                        /* no reencoding needed : output the packet directly */
1733
                        /* force the input stream PTS */
1734

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

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

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

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

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

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

    
1773
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1774
                        ost->st->codec->frame_number++;
1775
                        ost->frame_number++;
1776
                        av_free_packet(&opkt);
1777
                    }
1778
                }
1779
#if CONFIG_AVFILTER
1780
                frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1781
                        ist->out_video_filter && avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1782
#endif
1783
            }
1784

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

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

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

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

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

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

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

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

    
1891
    return 0;
1892
 fail_decode:
1893
    return -1;
1894
}
1895

    
1896
static void print_sdp(AVFormatContext **avc, int n)
1897
{
1898
    char sdp[2048];
1899

    
1900
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1901
    printf("SDP:\n%s\n", sdp);
1902
    fflush(stdout);
1903
}
1904

    
1905
static int copy_chapters(int infile, int outfile)
1906
{
1907
    AVFormatContext *is = input_files[infile];
1908
    AVFormatContext *os = output_files[outfile];
1909
    int i;
1910

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

    
1919

    
1920
        if (in_ch->end < ts_off)
1921
            continue;
1922
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1923
            break;
1924

    
1925
        out_ch = av_mallocz(sizeof(AVChapter));
1926
        if (!out_ch)
1927
            return AVERROR(ENOMEM);
1928

    
1929
        out_ch->id        = in_ch->id;
1930
        out_ch->time_base = in_ch->time_base;
1931
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1932
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1933

    
1934
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1935
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1936

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

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

    
1967
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1968
    if (!file_table)
1969
        goto fail;
1970

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

    
1981
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1982
    if (!ist_table)
1983
        goto fail;
1984

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

    
2002
            if (rate_emu) {
2003
                ist->start = av_gettime();
2004
            }
2005
        }
2006
    }
2007

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2410

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

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

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

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

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

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

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

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

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

    
2481
    timer_start = av_gettime();
2482

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2621
    discard_packet:
2622
        av_free_packet(&pkt);
2623

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

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

    
2636
    term_exit();
2637

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

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

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

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

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

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

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

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

    
2721
    last_asked_format = arg;
2722
}
2723

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

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

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

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

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

    
2754
    opt_default(opt, arg);
2755

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

    
2759
    return 0;
2760
}
2761

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

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

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

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

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

    
2830
static void opt_pad(const char *arg) {
2831
    fprintf(stderr, "Please use vf=pad\n");
2832
    av_exit(1);
2833
}
2834

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

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

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

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

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

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

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

    
2888
    return 0;
2889
}
2890

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3050
    if(stream >= MAX_STREAMS)
3051
        av_exit(1);
3052

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3156
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3157

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

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

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

    
3202
    ic->loop_input = loop_input;
3203

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

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

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

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

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

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

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

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

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

    
3305
    nb_input_files++;
3306

    
3307
    video_channel = 0;
3308

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

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

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

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

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

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

    
3368
    video_enc = st->codec;
3369

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

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

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

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

    
3404
        video_enc->codec_id = codec_id;
3405

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

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

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

    
3419
        choose_pixel_fmt(st, codec);
3420

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3637
static void opt_output_file(const char *filename)
3638
{
3639
    AVFormatContext *oc;
3640
    int err, use_video, use_audio, use_subtitle;
3641
    int input_has_video, input_has_audio, input_has_subtitle;
3642
    AVFormatParameters params, *ap = &params;
3643
    AVOutputFormat *file_oformat;
3644

    
3645
    if (!strcmp(filename, "-"))
3646
        filename = "pipe:";
3647

    
3648
    oc = avformat_alloc_context();
3649
    if (!oc) {
3650
        print_error(filename, AVERROR(ENOMEM));
3651
        av_exit(1);
3652
    }
3653

    
3654
    if (last_asked_format) {
3655
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3656
        if (!file_oformat) {
3657
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3658
            av_exit(1);
3659
        }
3660
        last_asked_format = NULL;
3661
    } else {
3662
        file_oformat = av_guess_format(NULL, filename, NULL);
3663
        if (!file_oformat) {
3664
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3665
                    filename);
3666
            av_exit(1);
3667
        }
3668
    }
3669

    
3670
    oc->oformat = file_oformat;
3671
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3672

    
3673
    if (!strcmp(file_oformat->name, "ffm") &&
3674
        av_strstart(filename, "http:", NULL)) {
3675
        /* special case for files sent to ffserver: we get the stream
3676
           parameters from ffserver */
3677
        int err = read_ffserver_streams(oc, filename);
3678
        if (err < 0) {
3679
            print_error(filename, err);
3680
            av_exit(1);
3681
        }
3682
    } else {
3683
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3684
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3685
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3686

    
3687
        /* disable if no corresponding type found and at least one
3688
           input file */
3689
        if (nb_input_files > 0) {
3690
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3691
                                         &input_has_subtitle);
3692
            if (!input_has_video)
3693
                use_video = 0;
3694
            if (!input_has_audio)
3695
                use_audio = 0;
3696
            if (!input_has_subtitle)
3697
                use_subtitle = 0;
3698
        }
3699

    
3700
        /* manual disable */
3701
        if (audio_disable) {
3702
            use_audio = 0;
3703
        }
3704
        if (video_disable) {
3705
            use_video = 0;
3706
        }
3707
        if (subtitle_disable) {
3708
            use_subtitle = 0;
3709
        }
3710

    
3711
        if (use_video) {
3712
            new_video_stream(oc);
3713
        }
3714

    
3715
        if (use_audio) {
3716
            new_audio_stream(oc);
3717
        }
3718

    
3719
        if (use_subtitle) {
3720
            new_subtitle_stream(oc);
3721
        }
3722

    
3723
        oc->timestamp = rec_timestamp;
3724

    
3725
        for(; metadata_count>0; metadata_count--){
3726
            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3727
                                            metadata[metadata_count-1].value, 0);
3728
        }
3729
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3730
    }
3731

    
3732
    output_files[nb_output_files++] = oc;
3733

    
3734
    /* check filename in case of an image number is expected */
3735
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3736
        if (!av_filename_number_test(oc->filename)) {
3737
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3738
            av_exit(1);
3739
        }
3740
    }
3741

    
3742
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3743
        /* test if it already exists to avoid loosing precious files */
3744
        if (!file_overwrite &&
3745
            (strchr(filename, ':') == NULL ||
3746
             filename[1] == ':' ||
3747
             av_strstart(filename, "file:", NULL))) {
3748
            if (url_exist(filename)) {
3749
                if (!using_stdin) {
3750
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3751
                    fflush(stderr);
3752
                    if (!read_yesno()) {
3753
                        fprintf(stderr, "Not overwriting - exiting\n");
3754
                        av_exit(1);
3755
                    }
3756
                }
3757
                else {
3758
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3759
                    av_exit(1);
3760
                }
3761
            }
3762
        }
3763

    
3764
        /* open the file */
3765
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3766
            print_error(filename, err);
3767
            av_exit(1);
3768
        }
3769
    }
3770

    
3771
    memset(ap, 0, sizeof(*ap));
3772
    if (av_set_parameters(oc, ap) < 0) {
3773
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3774
                oc->filename);
3775
        av_exit(1);
3776
    }
3777

    
3778
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3779
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3780
    oc->loop_output = loop_output;
3781
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3782

    
3783
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3784
}
3785

    
3786
/* same option as mencoder */
3787
static void opt_pass(const char *pass_str)
3788
{
3789
    int pass;
3790
    pass = atoi(pass_str);
3791
    if (pass != 1 && pass != 2) {
3792
        fprintf(stderr, "pass number can be only 1 or 2\n");
3793
        av_exit(1);
3794
    }
3795
    do_pass = pass;
3796
}
3797

    
3798
static int64_t getutime(void)
3799
{
3800
#if HAVE_GETRUSAGE
3801
    struct rusage rusage;
3802

    
3803
    getrusage(RUSAGE_SELF, &rusage);
3804
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3805
#elif HAVE_GETPROCESSTIMES
3806
    HANDLE proc;
3807
    FILETIME c, e, k, u;
3808
    proc = GetCurrentProcess();
3809
    GetProcessTimes(proc, &c, &e, &k, &u);
3810
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3811
#else
3812
    return av_gettime();
3813
#endif
3814
}
3815

    
3816
static int64_t getmaxrss(void)
3817
{
3818
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3819
    struct rusage rusage;
3820
    getrusage(RUSAGE_SELF, &rusage);
3821
    return (int64_t)rusage.ru_maxrss * 1024;
3822
#elif HAVE_GETPROCESSMEMORYINFO
3823
    HANDLE proc;
3824
    PROCESS_MEMORY_COUNTERS memcounters;
3825
    proc = GetCurrentProcess();
3826
    memcounters.cb = sizeof(memcounters);
3827
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3828
    return memcounters.PeakPagefileUsage;
3829
#else
3830
    return 0;
3831
#endif
3832
}
3833

    
3834
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3835
{
3836
    int i;
3837
    const char *p = str;
3838
    for(i = 0;; i++) {
3839
        dest[i] = atoi(p);
3840
        if(i == 63)
3841
            break;
3842
        p = strchr(p, ',');
3843
        if(!p) {
3844
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3845
            av_exit(1);
3846
        }
3847
        p++;
3848
    }
3849
}
3850

    
3851
static void opt_inter_matrix(const char *arg)
3852
{
3853
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3854
    parse_matrix_coeffs(inter_matrix, arg);
3855
}
3856

    
3857
static void opt_intra_matrix(const char *arg)
3858
{
3859
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3860
    parse_matrix_coeffs(intra_matrix, arg);
3861
}
3862

    
3863
/**
3864
 * Trivial log callback.
3865
 * Only suitable for show_help and similar since it lacks prefix handling.
3866
 */
3867
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3868
{
3869
    vfprintf(stdout, fmt, vl);
3870
}
3871

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

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

    
3914
static void opt_target(const char *arg)
3915
{
3916
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3917
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3918

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

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

    
3970
    if(!strcmp(arg, "vcd")) {
3971

    
3972
        opt_video_codec("mpeg1video");
3973
        opt_audio_codec("mp2");
3974
        opt_format("vcd");
3975

    
3976
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3977
        opt_frame_rate(NULL, frame_rates[norm]);
3978
        opt_default("g", norm == PAL ? "15" : "18");
3979

    
3980
        opt_default("b", "1150000");
3981
        opt_default("maxrate", "1150000");
3982
        opt_default("minrate", "1150000");
3983
        opt_default("bufsize", "327680"); // 40*1024*8;
3984

    
3985
        opt_default("ab", "224000");
3986
        audio_sample_rate = 44100;
3987
        audio_channels = 2;
3988

    
3989
        opt_default("packetsize", "2324");
3990
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3991

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

    
4000
        opt_video_codec("mpeg2video");
4001
        opt_audio_codec("mp2");
4002
        opt_format("svcd");
4003

    
4004
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4005
        opt_frame_rate(NULL, frame_rates[norm]);
4006
        opt_default("g", norm == PAL ? "15" : "18");
4007

    
4008
        opt_default("b", "2040000");
4009
        opt_default("maxrate", "2516000");
4010
        opt_default("minrate", "0"); //1145000;
4011
        opt_default("bufsize", "1835008"); //224*1024*8;
4012
        opt_default("flags", "+scan_offset");
4013

    
4014

    
4015
        opt_default("ab", "224000");
4016
        audio_sample_rate = 44100;
4017

    
4018
        opt_default("packetsize", "2324");
4019

    
4020
    } else if(!strcmp(arg, "dvd")) {
4021

    
4022
        opt_video_codec("mpeg2video");
4023
        opt_audio_codec("ac3");
4024
        opt_format("dvd");
4025

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

    
4030
        opt_default("b", "6000000");
4031
        opt_default("maxrate", "9000000");
4032
        opt_default("minrate", "0"); //1500000;
4033
        opt_default("bufsize", "1835008"); //224*1024*8;
4034

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

    
4038
        opt_default("ab", "448000");
4039
        audio_sample_rate = 48000;
4040

    
4041
    } else if(!strncmp(arg, "dv", 2)) {
4042

    
4043
        opt_format("dv");
4044

    
4045
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4046
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4047
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4048
        opt_frame_rate(NULL, frame_rates[norm]);
4049

    
4050
        audio_sample_rate = 48000;
4051
        audio_channels = 2;
4052

    
4053
    } else {
4054
        fprintf(stderr, "Unknown target: %s\n", arg);
4055
        av_exit(1);
4056
    }
4057
}
4058

    
4059
static void opt_vstats_file (const char *arg)
4060
{
4061
    av_free (vstats_filename);
4062
    vstats_filename=av_strdup (arg);
4063
}
4064

    
4065
static void opt_vstats (void)
4066
{
4067
    char filename[40];
4068
    time_t today2 = time(NULL);
4069
    struct tm *today = localtime(&today2);
4070

    
4071
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4072
             today->tm_sec);
4073
    opt_vstats_file(filename);
4074
}
4075

    
4076
static int opt_bsf(const char *opt, const char *arg)
4077
{
4078
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4079
    AVBitStreamFilterContext **bsfp;
4080

    
4081
    if(!bsfc){
4082
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4083
        av_exit(1);
4084
    }
4085

    
4086
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4087
          *opt == 'a' ? &audio_bitstream_filters :
4088
                        &subtitle_bitstream_filters;
4089
    while(*bsfp)
4090
        bsfp= &(*bsfp)->next;
4091

    
4092
    *bsfp= bsfc;
4093

    
4094
    return 0;
4095
}
4096

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

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

    
4126
    if(!f){
4127
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4128
        av_exit(1);
4129
    }
4130

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

    
4152
    fclose(f);
4153

    
4154
    return 0;
4155
}
4156

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

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

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

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

    
4264
    /* grab options */
4265
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4266
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4267
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4268

    
4269
    /* muxer options */
4270
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4271
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4272

    
4273
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4274
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4275
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4276

    
4277
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4278
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4279
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4280
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4281

    
4282
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4283
    { NULL, },
4284
};
4285

    
4286
int main(int argc, char **argv)
4287
{
4288
    int i;
4289
    int64_t ti;
4290

    
4291
    avcodec_register_all();
4292
#if CONFIG_AVDEVICE
4293
    avdevice_register_all();
4294
#endif
4295
#if CONFIG_AVFILTER
4296
    avfilter_register_all();
4297
#endif
4298
    av_register_all();
4299

    
4300
#if HAVE_ISATTY
4301
    if(isatty(STDIN_FILENO))
4302
        url_set_interrupt_cb(decode_interrupt_cb);
4303
#endif
4304

    
4305
    for(i=0; i<AVMEDIA_TYPE_NB; i++){
4306
        avcodec_opts[i]= avcodec_alloc_context2(i);
4307
    }
4308
    avformat_opts = avformat_alloc_context();
4309
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4310

    
4311
    show_banner();
4312

    
4313
    /* parse options */
4314
    parse_options(argc, argv, options, opt_output_file);
4315

    
4316
    if(nb_output_files <= 0 && nb_input_files == 0) {
4317
        show_usage();
4318
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4319
        av_exit(1);
4320
    }
4321

    
4322
    /* file converter / grab */
4323
    if (nb_output_files <= 0) {
4324
        fprintf(stderr, "At least one output file must be specified\n");
4325
        av_exit(1);
4326
    }
4327

    
4328
    if (nb_input_files == 0) {
4329
        fprintf(stderr, "At least one input file must be specified\n");
4330
        av_exit(1);
4331
    }
4332

    
4333
    ti = getutime();
4334
    if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4335
                     stream_maps, nb_stream_maps) < 0)
4336
        av_exit(1);
4337
    ti = getutime() - ti;
4338
    if (do_benchmark) {
4339
        int maxrss = getmaxrss() / 1024;
4340
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4341
    }
4342

    
4343
    return av_exit(0);
4344
}