Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ c4ab519e

History | View | Annotate | Download (157 KB)

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

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

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

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

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

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

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

    
80
#include "cmdutils.h"
81

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

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

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

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

    
102
static const OptionDef options[];
103

    
104
#define MAX_FILES 100
105

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

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

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

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

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

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

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

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

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

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

    
207
static int rate_emu = 0;
208

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

    
212
static int audio_volume = 256;
213

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

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

    
231
static unsigned int sws_flags = SWS_BICUBIC;
232

    
233
static int64_t timer_start;
234

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

    
239
static short *samples;
240

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

    
246
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
247

    
248
struct AVInputStream;
249

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

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

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

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

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

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

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

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

    
327
#if HAVE_TERMIOS_H
328

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

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

    
338

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

    
343
    if(!opaque) return -1;
344

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

    
347
    return 0;
348
}
349

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

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

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

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

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

    
376
    *pts          = pic->pts;
377

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

    
383
    return 1;
384
}
385

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

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

    
393
    .query_formats = output_query_formats,
394

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

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

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

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

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

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

    
429
    last_filter = ist->input_video_filter;
430

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

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

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

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

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

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

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

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

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

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

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

    
511
static volatile int received_sigterm = 0;
512

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
617
    av_free(opt_names);
618

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

    
623
    av_free(video_standard);
624

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
783
        bsfc= bsfc->next;
784
    }
785

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

    
793
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
794

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1149
    *frame_size = 0;
1150

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1404

    
1405
    oc = output_files[0];
1406

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

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

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

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

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

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

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

    
1485
        fflush(stderr);
1486
    }
1487

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1723
                        av_init_packet(&opkt);
1724

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1913

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2410

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

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

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

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

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

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

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

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

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

    
2481
    timer_start = av_gettime();
2482

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2621
    discard_packet:
2622
        av_free_packet(&pkt);
2623

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

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

    
2636
    term_exit();
2637

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

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

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

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

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

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

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

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

    
2721
    last_asked_format = arg;
2722
}
2723

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

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

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

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

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

    
2754
    opt_default(opt, arg);
2755

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

    
2759
    return 0;
2760
}
2761

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2888
    return 0;
2889
}
2890

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3156
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3157

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

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

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

    
3202
    ic->loop_input = loop_input;
3203

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

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

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

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

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

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

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

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

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

    
3306
    nb_input_files++;
3307

    
3308
    video_channel = 0;
3309

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

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

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

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

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

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

    
3369
    video_enc = st->codec;
3370

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

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

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

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

    
3405
        video_enc->codec_id = codec_id;
3406

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

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

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

    
3420
        choose_pixel_fmt(st, codec);
3421

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3745
        oc->timestamp = recording_timestamp;
3746

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

    
3754
    output_files[nb_output_files++] = oc;
3755

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

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

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

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

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

    
3805
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3806

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4038

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

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

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

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

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

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

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

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

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

    
4067
        opt_format("dv");
4068

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

    
4074
        audio_sample_rate = 48000;
4075
        audio_channels = 2;
4076

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

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

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

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

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

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

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

    
4116
    *bsfp= bsfc;
4117

    
4118
    return 0;
4119
}
4120

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

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

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

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

    
4176
    fclose(f);
4177

    
4178
    return 0;
4179
}
4180

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4336
    show_banner();
4337

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

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

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

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

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

    
4368
    return ffmpeg_exit(0);
4369
}