Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0a6d97b3

History | View | Annotate | Download (159 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
#include "libavutil/avassert.h"
83

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

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

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

    
103
static const OptionDef options[];
104

    
105
#define MAX_FILES 100
106

    
107
static const char *last_asked_format = NULL;
108
static AVFormatContext *input_files[MAX_FILES];
109
static int64_t input_files_ts_offset[MAX_FILES];
110
static double *input_files_ts_scale[MAX_FILES] = {NULL};
111
static AVCodec **input_codecs = NULL;
112
static int nb_input_files = 0;
113
static int nb_input_codecs = 0;
114
static int nb_input_files_ts_scale[MAX_FILES] = {0};
115

    
116
static AVFormatContext *output_files[MAX_FILES];
117
static AVCodec **output_codecs = NULL;
118
static int nb_output_files = 0;
119
static int nb_output_codecs = 0;
120

    
121
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
122
static int nb_stream_maps;
123

    
124
static AVMetaDataMap meta_data_maps[MAX_FILES];
125
static int nb_meta_data_maps;
126

    
127
/* indexed by output file stream index */
128
static int *streamid_map = NULL;
129
static int nb_streamid_map = 0;
130

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

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

    
175
static int subtitle_disable = 0;
176
static char *subtitle_codec_name = NULL;
177
static char *subtitle_language = NULL;
178
static unsigned int subtitle_codec_tag = 0;
179

    
180
static float mux_preload= 0.5;
181
static float mux_max_delay= 0.7;
182

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

    
210
static int rate_emu = 0;
211

    
212
static int  video_channel = 0;
213
static char *video_standard;
214

    
215
static int audio_volume = 256;
216

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

    
231
static int pgmyuv_compatibility_hack=0;
232
static float dts_delta_threshold = 10;
233

    
234
static unsigned int sws_flags = SWS_BICUBIC;
235

    
236
static int64_t timer_start;
237

    
238
static uint8_t *audio_buf;
239
static uint8_t *audio_out;
240
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
241

    
242
static short *samples;
243

    
244
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
245
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
246
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
247
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
248

    
249
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
250

    
251
struct AVInputStream;
252

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

    
273
    /* full frame size of first frame */
274
    int original_height;
275
    int original_width;
276

    
277
    /* cropping area sizes */
278
    int video_crop;
279
    int topBand;
280
    int bottomBand;
281
    int leftBand;
282
    int rightBand;
283

    
284
    /* cropping area of first frame */
285
    int original_topBand;
286
    int original_bottomBand;
287
    int original_leftBand;
288
    int original_rightBand;
289

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

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

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

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

    
330
#if HAVE_TERMIOS_H
331

    
332
/* init terminal so that we can grab keys */
333
static struct termios oldtty;
334
#endif
335

    
336
#if CONFIG_AVFILTER
337
typedef struct {
338
    int pix_fmt;
339
} FilterOutPriv;
340

    
341

    
342
static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
343
{
344
    FilterOutPriv *priv = ctx->priv;
345

    
346
    if(!opaque) return -1;
347

    
348
    priv->pix_fmt = *((int *)opaque);
349

    
350
    return 0;
351
}
352

    
353
static void output_end_frame(AVFilterLink *link)
354
{
355
}
356

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

    
362
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
363
    return 0;
364
}
365

    
366
static int get_filtered_video_pic(AVFilterContext *ctx,
367
                                  AVFilterBufferRef **picref, AVFrame *pic2,
368
                                  uint64_t *pts)
369
{
370
    AVFilterBufferRef *pic;
371

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

    
379
    *pts          = pic->pts;
380

    
381
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
382
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
383
    pic2->interlaced_frame = pic->video->interlaced;
384
    pic2->top_field_first  = pic->video->top_field_first;
385

    
386
    return 1;
387
}
388

    
389
static AVFilter output_filter =
390
{
391
    .name      = "ffmpeg_output",
392

    
393
    .priv_size = sizeof(FilterOutPriv),
394
    .init      = output_init,
395

    
396
    .query_formats = output_query_formats,
397

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

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

    
415
    graph = av_mallocz(sizeof(AVFilterGraph));
416

    
417
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
418
        return ret;
419
    if ((ret = avfilter_open(&ist->output_video_filter, &output_filter, "out")) < 0)
420
        return ret;
421

    
422
    snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
423
             ist->st->codec->height, ist->st->codec->pix_fmt);
424
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
425
        return ret;
426
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &codec->pix_fmt)) < 0)
427
        return ret;
428

    
429
    /* add input and output filters to the overall graph */
430
    avfilter_graph_add_filter(graph, ist->input_video_filter);
431
    avfilter_graph_add_filter(graph, ist->output_video_filter);
432

    
433
    last_filter = ist->input_video_filter;
434

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

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

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

    
469
    if (vfilters) {
470
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
471
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
472

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

    
478
        inputs->name    = av_strdup("out");
479
        inputs->filter  = ist->output_video_filter;
480
        inputs->pad_idx = 0;
481
        inputs->next    = NULL;
482

    
483
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
484
            return ret;
485
        av_freep(&vfilters);
486
    } else {
487
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
488
            return ret;
489
    }
490

    
491
    /* configure all the filter links */
492
    if ((ret = avfilter_graph_check_validity(graph, NULL)) < 0)
493
        return ret;
494
    if ((ret = avfilter_graph_config_formats(graph, NULL)) < 0)
495
        return ret;
496
    if ((ret = avfilter_graph_config_links(graph, NULL)) < 0)
497
        return ret;
498

    
499
    codec->width  = ist->output_video_filter->inputs[0]->w;
500
    codec->height = ist->output_video_filter->inputs[0]->h;
501

    
502
    return 0;
503
}
504
#endif /* CONFIG_AVFILTER */
505

    
506
static void term_exit(void)
507
{
508
    av_log(NULL, AV_LOG_QUIET, "");
509
#if HAVE_TERMIOS_H
510
    tcsetattr (0, TCSANOW, &oldtty);
511
#endif
512
}
513

    
514
static volatile int received_sigterm = 0;
515

    
516
static void
517
sigterm_handler(int sig)
518
{
519
    received_sigterm = sig;
520
    term_exit();
521
}
522

    
523
static void term_init(void)
524
{
525
#if HAVE_TERMIOS_H
526
    struct termios tty;
527

    
528
    tcgetattr (0, &tty);
529
    oldtty = tty;
530
    atexit(term_exit);
531

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

    
541
    tcsetattr (0, TCSANOW, &tty);
542
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
543
#endif
544

    
545
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
546
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
547
#ifdef SIGXCPU
548
    signal(SIGXCPU, sigterm_handler);
549
#endif
550
}
551

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

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

    
571
        return n;
572
    }
573
#elif HAVE_CONIO_H
574
    if(kbhit())
575
        return(getch());
576
#endif
577
    return -1;
578
}
579

    
580
static int decode_interrupt_cb(void)
581
{
582
    return q_pressed || (q_pressed = read_key() == 'q');
583
}
584

    
585
static int ffmpeg_exit(int ret)
586
{
587
    int i;
588

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

    
615
    av_free(intra_matrix);
616
    av_free(inter_matrix);
617

    
618
    if (vstats_file)
619
        fclose(vstats_file);
620
    av_free(vstats_filename);
621

    
622
    av_free(opt_names);
623
    av_free(streamid_map);
624
    av_free(input_codecs);
625
    av_free(output_codecs);
626

    
627
    av_free(video_codec_name);
628
    av_free(audio_codec_name);
629
    av_free(subtitle_codec_name);
630

    
631
    av_free(video_standard);
632

    
633
    for (i=0;i<AVMEDIA_TYPE_NB;i++)
634
        av_free(avcodec_opts[i]);
635
    av_free(avformat_opts);
636
    av_free(sws_opts);
637
    av_free(audio_buf);
638
    av_free(audio_out);
639
    allocated_audio_buf_size= allocated_audio_out_size= 0;
640
    av_free(samples);
641

    
642
#if CONFIG_AVFILTER
643
    avfilter_uninit();
644
#endif
645

    
646
    if (received_sigterm) {
647
        fprintf(stderr,
648
            "Received signal %d: terminating.\n",
649
            (int) received_sigterm);
650
        exit (255);
651
    }
652

    
653
    exit(ret); /* not all OS-es handle main() return value */
654
    return ret;
655
}
656

    
657
/* similar to ff_dynarray_add() and av_fast_realloc() */
658
static void *grow_array(void *array, int elem_size, int *size, int new_size)
659
{
660
    if (new_size >= INT_MAX / elem_size) {
661
        fprintf(stderr, "Array too big.\n");
662
        ffmpeg_exit(1);
663
    }
664
    if (*size < new_size) {
665
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
666
        if (!tmp) {
667
            fprintf(stderr, "Could not alloc buffer.\n");
668
            ffmpeg_exit(1);
669
        }
670
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
671
        *size = new_size;
672
        return tmp;
673
    }
674
    return array;
675
}
676

    
677
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
678
{
679
    if(codec && codec->sample_fmts){
680
        const enum SampleFormat *p= codec->sample_fmts;
681
        for(; *p!=-1; p++){
682
            if(*p == st->codec->sample_fmt)
683
                break;
684
        }
685
        if(*p == -1)
686
            st->codec->sample_fmt = codec->sample_fmts[0];
687
    }
688
}
689

    
690
static void choose_sample_rate(AVStream *st, AVCodec *codec)
691
{
692
    if(codec && codec->supported_samplerates){
693
        const int *p= codec->supported_samplerates;
694
        int best=0;
695
        int best_dist=INT_MAX;
696
        for(; *p; p++){
697
            int dist= abs(st->codec->sample_rate - *p);
698
            if(dist < best_dist){
699
                best_dist= dist;
700
                best= *p;
701
            }
702
        }
703
        if(best_dist){
704
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
705
        }
706
        st->codec->sample_rate= best;
707
    }
708
}
709

    
710
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
711
{
712
    if(codec && codec->pix_fmts){
713
        const enum PixelFormat *p= codec->pix_fmts;
714
        for(; *p!=-1; p++){
715
            if(*p == st->codec->pix_fmt)
716
                break;
717
        }
718
        if(*p == -1
719
           && !(   st->codec->codec_id==CODEC_ID_MJPEG
720
                && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
721
                && (   st->codec->pix_fmt == PIX_FMT_YUV420P
722
                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))
723
            st->codec->pix_fmt = codec->pix_fmts[0];
724
    }
725
}
726

    
727
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
728
{
729
    int i, err;
730
    AVFormatContext *ic;
731
    int nopts = 0;
732

    
733
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
734
    if (err < 0)
735
        return err;
736
    /* copy stream format */
737
    s->nb_streams = ic->nb_streams;
738
    for(i=0;i<ic->nb_streams;i++) {
739
        AVStream *st;
740
        AVCodec *codec;
741

    
742
        // FIXME: a more elegant solution is needed
743
        st = av_mallocz(sizeof(AVStream));
744
        memcpy(st, ic->streams[i], sizeof(AVStream));
745
        st->codec = avcodec_alloc_context();
746
        if (!st->codec) {
747
            print_error(filename, AVERROR(ENOMEM));
748
            ffmpeg_exit(1);
749
        }
750
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
751
        s->streams[i] = st;
752

    
753
        codec = avcodec_find_encoder(st->codec->codec_id);
754
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
755
            if (audio_stream_copy) {
756
                st->stream_copy = 1;
757
            } else
758
                choose_sample_fmt(st, codec);
759
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
760
            if (video_stream_copy) {
761
                st->stream_copy = 1;
762
            } else
763
                choose_pixel_fmt(st, codec);
764
        }
765

    
766
        if(!st->codec->thread_count)
767
            st->codec->thread_count = 1;
768
        if(st->codec->thread_count>1)
769
            avcodec_thread_init(st->codec, st->codec->thread_count);
770

    
771
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
772
            nopts = 1;
773
    }
774

    
775
    if (!nopts)
776
        s->timestamp = av_gettime();
777

    
778
    av_close_input_file(ic);
779
    return 0;
780
}
781

    
782
static double
783
get_sync_ipts(const AVOutputStream *ost)
784
{
785
    const AVInputStream *ist = ost->sync_ist;
786
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
787
}
788

    
789
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
790
    int ret;
791

    
792
    while(bsfc){
793
        AVPacket new_pkt= *pkt;
794
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
795
                                          &new_pkt.data, &new_pkt.size,
796
                                          pkt->data, pkt->size,
797
                                          pkt->flags & AV_PKT_FLAG_KEY);
798
        if(a>0){
799
            av_free_packet(pkt);
800
            new_pkt.destruct= av_destruct_packet;
801
        } else if(a<0){
802
            fprintf(stderr, "%s failed for stream %d, codec %s",
803
                    bsfc->filter->name, pkt->stream_index,
804
                    avctx->codec ? avctx->codec->name : "copy");
805
            print_error("", a);
806
            if (exit_on_error)
807
                ffmpeg_exit(1);
808
        }
809
        *pkt= new_pkt;
810

    
811
        bsfc= bsfc->next;
812
    }
813

    
814
    ret= av_interleaved_write_frame(s, pkt);
815
    if(ret < 0){
816
        print_error("av_interleaved_write_frame()", ret);
817
        ffmpeg_exit(1);
818
    }
819
}
820

    
821
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
822

    
823
static void do_audio_out(AVFormatContext *s,
824
                         AVOutputStream *ost,
825
                         AVInputStream *ist,
826
                         unsigned char *buf, int size)
827
{
828
    uint8_t *buftmp;
829
    int64_t audio_out_size, audio_buf_size;
830
    int64_t allocated_for_size= size;
831

    
832
    int size_out, frame_bytes, ret;
833
    AVCodecContext *enc= ost->st->codec;
834
    AVCodecContext *dec= ist->st->codec;
835
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
836
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
837
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
838

    
839
need_realloc:
840
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
841
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
842
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
843
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
844
    audio_buf_size*= osize*enc->channels;
845

    
846
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
847
    if(coded_bps > 8*osize)
848
        audio_out_size= audio_out_size * coded_bps / (8*osize);
849
    audio_out_size += FF_MIN_BUFFER_SIZE;
850

    
851
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
852
        fprintf(stderr, "Buffer sizes too large\n");
853
        ffmpeg_exit(1);
854
    }
855

    
856
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
857
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
858
    if (!audio_buf || !audio_out){
859
        fprintf(stderr, "Out of memory in do_audio_out\n");
860
        ffmpeg_exit(1);
861
    }
862

    
863
    if (enc->channels != dec->channels)
864
        ost->audio_resample = 1;
865

    
866
    if (ost->audio_resample && !ost->resample) {
867
        if (dec->sample_fmt != SAMPLE_FMT_S16)
868
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
869
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
870
                                               enc->sample_rate, dec->sample_rate,
871
                                               enc->sample_fmt,  dec->sample_fmt,
872
                                               16, 10, 0, 0.8);
873
        if (!ost->resample) {
874
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
875
                    dec->channels, dec->sample_rate,
876
                    enc->channels, enc->sample_rate);
877
            ffmpeg_exit(1);
878
        }
879
    }
880

    
881
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
882
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
883
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
884
        if (ost->reformat_ctx)
885
            av_audio_convert_free(ost->reformat_ctx);
886
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
887
                                                   dec->sample_fmt, 1, NULL, 0);
888
        if (!ost->reformat_ctx) {
889
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
890
                avcodec_get_sample_fmt_name(dec->sample_fmt),
891
                avcodec_get_sample_fmt_name(enc->sample_fmt));
892
            ffmpeg_exit(1);
893
        }
894
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
895
    }
896

    
897
    if(audio_sync_method){
898
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
899
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
900
        double idelta= delta*dec->sample_rate / enc->sample_rate;
901
        int byte_delta= ((int)idelta)*2*dec->channels;
902

    
903
        //FIXME resample delay
904
        if(fabs(delta) > 50){
905
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
906
                if(byte_delta < 0){
907
                    byte_delta= FFMAX(byte_delta, -size);
908
                    size += byte_delta;
909
                    buf  -= byte_delta;
910
                    if(verbose > 2)
911
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
912
                    if(!size)
913
                        return;
914
                    ist->is_start=0;
915
                }else{
916
                    static uint8_t *input_tmp= NULL;
917
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
918

    
919
                    if(byte_delta > allocated_for_size - size){
920
                        allocated_for_size= byte_delta + (int64_t)size;
921
                        goto need_realloc;
922
                    }
923
                    ist->is_start=0;
924

    
925
                    memset(input_tmp, 0, byte_delta);
926
                    memcpy(input_tmp + byte_delta, buf, size);
927
                    buf= input_tmp;
928
                    size += byte_delta;
929
                    if(verbose > 2)
930
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
931
                }
932
            }else if(audio_sync_method>1){
933
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
934
                av_assert0(ost->audio_resample);
935
                if(verbose > 2)
936
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
937
//                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));
938
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
939
            }
940
        }
941
    }else
942
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
943
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
944

    
945
    if (ost->audio_resample) {
946
        buftmp = audio_buf;
947
        size_out = audio_resample(ost->resample,
948
                                  (short *)buftmp, (short *)buf,
949
                                  size / (dec->channels * isize));
950
        size_out = size_out * enc->channels * osize;
951
    } else {
952
        buftmp = buf;
953
        size_out = size;
954
    }
955

    
956
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
957
        const void *ibuf[6]= {buftmp};
958
        void *obuf[6]= {audio_buf};
959
        int istride[6]= {isize};
960
        int ostride[6]= {osize};
961
        int len= size_out/istride[0];
962
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
963
            printf("av_audio_convert() failed\n");
964
            if (exit_on_error)
965
                ffmpeg_exit(1);
966
            return;
967
        }
968
        buftmp = audio_buf;
969
        size_out = len*osize;
970
    }
971

    
972
    /* now encode as many frames as possible */
973
    if (enc->frame_size > 1) {
974
        /* output resampled raw samples */
975
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
976
            fprintf(stderr, "av_fifo_realloc2() failed\n");
977
            ffmpeg_exit(1);
978
        }
979
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
980

    
981
        frame_bytes = enc->frame_size * osize * enc->channels;
982

    
983
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
984
            AVPacket pkt;
985
            av_init_packet(&pkt);
986

    
987
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
988

    
989
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
990

    
991
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
992
                                       (short *)audio_buf);
993
            if (ret < 0) {
994
                fprintf(stderr, "Audio encoding failed\n");
995
                ffmpeg_exit(1);
996
            }
997
            audio_size += ret;
998
            pkt.stream_index= ost->index;
999
            pkt.data= audio_out;
1000
            pkt.size= ret;
1001
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1002
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1003
            pkt.flags |= AV_PKT_FLAG_KEY;
1004
            write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
1005

    
1006
            ost->sync_opts += enc->frame_size;
1007
        }
1008
    } else {
1009
        AVPacket pkt;
1010
        av_init_packet(&pkt);
1011

    
1012
        ost->sync_opts += size_out / (osize * enc->channels);
1013

    
1014
        /* output a pcm frame */
1015
        /* determine the size of the coded buffer */
1016
        size_out /= osize;
1017
        if (coded_bps)
1018
            size_out = size_out*coded_bps/8;
1019

    
1020
        if(size_out > audio_out_size){
1021
            fprintf(stderr, "Internal error, buffer size too small\n");
1022
            ffmpeg_exit(1);
1023
        }
1024

    
1025
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1026
        ret = avcodec_encode_audio(enc, audio_out, size_out,
1027
                                   (short *)buftmp);
1028
        if (ret < 0) {
1029
            fprintf(stderr, "Audio encoding failed\n");
1030
            ffmpeg_exit(1);
1031
        }
1032
        audio_size += ret;
1033
        pkt.stream_index= ost->index;
1034
        pkt.data= audio_out;
1035
        pkt.size= ret;
1036
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1037
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1038
        pkt.flags |= AV_PKT_FLAG_KEY;
1039
        write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
1040
    }
1041
}
1042

    
1043
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1044
{
1045
    AVCodecContext *dec;
1046
    AVPicture *picture2;
1047
    AVPicture picture_tmp;
1048
    uint8_t *buf = 0;
1049

    
1050
    dec = ist->st->codec;
1051

    
1052
    /* deinterlace : must be done before any resize */
1053
    if (do_deinterlace) {
1054
        int size;
1055

    
1056
        /* create temporary picture */
1057
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1058
        buf = av_malloc(size);
1059
        if (!buf)
1060
            return;
1061

    
1062
        picture2 = &picture_tmp;
1063
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1064

    
1065
        if(avpicture_deinterlace(picture2, picture,
1066
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1067
            /* if error, do not deinterlace */
1068
            fprintf(stderr, "Deinterlacing failed\n");
1069
            av_free(buf);
1070
            buf = NULL;
1071
            picture2 = picture;
1072
        }
1073
    } else {
1074
        picture2 = picture;
1075
    }
1076

    
1077
    if (picture != picture2)
1078
        *picture = *picture2;
1079
    *bufp = buf;
1080
}
1081

    
1082
/* we begin to correct av delay at this threshold */
1083
#define AV_DELAY_MAX 0.100
1084

    
1085
static void do_subtitle_out(AVFormatContext *s,
1086
                            AVOutputStream *ost,
1087
                            AVInputStream *ist,
1088
                            AVSubtitle *sub,
1089
                            int64_t pts)
1090
{
1091
    static uint8_t *subtitle_out = NULL;
1092
    int subtitle_out_max_size = 1024 * 1024;
1093
    int subtitle_out_size, nb, i;
1094
    AVCodecContext *enc;
1095
    AVPacket pkt;
1096

    
1097
    if (pts == AV_NOPTS_VALUE) {
1098
        fprintf(stderr, "Subtitle packets must have a pts\n");
1099
        if (exit_on_error)
1100
            ffmpeg_exit(1);
1101
        return;
1102
    }
1103

    
1104
    enc = ost->st->codec;
1105

    
1106
    if (!subtitle_out) {
1107
        subtitle_out = av_malloc(subtitle_out_max_size);
1108
    }
1109

    
1110
    /* Note: DVB subtitle need one packet to draw them and one other
1111
       packet to clear them */
1112
    /* XXX: signal it in the codec context ? */
1113
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1114
        nb = 2;
1115
    else
1116
        nb = 1;
1117

    
1118
    for(i = 0; i < nb; i++) {
1119
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1120
        // start_display_time is required to be 0
1121
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1122
        sub->end_display_time -= sub->start_display_time;
1123
        sub->start_display_time = 0;
1124
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1125
                                                    subtitle_out_max_size, sub);
1126
        if (subtitle_out_size < 0) {
1127
            fprintf(stderr, "Subtitle encoding failed\n");
1128
            ffmpeg_exit(1);
1129
        }
1130

    
1131
        av_init_packet(&pkt);
1132
        pkt.stream_index = ost->index;
1133
        pkt.data = subtitle_out;
1134
        pkt.size = subtitle_out_size;
1135
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1136
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1137
            /* XXX: the pts correction is handled here. Maybe handling
1138
               it in the codec would be better */
1139
            if (i == 0)
1140
                pkt.pts += 90 * sub->start_display_time;
1141
            else
1142
                pkt.pts += 90 * sub->end_display_time;
1143
        }
1144
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1145
    }
1146
}
1147

    
1148
static int bit_buffer_size= 1024*256;
1149
static uint8_t *bit_buffer= NULL;
1150

    
1151
static void do_video_out(AVFormatContext *s,
1152
                         AVOutputStream *ost,
1153
                         AVInputStream *ist,
1154
                         AVFrame *in_picture,
1155
                         int *frame_size)
1156
{
1157
    int nb_frames, i, ret;
1158
#if !CONFIG_AVFILTER
1159
    int64_t topBand, bottomBand, leftBand, rightBand;
1160
#endif
1161
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1162
    AVFrame picture_crop_temp, picture_pad_temp;
1163
    AVCodecContext *enc, *dec;
1164
    double sync_ipts;
1165

    
1166
    avcodec_get_frame_defaults(&picture_crop_temp);
1167
    avcodec_get_frame_defaults(&picture_pad_temp);
1168

    
1169
    enc = ost->st->codec;
1170
    dec = ist->st->codec;
1171

    
1172
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1173

    
1174
    /* by default, we output a single frame */
1175
    nb_frames = 1;
1176

    
1177
    *frame_size = 0;
1178

    
1179
    if(video_sync_method){
1180
        double vdelta = sync_ipts - ost->sync_opts;
1181
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1182
        if (vdelta < -1.1)
1183
            nb_frames = 0;
1184
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1185
            if(vdelta<=-0.6){
1186
                nb_frames=0;
1187
            }else if(vdelta>0.6)
1188
            ost->sync_opts= lrintf(sync_ipts);
1189
        }else if (vdelta > 1.1)
1190
            nb_frames = lrintf(vdelta);
1191
//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);
1192
        if (nb_frames == 0){
1193
            ++nb_frames_drop;
1194
            if (verbose>2)
1195
                fprintf(stderr, "*** drop!\n");
1196
        }else if (nb_frames > 1) {
1197
            nb_frames_dup += nb_frames - 1;
1198
            if (verbose>2)
1199
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1200
        }
1201
    }else
1202
        ost->sync_opts= lrintf(sync_ipts);
1203

    
1204
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1205
    if (nb_frames <= 0)
1206
        return;
1207

    
1208
#if CONFIG_AVFILTER
1209
    formatted_picture = in_picture;
1210
#else
1211
    if (ost->video_crop) {
1212
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1213
            fprintf(stderr, "error cropping picture\n");
1214
            if (exit_on_error)
1215
                ffmpeg_exit(1);
1216
            return;
1217
        }
1218
        formatted_picture = &picture_crop_temp;
1219
    } else {
1220
        formatted_picture = in_picture;
1221
    }
1222
#endif
1223

    
1224
    final_picture = formatted_picture;
1225
    padding_src = formatted_picture;
1226
    resampling_dst = &ost->pict_tmp;
1227

    
1228
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1229
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1230
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1231

    
1232
        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));
1233
        if(!ost->video_resample)
1234
            ffmpeg_exit(1);
1235
    }
1236

    
1237
#if !CONFIG_AVFILTER
1238
    if (ost->video_resample) {
1239
        padding_src = NULL;
1240
        final_picture = &ost->pict_tmp;
1241
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1242
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1243
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1244

    
1245
            /* keep bands proportional to the frame size */
1246
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
1247
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1248
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
1249
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
1250

    
1251
            /* sanity check to ensure no bad band sizes sneak in */
1252
            av_assert0(topBand    <= INT_MAX && topBand    >= 0);
1253
            av_assert0(bottomBand <= INT_MAX && bottomBand >= 0);
1254
            av_assert0(leftBand   <= INT_MAX && leftBand   >= 0);
1255
            av_assert0(rightBand  <= INT_MAX && rightBand  >= 0);
1256

    
1257
            ost->topBand    = topBand;
1258
            ost->bottomBand = bottomBand;
1259
            ost->leftBand   = leftBand;
1260
            ost->rightBand  = rightBand;
1261

    
1262
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1263
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1264
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1265

    
1266
            /* initialize a new scaler context */
1267
            sws_freeContext(ost->img_resample_ctx);
1268
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1269
            ost->img_resample_ctx = sws_getContext(
1270
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1271
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1272
                ist->st->codec->pix_fmt,
1273
                ost->st->codec->width,
1274
                ost->st->codec->height,
1275
                ost->st->codec->pix_fmt,
1276
                sws_flags, NULL, NULL, NULL);
1277
            if (ost->img_resample_ctx == NULL) {
1278
                fprintf(stderr, "Cannot get resampling context\n");
1279
                ffmpeg_exit(1);
1280
            }
1281
        }
1282
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1283
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1284
    }
1285
#endif
1286

    
1287
    /* duplicates frame if needed */
1288
    for(i=0;i<nb_frames;i++) {
1289
        AVPacket pkt;
1290
        av_init_packet(&pkt);
1291
        pkt.stream_index= ost->index;
1292

    
1293
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1294
            /* raw pictures are written as AVPicture structure to
1295
               avoid any copies. We support temorarily the older
1296
               method. */
1297
            AVFrame* old_frame = enc->coded_frame;
1298
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1299
            pkt.data= (uint8_t *)final_picture;
1300
            pkt.size=  sizeof(AVPicture);
1301
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1302
            pkt.flags |= AV_PKT_FLAG_KEY;
1303

    
1304
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1305
            enc->coded_frame = old_frame;
1306
        } else {
1307
            AVFrame big_picture;
1308

    
1309
            big_picture= *final_picture;
1310
            /* better than nothing: use input picture interlaced
1311
               settings */
1312
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1313
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1314
                if(top_field_first == -1)
1315
                    big_picture.top_field_first = in_picture->top_field_first;
1316
                else
1317
                    big_picture.top_field_first = top_field_first;
1318
            }
1319

    
1320
            /* handles sameq here. This is not correct because it may
1321
               not be a global option */
1322
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1323
            if(!me_threshold)
1324
                big_picture.pict_type = 0;
1325
//            big_picture.pts = AV_NOPTS_VALUE;
1326
            big_picture.pts= ost->sync_opts;
1327
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1328
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1329
            ret = avcodec_encode_video(enc,
1330
                                       bit_buffer, bit_buffer_size,
1331
                                       &big_picture);
1332
            if (ret < 0) {
1333
                fprintf(stderr, "Video encoding failed\n");
1334
                ffmpeg_exit(1);
1335
            }
1336

    
1337
            if(ret>0){
1338
                pkt.data= bit_buffer;
1339
                pkt.size= ret;
1340
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1341
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1342
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1343
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1344
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1345

    
1346
                if(enc->coded_frame->key_frame)
1347
                    pkt.flags |= AV_PKT_FLAG_KEY;
1348
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1349
                *frame_size = ret;
1350
                video_size += ret;
1351
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1352
                //        enc->frame_number-1, ret, enc->pict_type);
1353
                /* if two pass, output log */
1354
                if (ost->logfile && enc->stats_out) {
1355
                    fprintf(ost->logfile, "%s", enc->stats_out);
1356
                }
1357
            }
1358
        }
1359
        ost->sync_opts++;
1360
        ost->frame_number++;
1361
    }
1362
}
1363

    
1364
static double psnr(double d){
1365
    return -10.0*log(d)/log(10.0);
1366
}
1367

    
1368
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1369
                           int frame_size)
1370
{
1371
    AVCodecContext *enc;
1372
    int frame_number;
1373
    double ti1, bitrate, avg_bitrate;
1374

    
1375
    /* this is executed just the first time do_video_stats is called */
1376
    if (!vstats_file) {
1377
        vstats_file = fopen(vstats_filename, "w");
1378
        if (!vstats_file) {
1379
            perror("fopen");
1380
            ffmpeg_exit(1);
1381
        }
1382
    }
1383

    
1384
    enc = ost->st->codec;
1385
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1386
        frame_number = ost->frame_number;
1387
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1388
        if (enc->flags&CODEC_FLAG_PSNR)
1389
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1390

    
1391
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1392
        /* compute pts value */
1393
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1394
        if (ti1 < 0.01)
1395
            ti1 = 0.01;
1396

    
1397
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1398
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1399
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1400
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1401
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1402
    }
1403
}
1404

    
1405
static void print_report(AVFormatContext **output_files,
1406
                         AVOutputStream **ost_table, int nb_ostreams,
1407
                         int is_last_report)
1408
{
1409
    char buf[1024];
1410
    AVOutputStream *ost;
1411
    AVFormatContext *oc;
1412
    int64_t total_size;
1413
    AVCodecContext *enc;
1414
    int frame_number, vid, i;
1415
    double bitrate, ti1, pts;
1416
    static int64_t last_time = -1;
1417
    static int qp_histogram[52];
1418

    
1419
    if (!is_last_report) {
1420
        int64_t cur_time;
1421
        /* display the report every 0.5 seconds */
1422
        cur_time = av_gettime();
1423
        if (last_time == -1) {
1424
            last_time = cur_time;
1425
            return;
1426
        }
1427
        if ((cur_time - last_time) < 500000)
1428
            return;
1429
        last_time = cur_time;
1430
    }
1431

    
1432

    
1433
    oc = output_files[0];
1434

    
1435
    total_size = url_fsize(oc->pb);
1436
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1437
        total_size= url_ftell(oc->pb);
1438

    
1439
    buf[0] = '\0';
1440
    ti1 = 1e10;
1441
    vid = 0;
1442
    for(i=0;i<nb_ostreams;i++) {
1443
        ost = ost_table[i];
1444
        enc = ost->st->codec;
1445
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1446
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1447
                     !ost->st->stream_copy ?
1448
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1449
        }
1450
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1451
            float t = (av_gettime()-timer_start) / 1000000.0;
1452

    
1453
            frame_number = ost->frame_number;
1454
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1455
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1456
                     !ost->st->stream_copy ?
1457
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1458
            if(is_last_report)
1459
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1460
            if(qp_hist){
1461
                int j;
1462
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1463
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1464
                    qp_histogram[qp]++;
1465
                for(j=0; j<32; j++)
1466
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1467
            }
1468
            if (enc->flags&CODEC_FLAG_PSNR){
1469
                int j;
1470
                double error, error_sum=0;
1471
                double scale, scale_sum=0;
1472
                char type[3]= {'Y','U','V'};
1473
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1474
                for(j=0; j<3; j++){
1475
                    if(is_last_report){
1476
                        error= enc->error[j];
1477
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1478
                    }else{
1479
                        error= enc->coded_frame->error[j];
1480
                        scale= enc->width*enc->height*255.0*255.0;
1481
                    }
1482
                    if(j) scale/=4;
1483
                    error_sum += error;
1484
                    scale_sum += scale;
1485
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1486
                }
1487
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1488
            }
1489
            vid = 1;
1490
        }
1491
        /* compute min output value */
1492
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1493
        if ((pts < ti1) && (pts > 0))
1494
            ti1 = pts;
1495
    }
1496
    if (ti1 < 0.01)
1497
        ti1 = 0.01;
1498

    
1499
    if (verbose || is_last_report) {
1500
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1501

    
1502
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1503
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1504
            (double)total_size / 1024, ti1, bitrate);
1505

    
1506
        if (nb_frames_dup || nb_frames_drop)
1507
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1508
                  nb_frames_dup, nb_frames_drop);
1509

    
1510
        if (verbose >= 0)
1511
            fprintf(stderr, "%s    \r", buf);
1512

    
1513
        fflush(stderr);
1514
    }
1515

    
1516
    if (is_last_report && verbose >= 0){
1517
        int64_t raw= audio_size + video_size + extra_size;
1518
        fprintf(stderr, "\n");
1519
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1520
                video_size/1024.0,
1521
                audio_size/1024.0,
1522
                extra_size/1024.0,
1523
                100.0*(total_size - raw)/raw
1524
        );
1525
    }
1526
}
1527

    
1528
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1529
static int output_packet(AVInputStream *ist, int ist_index,
1530
                         AVOutputStream **ost_table, int nb_ostreams,
1531
                         const AVPacket *pkt)
1532
{
1533
    AVFormatContext *os;
1534
    AVOutputStream *ost;
1535
    int ret, i;
1536
    int got_picture;
1537
    AVFrame picture;
1538
    void *buffer_to_free;
1539
    static unsigned int samples_size= 0;
1540
    AVSubtitle subtitle, *subtitle_to_free;
1541
#if CONFIG_AVFILTER
1542
    int frame_available;
1543
#endif
1544

    
1545
    AVPacket avpkt;
1546
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1547

    
1548
    if(ist->next_pts == AV_NOPTS_VALUE)
1549
        ist->next_pts= ist->pts;
1550

    
1551
    if (pkt == NULL) {
1552
        /* EOF handling */
1553
        av_init_packet(&avpkt);
1554
        avpkt.data = NULL;
1555
        avpkt.size = 0;
1556
        goto handle_eof;
1557
    } else {
1558
        avpkt = *pkt;
1559
    }
1560

    
1561
    if(pkt->dts != AV_NOPTS_VALUE)
1562
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1563

    
1564
    //while we have more to decode or while the decoder did output something on EOF
1565
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1566
        uint8_t *data_buf, *decoded_data_buf;
1567
        int data_size, decoded_data_size;
1568
    handle_eof:
1569
        ist->pts= ist->next_pts;
1570

    
1571
        if(avpkt.size && avpkt.size != pkt->size &&
1572
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1573
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1574
            ist->showed_multi_packet_warning=1;
1575
        }
1576

    
1577
        /* decode the packet if needed */
1578
        decoded_data_buf = NULL; /* fail safe */
1579
        decoded_data_size= 0;
1580
        data_buf  = avpkt.data;
1581
        data_size = avpkt.size;
1582
        subtitle_to_free = NULL;
1583
        if (ist->decoding_needed) {
1584
            switch(ist->st->codec->codec_type) {
1585
            case AVMEDIA_TYPE_AUDIO:{
1586
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1587
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1588
                    av_free(samples);
1589
                    samples= av_malloc(samples_size);
1590
                }
1591
                decoded_data_size= samples_size;
1592
                    /* XXX: could avoid copy if PCM 16 bits with same
1593
                       endianness as CPU */
1594
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1595
                                            &avpkt);
1596
                if (ret < 0)
1597
                    goto fail_decode;
1598
                avpkt.data += ret;
1599
                avpkt.size -= ret;
1600
                data_size   = ret;
1601
                /* Some bug in mpeg audio decoder gives */
1602
                /* decoded_data_size < 0, it seems they are overflows */
1603
                if (decoded_data_size <= 0) {
1604
                    /* no audio frame */
1605
                    continue;
1606
                }
1607
                decoded_data_buf = (uint8_t *)samples;
1608
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1609
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1610
                break;}
1611
            case AVMEDIA_TYPE_VIDEO:
1612
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1613
                    /* XXX: allocate picture correctly */
1614
                    avcodec_get_frame_defaults(&picture);
1615

    
1616
                    ret = avcodec_decode_video2(ist->st->codec,
1617
                                                &picture, &got_picture, &avpkt);
1618
                    ist->st->quality= picture.quality;
1619
                    if (ret < 0)
1620
                        goto fail_decode;
1621
                    if (!got_picture) {
1622
                        /* no picture yet */
1623
                        goto discard_packet;
1624
                    }
1625
                    if (ist->st->codec->time_base.num != 0) {
1626
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1627
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1628
                                          ist->st->codec->time_base.num * ticks) /
1629
                            ist->st->codec->time_base.den;
1630
                    }
1631
                    avpkt.size = 0;
1632
                    break;
1633
            case AVMEDIA_TYPE_SUBTITLE:
1634
                ret = avcodec_decode_subtitle2(ist->st->codec,
1635
                                               &subtitle, &got_picture, &avpkt);
1636
                if (ret < 0)
1637
                    goto fail_decode;
1638
                if (!got_picture) {
1639
                    goto discard_packet;
1640
                }
1641
                subtitle_to_free = &subtitle;
1642
                avpkt.size = 0;
1643
                break;
1644
            default:
1645
                goto fail_decode;
1646
            }
1647
        } else {
1648
            switch(ist->st->codec->codec_type) {
1649
            case AVMEDIA_TYPE_AUDIO:
1650
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1651
                    ist->st->codec->sample_rate;
1652
                break;
1653
            case AVMEDIA_TYPE_VIDEO:
1654
                if (ist->st->codec->time_base.num != 0) {
1655
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1656
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1657
                                      ist->st->codec->time_base.num * ticks) /
1658
                        ist->st->codec->time_base.den;
1659
                }
1660
                break;
1661
            }
1662
            ret = avpkt.size;
1663
            avpkt.size = 0;
1664
        }
1665

    
1666
        buffer_to_free = NULL;
1667
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1668
            pre_process_video_frame(ist, (AVPicture *)&picture,
1669
                                    &buffer_to_free);
1670
        }
1671

    
1672
#if CONFIG_AVFILTER
1673
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1674
            // add it to be filtered
1675
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1676
                                     ist->pts,
1677
                                     ist->st->codec->sample_aspect_ratio);
1678
        }
1679
#endif
1680

    
1681
        // preprocess audio (volume)
1682
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1683
            if (audio_volume != 256) {
1684
                short *volp;
1685
                volp = samples;
1686
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1687
                    int v = ((*volp) * audio_volume + 128) >> 8;
1688
                    if (v < -32768) v = -32768;
1689
                    if (v >  32767) v = 32767;
1690
                    *volp++ = v;
1691
                }
1692
            }
1693
        }
1694

    
1695
        /* frame rate emulation */
1696
        if (rate_emu) {
1697
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1698
            int64_t now = av_gettime() - ist->start;
1699
            if (pts > now)
1700
                usleep(pts - now);
1701
        }
1702
#if CONFIG_AVFILTER
1703
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1704
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1705
#endif
1706
        /* if output time reached then transcode raw format,
1707
           encode packets and output them */
1708
        if (start_time == 0 || ist->pts >= start_time)
1709
#if CONFIG_AVFILTER
1710
        while (frame_available) {
1711
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1712
                get_filtered_video_pic(ist->output_video_filter, &ist->picref, &picture, &ist->pts);
1713
#endif
1714
            for(i=0;i<nb_ostreams;i++) {
1715
                int frame_size;
1716

    
1717
                ost = ost_table[i];
1718
                if (ost->source_index == ist_index) {
1719
                    os = output_files[ost->file_index];
1720

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

    
1724
                    if (ost->encoding_needed) {
1725
                        av_assert0(ist->decoding_needed);
1726
                        switch(ost->st->codec->codec_type) {
1727
                        case AVMEDIA_TYPE_AUDIO:
1728
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1729
                            break;
1730
                        case AVMEDIA_TYPE_VIDEO:
1731
#if CONFIG_AVFILTER
1732
                            if (ist->picref->video)
1733
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1734
#endif
1735
                            do_video_out(os, ost, ist, &picture, &frame_size);
1736
                            if (vstats_filename && frame_size)
1737
                                do_video_stats(os, ost, frame_size);
1738
                            break;
1739
                        case AVMEDIA_TYPE_SUBTITLE:
1740
                            do_subtitle_out(os, ost, ist, &subtitle,
1741
                                            pkt->pts);
1742
                            break;
1743
                        default:
1744
                            abort();
1745
                        }
1746
                    } else {
1747
                        AVFrame avframe; //FIXME/XXX remove this
1748
                        AVPacket opkt;
1749
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1750

    
1751
                        av_init_packet(&opkt);
1752

    
1753
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1754
                            continue;
1755

    
1756
                        /* no reencoding needed : output the packet directly */
1757
                        /* force the input stream PTS */
1758

    
1759
                        avcodec_get_frame_defaults(&avframe);
1760
                        ost->st->codec->coded_frame= &avframe;
1761
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1762

    
1763
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1764
                            audio_size += data_size;
1765
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1766
                            video_size += data_size;
1767
                            ost->sync_opts++;
1768
                        }
1769

    
1770
                        opkt.stream_index= ost->index;
1771
                        if(pkt->pts != AV_NOPTS_VALUE)
1772
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1773
                        else
1774
                            opkt.pts= AV_NOPTS_VALUE;
1775

    
1776
                        if (pkt->dts == AV_NOPTS_VALUE)
1777
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1778
                        else
1779
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1780
                        opkt.dts -= ost_tb_start_time;
1781

    
1782
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1783
                        opkt.flags= pkt->flags;
1784

    
1785
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1786
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1787
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1788
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1789
                           ) {
1790
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1791
                                opkt.destruct= av_destruct_packet;
1792
                        } else {
1793
                            opkt.data = data_buf;
1794
                            opkt.size = data_size;
1795
                        }
1796

    
1797
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1798
                        ost->st->codec->frame_number++;
1799
                        ost->frame_number++;
1800
                        av_free_packet(&opkt);
1801
                    }
1802
                }
1803
            }
1804

    
1805
#if CONFIG_AVFILTER
1806
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1807
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1808
            if(ist->picref)
1809
                avfilter_unref_buffer(ist->picref);
1810
        }
1811
#endif
1812
        av_free(buffer_to_free);
1813
        /* XXX: allocate the subtitles in the codec ? */
1814
        if (subtitle_to_free) {
1815
            if (subtitle_to_free->rects != NULL) {
1816
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1817
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1818
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1819
                    av_freep(&subtitle_to_free->rects[i]);
1820
                }
1821
                av_freep(&subtitle_to_free->rects);
1822
            }
1823
            subtitle_to_free->num_rects = 0;
1824
            subtitle_to_free = NULL;
1825
        }
1826
    }
1827
 discard_packet:
1828
    if (pkt == NULL) {
1829
        /* EOF handling */
1830

    
1831
        for(i=0;i<nb_ostreams;i++) {
1832
            ost = ost_table[i];
1833
            if (ost->source_index == ist_index) {
1834
                AVCodecContext *enc= ost->st->codec;
1835
                os = output_files[ost->file_index];
1836

    
1837
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1838
                    continue;
1839
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1840
                    continue;
1841

    
1842
                if (ost->encoding_needed) {
1843
                    for(;;) {
1844
                        AVPacket pkt;
1845
                        int fifo_bytes;
1846
                        av_init_packet(&pkt);
1847
                        pkt.stream_index= ost->index;
1848

    
1849
                        switch(ost->st->codec->codec_type) {
1850
                        case AVMEDIA_TYPE_AUDIO:
1851
                            fifo_bytes = av_fifo_size(ost->fifo);
1852
                            ret = 0;
1853
                            /* encode any samples remaining in fifo */
1854
                            if (fifo_bytes > 0) {
1855
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1856
                                int fs_tmp = enc->frame_size;
1857

    
1858
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1859
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1860
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1861
                                } else { /* pad */
1862
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1863
                                    if (allocated_audio_buf_size < frame_bytes)
1864
                                        ffmpeg_exit(1);
1865
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1866
                                }
1867

    
1868
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1869
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1870
                                                          ost->st->time_base.num, enc->sample_rate);
1871
                                enc->frame_size = fs_tmp;
1872
                            }
1873
                            if(ret <= 0) {
1874
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1875
                            }
1876
                            if (ret < 0) {
1877
                                fprintf(stderr, "Audio encoding failed\n");
1878
                                ffmpeg_exit(1);
1879
                            }
1880
                            audio_size += ret;
1881
                            pkt.flags |= AV_PKT_FLAG_KEY;
1882
                            break;
1883
                        case AVMEDIA_TYPE_VIDEO:
1884
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1885
                            if (ret < 0) {
1886
                                fprintf(stderr, "Video encoding failed\n");
1887
                                ffmpeg_exit(1);
1888
                            }
1889
                            video_size += ret;
1890
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1891
                                pkt.flags |= AV_PKT_FLAG_KEY;
1892
                            if (ost->logfile && enc->stats_out) {
1893
                                fprintf(ost->logfile, "%s", enc->stats_out);
1894
                            }
1895
                            break;
1896
                        default:
1897
                            ret=-1;
1898
                        }
1899

    
1900
                        if(ret<=0)
1901
                            break;
1902
                        pkt.data= bit_buffer;
1903
                        pkt.size= ret;
1904
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1905
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1906
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1907
                    }
1908
                }
1909
            }
1910
        }
1911
    }
1912

    
1913
    return 0;
1914
 fail_decode:
1915
    return -1;
1916
}
1917

    
1918
static void print_sdp(AVFormatContext **avc, int n)
1919
{
1920
    char sdp[2048];
1921

    
1922
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1923
    printf("SDP:\n%s\n", sdp);
1924
    fflush(stdout);
1925
}
1926

    
1927
static int copy_chapters(int infile, int outfile)
1928
{
1929
    AVFormatContext *is = input_files[infile];
1930
    AVFormatContext *os = output_files[outfile];
1931
    int i;
1932

    
1933
    for (i = 0; i < is->nb_chapters; i++) {
1934
        AVChapter *in_ch = is->chapters[i], *out_ch;
1935
        AVMetadataTag *t = NULL;
1936
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1937
                                      AV_TIME_BASE_Q, in_ch->time_base);
1938
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1939
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1940

    
1941

    
1942
        if (in_ch->end < ts_off)
1943
            continue;
1944
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1945
            break;
1946

    
1947
        out_ch = av_mallocz(sizeof(AVChapter));
1948
        if (!out_ch)
1949
            return AVERROR(ENOMEM);
1950

    
1951
        out_ch->id        = in_ch->id;
1952
        out_ch->time_base = in_ch->time_base;
1953
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1954
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1955

    
1956
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1957
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1958

    
1959
        os->nb_chapters++;
1960
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1961
        if (!os->chapters)
1962
            return AVERROR(ENOMEM);
1963
        os->chapters[os->nb_chapters - 1] = out_ch;
1964
    }
1965
    return 0;
1966
}
1967

    
1968
/*
1969
 * The following code is the main loop of the file converter
1970
 */
1971
static int transcode(AVFormatContext **output_files,
1972
                     int nb_output_files,
1973
                     AVFormatContext **input_files,
1974
                     int nb_input_files,
1975
                     AVStreamMap *stream_maps, int nb_stream_maps)
1976
{
1977
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1978
    AVFormatContext *is, *os;
1979
    AVCodecContext *codec, *icodec;
1980
    AVOutputStream *ost, **ost_table = NULL;
1981
    AVInputStream *ist, **ist_table = NULL;
1982
    AVInputFile *file_table;
1983
    char error[1024];
1984
    int key;
1985
    int want_sdp = 1;
1986
    uint8_t no_packet[MAX_FILES]={0};
1987
    int no_packet_count=0;
1988

    
1989
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1990
    if (!file_table)
1991
        goto fail;
1992

    
1993
    /* input stream init */
1994
    j = 0;
1995
    for(i=0;i<nb_input_files;i++) {
1996
        is = input_files[i];
1997
        file_table[i].ist_index = j;
1998
        file_table[i].nb_streams = is->nb_streams;
1999
        j += is->nb_streams;
2000
    }
2001
    nb_istreams = j;
2002

    
2003
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
2004
    if (!ist_table)
2005
        goto fail;
2006

    
2007
    for(i=0;i<nb_istreams;i++) {
2008
        ist = av_mallocz(sizeof(AVInputStream));
2009
        if (!ist)
2010
            goto fail;
2011
        ist_table[i] = ist;
2012
    }
2013
    j = 0;
2014
    for(i=0;i<nb_input_files;i++) {
2015
        is = input_files[i];
2016
        for(k=0;k<is->nb_streams;k++) {
2017
            ist = ist_table[j++];
2018
            ist->st = is->streams[k];
2019
            ist->file_index = i;
2020
            ist->index = k;
2021
            ist->discard = 1; /* the stream is discarded by default
2022
                                 (changed later) */
2023

    
2024
            if (rate_emu) {
2025
                ist->start = av_gettime();
2026
            }
2027
        }
2028
    }
2029

    
2030
    /* output stream init */
2031
    nb_ostreams = 0;
2032
    for(i=0;i<nb_output_files;i++) {
2033
        os = output_files[i];
2034
        if (!os->nb_streams) {
2035
            dump_format(output_files[i], i, output_files[i]->filename, 1);
2036
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2037
            ret = AVERROR(EINVAL);
2038
            goto fail;
2039
        }
2040
        nb_ostreams += os->nb_streams;
2041
    }
2042
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2043
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2044
        ret = AVERROR(EINVAL);
2045
        goto fail;
2046
    }
2047

    
2048
    /* Sanity check the mapping args -- do the input files & streams exist? */
2049
    for(i=0;i<nb_stream_maps;i++) {
2050
        int fi = stream_maps[i].file_index;
2051
        int si = stream_maps[i].stream_index;
2052

    
2053
        if (fi < 0 || fi > nb_input_files - 1 ||
2054
            si < 0 || si > file_table[fi].nb_streams - 1) {
2055
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2056
            ret = AVERROR(EINVAL);
2057
            goto fail;
2058
        }
2059
        fi = stream_maps[i].sync_file_index;
2060
        si = stream_maps[i].sync_stream_index;
2061
        if (fi < 0 || fi > nb_input_files - 1 ||
2062
            si < 0 || si > file_table[fi].nb_streams - 1) {
2063
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2064
            ret = AVERROR(EINVAL);
2065
            goto fail;
2066
        }
2067
    }
2068

    
2069
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2070
    if (!ost_table)
2071
        goto fail;
2072
    for(i=0;i<nb_ostreams;i++) {
2073
        ost = av_mallocz(sizeof(AVOutputStream));
2074
        if (!ost)
2075
            goto fail;
2076
        ost_table[i] = ost;
2077
    }
2078

    
2079
    n = 0;
2080
    for(k=0;k<nb_output_files;k++) {
2081
        os = output_files[k];
2082
        for(i=0;i<os->nb_streams;i++,n++) {
2083
            int found;
2084
            ost = ost_table[n];
2085
            ost->file_index = k;
2086
            ost->index = i;
2087
            ost->st = os->streams[i];
2088
            if (nb_stream_maps > 0) {
2089
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2090
                    stream_maps[n].stream_index;
2091

    
2092
                /* Sanity check that the stream types match */
2093
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2094
                    int i= ost->file_index;
2095
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2096
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2097
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2098
                        ost->file_index, ost->index);
2099
                    ffmpeg_exit(1);
2100
                }
2101

    
2102
            } else {
2103
                int best_nb_frames=-1;
2104
                /* get corresponding input stream index : we select the first one with the right type */
2105
                found = 0;
2106
                for(j=0;j<nb_istreams;j++) {
2107
                    int skip=0;
2108
                    ist = ist_table[j];
2109
                    if(opt_programid){
2110
                        int pi,si;
2111
                        AVFormatContext *f= input_files[ ist->file_index ];
2112
                        skip=1;
2113
                        for(pi=0; pi<f->nb_programs; pi++){
2114
                            AVProgram *p= f->programs[pi];
2115
                            if(p->id == opt_programid)
2116
                                for(si=0; si<p->nb_stream_indexes; si++){
2117
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2118
                                        skip=0;
2119
                                }
2120
                        }
2121
                    }
2122
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2123
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2124
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2125
                            best_nb_frames= ist->st->codec_info_nb_frames;
2126
                            ost->source_index = j;
2127
                            found = 1;
2128
                        }
2129
                    }
2130
                }
2131

    
2132
                if (!found) {
2133
                    if(! opt_programid) {
2134
                        /* try again and reuse existing stream */
2135
                        for(j=0;j<nb_istreams;j++) {
2136
                            ist = ist_table[j];
2137
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2138
                                && ist->st->discard != AVDISCARD_ALL) {
2139
                                ost->source_index = j;
2140
                                found = 1;
2141
                            }
2142
                        }
2143
                    }
2144
                    if (!found) {
2145
                        int i= ost->file_index;
2146
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2147
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2148
                                ost->file_index, ost->index);
2149
                        ffmpeg_exit(1);
2150
                    }
2151
                }
2152
            }
2153
            ist = ist_table[ost->source_index];
2154
            ist->discard = 0;
2155
            ost->sync_ist = (nb_stream_maps > 0) ?
2156
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2157
                         stream_maps[n].sync_stream_index] : ist;
2158
        }
2159
    }
2160

    
2161
    /* for each output stream, we compute the right encoding parameters */
2162
    for(i=0;i<nb_ostreams;i++) {
2163
        AVMetadataTag *t = NULL;
2164
        ost = ost_table[i];
2165
        os = output_files[ost->file_index];
2166
        ist = ist_table[ost->source_index];
2167

    
2168
        codec = ost->st->codec;
2169
        icodec = ist->st->codec;
2170

    
2171
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2172
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2173
        }
2174

    
2175
        ost->st->disposition = ist->st->disposition;
2176
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2177
        codec->chroma_sample_location = icodec->chroma_sample_location;
2178

    
2179
        if (ost->st->stream_copy) {
2180
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2181

    
2182
            if (extra_size > INT_MAX)
2183
                goto fail;
2184

    
2185
            /* if stream_copy is selected, no need to decode or encode */
2186
            codec->codec_id = icodec->codec_id;
2187
            codec->codec_type = icodec->codec_type;
2188

    
2189
            if(!codec->codec_tag){
2190
                if(   !os->oformat->codec_tag
2191
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2192
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2193
                    codec->codec_tag = icodec->codec_tag;
2194
            }
2195

    
2196
            codec->bit_rate = icodec->bit_rate;
2197
            codec->extradata= av_mallocz(extra_size);
2198
            if (!codec->extradata)
2199
                goto fail;
2200
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2201
            codec->extradata_size= icodec->extradata_size;
2202
            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){
2203
                codec->time_base = icodec->time_base;
2204
                codec->time_base.num *= icodec->ticks_per_frame;
2205
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2206
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2207
            }else
2208
                codec->time_base = ist->st->time_base;
2209
            switch(codec->codec_type) {
2210
            case AVMEDIA_TYPE_AUDIO:
2211
                if(audio_volume != 256) {
2212
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2213
                    ffmpeg_exit(1);
2214
                }
2215
                codec->channel_layout = icodec->channel_layout;
2216
                codec->sample_rate = icodec->sample_rate;
2217
                codec->channels = icodec->channels;
2218
                codec->frame_size = icodec->frame_size;
2219
                codec->block_align= icodec->block_align;
2220
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2221
                    codec->block_align= 0;
2222
                if(codec->codec_id == CODEC_ID_AC3)
2223
                    codec->block_align= 0;
2224
                break;
2225
            case AVMEDIA_TYPE_VIDEO:
2226
                codec->pix_fmt = icodec->pix_fmt;
2227
                codec->width = icodec->width;
2228
                codec->height = icodec->height;
2229
                codec->has_b_frames = icodec->has_b_frames;
2230
                break;
2231
            case AVMEDIA_TYPE_SUBTITLE:
2232
                codec->width = icodec->width;
2233
                codec->height = icodec->height;
2234
                break;
2235
            default:
2236
                abort();
2237
            }
2238
        } else {
2239
            switch(codec->codec_type) {
2240
            case AVMEDIA_TYPE_AUDIO:
2241
                ost->fifo= av_fifo_alloc(1024);
2242
                if(!ost->fifo)
2243
                    goto fail;
2244
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2245
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2246
                icodec->request_channels = codec->channels;
2247
                ist->decoding_needed = 1;
2248
                ost->encoding_needed = 1;
2249
                break;
2250
            case AVMEDIA_TYPE_VIDEO:
2251
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2252
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2253
                    ffmpeg_exit(1);
2254
                }
2255
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2256
                ost->video_resample = ((codec->width != icodec->width -
2257
                                (frame_leftBand + frame_rightBand)) ||
2258
                        (codec->height != icodec->height -
2259
                                (frame_topBand  + frame_bottomBand)) ||
2260
                        (codec->pix_fmt != icodec->pix_fmt));
2261
                if (ost->video_crop) {
2262
                    ost->topBand    = ost->original_topBand    = frame_topBand;
2263
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2264
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
2265
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
2266
                }
2267
                if (ost->video_resample) {
2268
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2269
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2270
                                         codec->width, codec->height)) {
2271
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2272
                        ffmpeg_exit(1);
2273
                    }
2274
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2275
                    ost->img_resample_ctx = sws_getContext(
2276
                            icodec->width - (frame_leftBand + frame_rightBand),
2277
                            icodec->height - (frame_topBand + frame_bottomBand),
2278
                            icodec->pix_fmt,
2279
                            codec->width,
2280
                            codec->height,
2281
                            codec->pix_fmt,
2282
                            sws_flags, NULL, NULL, NULL);
2283
                    if (ost->img_resample_ctx == NULL) {
2284
                        fprintf(stderr, "Cannot get resampling context\n");
2285
                        ffmpeg_exit(1);
2286
                    }
2287

    
2288
#if !CONFIG_AVFILTER
2289
                    ost->original_height = icodec->height;
2290
                    ost->original_width  = icodec->width;
2291
#endif
2292
                    codec->bits_per_raw_sample= 0;
2293
                }
2294
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2295
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2296
                ost->resample_pix_fmt= icodec->pix_fmt;
2297
                ost->encoding_needed = 1;
2298
                ist->decoding_needed = 1;
2299

    
2300
#if CONFIG_AVFILTER
2301
                if (configure_filters(ist, ost)) {
2302
                    fprintf(stderr, "Error opening filters!\n");
2303
                    exit(1);
2304
                }
2305
#endif
2306
                break;
2307
            case AVMEDIA_TYPE_SUBTITLE:
2308
                ost->encoding_needed = 1;
2309
                ist->decoding_needed = 1;
2310
                break;
2311
            default:
2312
                abort();
2313
                break;
2314
            }
2315
            /* two pass mode */
2316
            if (ost->encoding_needed &&
2317
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2318
                char logfilename[1024];
2319
                FILE *f;
2320

    
2321
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2322
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2323
                         i);
2324
                if (codec->flags & CODEC_FLAG_PASS1) {
2325
                    f = fopen(logfilename, "wb");
2326
                    if (!f) {
2327
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2328
                        ffmpeg_exit(1);
2329
                    }
2330
                    ost->logfile = f;
2331
                } else {
2332
                    char  *logbuffer;
2333
                    size_t logbuffer_size;
2334
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2335
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2336
                        ffmpeg_exit(1);
2337
                    }
2338
                    codec->stats_in = logbuffer;
2339
                }
2340
            }
2341
        }
2342
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2343
            int size= codec->width * codec->height;
2344
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2345
        }
2346
    }
2347

    
2348
    if (!bit_buffer)
2349
        bit_buffer = av_malloc(bit_buffer_size);
2350
    if (!bit_buffer) {
2351
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2352
                bit_buffer_size);
2353
        ret = AVERROR(ENOMEM);
2354
        goto fail;
2355
    }
2356

    
2357
    /* open each encoder */
2358
    for(i=0;i<nb_ostreams;i++) {
2359
        ost = ost_table[i];
2360
        if (ost->encoding_needed) {
2361
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2362
            if (!codec)
2363
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2364
            if (!codec) {
2365
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2366
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2367
                ret = AVERROR(EINVAL);
2368
                goto dump_format;
2369
            }
2370
            if (avcodec_open(ost->st->codec, codec) < 0) {
2371
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2372
                        ost->file_index, ost->index);
2373
                ret = AVERROR(EINVAL);
2374
                goto dump_format;
2375
            }
2376
            extra_size += ost->st->codec->extradata_size;
2377
        }
2378
    }
2379

    
2380
    /* open each decoder */
2381
    for(i=0;i<nb_istreams;i++) {
2382
        ist = ist_table[i];
2383
        if (ist->decoding_needed) {
2384
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2385
            if (!codec)
2386
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2387
            if (!codec) {
2388
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2389
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2390
                ret = AVERROR(EINVAL);
2391
                goto dump_format;
2392
            }
2393
            if (avcodec_open(ist->st->codec, codec) < 0) {
2394
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2395
                        ist->file_index, ist->index);
2396
                ret = AVERROR(EINVAL);
2397
                goto dump_format;
2398
            }
2399
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2400
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2401
        }
2402
    }
2403

    
2404
    /* init pts */
2405
    for(i=0;i<nb_istreams;i++) {
2406
        AVStream *st;
2407
        ist = ist_table[i];
2408
        st= ist->st;
2409
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2410
        ist->next_pts = AV_NOPTS_VALUE;
2411
        ist->is_start = 1;
2412
    }
2413

    
2414
    /* set meta data information from input file if required */
2415
    for (i=0;i<nb_meta_data_maps;i++) {
2416
        AVFormatContext *out_file;
2417
        AVFormatContext *in_file;
2418
        AVMetadataTag *mtag;
2419

    
2420
        int out_file_index = meta_data_maps[i].out_file;
2421
        int in_file_index = meta_data_maps[i].in_file;
2422
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2423
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2424
                     out_file_index, out_file_index, in_file_index);
2425
            ret = AVERROR(EINVAL);
2426
            goto dump_format;
2427
        }
2428
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2429
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2430
                     in_file_index, out_file_index, in_file_index);
2431
            ret = AVERROR(EINVAL);
2432
            goto dump_format;
2433
        }
2434

    
2435
        out_file = output_files[out_file_index];
2436
        in_file = input_files[in_file_index];
2437

    
2438

    
2439
        mtag=NULL;
2440
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2441
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2442
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2443
                                    in_file->iformat->metadata_conv);
2444
    }
2445

    
2446
    /* copy chapters from the first input file that has them*/
2447
    for (i = 0; i < nb_input_files; i++) {
2448
        if (!input_files[i]->nb_chapters)
2449
            continue;
2450

    
2451
        for (j = 0; j < nb_output_files; j++)
2452
            if ((ret = copy_chapters(i, j)) < 0)
2453
                goto dump_format;
2454
    }
2455

    
2456
    /* open files and write file headers */
2457
    for(i=0;i<nb_output_files;i++) {
2458
        os = output_files[i];
2459
        if (av_write_header(os) < 0) {
2460
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2461
            ret = AVERROR(EINVAL);
2462
            goto dump_format;
2463
        }
2464
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2465
            want_sdp = 0;
2466
        }
2467
    }
2468

    
2469
 dump_format:
2470
    /* dump the file output parameters - cannot be done before in case
2471
       of stream copy */
2472
    for(i=0;i<nb_output_files;i++) {
2473
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2474
    }
2475

    
2476
    /* dump the stream mapping */
2477
    if (verbose >= 0) {
2478
        fprintf(stderr, "Stream mapping:\n");
2479
        for(i=0;i<nb_ostreams;i++) {
2480
            ost = ost_table[i];
2481
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2482
                    ist_table[ost->source_index]->file_index,
2483
                    ist_table[ost->source_index]->index,
2484
                    ost->file_index,
2485
                    ost->index);
2486
            if (ost->sync_ist != ist_table[ost->source_index])
2487
                fprintf(stderr, " [sync #%d.%d]",
2488
                        ost->sync_ist->file_index,
2489
                        ost->sync_ist->index);
2490
            fprintf(stderr, "\n");
2491
        }
2492
    }
2493

    
2494
    if (ret) {
2495
        fprintf(stderr, "%s\n", error);
2496
        goto fail;
2497
    }
2498

    
2499
    if (want_sdp) {
2500
        print_sdp(output_files, nb_output_files);
2501
    }
2502

    
2503
    if (!using_stdin && verbose >= 0) {
2504
        fprintf(stderr, "Press [q] to stop encoding\n");
2505
        url_set_interrupt_cb(decode_interrupt_cb);
2506
    }
2507
    term_init();
2508

    
2509
    timer_start = av_gettime();
2510

    
2511
    for(; received_sigterm == 0;) {
2512
        int file_index, ist_index;
2513
        AVPacket pkt;
2514
        double ipts_min;
2515
        double opts_min;
2516

    
2517
    redo:
2518
        ipts_min= 1e100;
2519
        opts_min= 1e100;
2520
        /* if 'q' pressed, exits */
2521
        if (!using_stdin) {
2522
            if (q_pressed)
2523
                break;
2524
            /* read_key() returns 0 on EOF */
2525
            key = read_key();
2526
            if (key == 'q')
2527
                break;
2528
        }
2529

    
2530
        /* select the stream that we must read now by looking at the
2531
           smallest output pts */
2532
        file_index = -1;
2533
        for(i=0;i<nb_ostreams;i++) {
2534
            double ipts, opts;
2535
            ost = ost_table[i];
2536
            os = output_files[ost->file_index];
2537
            ist = ist_table[ost->source_index];
2538
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2539
                continue;
2540
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2541
            ipts = (double)ist->pts;
2542
            if (!file_table[ist->file_index].eof_reached){
2543
                if(ipts < ipts_min) {
2544
                    ipts_min = ipts;
2545
                    if(input_sync ) file_index = ist->file_index;
2546
                }
2547
                if(opts < opts_min) {
2548
                    opts_min = opts;
2549
                    if(!input_sync) file_index = ist->file_index;
2550
                }
2551
            }
2552
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2553
                file_index= -1;
2554
                break;
2555
            }
2556
        }
2557
        /* if none, if is finished */
2558
        if (file_index < 0) {
2559
            if(no_packet_count){
2560
                no_packet_count=0;
2561
                memset(no_packet, 0, sizeof(no_packet));
2562
                usleep(10000);
2563
                continue;
2564
            }
2565
            break;
2566
        }
2567

    
2568
        /* finish if limit size exhausted */
2569
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2570
            break;
2571

    
2572
        /* read a frame from it and output it in the fifo */
2573
        is = input_files[file_index];
2574
        ret= av_read_frame(is, &pkt);
2575
        if(ret == AVERROR(EAGAIN)){
2576
            no_packet[file_index]=1;
2577
            no_packet_count++;
2578
            continue;
2579
        }
2580
        if (ret < 0) {
2581
            file_table[file_index].eof_reached = 1;
2582
            if (opt_shortest)
2583
                break;
2584
            else
2585
                continue;
2586
        }
2587

    
2588
        no_packet_count=0;
2589
        memset(no_packet, 0, sizeof(no_packet));
2590

    
2591
        if (do_pkt_dump) {
2592
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2593
        }
2594
        /* the following test is needed in case new streams appear
2595
           dynamically in stream : we ignore them */
2596
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2597
            goto discard_packet;
2598
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2599
        ist = ist_table[ist_index];
2600
        if (ist->discard)
2601
            goto discard_packet;
2602

    
2603
        if (pkt.dts != AV_NOPTS_VALUE)
2604
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2605
        if (pkt.pts != AV_NOPTS_VALUE)
2606
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2607

    
2608
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2609
            && input_files_ts_scale[file_index][pkt.stream_index]){
2610
            if(pkt.pts != AV_NOPTS_VALUE)
2611
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2612
            if(pkt.dts != AV_NOPTS_VALUE)
2613
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2614
        }
2615

    
2616
//        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);
2617
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2618
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2619
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2620
            int64_t delta= pkt_dts - ist->next_pts;
2621
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2622
                input_files_ts_offset[ist->file_index]-= delta;
2623
                if (verbose > 2)
2624
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2625
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2626
                if(pkt.pts != AV_NOPTS_VALUE)
2627
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2628
            }
2629
        }
2630

    
2631
        /* finish if recording time exhausted */
2632
        if (recording_time != INT64_MAX &&
2633
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2634
            ist->is_past_recording_time = 1;
2635
            goto discard_packet;
2636
        }
2637

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

    
2641
            if (verbose >= 0)
2642
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2643
                        ist->file_index, ist->index);
2644
            if (exit_on_error)
2645
                ffmpeg_exit(1);
2646
            av_free_packet(&pkt);
2647
            goto redo;
2648
        }
2649

    
2650
    discard_packet:
2651
        av_free_packet(&pkt);
2652

    
2653
        /* dump report by using the output first video and audio streams */
2654
        print_report(output_files, ost_table, nb_ostreams, 0);
2655
    }
2656

    
2657
    /* at the end of stream, we must flush the decoder buffers */
2658
    for(i=0;i<nb_istreams;i++) {
2659
        ist = ist_table[i];
2660
        if (ist->decoding_needed) {
2661
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2662
        }
2663
    }
2664

    
2665
    term_exit();
2666

    
2667
    /* write the trailer if needed and close file */
2668
    for(i=0;i<nb_output_files;i++) {
2669
        os = output_files[i];
2670
        av_write_trailer(os);
2671
    }
2672

    
2673
    /* dump report by using the first video and audio streams */
2674
    print_report(output_files, ost_table, nb_ostreams, 1);
2675

    
2676
    /* close each encoder */
2677
    for(i=0;i<nb_ostreams;i++) {
2678
        ost = ost_table[i];
2679
        if (ost->encoding_needed) {
2680
            av_freep(&ost->st->codec->stats_in);
2681
            avcodec_close(ost->st->codec);
2682
        }
2683
    }
2684

    
2685
    /* close each decoder */
2686
    for(i=0;i<nb_istreams;i++) {
2687
        ist = ist_table[i];
2688
        if (ist->decoding_needed) {
2689
            avcodec_close(ist->st->codec);
2690
        }
2691
    }
2692
#if CONFIG_AVFILTER
2693
    if (graph) {
2694
        avfilter_graph_destroy(graph);
2695
        av_freep(&graph);
2696
    }
2697
#endif
2698

    
2699
    /* finished ! */
2700
    ret = 0;
2701

    
2702
 fail:
2703
    av_freep(&bit_buffer);
2704
    av_free(file_table);
2705

    
2706
    if (ist_table) {
2707
        for(i=0;i<nb_istreams;i++) {
2708
            ist = ist_table[i];
2709
            av_free(ist);
2710
        }
2711
        av_free(ist_table);
2712
    }
2713
    if (ost_table) {
2714
        for(i=0;i<nb_ostreams;i++) {
2715
            ost = ost_table[i];
2716
            if (ost) {
2717
                if (ost->st->stream_copy)
2718
                    av_freep(&ost->st->codec->extradata);
2719
                if (ost->logfile) {
2720
                    fclose(ost->logfile);
2721
                    ost->logfile = NULL;
2722
                }
2723
                av_fifo_free(ost->fifo); /* works even if fifo is not
2724
                                             initialized but set to zero */
2725
                av_free(ost->pict_tmp.data[0]);
2726
                if (ost->video_resample)
2727
                    sws_freeContext(ost->img_resample_ctx);
2728
                if (ost->resample)
2729
                    audio_resample_close(ost->resample);
2730
                if (ost->reformat_ctx)
2731
                    av_audio_convert_free(ost->reformat_ctx);
2732
                av_free(ost);
2733
            }
2734
        }
2735
        av_free(ost_table);
2736
    }
2737
    return ret;
2738
}
2739

    
2740
static void opt_format(const char *arg)
2741
{
2742
    /* compatibility stuff for pgmyuv */
2743
    if (!strcmp(arg, "pgmyuv")) {
2744
        pgmyuv_compatibility_hack=1;
2745
//        opt_image_format(arg);
2746
        arg = "image2";
2747
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2748
    }
2749

    
2750
    last_asked_format = arg;
2751
}
2752

    
2753
static void opt_video_rc_override_string(const char *arg)
2754
{
2755
    video_rc_override_string = arg;
2756
}
2757

    
2758
static int opt_me_threshold(const char *opt, const char *arg)
2759
{
2760
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2761
    return 0;
2762
}
2763

    
2764
static int opt_verbose(const char *opt, const char *arg)
2765
{
2766
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2767
    return 0;
2768
}
2769

    
2770
static int opt_frame_rate(const char *opt, const char *arg)
2771
{
2772
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2773
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2774
        ffmpeg_exit(1);
2775
    }
2776
    return 0;
2777
}
2778

    
2779
static int opt_bitrate(const char *opt, const char *arg)
2780
{
2781
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2782

    
2783
    opt_default(opt, arg);
2784

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

    
2788
    return 0;
2789
}
2790

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

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

    
2821
static void opt_frame_crop_left(const char *arg)
2822
{
2823
    frame_leftBand = atoi(arg);
2824
    if (frame_leftBand < 0) {
2825
        fprintf(stderr, "Incorrect left crop size\n");
2826
        ffmpeg_exit(1);
2827
    }
2828
    if ((frame_leftBand) >= frame_width){
2829
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2830
        ffmpeg_exit(1);
2831
    }
2832
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2833
    frame_width -= frame_leftBand;
2834
}
2835

    
2836
static void opt_frame_crop_right(const char *arg)
2837
{
2838
    frame_rightBand = atoi(arg);
2839
    if (frame_rightBand < 0) {
2840
        fprintf(stderr, "Incorrect right crop size\n");
2841
        ffmpeg_exit(1);
2842
    }
2843
    if ((frame_rightBand) >= frame_width){
2844
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2845
        ffmpeg_exit(1);
2846
    }
2847
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2848
    frame_width -= frame_rightBand;
2849
}
2850

    
2851
static void opt_frame_size(const char *arg)
2852
{
2853
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2854
        fprintf(stderr, "Incorrect frame size\n");
2855
        ffmpeg_exit(1);
2856
    }
2857
}
2858

    
2859
static int opt_pad(const char *opt, const char *arg) {
2860
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2861
    return -1;
2862
}
2863

    
2864
static void opt_frame_pix_fmt(const char *arg)
2865
{
2866
    if (strcmp(arg, "list")) {
2867
        frame_pix_fmt = av_get_pix_fmt(arg);
2868
        if (frame_pix_fmt == PIX_FMT_NONE) {
2869
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2870
            ffmpeg_exit(1);
2871
        }
2872
    } else {
2873
        show_pix_fmts();
2874
        ffmpeg_exit(0);
2875
    }
2876
}
2877

    
2878
static void opt_frame_aspect_ratio(const char *arg)
2879
{
2880
    int x = 0, y = 0;
2881
    double ar = 0;
2882
    const char *p;
2883
    char *end;
2884

    
2885
    p = strchr(arg, ':');
2886
    if (p) {
2887
        x = strtol(arg, &end, 10);
2888
        if (end == p)
2889
            y = strtol(end+1, &end, 10);
2890
        if (x > 0 && y > 0)
2891
            ar = (double)x / (double)y;
2892
    } else
2893
        ar = strtod(arg, NULL);
2894

    
2895
    if (!ar) {
2896
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2897
        ffmpeg_exit(1);
2898
    }
2899
    frame_aspect_ratio = ar;
2900
}
2901

    
2902
static int opt_metadata(const char *opt, const char *arg)
2903
{
2904
    char *mid= strchr(arg, '=');
2905

    
2906
    if(!mid){
2907
        fprintf(stderr, "Missing =\n");
2908
        ffmpeg_exit(1);
2909
    }
2910
    *mid++= 0;
2911

    
2912
    metadata_count++;
2913
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2914
    metadata[metadata_count-1].key  = av_strdup(arg);
2915
    metadata[metadata_count-1].value= av_strdup(mid);
2916

    
2917
    return 0;
2918
}
2919

    
2920
static void opt_qscale(const char *arg)
2921
{
2922
    video_qscale = atof(arg);
2923
    if (video_qscale <= 0 ||
2924
        video_qscale > 255) {
2925
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2926
        ffmpeg_exit(1);
2927
    }
2928
}
2929

    
2930
static void opt_top_field_first(const char *arg)
2931
{
2932
    top_field_first= atoi(arg);
2933
}
2934

    
2935
static int opt_thread_count(const char *opt, const char *arg)
2936
{
2937
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2938
#if !HAVE_THREADS
2939
    if (verbose >= 0)
2940
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2941
#endif
2942
    return 0;
2943
}
2944

    
2945
static void opt_audio_sample_fmt(const char *arg)
2946
{
2947
    if (strcmp(arg, "list"))
2948
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2949
    else {
2950
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2951
        ffmpeg_exit(0);
2952
    }
2953
}
2954

    
2955
static int opt_audio_rate(const char *opt, const char *arg)
2956
{
2957
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2958
    return 0;
2959
}
2960

    
2961
static int opt_audio_channels(const char *opt, const char *arg)
2962
{
2963
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2964
    return 0;
2965
}
2966

    
2967
static void opt_video_channel(const char *arg)
2968
{
2969
    video_channel = strtol(arg, NULL, 0);
2970
}
2971

    
2972
static void opt_video_standard(const char *arg)
2973
{
2974
    video_standard = av_strdup(arg);
2975
}
2976

    
2977
static void opt_codec(int *pstream_copy, char **pcodec_name,
2978
                      int codec_type, const char *arg)
2979
{
2980
    av_freep(pcodec_name);
2981
    if (!strcmp(arg, "copy")) {
2982
        *pstream_copy = 1;
2983
    } else {
2984
        *pcodec_name = av_strdup(arg);
2985
    }
2986
}
2987

    
2988
static void opt_audio_codec(const char *arg)
2989
{
2990
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2991
}
2992

    
2993
static void opt_audio_tag(const char *arg)
2994
{
2995
    char *tail;
2996
    audio_codec_tag= strtol(arg, &tail, 0);
2997

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

    
3002
static void opt_video_tag(const char *arg)
3003
{
3004
    char *tail;
3005
    video_codec_tag= strtol(arg, &tail, 0);
3006

    
3007
    if(!tail || *tail)
3008
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3009
}
3010

    
3011
static void opt_video_codec(const char *arg)
3012
{
3013
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3014
}
3015

    
3016
static void opt_subtitle_codec(const char *arg)
3017
{
3018
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3019
}
3020

    
3021
static void opt_subtitle_tag(const char *arg)
3022
{
3023
    char *tail;
3024
    subtitle_codec_tag= strtol(arg, &tail, 0);
3025

    
3026
    if(!tail || *tail)
3027
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3028
}
3029

    
3030
static void opt_map(const char *arg)
3031
{
3032
    AVStreamMap *m;
3033
    char *p;
3034

    
3035
    m = &stream_maps[nb_stream_maps++];
3036

    
3037
    m->file_index = strtol(arg, &p, 0);
3038
    if (*p)
3039
        p++;
3040

    
3041
    m->stream_index = strtol(p, &p, 0);
3042
    if (*p) {
3043
        p++;
3044
        m->sync_file_index = strtol(p, &p, 0);
3045
        if (*p)
3046
            p++;
3047
        m->sync_stream_index = strtol(p, &p, 0);
3048
    } else {
3049
        m->sync_file_index = m->file_index;
3050
        m->sync_stream_index = m->stream_index;
3051
    }
3052
}
3053

    
3054
static void opt_map_meta_data(const char *arg)
3055
{
3056
    AVMetaDataMap *m;
3057
    char *p;
3058

    
3059
    m = &meta_data_maps[nb_meta_data_maps++];
3060

    
3061
    m->out_file = strtol(arg, &p, 0);
3062
    if (*p)
3063
        p++;
3064

    
3065
    m->in_file = strtol(p, &p, 0);
3066
}
3067

    
3068
static void opt_input_ts_scale(const char *arg)
3069
{
3070
    unsigned int stream;
3071
    double scale;
3072
    char *p;
3073

    
3074
    stream = strtol(arg, &p, 0);
3075
    if (*p)
3076
        p++;
3077
    scale= strtod(p, &p);
3078

    
3079
    if(stream >= MAX_STREAMS)
3080
        ffmpeg_exit(1);
3081

    
3082
    input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3083
    input_files_ts_scale[nb_input_files][stream]= scale;
3084
}
3085

    
3086
static int opt_recording_time(const char *opt, const char *arg)
3087
{
3088
    recording_time = parse_time_or_die(opt, arg, 1);
3089
    return 0;
3090
}
3091

    
3092
static int opt_start_time(const char *opt, const char *arg)
3093
{
3094
    start_time = parse_time_or_die(opt, arg, 1);
3095
    return 0;
3096
}
3097

    
3098
static int opt_recording_timestamp(const char *opt, const char *arg)
3099
{
3100
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3101
    return 0;
3102
}
3103

    
3104
static int opt_input_ts_offset(const char *opt, const char *arg)
3105
{
3106
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3107
    return 0;
3108
}
3109

    
3110
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3111
{
3112
    const char *codec_string = encoder ? "encoder" : "decoder";
3113
    AVCodec *codec;
3114

    
3115
    if(!name)
3116
        return CODEC_ID_NONE;
3117
    codec = encoder ?
3118
        avcodec_find_encoder_by_name(name) :
3119
        avcodec_find_decoder_by_name(name);
3120
    if(!codec) {
3121
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3122
        ffmpeg_exit(1);
3123
    }
3124
    if(codec->type != type) {
3125
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3126
        ffmpeg_exit(1);
3127
    }
3128
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3129
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3130
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3131
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3132
                codec_string, codec->name);
3133
        codec = encoder ?
3134
            avcodec_find_encoder(codec->id) :
3135
            avcodec_find_decoder(codec->id);
3136
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3137
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3138
                    codec_string, codec->name);
3139
        ffmpeg_exit(1);
3140
    }
3141
    return codec->id;
3142
}
3143

    
3144
static void opt_input_file(const char *filename)
3145
{
3146
    AVFormatContext *ic;
3147
    AVFormatParameters params, *ap = &params;
3148
    AVInputFormat *file_iformat = NULL;
3149
    int err, i, ret, rfps, rfps_base;
3150
    int64_t timestamp;
3151

    
3152
    if (last_asked_format) {
3153
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3154
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3155
            ffmpeg_exit(1);
3156
        }
3157
        last_asked_format = NULL;
3158
    }
3159

    
3160
    if (!strcmp(filename, "-"))
3161
        filename = "pipe:";
3162

    
3163
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3164
                    !strcmp(filename, "/dev/stdin");
3165

    
3166
    /* get default parameters from command line */
3167
    ic = avformat_alloc_context();
3168
    if (!ic) {
3169
        print_error(filename, AVERROR(ENOMEM));
3170
        ffmpeg_exit(1);
3171
    }
3172

    
3173
    memset(ap, 0, sizeof(*ap));
3174
    ap->prealloced_context = 1;
3175
    ap->sample_rate = audio_sample_rate;
3176
    ap->channels = audio_channels;
3177
    ap->time_base.den = frame_rate.num;
3178
    ap->time_base.num = frame_rate.den;
3179
    ap->width = frame_width;
3180
    ap->height = frame_height;
3181
    ap->pix_fmt = frame_pix_fmt;
3182
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3183
    ap->channel = video_channel;
3184
    ap->standard = video_standard;
3185

    
3186
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3187

    
3188
    ic->video_codec_id   =
3189
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3190
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3191
    ic->audio_codec_id   =
3192
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3193
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3194
    ic->subtitle_codec_id=
3195
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3196
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3197
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3198

    
3199
    if(pgmyuv_compatibility_hack)
3200
        ic->video_codec_id= CODEC_ID_PGMYUV;
3201

    
3202
    /* open the input file with generic libav function */
3203
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3204
    if (err < 0) {
3205
        print_error(filename, err);
3206
        ffmpeg_exit(1);
3207
    }
3208
    if(opt_programid) {
3209
        int i, j;
3210
        int found=0;
3211
        for(i=0; i<ic->nb_streams; i++){
3212
            ic->streams[i]->discard= AVDISCARD_ALL;
3213
        }
3214
        for(i=0; i<ic->nb_programs; i++){
3215
            AVProgram *p= ic->programs[i];
3216
            if(p->id != opt_programid){
3217
                p->discard = AVDISCARD_ALL;
3218
            }else{
3219
                found=1;
3220
                for(j=0; j<p->nb_stream_indexes; j++){
3221
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3222
                }
3223
            }
3224
        }
3225
        if(!found){
3226
            fprintf(stderr, "Specified program id not found\n");
3227
            ffmpeg_exit(1);
3228
        }
3229
        opt_programid=0;
3230
    }
3231

    
3232
    ic->loop_input = loop_input;
3233

    
3234
    /* If not enough info to get the stream parameters, we decode the
3235
       first frames to get it. (used in mpeg case for example) */
3236
    ret = av_find_stream_info(ic);
3237
    if (ret < 0 && verbose >= 0) {
3238
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3239
        av_close_input_file(ic);
3240
        ffmpeg_exit(1);
3241
    }
3242

    
3243
    timestamp = start_time;
3244
    /* add the stream start time */
3245
    if (ic->start_time != AV_NOPTS_VALUE)
3246
        timestamp += ic->start_time;
3247

    
3248
    /* if seeking requested, we execute it */
3249
    if (start_time != 0) {
3250
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3251
        if (ret < 0) {
3252
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3253
                    filename, (double)timestamp / AV_TIME_BASE);
3254
        }
3255
        /* reset seek info */
3256
        start_time = 0;
3257
    }
3258

    
3259
    /* update the current parameters so that they match the one of the input stream */
3260
    for(i=0;i<ic->nb_streams;i++) {
3261
        AVStream *st = ic->streams[i];
3262
        AVCodecContext *dec = st->codec;
3263
        avcodec_thread_init(dec, thread_count);
3264
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3265
        switch (dec->codec_type) {
3266
        case AVMEDIA_TYPE_AUDIO:
3267
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3268
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3269
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3270
            channel_layout    = dec->channel_layout;
3271
            audio_channels    = dec->channels;
3272
            audio_sample_rate = dec->sample_rate;
3273
            audio_sample_fmt  = dec->sample_fmt;
3274
            if(audio_disable)
3275
                st->discard= AVDISCARD_ALL;
3276
            /* Note that av_find_stream_info can add more streams, and we
3277
             * currently have no chance of setting up lowres decoding
3278
             * early enough for them. */
3279
            if (dec->lowres)
3280
                audio_sample_rate >>= dec->lowres;
3281
            break;
3282
        case AVMEDIA_TYPE_VIDEO:
3283
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3284
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3285
            frame_height = dec->height;
3286
            frame_width  = dec->width;
3287
            if(ic->streams[i]->sample_aspect_ratio.num)
3288
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3289
            else
3290
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3291
            frame_aspect_ratio *= (float) dec->width / dec->height;
3292
            frame_pix_fmt = dec->pix_fmt;
3293
            rfps      = ic->streams[i]->r_frame_rate.num;
3294
            rfps_base = ic->streams[i]->r_frame_rate.den;
3295
            if (dec->lowres) {
3296
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3297
                frame_height >>= dec->lowres;
3298
                frame_width  >>= dec->lowres;
3299
            }
3300
            if(me_threshold)
3301
                dec->debug |= FF_DEBUG_MV;
3302

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

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

    
3309
                    (float)rfps / rfps_base, rfps, rfps_base);
3310
            }
3311
            /* update the current frame rate to match the stream frame rate */
3312
            frame_rate.num = rfps;
3313
            frame_rate.den = rfps_base;
3314

    
3315
            if(video_disable)
3316
                st->discard= AVDISCARD_ALL;
3317
            else if(video_discard)
3318
                st->discard= video_discard;
3319
            break;
3320
        case AVMEDIA_TYPE_DATA:
3321
            break;
3322
        case AVMEDIA_TYPE_SUBTITLE:
3323
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3324
            if(subtitle_disable)
3325
                st->discard = AVDISCARD_ALL;
3326
            break;
3327
        case AVMEDIA_TYPE_ATTACHMENT:
3328
        case AVMEDIA_TYPE_UNKNOWN:
3329
            break;
3330
        default:
3331
            abort();
3332
        }
3333
    }
3334

    
3335
    input_files[nb_input_files] = ic;
3336
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3337
    /* dump the file content */
3338
    if (verbose >= 0)
3339
        dump_format(ic, nb_input_files, filename, 0);
3340

    
3341
    nb_input_files++;
3342

    
3343
    video_channel = 0;
3344

    
3345
    av_freep(&video_codec_name);
3346
    av_freep(&audio_codec_name);
3347
    av_freep(&subtitle_codec_name);
3348
}
3349

    
3350
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3351
                                         int *has_subtitle_ptr)
3352
{
3353
    int has_video, has_audio, has_subtitle, i, j;
3354
    AVFormatContext *ic;
3355

    
3356
    has_video = 0;
3357
    has_audio = 0;
3358
    has_subtitle = 0;
3359
    for(j=0;j<nb_input_files;j++) {
3360
        ic = input_files[j];
3361
        for(i=0;i<ic->nb_streams;i++) {
3362
            AVCodecContext *enc = ic->streams[i]->codec;
3363
            switch(enc->codec_type) {
3364
            case AVMEDIA_TYPE_AUDIO:
3365
                has_audio = 1;
3366
                break;
3367
            case AVMEDIA_TYPE_VIDEO:
3368
                has_video = 1;
3369
                break;
3370
            case AVMEDIA_TYPE_SUBTITLE:
3371
                has_subtitle = 1;
3372
                break;
3373
            case AVMEDIA_TYPE_DATA:
3374
            case AVMEDIA_TYPE_ATTACHMENT:
3375
            case AVMEDIA_TYPE_UNKNOWN:
3376
                break;
3377
            default:
3378
                abort();
3379
            }
3380
        }
3381
    }
3382
    *has_video_ptr = has_video;
3383
    *has_audio_ptr = has_audio;
3384
    *has_subtitle_ptr = has_subtitle;
3385
}
3386

    
3387
static void new_video_stream(AVFormatContext *oc)
3388
{
3389
    AVStream *st;
3390
    AVCodecContext *video_enc;
3391
    enum CodecID codec_id;
3392
    AVCodec *codec= NULL;
3393

    
3394
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3395
    if (!st) {
3396
        fprintf(stderr, "Could not alloc stream\n");
3397
        ffmpeg_exit(1);
3398
    }
3399

    
3400
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3401
    if(!video_stream_copy){
3402
        if (video_codec_name) {
3403
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3404
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3405
            codec = avcodec_find_encoder_by_name(video_codec_name);
3406
            output_codecs[nb_output_codecs-1] = codec;
3407
        } else {
3408
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3409
            codec = avcodec_find_encoder(codec_id);
3410
        }
3411
    }
3412

    
3413
    avcodec_get_context_defaults3(st->codec, codec);
3414
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3415
    video_bitstream_filters= NULL;
3416

    
3417
    avcodec_thread_init(st->codec, thread_count);
3418

    
3419
    video_enc = st->codec;
3420

    
3421
    if(video_codec_tag)
3422
        video_enc->codec_tag= video_codec_tag;
3423

    
3424
    if(   (video_global_header&1)
3425
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3426
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3427
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3428
    }
3429
    if(video_global_header&2){
3430
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3431
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3432
    }
3433

    
3434
    if (video_stream_copy) {
3435
        st->stream_copy = 1;
3436
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3437
        video_enc->sample_aspect_ratio =
3438
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3439
    } else {
3440
        const char *p;
3441
        int i;
3442
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3443

    
3444
        video_enc->codec_id = codec_id;
3445
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3446

    
3447
        if (codec && codec->supported_framerates && !force_fps)
3448
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3449
        video_enc->time_base.den = fps.num;
3450
        video_enc->time_base.num = fps.den;
3451

    
3452
        video_enc->width = frame_width;
3453
        video_enc->height = frame_height;
3454
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3455
        video_enc->pix_fmt = frame_pix_fmt;
3456
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3457

    
3458
        choose_pixel_fmt(st, codec);
3459

    
3460
        if (intra_only)
3461
            video_enc->gop_size = 0;
3462
        if (video_qscale || same_quality) {
3463
            video_enc->flags |= CODEC_FLAG_QSCALE;
3464
            video_enc->global_quality=
3465
                st->quality = FF_QP2LAMBDA * video_qscale;
3466
        }
3467

    
3468
        if(intra_matrix)
3469
            video_enc->intra_matrix = intra_matrix;
3470
        if(inter_matrix)
3471
            video_enc->inter_matrix = inter_matrix;
3472

    
3473
        p= video_rc_override_string;
3474
        for(i=0; p; i++){
3475
            int start, end, q;
3476
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3477
            if(e!=3){
3478
                fprintf(stderr, "error parsing rc_override\n");
3479
                ffmpeg_exit(1);
3480
            }
3481
            video_enc->rc_override=
3482
                av_realloc(video_enc->rc_override,
3483
                           sizeof(RcOverride)*(i+1));
3484
            video_enc->rc_override[i].start_frame= start;
3485
            video_enc->rc_override[i].end_frame  = end;
3486
            if(q>0){
3487
                video_enc->rc_override[i].qscale= q;
3488
                video_enc->rc_override[i].quality_factor= 1.0;
3489
            }
3490
            else{
3491
                video_enc->rc_override[i].qscale= 0;
3492
                video_enc->rc_override[i].quality_factor= -q/100.0;
3493
            }
3494
            p= strchr(p, '/');
3495
            if(p) p++;
3496
        }
3497
        video_enc->rc_override_count=i;
3498
        if (!video_enc->rc_initial_buffer_occupancy)
3499
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3500
        video_enc->me_threshold= me_threshold;
3501
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3502

    
3503
        if (do_psnr)
3504
            video_enc->flags|= CODEC_FLAG_PSNR;
3505

    
3506
        /* two pass mode */
3507
        if (do_pass) {
3508
            if (do_pass == 1) {
3509
                video_enc->flags |= CODEC_FLAG_PASS1;
3510
            } else {
3511
                video_enc->flags |= CODEC_FLAG_PASS2;
3512
            }
3513
        }
3514
    }
3515
    if (video_language) {
3516
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3517
        av_freep(&video_language);
3518
    }
3519

    
3520
    /* reset some key parameters */
3521
    video_disable = 0;
3522
    av_freep(&video_codec_name);
3523
    video_stream_copy = 0;
3524
    frame_pix_fmt = PIX_FMT_NONE;
3525
}
3526

    
3527
static void new_audio_stream(AVFormatContext *oc)
3528
{
3529
    AVStream *st;
3530
    AVCodec *codec= NULL;
3531
    AVCodecContext *audio_enc;
3532
    enum CodecID codec_id;
3533

    
3534
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3535
    if (!st) {
3536
        fprintf(stderr, "Could not alloc stream\n");
3537
        ffmpeg_exit(1);
3538
    }
3539

    
3540
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3541
    if(!audio_stream_copy){
3542
        if (audio_codec_name) {
3543
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3544
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3545
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3546
            output_codecs[nb_output_codecs-1] = codec;
3547
        } else {
3548
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3549
            codec = avcodec_find_encoder(codec_id);
3550
        }
3551
    }
3552

    
3553
    avcodec_get_context_defaults3(st->codec, codec);
3554

    
3555
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3556
    audio_bitstream_filters= NULL;
3557

    
3558
    avcodec_thread_init(st->codec, thread_count);
3559

    
3560
    audio_enc = st->codec;
3561
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3562

    
3563
    if(audio_codec_tag)
3564
        audio_enc->codec_tag= audio_codec_tag;
3565

    
3566
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3567
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3568
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3569
    }
3570
    if (audio_stream_copy) {
3571
        st->stream_copy = 1;
3572
        audio_enc->channels = audio_channels;
3573
        audio_enc->sample_rate = audio_sample_rate;
3574
    } else {
3575
        audio_enc->codec_id = codec_id;
3576
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3577

    
3578
        if (audio_qscale > QSCALE_NONE) {
3579
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3580
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3581
        }
3582
        audio_enc->channels = audio_channels;
3583
        audio_enc->sample_fmt = audio_sample_fmt;
3584
        audio_enc->sample_rate = audio_sample_rate;
3585
        audio_enc->channel_layout = channel_layout;
3586
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3587
            audio_enc->channel_layout = 0;
3588
        choose_sample_fmt(st, codec);
3589
        choose_sample_rate(st, codec);
3590
    }
3591
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3592
    if (audio_language) {
3593
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3594
        av_freep(&audio_language);
3595
    }
3596

    
3597
    /* reset some key parameters */
3598
    audio_disable = 0;
3599
    av_freep(&audio_codec_name);
3600
    audio_stream_copy = 0;
3601
}
3602

    
3603
static void new_subtitle_stream(AVFormatContext *oc)
3604
{
3605
    AVStream *st;
3606
    AVCodec *codec=NULL;
3607
    AVCodecContext *subtitle_enc;
3608

    
3609
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3610
    if (!st) {
3611
        fprintf(stderr, "Could not alloc stream\n");
3612
        ffmpeg_exit(1);
3613
    }
3614
    subtitle_enc = st->codec;
3615
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3616
    if(!subtitle_stream_copy){
3617
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3618
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3619
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3620
    }
3621
    avcodec_get_context_defaults3(st->codec, codec);
3622

    
3623
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3624
    subtitle_bitstream_filters= NULL;
3625

    
3626
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3627

    
3628
    if(subtitle_codec_tag)
3629
        subtitle_enc->codec_tag= subtitle_codec_tag;
3630

    
3631
    if (subtitle_stream_copy) {
3632
        st->stream_copy = 1;
3633
    } else {
3634
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3635
    }
3636

    
3637
    if (subtitle_language) {
3638
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3639
        av_freep(&subtitle_language);
3640
    }
3641

    
3642
    subtitle_disable = 0;
3643
    av_freep(&subtitle_codec_name);
3644
    subtitle_stream_copy = 0;
3645
}
3646

    
3647
static void opt_new_stream(const char *opt, const char *arg)
3648
{
3649
    AVFormatContext *oc;
3650
    if (nb_output_files <= 0) {
3651
        fprintf(stderr, "At least one output file must be specified\n");
3652
        ffmpeg_exit(1);
3653
    }
3654
    oc = output_files[nb_output_files - 1];
3655

    
3656
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc);
3657
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc);
3658
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc);
3659
    else av_assert0(0);
3660
}
3661

    
3662
/* arg format is "output-stream-index:streamid-value". */
3663
static void opt_streamid(const char *opt, const char *arg)
3664
{
3665
    int idx;
3666
    char *p;
3667
    char idx_str[16];
3668

    
3669
    strncpy(idx_str, arg, sizeof(idx_str));
3670
    idx_str[sizeof(idx_str)-1] = '\0';
3671
    p = strchr(idx_str, ':');
3672
    if (!p) {
3673
        fprintf(stderr,
3674
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3675
                arg, opt);
3676
        ffmpeg_exit(1);
3677
    }
3678
    *p++ = '\0';
3679
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3680
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3681
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3682
}
3683

    
3684
static void opt_output_file(const char *filename)
3685
{
3686
    AVFormatContext *oc;
3687
    int err, use_video, use_audio, use_subtitle;
3688
    int input_has_video, input_has_audio, input_has_subtitle;
3689
    AVFormatParameters params, *ap = &params;
3690
    AVOutputFormat *file_oformat;
3691

    
3692
    if (!strcmp(filename, "-"))
3693
        filename = "pipe:";
3694

    
3695
    oc = avformat_alloc_context();
3696
    if (!oc) {
3697
        print_error(filename, AVERROR(ENOMEM));
3698
        ffmpeg_exit(1);
3699
    }
3700

    
3701
    if (last_asked_format) {
3702
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3703
        if (!file_oformat) {
3704
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3705
            ffmpeg_exit(1);
3706
        }
3707
        last_asked_format = NULL;
3708
    } else {
3709
        file_oformat = av_guess_format(NULL, filename, NULL);
3710
        if (!file_oformat) {
3711
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3712
                    filename);
3713
            ffmpeg_exit(1);
3714
        }
3715
    }
3716

    
3717
    oc->oformat = file_oformat;
3718
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3719

    
3720
    if (!strcmp(file_oformat->name, "ffm") &&
3721
        av_strstart(filename, "http:", NULL)) {
3722
        /* special case for files sent to ffserver: we get the stream
3723
           parameters from ffserver */
3724
        int err = read_ffserver_streams(oc, filename);
3725
        if (err < 0) {
3726
            print_error(filename, err);
3727
            ffmpeg_exit(1);
3728
        }
3729
    } else {
3730
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3731
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3732
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3733

    
3734
        /* disable if no corresponding type found and at least one
3735
           input file */
3736
        if (nb_input_files > 0) {
3737
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3738
                                         &input_has_subtitle);
3739
            if (!input_has_video)
3740
                use_video = 0;
3741
            if (!input_has_audio)
3742
                use_audio = 0;
3743
            if (!input_has_subtitle)
3744
                use_subtitle = 0;
3745
        }
3746

    
3747
        /* manual disable */
3748
        if (audio_disable) {
3749
            use_audio = 0;
3750
        }
3751
        if (video_disable) {
3752
            use_video = 0;
3753
        }
3754
        if (subtitle_disable) {
3755
            use_subtitle = 0;
3756
        }
3757

    
3758
        if (use_video) {
3759
            new_video_stream(oc);
3760
        }
3761

    
3762
        if (use_audio) {
3763
            new_audio_stream(oc);
3764
        }
3765

    
3766
        if (use_subtitle) {
3767
            new_subtitle_stream(oc);
3768
        }
3769

    
3770
        oc->timestamp = recording_timestamp;
3771

    
3772
        for(; metadata_count>0; metadata_count--){
3773
            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3774
                                            metadata[metadata_count-1].value, 0);
3775
        }
3776
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3777
    }
3778

    
3779
    output_files[nb_output_files++] = oc;
3780

    
3781
    /* check filename in case of an image number is expected */
3782
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3783
        if (!av_filename_number_test(oc->filename)) {
3784
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3785
            ffmpeg_exit(1);
3786
        }
3787
    }
3788

    
3789
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3790
        /* test if it already exists to avoid loosing precious files */
3791
        if (!file_overwrite &&
3792
            (strchr(filename, ':') == NULL ||
3793
             filename[1] == ':' ||
3794
             av_strstart(filename, "file:", NULL))) {
3795
            if (url_exist(filename)) {
3796
                if (!using_stdin) {
3797
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3798
                    fflush(stderr);
3799
                    if (!read_yesno()) {
3800
                        fprintf(stderr, "Not overwriting - exiting\n");
3801
                        ffmpeg_exit(1);
3802
                    }
3803
                }
3804
                else {
3805
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3806
                    ffmpeg_exit(1);
3807
                }
3808
            }
3809
        }
3810

    
3811
        /* open the file */
3812
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3813
            print_error(filename, err);
3814
            ffmpeg_exit(1);
3815
        }
3816
    }
3817

    
3818
    memset(ap, 0, sizeof(*ap));
3819
    if (av_set_parameters(oc, ap) < 0) {
3820
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3821
                oc->filename);
3822
        ffmpeg_exit(1);
3823
    }
3824

    
3825
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3826
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3827
    oc->loop_output = loop_output;
3828
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3829

    
3830
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3831

    
3832
    nb_streamid_map = 0;
3833
}
3834

    
3835
/* same option as mencoder */
3836
static void opt_pass(const char *pass_str)
3837
{
3838
    int pass;
3839
    pass = atoi(pass_str);
3840
    if (pass != 1 && pass != 2) {
3841
        fprintf(stderr, "pass number can be only 1 or 2\n");
3842
        ffmpeg_exit(1);
3843
    }
3844
    do_pass = pass;
3845
}
3846

    
3847
static int64_t getutime(void)
3848
{
3849
#if HAVE_GETRUSAGE
3850
    struct rusage rusage;
3851

    
3852
    getrusage(RUSAGE_SELF, &rusage);
3853
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3854
#elif HAVE_GETPROCESSTIMES
3855
    HANDLE proc;
3856
    FILETIME c, e, k, u;
3857
    proc = GetCurrentProcess();
3858
    GetProcessTimes(proc, &c, &e, &k, &u);
3859
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3860
#else
3861
    return av_gettime();
3862
#endif
3863
}
3864

    
3865
static int64_t getmaxrss(void)
3866
{
3867
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3868
    struct rusage rusage;
3869
    getrusage(RUSAGE_SELF, &rusage);
3870
    return (int64_t)rusage.ru_maxrss * 1024;
3871
#elif HAVE_GETPROCESSMEMORYINFO
3872
    HANDLE proc;
3873
    PROCESS_MEMORY_COUNTERS memcounters;
3874
    proc = GetCurrentProcess();
3875
    memcounters.cb = sizeof(memcounters);
3876
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3877
    return memcounters.PeakPagefileUsage;
3878
#else
3879
    return 0;
3880
#endif
3881
}
3882

    
3883
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3884
{
3885
    int i;
3886
    const char *p = str;
3887
    for(i = 0;; i++) {
3888
        dest[i] = atoi(p);
3889
        if(i == 63)
3890
            break;
3891
        p = strchr(p, ',');
3892
        if(!p) {
3893
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3894
            ffmpeg_exit(1);
3895
        }
3896
        p++;
3897
    }
3898
}
3899

    
3900
static void opt_inter_matrix(const char *arg)
3901
{
3902
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3903
    parse_matrix_coeffs(inter_matrix, arg);
3904
}
3905

    
3906
static void opt_intra_matrix(const char *arg)
3907
{
3908
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3909
    parse_matrix_coeffs(intra_matrix, arg);
3910
}
3911

    
3912
static void show_usage(void)
3913
{
3914
    printf("Hyper fast Audio and Video encoder\n");
3915
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3916
    printf("\n");
3917
}
3918

    
3919
static void show_help(void)
3920
{
3921
    av_log_set_callback(log_callback_help);
3922
    show_usage();
3923
    show_help_options(options, "Main options:\n",
3924
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3925
    show_help_options(options, "\nAdvanced options:\n",
3926
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3927
                      OPT_EXPERT);
3928
    show_help_options(options, "\nVideo options:\n",
3929
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3930
                      OPT_VIDEO);
3931
    show_help_options(options, "\nAdvanced Video options:\n",
3932
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3933
                      OPT_VIDEO | OPT_EXPERT);
3934
    show_help_options(options, "\nAudio options:\n",
3935
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3936
                      OPT_AUDIO);
3937
    show_help_options(options, "\nAdvanced Audio options:\n",
3938
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3939
                      OPT_AUDIO | OPT_EXPERT);
3940
    show_help_options(options, "\nSubtitle options:\n",
3941
                      OPT_SUBTITLE | OPT_GRAB,
3942
                      OPT_SUBTITLE);
3943
    show_help_options(options, "\nAudio/Video grab options:\n",
3944
                      OPT_GRAB,
3945
                      OPT_GRAB);
3946
    printf("\n");
3947
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3948
    printf("\n");
3949
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3950
    printf("\n");
3951
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3952
}
3953

    
3954
static void opt_target(const char *arg)
3955
{
3956
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3957
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3958

    
3959
    if(!strncmp(arg, "pal-", 4)) {
3960
        norm = PAL;
3961
        arg += 4;
3962
    } else if(!strncmp(arg, "ntsc-", 5)) {
3963
        norm = NTSC;
3964
        arg += 5;
3965
    } else if(!strncmp(arg, "film-", 5)) {
3966
        norm = FILM;
3967
        arg += 5;
3968
    } else {
3969
        int fr;
3970
        /* Calculate FR via float to avoid int overflow */
3971
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3972
        if(fr == 25000) {
3973
            norm = PAL;
3974
        } else if((fr == 29970) || (fr == 23976)) {
3975
            norm = NTSC;
3976
        } else {
3977
            /* Try to determine PAL/NTSC by peeking in the input files */
3978
            if(nb_input_files) {
3979
                int i, j;
3980
                for(j = 0; j < nb_input_files; j++) {
3981
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3982
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3983
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3984
                            continue;
3985
                        fr = c->time_base.den * 1000 / c->time_base.num;
3986
                        if(fr == 25000) {
3987
                            norm = PAL;
3988
                            break;
3989
                        } else if((fr == 29970) || (fr == 23976)) {
3990
                            norm = NTSC;
3991
                            break;
3992
                        }
3993
                    }
3994
                    if(norm != UNKNOWN)
3995
                        break;
3996
                }
3997
            }
3998
        }
3999
        if(verbose && norm != UNKNOWN)
4000
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4001
    }
4002

    
4003
    if(norm == UNKNOWN) {
4004
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4005
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4006
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4007
        ffmpeg_exit(1);
4008
    }
4009

    
4010
    if(!strcmp(arg, "vcd")) {
4011

    
4012
        opt_video_codec("mpeg1video");
4013
        opt_audio_codec("mp2");
4014
        opt_format("vcd");
4015

    
4016
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4017
        opt_frame_rate(NULL, frame_rates[norm]);
4018
        opt_default("g", norm == PAL ? "15" : "18");
4019

    
4020
        opt_default("b", "1150000");
4021
        opt_default("maxrate", "1150000");
4022
        opt_default("minrate", "1150000");
4023
        opt_default("bufsize", "327680"); // 40*1024*8;
4024

    
4025
        opt_default("ab", "224000");
4026
        audio_sample_rate = 44100;
4027
        audio_channels = 2;
4028

    
4029
        opt_default("packetsize", "2324");
4030
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4031

    
4032
        /* We have to offset the PTS, so that it is consistent with the SCR.
4033
           SCR starts at 36000, but the first two packs contain only padding
4034
           and the first pack from the other stream, respectively, may also have
4035
           been written before.
4036
           So the real data starts at SCR 36000+3*1200. */
4037
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4038
    } else if(!strcmp(arg, "svcd")) {
4039

    
4040
        opt_video_codec("mpeg2video");
4041
        opt_audio_codec("mp2");
4042
        opt_format("svcd");
4043

    
4044
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4045
        opt_frame_rate(NULL, frame_rates[norm]);
4046
        opt_default("g", norm == PAL ? "15" : "18");
4047

    
4048
        opt_default("b", "2040000");
4049
        opt_default("maxrate", "2516000");
4050
        opt_default("minrate", "0"); //1145000;
4051
        opt_default("bufsize", "1835008"); //224*1024*8;
4052
        opt_default("flags", "+scan_offset");
4053

    
4054

    
4055
        opt_default("ab", "224000");
4056
        audio_sample_rate = 44100;
4057

    
4058
        opt_default("packetsize", "2324");
4059

    
4060
    } else if(!strcmp(arg, "dvd")) {
4061

    
4062
        opt_video_codec("mpeg2video");
4063
        opt_audio_codec("ac3");
4064
        opt_format("dvd");
4065

    
4066
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4067
        opt_frame_rate(NULL, frame_rates[norm]);
4068
        opt_default("g", norm == PAL ? "15" : "18");
4069

    
4070
        opt_default("b", "6000000");
4071
        opt_default("maxrate", "9000000");
4072
        opt_default("minrate", "0"); //1500000;
4073
        opt_default("bufsize", "1835008"); //224*1024*8;
4074

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

    
4078
        opt_default("ab", "448000");
4079
        audio_sample_rate = 48000;
4080

    
4081
    } else if(!strncmp(arg, "dv", 2)) {
4082

    
4083
        opt_format("dv");
4084

    
4085
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4086
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4087
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4088
        opt_frame_rate(NULL, frame_rates[norm]);
4089

    
4090
        audio_sample_rate = 48000;
4091
        audio_channels = 2;
4092

    
4093
    } else {
4094
        fprintf(stderr, "Unknown target: %s\n", arg);
4095
        ffmpeg_exit(1);
4096
    }
4097
}
4098

    
4099
static void opt_vstats_file (const char *arg)
4100
{
4101
    av_free (vstats_filename);
4102
    vstats_filename=av_strdup (arg);
4103
}
4104

    
4105
static void opt_vstats (void)
4106
{
4107
    char filename[40];
4108
    time_t today2 = time(NULL);
4109
    struct tm *today = localtime(&today2);
4110

    
4111
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4112
             today->tm_sec);
4113
    opt_vstats_file(filename);
4114
}
4115

    
4116
static int opt_bsf(const char *opt, const char *arg)
4117
{
4118
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4119
    AVBitStreamFilterContext **bsfp;
4120

    
4121
    if(!bsfc){
4122
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4123
        ffmpeg_exit(1);
4124
    }
4125

    
4126
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4127
          *opt == 'a' ? &audio_bitstream_filters :
4128
                        &subtitle_bitstream_filters;
4129
    while(*bsfp)
4130
        bsfp= &(*bsfp)->next;
4131

    
4132
    *bsfp= bsfc;
4133

    
4134
    return 0;
4135
}
4136

    
4137
static int opt_preset(const char *opt, const char *arg)
4138
{
4139
    FILE *f=NULL;
4140
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4141
    int i;
4142
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
4143
                           getenv("HOME"),
4144
                           FFMPEG_DATADIR,
4145
                         };
4146

    
4147
    if (*opt != 'f') {
4148
        for(i=0; i<3 && !f; i++){
4149
            if(!base[i])
4150
                continue;
4151
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4152
            f= fopen(filename, "r");
4153
            if(!f){
4154
                char *codec_name= *opt == 'v' ? video_codec_name :
4155
                                  *opt == 'a' ? audio_codec_name :
4156
                                                subtitle_codec_name;
4157
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4158
                f= fopen(filename, "r");
4159
            }
4160
        }
4161
    } else {
4162
        av_strlcpy(filename, arg, sizeof(filename));
4163
        f= fopen(filename, "r");
4164
    }
4165

    
4166
    if(!f){
4167
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4168
        ffmpeg_exit(1);
4169
    }
4170

    
4171
    while(!feof(f)){
4172
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4173
        if(line[0] == '#' && !e)
4174
            continue;
4175
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4176
        if(e){
4177
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4178
            ffmpeg_exit(1);
4179
        }
4180
        if(!strcmp(tmp, "acodec")){
4181
            opt_audio_codec(tmp2);
4182
        }else if(!strcmp(tmp, "vcodec")){
4183
            opt_video_codec(tmp2);
4184
        }else if(!strcmp(tmp, "scodec")){
4185
            opt_subtitle_codec(tmp2);
4186
        }else if(opt_default(tmp, tmp2) < 0){
4187
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4188
            ffmpeg_exit(1);
4189
        }
4190
    }
4191

    
4192
    fclose(f);
4193

    
4194
    return 0;
4195
}
4196

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

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

    
4284
    /* audio options */
4285
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4286
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4287
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4288
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4289
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4290
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4291
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4292
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4293
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4294
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4295
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4296
    { "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" },
4297

    
4298
    /* subtitle options */
4299
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4300
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4301
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4302
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4303
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4304

    
4305
    /* grab options */
4306
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4307
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4308
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4309

    
4310
    /* muxer options */
4311
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4312
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4313

    
4314
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4315
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4316
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4317

    
4318
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4319
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4320
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4321
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4322

    
4323
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4324
    { NULL, },
4325
};
4326

    
4327
int main(int argc, char **argv)
4328
{
4329
    int i;
4330
    int64_t ti;
4331

    
4332
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4333

    
4334
    avcodec_register_all();
4335
#if CONFIG_AVDEVICE
4336
    avdevice_register_all();
4337
#endif
4338
#if CONFIG_AVFILTER
4339
    avfilter_register_all();
4340
#endif
4341
    av_register_all();
4342

    
4343
#if HAVE_ISATTY
4344
    if(isatty(STDIN_FILENO))
4345
        url_set_interrupt_cb(decode_interrupt_cb);
4346
#endif
4347

    
4348
    for(i=0; i<AVMEDIA_TYPE_NB; i++){
4349
        avcodec_opts[i]= avcodec_alloc_context2(i);
4350
    }
4351
    avformat_opts = avformat_alloc_context();
4352
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4353

    
4354
    show_banner();
4355

    
4356
    /* parse options */
4357
    parse_options(argc, argv, options, opt_output_file);
4358

    
4359
    if(nb_output_files <= 0 && nb_input_files == 0) {
4360
        show_usage();
4361
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4362
        ffmpeg_exit(1);
4363
    }
4364

    
4365
    /* file converter / grab */
4366
    if (nb_output_files <= 0) {
4367
        fprintf(stderr, "At least one output file must be specified\n");
4368
        ffmpeg_exit(1);
4369
    }
4370

    
4371
    if (nb_input_files == 0) {
4372
        fprintf(stderr, "At least one input file must be specified\n");
4373
        ffmpeg_exit(1);
4374
    }
4375

    
4376
    ti = getutime();
4377
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4378
                  stream_maps, nb_stream_maps) < 0)
4379
        ffmpeg_exit(1);
4380
    ti = getutime() - ti;
4381
    if (do_benchmark) {
4382
        int maxrss = getmaxrss() / 1024;
4383
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4384
    }
4385

    
4386
    return ffmpeg_exit(0);
4387
}