Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a1629e28

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*= osize*enc->channels;
817

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1149
    *frame_size = 0;
1150

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

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

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

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

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

    
1204
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1205
        if(!ost->video_resample)
1206
            av_exit(1);
1207
    }
1208

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1407

    
1408
    oc = output_files[0];
1409

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

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

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

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

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

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

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

    
1488
        fflush(stderr);
1489
    }
1490

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1726
                        av_init_packet(&opkt);
1727

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1918

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2409

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

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

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

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

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

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

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

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

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

    
2480
    timer_start = av_gettime();
2481

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2620
    discard_packet:
2621
        av_free_packet(&pkt);
2622

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

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

    
2635
    term_exit();
2636

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

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

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

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

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

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

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

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

    
2720
    last_asked_format = arg;
2721
}
2722

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

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

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

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

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

    
2753
    opt_default(opt, arg);
2754

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

    
2758
    return 0;
2759
}
2760

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

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

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

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

    
2817
static void opt_frame_size(const char *arg)
2818
{
2819
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2820
        fprintf(stderr, "Incorrect frame size\n");
2821
        av_exit(1);
2822
    }
2823
}
2824

    
2825
static void opt_pad(const char *arg) {
2826
    fprintf(stderr, "Please use vf=pad\n");
2827
    av_exit(1);
2828
}
2829

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

    
2844
static void opt_frame_aspect_ratio(const char *arg)
2845
{
2846
    int x = 0, y = 0;
2847
    double ar = 0;
2848
    const char *p;
2849
    char *end;
2850

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

    
2861
    if (!ar) {
2862
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2863
        av_exit(1);
2864
    }
2865
    frame_aspect_ratio = ar;
2866
}
2867

    
2868
static int opt_metadata(const char *opt, const char *arg)
2869
{
2870
    char *mid= strchr(arg, '=');
2871

    
2872
    if(!mid){
2873
        fprintf(stderr, "Missing =\n");
2874
        av_exit(1);
2875
    }
2876
    *mid++= 0;
2877

    
2878
    metadata_count++;
2879
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2880
    metadata[metadata_count-1].key  = av_strdup(arg);
2881
    metadata[metadata_count-1].value= av_strdup(mid);
2882

    
2883
    return 0;
2884
}
2885

    
2886
static void opt_qscale(const char *arg)
2887
{
2888
    video_qscale = atof(arg);
2889
    if (video_qscale <= 0 ||
2890
        video_qscale > 255) {
2891
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2892
        av_exit(1);
2893
    }
2894
}
2895

    
2896
static void opt_top_field_first(const char *arg)
2897
{
2898
    top_field_first= atoi(arg);
2899
}
2900

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

    
2911
static void opt_audio_sample_fmt(const char *arg)
2912
{
2913
    if (strcmp(arg, "list"))
2914
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2915
    else {
2916
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2917
        av_exit(0);
2918
    }
2919
}
2920

    
2921
static int opt_audio_rate(const char *opt, const char *arg)
2922
{
2923
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2924
    return 0;
2925
}
2926

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

    
2933
static void opt_video_channel(const char *arg)
2934
{
2935
    video_channel = strtol(arg, NULL, 0);
2936
}
2937

    
2938
static void opt_video_standard(const char *arg)
2939
{
2940
    video_standard = av_strdup(arg);
2941
}
2942

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

    
2954
static void opt_audio_codec(const char *arg)
2955
{
2956
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2957
}
2958

    
2959
static void opt_audio_tag(const char *arg)
2960
{
2961
    char *tail;
2962
    audio_codec_tag= strtol(arg, &tail, 0);
2963

    
2964
    if(!tail || *tail)
2965
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2966
}
2967

    
2968
static void opt_video_tag(const char *arg)
2969
{
2970
    char *tail;
2971
    video_codec_tag= strtol(arg, &tail, 0);
2972

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

    
2977
static void opt_video_codec(const char *arg)
2978
{
2979
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2980
}
2981

    
2982
static void opt_subtitle_codec(const char *arg)
2983
{
2984
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2985
}
2986

    
2987
static void opt_subtitle_tag(const char *arg)
2988
{
2989
    char *tail;
2990
    subtitle_codec_tag= strtol(arg, &tail, 0);
2991

    
2992
    if(!tail || *tail)
2993
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2994
}
2995

    
2996
static void opt_map(const char *arg)
2997
{
2998
    AVStreamMap *m;
2999
    char *p;
3000

    
3001
    m = &stream_maps[nb_stream_maps++];
3002

    
3003
    m->file_index = strtol(arg, &p, 0);
3004
    if (*p)
3005
        p++;
3006

    
3007
    m->stream_index = strtol(p, &p, 0);
3008
    if (*p) {
3009
        p++;
3010
        m->sync_file_index = strtol(p, &p, 0);
3011
        if (*p)
3012
            p++;
3013
        m->sync_stream_index = strtol(p, &p, 0);
3014
    } else {
3015
        m->sync_file_index = m->file_index;
3016
        m->sync_stream_index = m->stream_index;
3017
    }
3018
}
3019

    
3020
static void opt_map_meta_data(const char *arg)
3021
{
3022
    AVMetaDataMap *m;
3023
    char *p;
3024

    
3025
    m = &meta_data_maps[nb_meta_data_maps++];
3026

    
3027
    m->out_file = strtol(arg, &p, 0);
3028
    if (*p)
3029
        p++;
3030

    
3031
    m->in_file = strtol(p, &p, 0);
3032
}
3033

    
3034
static void opt_input_ts_scale(const char *arg)
3035
{
3036
    unsigned int stream;
3037
    double scale;
3038
    char *p;
3039

    
3040
    stream = strtol(arg, &p, 0);
3041
    if (*p)
3042
        p++;
3043
    scale= strtod(p, &p);
3044

    
3045
    if(stream >= MAX_STREAMS)
3046
        av_exit(1);
3047

    
3048
    input_files_ts_scale[nb_input_files][stream]= scale;
3049
}
3050

    
3051
static int opt_recording_time(const char *opt, const char *arg)
3052
{
3053
    recording_time = parse_time_or_die(opt, arg, 1);
3054
    return 0;
3055
}
3056

    
3057
static int opt_start_time(const char *opt, const char *arg)
3058
{
3059
    start_time = parse_time_or_die(opt, arg, 1);
3060
    return 0;
3061
}
3062

    
3063
static int opt_rec_timestamp(const char *opt, const char *arg)
3064
{
3065
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3066
    return 0;
3067
}
3068

    
3069
static int opt_input_ts_offset(const char *opt, const char *arg)
3070
{
3071
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3072
    return 0;
3073
}
3074

    
3075
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3076
{
3077
    const char *codec_string = encoder ? "encoder" : "decoder";
3078
    AVCodec *codec;
3079

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

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

    
3117
    if (last_asked_format) {
3118
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3119
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3120
            av_exit(1);
3121
        }
3122
        last_asked_format = NULL;
3123
    }
3124

    
3125
    if (!strcmp(filename, "-"))
3126
        filename = "pipe:";
3127

    
3128
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3129
                    !strcmp(filename, "/dev/stdin");
3130

    
3131
    /* get default parameters from command line */
3132
    ic = avformat_alloc_context();
3133
    if (!ic) {
3134
        print_error(filename, AVERROR(ENOMEM));
3135
        av_exit(1);
3136
    }
3137

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

    
3151
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3152

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

    
3164
    if(pgmyuv_compatibility_hack)
3165
        ic->video_codec_id= CODEC_ID_PGMYUV;
3166

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

    
3197
    ic->loop_input = loop_input;
3198

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

    
3207
    timestamp = start_time;
3208
    /* add the stream start time */
3209
    if (ic->start_time != AV_NOPTS_VALUE)
3210
        timestamp += ic->start_time;
3211

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

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

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

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

    
3266
                    (float)rfps / rfps_base, rfps, rfps_base);
3267
            }
3268
            /* update the current frame rate to match the stream frame rate */
3269
            frame_rate.num = rfps;
3270
            frame_rate.den = rfps_base;
3271

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

    
3294
    input_files[nb_input_files] = ic;
3295
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3296
    /* dump the file content */
3297
    if (verbose >= 0)
3298
        dump_format(ic, nb_input_files, filename, 0);
3299

    
3300
    nb_input_files++;
3301

    
3302
    video_channel = 0;
3303

    
3304
    av_freep(&video_codec_name);
3305
    av_freep(&audio_codec_name);
3306
    av_freep(&subtitle_codec_name);
3307
}
3308

    
3309
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3310
                                         int *has_subtitle_ptr)
3311
{
3312
    int has_video, has_audio, has_subtitle, i, j;
3313
    AVFormatContext *ic;
3314

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

    
3346
static void new_video_stream(AVFormatContext *oc)
3347
{
3348
    AVStream *st;
3349
    AVCodecContext *video_enc;
3350
    enum CodecID codec_id;
3351

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

    
3361
    avcodec_thread_init(st->codec, thread_count);
3362

    
3363
    video_enc = st->codec;
3364

    
3365
    if(video_codec_tag)
3366
        video_enc->codec_tag= video_codec_tag;
3367

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

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

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

    
3399
        video_enc->codec_id = codec_id;
3400

    
3401
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3402

    
3403
        if (codec && codec->supported_framerates && !force_fps)
3404
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3405
        video_enc->time_base.den = fps.num;
3406
        video_enc->time_base.num = fps.den;
3407

    
3408
        video_enc->width = frame_width;
3409
        video_enc->height = frame_height;
3410
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3411
        video_enc->pix_fmt = frame_pix_fmt;
3412
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3413

    
3414
        choose_pixel_fmt(st, codec);
3415

    
3416
        if (intra_only)
3417
            video_enc->gop_size = 0;
3418
        if (video_qscale || same_quality) {
3419
            video_enc->flags |= CODEC_FLAG_QSCALE;
3420
            video_enc->global_quality=
3421
                st->quality = FF_QP2LAMBDA * video_qscale;
3422
        }
3423

    
3424
        if(intra_matrix)
3425
            video_enc->intra_matrix = intra_matrix;
3426
        if(inter_matrix)
3427
            video_enc->inter_matrix = inter_matrix;
3428

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

    
3459
        if (do_psnr)
3460
            video_enc->flags|= CODEC_FLAG_PSNR;
3461

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

    
3477
    /* reset some key parameters */
3478
    video_disable = 0;
3479
    av_freep(&video_codec_name);
3480
    video_stream_copy = 0;
3481
    frame_pix_fmt = PIX_FMT_NONE;
3482
}
3483

    
3484
static void new_audio_stream(AVFormatContext *oc)
3485
{
3486
    AVStream *st;
3487
    AVCodecContext *audio_enc;
3488
    enum CodecID codec_id;
3489

    
3490
    st = av_new_stream(oc, oc->nb_streams);
3491
    if (!st) {
3492
        fprintf(stderr, "Could not alloc stream\n");
3493
        av_exit(1);
3494
    }
3495
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3496

    
3497
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3498
    audio_bitstream_filters= NULL;
3499

    
3500
    avcodec_thread_init(st->codec, thread_count);
3501

    
3502
    audio_enc = st->codec;
3503
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3504

    
3505
    if(audio_codec_tag)
3506
        audio_enc->codec_tag= audio_codec_tag;
3507

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

    
3519
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3520

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

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

    
3552
    /* reset some key parameters */
3553
    audio_disable = 0;
3554
    av_freep(&audio_codec_name);
3555
    audio_stream_copy = 0;
3556
}
3557

    
3558
static void new_subtitle_stream(AVFormatContext *oc)
3559
{
3560
    AVStream *st;
3561
    AVCodecContext *subtitle_enc;
3562

    
3563
    st = av_new_stream(oc, oc->nb_streams);
3564
    if (!st) {
3565
        fprintf(stderr, "Could not alloc stream\n");
3566
        av_exit(1);
3567
    }
3568
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3569

    
3570
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3571
    subtitle_bitstream_filters= NULL;
3572

    
3573
    subtitle_enc = st->codec;
3574
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3575

    
3576
    if(subtitle_codec_tag)
3577
        subtitle_enc->codec_tag= subtitle_codec_tag;
3578

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

    
3589
    if (subtitle_language) {
3590
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3591
        av_freep(&subtitle_language);
3592
    }
3593

    
3594
    subtitle_disable = 0;
3595
    av_freep(&subtitle_codec_name);
3596
    subtitle_stream_copy = 0;
3597
}
3598

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

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

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

    
3632
static void opt_output_file(const char *filename)
3633
{
3634
    AVFormatContext *oc;
3635
    int err, use_video, use_audio, use_subtitle;
3636
    int input_has_video, input_has_audio, input_has_subtitle;
3637
    AVFormatParameters params, *ap = &params;
3638
    AVOutputFormat *file_oformat;
3639

    
3640
    if (!strcmp(filename, "-"))
3641
        filename = "pipe:";
3642

    
3643
    oc = avformat_alloc_context();
3644
    if (!oc) {
3645
        print_error(filename, AVERROR(ENOMEM));
3646
        av_exit(1);
3647
    }
3648

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

    
3665
    oc->oformat = file_oformat;
3666
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3667

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

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

    
3695
        /* manual disable */
3696
        if (audio_disable) {
3697
            use_audio = 0;
3698
        }
3699
        if (video_disable) {
3700
            use_video = 0;
3701
        }
3702
        if (subtitle_disable) {
3703
            use_subtitle = 0;
3704
        }
3705

    
3706
        if (use_video) {
3707
            new_video_stream(oc);
3708
        }
3709

    
3710
        if (use_audio) {
3711
            new_audio_stream(oc);
3712
        }
3713

    
3714
        if (use_subtitle) {
3715
            new_subtitle_stream(oc);
3716
        }
3717

    
3718
        oc->timestamp = rec_timestamp;
3719

    
3720
        for(; metadata_count>0; metadata_count--){
3721
            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3722
                                            metadata[metadata_count-1].value, 0);
3723
        }
3724
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3725
    }
3726

    
3727
    output_files[nb_output_files++] = oc;
3728

    
3729
    /* check filename in case of an image number is expected */
3730
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3731
        if (!av_filename_number_test(oc->filename)) {
3732
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3733
            av_exit(1);
3734
        }
3735
    }
3736

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

    
3759
        /* open the file */
3760
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3761
            print_error(filename, err);
3762
            av_exit(1);
3763
        }
3764
    }
3765

    
3766
    memset(ap, 0, sizeof(*ap));
3767
    if (av_set_parameters(oc, ap) < 0) {
3768
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3769
                oc->filename);
3770
        av_exit(1);
3771
    }
3772

    
3773
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3774
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3775
    oc->loop_output = loop_output;
3776
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3777

    
3778
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3779
}
3780

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

    
3793
static int64_t getutime(void)
3794
{
3795
#if HAVE_GETRUSAGE
3796
    struct rusage rusage;
3797

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

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

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

    
3846
static void opt_inter_matrix(const char *arg)
3847
{
3848
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3849
    parse_matrix_coeffs(inter_matrix, arg);
3850
}
3851

    
3852
static void opt_intra_matrix(const char *arg)
3853
{
3854
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3855
    parse_matrix_coeffs(intra_matrix, arg);
3856
}
3857

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

    
3867
static void show_usage(void)
3868
{
3869
    printf("Hyper fast Audio and Video encoder\n");
3870
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3871
    printf("\n");
3872
}
3873

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

    
3909
static void opt_target(const char *arg)
3910
{
3911
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3912
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3913

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

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

    
3965
    if(!strcmp(arg, "vcd")) {
3966

    
3967
        opt_video_codec("mpeg1video");
3968
        opt_audio_codec("mp2");
3969
        opt_format("vcd");
3970

    
3971
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3972
        opt_frame_rate(NULL, frame_rates[norm]);
3973
        opt_default("g", norm == PAL ? "15" : "18");
3974

    
3975
        opt_default("b", "1150000");
3976
        opt_default("maxrate", "1150000");
3977
        opt_default("minrate", "1150000");
3978
        opt_default("bufsize", "327680"); // 40*1024*8;
3979

    
3980
        opt_default("ab", "224000");
3981
        audio_sample_rate = 44100;
3982
        audio_channels = 2;
3983

    
3984
        opt_default("packetsize", "2324");
3985
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3986

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

    
3995
        opt_video_codec("mpeg2video");
3996
        opt_audio_codec("mp2");
3997
        opt_format("svcd");
3998

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

    
4003
        opt_default("b", "2040000");
4004
        opt_default("maxrate", "2516000");
4005
        opt_default("minrate", "0"); //1145000;
4006
        opt_default("bufsize", "1835008"); //224*1024*8;
4007
        opt_default("flags", "+scan_offset");
4008

    
4009

    
4010
        opt_default("ab", "224000");
4011
        audio_sample_rate = 44100;
4012

    
4013
        opt_default("packetsize", "2324");
4014

    
4015
    } else if(!strcmp(arg, "dvd")) {
4016

    
4017
        opt_video_codec("mpeg2video");
4018
        opt_audio_codec("ac3");
4019
        opt_format("dvd");
4020

    
4021
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4022
        opt_frame_rate(NULL, frame_rates[norm]);
4023
        opt_default("g", norm == PAL ? "15" : "18");
4024

    
4025
        opt_default("b", "6000000");
4026
        opt_default("maxrate", "9000000");
4027
        opt_default("minrate", "0"); //1500000;
4028
        opt_default("bufsize", "1835008"); //224*1024*8;
4029

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

    
4033
        opt_default("ab", "448000");
4034
        audio_sample_rate = 48000;
4035

    
4036
    } else if(!strncmp(arg, "dv", 2)) {
4037

    
4038
        opt_format("dv");
4039

    
4040
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4041
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4042
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4043
        opt_frame_rate(NULL, frame_rates[norm]);
4044

    
4045
        audio_sample_rate = 48000;
4046
        audio_channels = 2;
4047

    
4048
    } else {
4049
        fprintf(stderr, "Unknown target: %s\n", arg);
4050
        av_exit(1);
4051
    }
4052
}
4053

    
4054
static void opt_vstats_file (const char *arg)
4055
{
4056
    av_free (vstats_filename);
4057
    vstats_filename=av_strdup (arg);
4058
}
4059

    
4060
static void opt_vstats (void)
4061
{
4062
    char filename[40];
4063
    time_t today2 = time(NULL);
4064
    struct tm *today = localtime(&today2);
4065

    
4066
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4067
             today->tm_sec);
4068
    opt_vstats_file(filename);
4069
}
4070

    
4071
static int opt_bsf(const char *opt, const char *arg)
4072
{
4073
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4074
    AVBitStreamFilterContext **bsfp;
4075

    
4076
    if(!bsfc){
4077
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4078
        av_exit(1);
4079
    }
4080

    
4081
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4082
          *opt == 'a' ? &audio_bitstream_filters :
4083
                        &subtitle_bitstream_filters;
4084
    while(*bsfp)
4085
        bsfp= &(*bsfp)->next;
4086

    
4087
    *bsfp= bsfc;
4088

    
4089
    return 0;
4090
}
4091

    
4092
static int opt_preset(const char *opt, const char *arg)
4093
{
4094
    FILE *f=NULL;
4095
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4096
    int i;
4097
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
4098
                           getenv("HOME"),
4099
                           FFMPEG_DATADIR,
4100
                         };
4101

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

    
4121
    if(!f){
4122
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4123
        av_exit(1);
4124
    }
4125

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

    
4147
    fclose(f);
4148

    
4149
    return 0;
4150
}
4151

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

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

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

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

    
4259
    /* grab options */
4260
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4261
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4262
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4263

    
4264
    /* muxer options */
4265
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4266
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4267

    
4268
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4269
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4270
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4271

    
4272
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4273
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4274
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4275
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4276

    
4277
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4278
    { NULL, },
4279
};
4280

    
4281
int main(int argc, char **argv)
4282
{
4283
    int i;
4284
    int64_t ti;
4285

    
4286
    avcodec_register_all();
4287
#if CONFIG_AVDEVICE
4288
    avdevice_register_all();
4289
#endif
4290
#if CONFIG_AVFILTER
4291
    avfilter_register_all();
4292
#endif
4293
    av_register_all();
4294

    
4295
#if HAVE_ISATTY
4296
    if(isatty(STDIN_FILENO))
4297
        url_set_interrupt_cb(decode_interrupt_cb);
4298
#endif
4299

    
4300
    for(i=0; i<AVMEDIA_TYPE_NB; i++){
4301
        avcodec_opts[i]= avcodec_alloc_context2(i);
4302
    }
4303
    avformat_opts = avformat_alloc_context();
4304
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4305

    
4306
    show_banner();
4307

    
4308
    /* parse options */
4309
    parse_options(argc, argv, options, opt_output_file);
4310

    
4311
    if(nb_output_files <= 0 && nb_input_files == 0) {
4312
        show_usage();
4313
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4314
        av_exit(1);
4315
    }
4316

    
4317
    /* file converter / grab */
4318
    if (nb_output_files <= 0) {
4319
        fprintf(stderr, "At least one output file must be specified\n");
4320
        av_exit(1);
4321
    }
4322

    
4323
    if (nb_input_files == 0) {
4324
        fprintf(stderr, "At least one input file must be specified\n");
4325
        av_exit(1);
4326
    }
4327

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

    
4338
    return av_exit(0);
4339
}