Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 94498ec9

History | View | Annotate | Download (160 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
#if !FF_API_MAX_STREAMS
107
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
108
#endif
109

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

    
119
static AVFormatContext *output_files[MAX_FILES];
120
static AVCodec **output_codecs = NULL;
121
static int nb_output_files = 0;
122
static int nb_output_codecs = 0;
123

    
124
static AVStreamMap *stream_maps = NULL;
125
static int nb_stream_maps;
126

    
127
static AVMetaDataMap meta_data_maps[MAX_FILES];
128
static int nb_meta_data_maps;
129

    
130
/* indexed by output file stream index */
131
static int *streamid_map = NULL;
132
static int nb_streamid_map = 0;
133

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

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

    
178
static int subtitle_disable = 0;
179
static char *subtitle_codec_name = NULL;
180
static char *subtitle_language = NULL;
181
static unsigned int subtitle_codec_tag = 0;
182

    
183
static float mux_preload= 0.5;
184
static float mux_max_delay= 0.7;
185

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

    
213
static int rate_emu = 0;
214

    
215
static int  video_channel = 0;
216
static char *video_standard;
217

    
218
static int audio_volume = 256;
219

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

    
234
static int pgmyuv_compatibility_hack=0;
235
static float dts_delta_threshold = 10;
236

    
237
static unsigned int sws_flags = SWS_BICUBIC;
238

    
239
static int64_t timer_start;
240

    
241
static uint8_t *audio_buf;
242
static uint8_t *audio_out;
243
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
244

    
245
static short *samples;
246

    
247
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
248
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
249
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
250
static AVBitStreamFilterContext **bitstream_filters[MAX_FILES] = {NULL};
251
static int nb_bitstream_filters[MAX_FILES] = {0};
252

    
253
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
254

    
255
struct AVInputStream;
256

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

    
277
    /* full frame size of first frame */
278
    int original_height;
279
    int original_width;
280

    
281
    /* cropping area sizes */
282
    int video_crop;
283
    int topBand;
284
    int bottomBand;
285
    int leftBand;
286
    int rightBand;
287

    
288
    /* cropping area of first frame */
289
    int original_topBand;
290
    int original_bottomBand;
291
    int original_leftBand;
292
    int original_rightBand;
293

    
294
    /* audio only */
295
    int audio_resample;
296
    ReSampleContext *resample; /* for audio resampling */
297
    int reformat_pair;
298
    AVAudioConvert *reformat_ctx;
299
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
300
    FILE *logfile;
301
} AVOutputStream;
302

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

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

    
328
typedef struct AVInputFile {
329
    int eof_reached;      /* true if eof reached */
330
    int ist_index;        /* index of first stream in ist_table */
331
    int buffer_size;      /* current total buffer size */
332
    int nb_streams;       /* nb streams we are aware of */
333
} AVInputFile;
334

    
335
#if HAVE_TERMIOS_H
336

    
337
/* init terminal so that we can grab keys */
338
static struct termios oldtty;
339
#endif
340

    
341
#if CONFIG_AVFILTER
342
typedef struct {
343
    int pix_fmt;
344
} FilterOutPriv;
345

    
346

    
347
static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
348
{
349
    FilterOutPriv *priv = ctx->priv;
350

    
351
    if(!opaque) return -1;
352

    
353
    priv->pix_fmt = *((int *)opaque);
354

    
355
    return 0;
356
}
357

    
358
static void output_end_frame(AVFilterLink *link)
359
{
360
}
361

    
362
static int output_query_formats(AVFilterContext *ctx)
363
{
364
    FilterOutPriv *priv = ctx->priv;
365
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
366

    
367
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
368
    return 0;
369
}
370

    
371
static int get_filtered_video_pic(AVFilterContext *ctx,
372
                                  AVFilterBufferRef **picref, AVFrame *pic2,
373
                                  uint64_t *pts)
374
{
375
    AVFilterBufferRef *pic;
376

    
377
    if(avfilter_request_frame(ctx->inputs[0]))
378
        return -1;
379
    if(!(pic = ctx->inputs[0]->cur_buf))
380
        return -1;
381
    *picref = pic;
382
    ctx->inputs[0]->cur_buf = NULL;
383

    
384
    *pts          = pic->pts;
385

    
386
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
387
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
388
    pic2->interlaced_frame = pic->video->interlaced;
389
    pic2->top_field_first  = pic->video->top_field_first;
390

    
391
    return 1;
392
}
393

    
394
static AVFilter output_filter =
395
{
396
    .name      = "ffmpeg_output",
397

    
398
    .priv_size = sizeof(FilterOutPriv),
399
    .init      = output_init,
400

    
401
    .query_formats = output_query_formats,
402

    
403
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
404
                                    .type          = AVMEDIA_TYPE_VIDEO,
405
                                    .end_frame     = output_end_frame,
406
                                    .min_perms     = AV_PERM_READ, },
407
                                  { .name = NULL }},
408
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
409
};
410

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

    
420
    graph = av_mallocz(sizeof(AVFilterGraph));
421

    
422
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
423
        return ret;
424
    if ((ret = avfilter_open(&ist->output_video_filter, &output_filter, "out")) < 0)
425
        return ret;
426

    
427
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
428
             ist->st->codec->height, ist->st->codec->pix_fmt,
429
             ist->st->time_base.num, ist->st->time_base.den);
430
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
431
        return ret;
432
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &codec->pix_fmt)) < 0)
433
        return ret;
434

    
435
    /* add input and output filters to the overall graph */
436
    avfilter_graph_add_filter(graph, ist->input_video_filter);
437
    avfilter_graph_add_filter(graph, ist->output_video_filter);
438

    
439
    last_filter = ist->input_video_filter;
440

    
441
    if (ost->video_crop) {
442
        snprintf(args, 255, "%d:%d:%d:%d",
443
                 codec->width, codec->height,
444
                 ost->leftBand, ost->topBand);
445
        if ((ret = avfilter_open(&filter, avfilter_get_by_name("crop"), NULL)) < 0)
446
            return ret;
447
        if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
448
            return ret;
449
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
450
            return ret;
451
        last_filter = filter;
452
        avfilter_graph_add_filter(graph, last_filter);
453
    }
454

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

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

    
475
    if (vfilters) {
476
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
477
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
478

    
479
        outputs->name    = av_strdup("in");
480
        outputs->filter  = last_filter;
481
        outputs->pad_idx = 0;
482
        outputs->next    = NULL;
483

    
484
        inputs->name    = av_strdup("out");
485
        inputs->filter  = ist->output_video_filter;
486
        inputs->pad_idx = 0;
487
        inputs->next    = NULL;
488

    
489
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
490
            return ret;
491
        av_freep(&vfilters);
492
    } else {
493
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
494
            return ret;
495
    }
496

    
497
    /* configure all the filter links */
498
    if ((ret = avfilter_graph_check_validity(graph, NULL)) < 0)
499
        return ret;
500
    if ((ret = avfilter_graph_config_formats(graph, NULL)) < 0)
501
        return ret;
502
    if ((ret = avfilter_graph_config_links(graph, NULL)) < 0)
503
        return ret;
504

    
505
    codec->width  = ist->output_video_filter->inputs[0]->w;
506
    codec->height = ist->output_video_filter->inputs[0]->h;
507

    
508
    return 0;
509
}
510
#endif /* CONFIG_AVFILTER */
511

    
512
static void term_exit(void)
513
{
514
    av_log(NULL, AV_LOG_QUIET, "");
515
#if HAVE_TERMIOS_H
516
    tcsetattr (0, TCSANOW, &oldtty);
517
#endif
518
}
519

    
520
static volatile int received_sigterm = 0;
521

    
522
static void
523
sigterm_handler(int sig)
524
{
525
    received_sigterm = sig;
526
    term_exit();
527
}
528

    
529
static void term_init(void)
530
{
531
#if HAVE_TERMIOS_H
532
    struct termios tty;
533

    
534
    tcgetattr (0, &tty);
535
    oldtty = tty;
536
    atexit(term_exit);
537

    
538
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
539
                          |INLCR|IGNCR|ICRNL|IXON);
540
    tty.c_oflag |= OPOST;
541
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
542
    tty.c_cflag &= ~(CSIZE|PARENB);
543
    tty.c_cflag |= CS8;
544
    tty.c_cc[VMIN] = 1;
545
    tty.c_cc[VTIME] = 0;
546

    
547
    tcsetattr (0, TCSANOW, &tty);
548
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
549
#endif
550

    
551
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
552
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
553
#ifdef SIGXCPU
554
    signal(SIGXCPU, sigterm_handler);
555
#endif
556
}
557

    
558
/* read a key without blocking */
559
static int read_key(void)
560
{
561
#if HAVE_TERMIOS_H
562
    int n = 1;
563
    unsigned char ch;
564
    struct timeval tv;
565
    fd_set rfds;
566

    
567
    FD_ZERO(&rfds);
568
    FD_SET(0, &rfds);
569
    tv.tv_sec = 0;
570
    tv.tv_usec = 0;
571
    n = select(1, &rfds, NULL, NULL, &tv);
572
    if (n > 0) {
573
        n = read(0, &ch, 1);
574
        if (n == 1)
575
            return ch;
576

    
577
        return n;
578
    }
579
#elif HAVE_CONIO_H
580
    if(kbhit())
581
        return(getch());
582
#endif
583
    return -1;
584
}
585

    
586
static int decode_interrupt_cb(void)
587
{
588
    return q_pressed || (q_pressed = read_key() == 'q');
589
}
590

    
591
static int ffmpeg_exit(int ret)
592
{
593
    int i;
594

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

    
623
    av_free(intra_matrix);
624
    av_free(inter_matrix);
625

    
626
    if (vstats_file)
627
        fclose(vstats_file);
628
    av_free(vstats_filename);
629

    
630
    av_free(opt_names);
631
    av_free(streamid_map);
632
    av_free(input_codecs);
633
    av_free(output_codecs);
634
    av_free(stream_maps);
635

    
636
    av_free(video_codec_name);
637
    av_free(audio_codec_name);
638
    av_free(subtitle_codec_name);
639

    
640
    av_free(video_standard);
641

    
642
    uninit_opts();
643
    av_free(audio_buf);
644
    av_free(audio_out);
645
    allocated_audio_buf_size= allocated_audio_out_size= 0;
646
    av_free(samples);
647

    
648
#if CONFIG_AVFILTER
649
    avfilter_uninit();
650
#endif
651

    
652
    if (received_sigterm) {
653
        fprintf(stderr,
654
            "Received signal %d: terminating.\n",
655
            (int) received_sigterm);
656
        exit (255);
657
    }
658

    
659
    exit(ret); /* not all OS-es handle main() return value */
660
    return ret;
661
}
662

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

    
683
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
684
{
685
    if(codec && codec->sample_fmts){
686
        const enum SampleFormat *p= codec->sample_fmts;
687
        for(; *p!=-1; p++){
688
            if(*p == st->codec->sample_fmt)
689
                break;
690
        }
691
        if(*p == -1)
692
            st->codec->sample_fmt = codec->sample_fmts[0];
693
    }
694
}
695

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

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

    
733
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
734
{
735
    int i, err;
736
    AVFormatContext *ic;
737
    int nopts = 0;
738

    
739
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
740
    if (err < 0)
741
        return err;
742
    /* copy stream format */
743
    s->nb_streams = ic->nb_streams;
744
    for(i=0;i<ic->nb_streams;i++) {
745
        AVStream *st;
746
        AVCodec *codec;
747

    
748
        // FIXME: a more elegant solution is needed
749
        st = av_mallocz(sizeof(AVStream));
750
        memcpy(st, ic->streams[i], sizeof(AVStream));
751
        st->codec = avcodec_alloc_context();
752
        if (!st->codec) {
753
            print_error(filename, AVERROR(ENOMEM));
754
            ffmpeg_exit(1);
755
        }
756
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
757
        s->streams[i] = st;
758

    
759
        codec = avcodec_find_encoder(st->codec->codec_id);
760
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
761
            if (audio_stream_copy) {
762
                st->stream_copy = 1;
763
            } else
764
                choose_sample_fmt(st, codec);
765
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
766
            if (video_stream_copy) {
767
                st->stream_copy = 1;
768
            } else
769
                choose_pixel_fmt(st, codec);
770
        }
771

    
772
        if(!st->codec->thread_count)
773
            st->codec->thread_count = 1;
774
        if(st->codec->thread_count>1)
775
            avcodec_thread_init(st->codec, st->codec->thread_count);
776

    
777
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
778
            nopts = 1;
779
    }
780

    
781
    if (!nopts)
782
        s->timestamp = av_gettime();
783

    
784
    av_close_input_file(ic);
785
    return 0;
786
}
787

    
788
static double
789
get_sync_ipts(const AVOutputStream *ost)
790
{
791
    const AVInputStream *ist = ost->sync_ist;
792
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
793
}
794

    
795
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
796
    int ret;
797

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

    
817
        bsfc= bsfc->next;
818
    }
819

    
820
    ret= av_interleaved_write_frame(s, pkt);
821
    if(ret < 0){
822
        print_error("av_interleaved_write_frame()", ret);
823
        ffmpeg_exit(1);
824
    }
825
}
826

    
827
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
828

    
829
static void do_audio_out(AVFormatContext *s,
830
                         AVOutputStream *ost,
831
                         AVInputStream *ist,
832
                         unsigned char *buf, int size)
833
{
834
    uint8_t *buftmp;
835
    int64_t audio_out_size, audio_buf_size;
836
    int64_t allocated_for_size= size;
837

    
838
    int size_out, frame_bytes, ret;
839
    AVCodecContext *enc= ost->st->codec;
840
    AVCodecContext *dec= ist->st->codec;
841
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
842
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
843
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
844

    
845
need_realloc:
846
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
847
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
848
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
849
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
850
    audio_buf_size*= osize*enc->channels;
851

    
852
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
853
    if(coded_bps > 8*osize)
854
        audio_out_size= audio_out_size * coded_bps / (8*osize);
855
    audio_out_size += FF_MIN_BUFFER_SIZE;
856

    
857
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
858
        fprintf(stderr, "Buffer sizes too large\n");
859
        ffmpeg_exit(1);
860
    }
861

    
862
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
863
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
864
    if (!audio_buf || !audio_out){
865
        fprintf(stderr, "Out of memory in do_audio_out\n");
866
        ffmpeg_exit(1);
867
    }
868

    
869
    if (enc->channels != dec->channels)
870
        ost->audio_resample = 1;
871

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

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

    
903
    if(audio_sync_method){
904
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
905
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
906
        double idelta= delta*dec->sample_rate / enc->sample_rate;
907
        int byte_delta= ((int)idelta)*2*dec->channels;
908

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

    
925
                    if(byte_delta > allocated_for_size - size){
926
                        allocated_for_size= byte_delta + (int64_t)size;
927
                        goto need_realloc;
928
                    }
929
                    ist->is_start=0;
930

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

    
951
    if (ost->audio_resample) {
952
        buftmp = audio_buf;
953
        size_out = audio_resample(ost->resample,
954
                                  (short *)buftmp, (short *)buf,
955
                                  size / (dec->channels * isize));
956
        size_out = size_out * enc->channels * osize;
957
    } else {
958
        buftmp = buf;
959
        size_out = size;
960
    }
961

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

    
978
    /* now encode as many frames as possible */
979
    if (enc->frame_size > 1) {
980
        /* output resampled raw samples */
981
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
982
            fprintf(stderr, "av_fifo_realloc2() failed\n");
983
            ffmpeg_exit(1);
984
        }
985
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
986

    
987
        frame_bytes = enc->frame_size * osize * enc->channels;
988

    
989
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
990
            AVPacket pkt;
991
            av_init_packet(&pkt);
992

    
993
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
994

    
995
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
996

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

    
1012
            ost->sync_opts += enc->frame_size;
1013
        }
1014
    } else {
1015
        AVPacket pkt;
1016
        av_init_packet(&pkt);
1017

    
1018
        ost->sync_opts += size_out / (osize * enc->channels);
1019

    
1020
        /* output a pcm frame */
1021
        /* determine the size of the coded buffer */
1022
        size_out /= osize;
1023
        if (coded_bps)
1024
            size_out = size_out*coded_bps/8;
1025

    
1026
        if(size_out > audio_out_size){
1027
            fprintf(stderr, "Internal error, buffer size too small\n");
1028
            ffmpeg_exit(1);
1029
        }
1030

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

    
1049
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1050
{
1051
    AVCodecContext *dec;
1052
    AVPicture *picture2;
1053
    AVPicture picture_tmp;
1054
    uint8_t *buf = 0;
1055

    
1056
    dec = ist->st->codec;
1057

    
1058
    /* deinterlace : must be done before any resize */
1059
    if (do_deinterlace) {
1060
        int size;
1061

    
1062
        /* create temporary picture */
1063
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1064
        buf = av_malloc(size);
1065
        if (!buf)
1066
            return;
1067

    
1068
        picture2 = &picture_tmp;
1069
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1070

    
1071
        if(avpicture_deinterlace(picture2, picture,
1072
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1073
            /* if error, do not deinterlace */
1074
            fprintf(stderr, "Deinterlacing failed\n");
1075
            av_free(buf);
1076
            buf = NULL;
1077
            picture2 = picture;
1078
        }
1079
    } else {
1080
        picture2 = picture;
1081
    }
1082

    
1083
    if (picture != picture2)
1084
        *picture = *picture2;
1085
    *bufp = buf;
1086
}
1087

    
1088
/* we begin to correct av delay at this threshold */
1089
#define AV_DELAY_MAX 0.100
1090

    
1091
static void do_subtitle_out(AVFormatContext *s,
1092
                            AVOutputStream *ost,
1093
                            AVInputStream *ist,
1094
                            AVSubtitle *sub,
1095
                            int64_t pts)
1096
{
1097
    static uint8_t *subtitle_out = NULL;
1098
    int subtitle_out_max_size = 1024 * 1024;
1099
    int subtitle_out_size, nb, i;
1100
    AVCodecContext *enc;
1101
    AVPacket pkt;
1102

    
1103
    if (pts == AV_NOPTS_VALUE) {
1104
        fprintf(stderr, "Subtitle packets must have a pts\n");
1105
        if (exit_on_error)
1106
            ffmpeg_exit(1);
1107
        return;
1108
    }
1109

    
1110
    enc = ost->st->codec;
1111

    
1112
    if (!subtitle_out) {
1113
        subtitle_out = av_malloc(subtitle_out_max_size);
1114
    }
1115

    
1116
    /* Note: DVB subtitle need one packet to draw them and one other
1117
       packet to clear them */
1118
    /* XXX: signal it in the codec context ? */
1119
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1120
        nb = 2;
1121
    else
1122
        nb = 1;
1123

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

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

    
1154
static int bit_buffer_size= 1024*256;
1155
static uint8_t *bit_buffer= NULL;
1156

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

    
1172
    avcodec_get_frame_defaults(&picture_crop_temp);
1173
    avcodec_get_frame_defaults(&picture_pad_temp);
1174

    
1175
    enc = ost->st->codec;
1176
    dec = ist->st->codec;
1177

    
1178
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1179

    
1180
    /* by default, we output a single frame */
1181
    nb_frames = 1;
1182

    
1183
    *frame_size = 0;
1184

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

    
1210
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1211
    if (nb_frames <= 0)
1212
        return;
1213

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

    
1230
    final_picture = formatted_picture;
1231
    padding_src = formatted_picture;
1232
    resampling_dst = &ost->pict_tmp;
1233

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

    
1238
        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));
1239
        if(!ost->video_resample)
1240
            ffmpeg_exit(1);
1241
    }
1242

    
1243
#if !CONFIG_AVFILTER
1244
    if (ost->video_resample) {
1245
        padding_src = NULL;
1246
        final_picture = &ost->pict_tmp;
1247
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1248
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1249
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1250

    
1251
            /* keep bands proportional to the frame size */
1252
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
1253
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1254
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
1255
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
1256

    
1257
            /* sanity check to ensure no bad band sizes sneak in */
1258
            av_assert0(topBand    <= INT_MAX && topBand    >= 0);
1259
            av_assert0(bottomBand <= INT_MAX && bottomBand >= 0);
1260
            av_assert0(leftBand   <= INT_MAX && leftBand   >= 0);
1261
            av_assert0(rightBand  <= INT_MAX && rightBand  >= 0);
1262

    
1263
            ost->topBand    = topBand;
1264
            ost->bottomBand = bottomBand;
1265
            ost->leftBand   = leftBand;
1266
            ost->rightBand  = rightBand;
1267

    
1268
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1269
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1270
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1271

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

    
1293
    /* duplicates frame if needed */
1294
    for(i=0;i<nb_frames;i++) {
1295
        AVPacket pkt;
1296
        av_init_packet(&pkt);
1297
        pkt.stream_index= ost->index;
1298

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

    
1310
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1311
            enc->coded_frame = old_frame;
1312
        } else {
1313
            AVFrame big_picture;
1314

    
1315
            big_picture= *final_picture;
1316
            /* better than nothing: use input picture interlaced
1317
               settings */
1318
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1319
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1320
                if(top_field_first == -1)
1321
                    big_picture.top_field_first = in_picture->top_field_first;
1322
                else
1323
                    big_picture.top_field_first = top_field_first;
1324
            }
1325

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

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

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

    
1370
static double psnr(double d){
1371
    return -10.0*log(d)/log(10.0);
1372
}
1373

    
1374
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1375
                           int frame_size)
1376
{
1377
    AVCodecContext *enc;
1378
    int frame_number;
1379
    double ti1, bitrate, avg_bitrate;
1380

    
1381
    /* this is executed just the first time do_video_stats is called */
1382
    if (!vstats_file) {
1383
        vstats_file = fopen(vstats_filename, "w");
1384
        if (!vstats_file) {
1385
            perror("fopen");
1386
            ffmpeg_exit(1);
1387
        }
1388
    }
1389

    
1390
    enc = ost->st->codec;
1391
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1392
        frame_number = ost->frame_number;
1393
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1394
        if (enc->flags&CODEC_FLAG_PSNR)
1395
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1396

    
1397
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1398
        /* compute pts value */
1399
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1400
        if (ti1 < 0.01)
1401
            ti1 = 0.01;
1402

    
1403
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1404
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1405
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1406
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1407
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1408
    }
1409
}
1410

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

    
1425
    if (!is_last_report) {
1426
        int64_t cur_time;
1427
        /* display the report every 0.5 seconds */
1428
        cur_time = av_gettime();
1429
        if (last_time == -1) {
1430
            last_time = cur_time;
1431
            return;
1432
        }
1433
        if ((cur_time - last_time) < 500000)
1434
            return;
1435
        last_time = cur_time;
1436
    }
1437

    
1438

    
1439
    oc = output_files[0];
1440

    
1441
    total_size = url_fsize(oc->pb);
1442
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1443
        total_size= url_ftell(oc->pb);
1444

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

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

    
1505
    if (verbose || is_last_report) {
1506
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1507

    
1508
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1509
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1510
            (double)total_size / 1024, ti1, bitrate);
1511

    
1512
        if (nb_frames_dup || nb_frames_drop)
1513
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1514
                  nb_frames_dup, nb_frames_drop);
1515

    
1516
        if (verbose >= 0)
1517
            fprintf(stderr, "%s    \r", buf);
1518

    
1519
        fflush(stderr);
1520
    }
1521

    
1522
    if (is_last_report && verbose >= 0){
1523
        int64_t raw= audio_size + video_size + extra_size;
1524
        fprintf(stderr, "\n");
1525
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1526
                video_size/1024.0,
1527
                audio_size/1024.0,
1528
                extra_size/1024.0,
1529
                100.0*(total_size - raw)/raw
1530
        );
1531
    }
1532
}
1533

    
1534
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1535
static int output_packet(AVInputStream *ist, int ist_index,
1536
                         AVOutputStream **ost_table, int nb_ostreams,
1537
                         const AVPacket *pkt)
1538
{
1539
    AVFormatContext *os;
1540
    AVOutputStream *ost;
1541
    int ret, i;
1542
    int got_picture;
1543
    AVFrame picture;
1544
    void *buffer_to_free;
1545
    static unsigned int samples_size= 0;
1546
    AVSubtitle subtitle, *subtitle_to_free;
1547
    int64_t pkt_pts = AV_NOPTS_VALUE;
1548
#if CONFIG_AVFILTER
1549
    int frame_available;
1550
#endif
1551

    
1552
    AVPacket avpkt;
1553
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1554

    
1555
    if(ist->next_pts == AV_NOPTS_VALUE)
1556
        ist->next_pts= ist->pts;
1557

    
1558
    if (pkt == NULL) {
1559
        /* EOF handling */
1560
        av_init_packet(&avpkt);
1561
        avpkt.data = NULL;
1562
        avpkt.size = 0;
1563
        goto handle_eof;
1564
    } else {
1565
        avpkt = *pkt;
1566
    }
1567

    
1568
    if(pkt->dts != AV_NOPTS_VALUE)
1569
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1570
    if(pkt->pts != AV_NOPTS_VALUE)
1571
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1572

    
1573
    //while we have more to decode or while the decoder did output something on EOF
1574
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1575
        uint8_t *data_buf, *decoded_data_buf;
1576
        int data_size, decoded_data_size;
1577
    handle_eof:
1578
        ist->pts= ist->next_pts;
1579

    
1580
        if(avpkt.size && avpkt.size != pkt->size &&
1581
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1582
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1583
            ist->showed_multi_packet_warning=1;
1584
        }
1585

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

    
1627
                    ret = avcodec_decode_video2(ist->st->codec,
1628
                                                &picture, &got_picture, &avpkt);
1629
                    ist->st->quality= picture.quality;
1630
                    if (ret < 0)
1631
                        goto fail_decode;
1632
                    if (!got_picture) {
1633
                        /* no picture yet */
1634
                        goto discard_packet;
1635
                    }
1636
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1637
                    if (ist->st->codec->time_base.num != 0) {
1638
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1639
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1640
                                          ist->st->codec->time_base.num * ticks) /
1641
                            ist->st->codec->time_base.den;
1642
                    }
1643
                    avpkt.size = 0;
1644
                    break;
1645
            case AVMEDIA_TYPE_SUBTITLE:
1646
                ret = avcodec_decode_subtitle2(ist->st->codec,
1647
                                               &subtitle, &got_picture, &avpkt);
1648
                if (ret < 0)
1649
                    goto fail_decode;
1650
                if (!got_picture) {
1651
                    goto discard_packet;
1652
                }
1653
                subtitle_to_free = &subtitle;
1654
                avpkt.size = 0;
1655
                break;
1656
            default:
1657
                goto fail_decode;
1658
            }
1659
        } else {
1660
            switch(ist->st->codec->codec_type) {
1661
            case AVMEDIA_TYPE_AUDIO:
1662
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1663
                    ist->st->codec->sample_rate;
1664
                break;
1665
            case AVMEDIA_TYPE_VIDEO:
1666
                if (ist->st->codec->time_base.num != 0) {
1667
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1668
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1669
                                      ist->st->codec->time_base.num * ticks) /
1670
                        ist->st->codec->time_base.den;
1671
                }
1672
                break;
1673
            }
1674
            ret = avpkt.size;
1675
            avpkt.size = 0;
1676
        }
1677

    
1678
        buffer_to_free = NULL;
1679
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1680
            pre_process_video_frame(ist, (AVPicture *)&picture,
1681
                                    &buffer_to_free);
1682
        }
1683

    
1684
#if CONFIG_AVFILTER
1685
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1686
            // add it to be filtered
1687
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1688
                                     ist->pts,
1689
                                     ist->st->codec->sample_aspect_ratio);
1690
        }
1691
#endif
1692

    
1693
        // preprocess audio (volume)
1694
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1695
            if (audio_volume != 256) {
1696
                short *volp;
1697
                volp = samples;
1698
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1699
                    int v = ((*volp) * audio_volume + 128) >> 8;
1700
                    if (v < -32768) v = -32768;
1701
                    if (v >  32767) v = 32767;
1702
                    *volp++ = v;
1703
                }
1704
            }
1705
        }
1706

    
1707
        /* frame rate emulation */
1708
        if (rate_emu) {
1709
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1710
            int64_t now = av_gettime() - ist->start;
1711
            if (pts > now)
1712
                usleep(pts - now);
1713
        }
1714
#if CONFIG_AVFILTER
1715
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1716
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1717
#endif
1718
        /* if output time reached then transcode raw format,
1719
           encode packets and output them */
1720
        if (start_time == 0 || ist->pts >= start_time)
1721
#if CONFIG_AVFILTER
1722
        while (frame_available) {
1723
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1724
                get_filtered_video_pic(ist->output_video_filter, &ist->picref, &picture, &ist->pts);
1725
#endif
1726
            for(i=0;i<nb_ostreams;i++) {
1727
                int frame_size;
1728

    
1729
                ost = ost_table[i];
1730
                if (ost->source_index == ist_index) {
1731
                    os = output_files[ost->file_index];
1732

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

    
1736
                    if (ost->encoding_needed) {
1737
                        av_assert0(ist->decoding_needed);
1738
                        switch(ost->st->codec->codec_type) {
1739
                        case AVMEDIA_TYPE_AUDIO:
1740
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1741
                            break;
1742
                        case AVMEDIA_TYPE_VIDEO:
1743
#if CONFIG_AVFILTER
1744
                            if (ist->picref->video)
1745
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1746
#endif
1747
                            do_video_out(os, ost, ist, &picture, &frame_size);
1748
                            if (vstats_filename && frame_size)
1749
                                do_video_stats(os, ost, frame_size);
1750
                            break;
1751
                        case AVMEDIA_TYPE_SUBTITLE:
1752
                            do_subtitle_out(os, ost, ist, &subtitle,
1753
                                            pkt->pts);
1754
                            break;
1755
                        default:
1756
                            abort();
1757
                        }
1758
                    } else {
1759
                        AVFrame avframe; //FIXME/XXX remove this
1760
                        AVPacket opkt;
1761
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1762

    
1763
                        av_init_packet(&opkt);
1764

    
1765
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1766
                            continue;
1767

    
1768
                        /* no reencoding needed : output the packet directly */
1769
                        /* force the input stream PTS */
1770

    
1771
                        avcodec_get_frame_defaults(&avframe);
1772
                        ost->st->codec->coded_frame= &avframe;
1773
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1774

    
1775
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1776
                            audio_size += data_size;
1777
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1778
                            video_size += data_size;
1779
                            ost->sync_opts++;
1780
                        }
1781

    
1782
                        opkt.stream_index= ost->index;
1783
                        if(pkt->pts != AV_NOPTS_VALUE)
1784
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1785
                        else
1786
                            opkt.pts= AV_NOPTS_VALUE;
1787

    
1788
                        if (pkt->dts == AV_NOPTS_VALUE)
1789
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1790
                        else
1791
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1792
                        opkt.dts -= ost_tb_start_time;
1793

    
1794
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1795
                        opkt.flags= pkt->flags;
1796

    
1797
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1798
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1799
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1800
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1801
                           ) {
1802
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1803
                                opkt.destruct= av_destruct_packet;
1804
                        } else {
1805
                            opkt.data = data_buf;
1806
                            opkt.size = data_size;
1807
                        }
1808

    
1809
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1810
                        ost->st->codec->frame_number++;
1811
                        ost->frame_number++;
1812
                        av_free_packet(&opkt);
1813
                    }
1814
                }
1815
            }
1816

    
1817
#if CONFIG_AVFILTER
1818
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1819
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1820
            if(ist->picref)
1821
                avfilter_unref_buffer(ist->picref);
1822
        }
1823
#endif
1824
        av_free(buffer_to_free);
1825
        /* XXX: allocate the subtitles in the codec ? */
1826
        if (subtitle_to_free) {
1827
            if (subtitle_to_free->rects != NULL) {
1828
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1829
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1830
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1831
                    av_freep(&subtitle_to_free->rects[i]);
1832
                }
1833
                av_freep(&subtitle_to_free->rects);
1834
            }
1835
            subtitle_to_free->num_rects = 0;
1836
            subtitle_to_free = NULL;
1837
        }
1838
    }
1839
 discard_packet:
1840
    if (pkt == NULL) {
1841
        /* EOF handling */
1842

    
1843
        for(i=0;i<nb_ostreams;i++) {
1844
            ost = ost_table[i];
1845
            if (ost->source_index == ist_index) {
1846
                AVCodecContext *enc= ost->st->codec;
1847
                os = output_files[ost->file_index];
1848

    
1849
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1850
                    continue;
1851
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1852
                    continue;
1853

    
1854
                if (ost->encoding_needed) {
1855
                    for(;;) {
1856
                        AVPacket pkt;
1857
                        int fifo_bytes;
1858
                        av_init_packet(&pkt);
1859
                        pkt.stream_index= ost->index;
1860

    
1861
                        switch(ost->st->codec->codec_type) {
1862
                        case AVMEDIA_TYPE_AUDIO:
1863
                            fifo_bytes = av_fifo_size(ost->fifo);
1864
                            ret = 0;
1865
                            /* encode any samples remaining in fifo */
1866
                            if (fifo_bytes > 0) {
1867
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1868
                                int fs_tmp = enc->frame_size;
1869

    
1870
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1871
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1872
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1873
                                } else { /* pad */
1874
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1875
                                    if (allocated_audio_buf_size < frame_bytes)
1876
                                        ffmpeg_exit(1);
1877
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1878
                                }
1879

    
1880
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1881
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1882
                                                          ost->st->time_base.num, enc->sample_rate);
1883
                                enc->frame_size = fs_tmp;
1884
                            }
1885
                            if(ret <= 0) {
1886
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1887
                            }
1888
                            if (ret < 0) {
1889
                                fprintf(stderr, "Audio encoding failed\n");
1890
                                ffmpeg_exit(1);
1891
                            }
1892
                            audio_size += ret;
1893
                            pkt.flags |= AV_PKT_FLAG_KEY;
1894
                            break;
1895
                        case AVMEDIA_TYPE_VIDEO:
1896
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1897
                            if (ret < 0) {
1898
                                fprintf(stderr, "Video encoding failed\n");
1899
                                ffmpeg_exit(1);
1900
                            }
1901
                            video_size += ret;
1902
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1903
                                pkt.flags |= AV_PKT_FLAG_KEY;
1904
                            if (ost->logfile && enc->stats_out) {
1905
                                fprintf(ost->logfile, "%s", enc->stats_out);
1906
                            }
1907
                            break;
1908
                        default:
1909
                            ret=-1;
1910
                        }
1911

    
1912
                        if(ret<=0)
1913
                            break;
1914
                        pkt.data= bit_buffer;
1915
                        pkt.size= ret;
1916
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1917
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1918
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1919
                    }
1920
                }
1921
            }
1922
        }
1923
    }
1924

    
1925
    return 0;
1926
 fail_decode:
1927
    return -1;
1928
}
1929

    
1930
static void print_sdp(AVFormatContext **avc, int n)
1931
{
1932
    char sdp[2048];
1933

    
1934
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1935
    printf("SDP:\n%s\n", sdp);
1936
    fflush(stdout);
1937
}
1938

    
1939
static int copy_chapters(int infile, int outfile)
1940
{
1941
    AVFormatContext *is = input_files[infile];
1942
    AVFormatContext *os = output_files[outfile];
1943
    int i;
1944

    
1945
    for (i = 0; i < is->nb_chapters; i++) {
1946
        AVChapter *in_ch = is->chapters[i], *out_ch;
1947
        AVMetadataTag *t = NULL;
1948
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1949
                                      AV_TIME_BASE_Q, in_ch->time_base);
1950
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1951
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1952

    
1953

    
1954
        if (in_ch->end < ts_off)
1955
            continue;
1956
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1957
            break;
1958

    
1959
        out_ch = av_mallocz(sizeof(AVChapter));
1960
        if (!out_ch)
1961
            return AVERROR(ENOMEM);
1962

    
1963
        out_ch->id        = in_ch->id;
1964
        out_ch->time_base = in_ch->time_base;
1965
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1966
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1967

    
1968
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1969
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1970

    
1971
        os->nb_chapters++;
1972
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1973
        if (!os->chapters)
1974
            return AVERROR(ENOMEM);
1975
        os->chapters[os->nb_chapters - 1] = out_ch;
1976
    }
1977
    return 0;
1978
}
1979

    
1980
/*
1981
 * The following code is the main loop of the file converter
1982
 */
1983
static int transcode(AVFormatContext **output_files,
1984
                     int nb_output_files,
1985
                     AVFormatContext **input_files,
1986
                     int nb_input_files,
1987
                     AVStreamMap *stream_maps, int nb_stream_maps)
1988
{
1989
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1990
    AVFormatContext *is, *os;
1991
    AVCodecContext *codec, *icodec;
1992
    AVOutputStream *ost, **ost_table = NULL;
1993
    AVInputStream *ist, **ist_table = NULL;
1994
    AVInputFile *file_table;
1995
    char error[1024];
1996
    int key;
1997
    int want_sdp = 1;
1998
    uint8_t no_packet[MAX_FILES]={0};
1999
    int no_packet_count=0;
2000

    
2001
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
2002
    if (!file_table)
2003
        goto fail;
2004

    
2005
    /* input stream init */
2006
    j = 0;
2007
    for(i=0;i<nb_input_files;i++) {
2008
        is = input_files[i];
2009
        file_table[i].ist_index = j;
2010
        file_table[i].nb_streams = is->nb_streams;
2011
        j += is->nb_streams;
2012
    }
2013
    nb_istreams = j;
2014

    
2015
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
2016
    if (!ist_table)
2017
        goto fail;
2018

    
2019
    for(i=0;i<nb_istreams;i++) {
2020
        ist = av_mallocz(sizeof(AVInputStream));
2021
        if (!ist)
2022
            goto fail;
2023
        ist_table[i] = ist;
2024
    }
2025
    j = 0;
2026
    for(i=0;i<nb_input_files;i++) {
2027
        is = input_files[i];
2028
        for(k=0;k<is->nb_streams;k++) {
2029
            ist = ist_table[j++];
2030
            ist->st = is->streams[k];
2031
            ist->file_index = i;
2032
            ist->index = k;
2033
            ist->discard = 1; /* the stream is discarded by default
2034
                                 (changed later) */
2035

    
2036
            if (rate_emu) {
2037
                ist->start = av_gettime();
2038
            }
2039
        }
2040
    }
2041

    
2042
    /* output stream init */
2043
    nb_ostreams = 0;
2044
    for(i=0;i<nb_output_files;i++) {
2045
        os = output_files[i];
2046
        if (!os->nb_streams) {
2047
            dump_format(output_files[i], i, output_files[i]->filename, 1);
2048
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2049
            ret = AVERROR(EINVAL);
2050
            goto fail;
2051
        }
2052
        nb_ostreams += os->nb_streams;
2053
    }
2054
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2055
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2056
        ret = AVERROR(EINVAL);
2057
        goto fail;
2058
    }
2059

    
2060
    /* Sanity check the mapping args -- do the input files & streams exist? */
2061
    for(i=0;i<nb_stream_maps;i++) {
2062
        int fi = stream_maps[i].file_index;
2063
        int si = stream_maps[i].stream_index;
2064

    
2065
        if (fi < 0 || fi > nb_input_files - 1 ||
2066
            si < 0 || si > file_table[fi].nb_streams - 1) {
2067
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2068
            ret = AVERROR(EINVAL);
2069
            goto fail;
2070
        }
2071
        fi = stream_maps[i].sync_file_index;
2072
        si = stream_maps[i].sync_stream_index;
2073
        if (fi < 0 || fi > nb_input_files - 1 ||
2074
            si < 0 || si > file_table[fi].nb_streams - 1) {
2075
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2076
            ret = AVERROR(EINVAL);
2077
            goto fail;
2078
        }
2079
    }
2080

    
2081
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2082
    if (!ost_table)
2083
        goto fail;
2084
    for(i=0;i<nb_ostreams;i++) {
2085
        ost = av_mallocz(sizeof(AVOutputStream));
2086
        if (!ost)
2087
            goto fail;
2088
        ost_table[i] = ost;
2089
    }
2090

    
2091
    n = 0;
2092
    for(k=0;k<nb_output_files;k++) {
2093
        os = output_files[k];
2094
        for(i=0;i<os->nb_streams;i++,n++) {
2095
            int found;
2096
            ost = ost_table[n];
2097
            ost->file_index = k;
2098
            ost->index = i;
2099
            ost->st = os->streams[i];
2100
            if (nb_stream_maps > 0) {
2101
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2102
                    stream_maps[n].stream_index;
2103

    
2104
                /* Sanity check that the stream types match */
2105
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2106
                    int i= ost->file_index;
2107
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2108
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2109
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2110
                        ost->file_index, ost->index);
2111
                    ffmpeg_exit(1);
2112
                }
2113

    
2114
            } else {
2115
                int best_nb_frames=-1;
2116
                /* get corresponding input stream index : we select the first one with the right type */
2117
                found = 0;
2118
                for(j=0;j<nb_istreams;j++) {
2119
                    int skip=0;
2120
                    ist = ist_table[j];
2121
                    if(opt_programid){
2122
                        int pi,si;
2123
                        AVFormatContext *f= input_files[ ist->file_index ];
2124
                        skip=1;
2125
                        for(pi=0; pi<f->nb_programs; pi++){
2126
                            AVProgram *p= f->programs[pi];
2127
                            if(p->id == opt_programid)
2128
                                for(si=0; si<p->nb_stream_indexes; si++){
2129
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2130
                                        skip=0;
2131
                                }
2132
                        }
2133
                    }
2134
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2135
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2136
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2137
                            best_nb_frames= ist->st->codec_info_nb_frames;
2138
                            ost->source_index = j;
2139
                            found = 1;
2140
                        }
2141
                    }
2142
                }
2143

    
2144
                if (!found) {
2145
                    if(! opt_programid) {
2146
                        /* try again and reuse existing stream */
2147
                        for(j=0;j<nb_istreams;j++) {
2148
                            ist = ist_table[j];
2149
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2150
                                && ist->st->discard != AVDISCARD_ALL) {
2151
                                ost->source_index = j;
2152
                                found = 1;
2153
                            }
2154
                        }
2155
                    }
2156
                    if (!found) {
2157
                        int i= ost->file_index;
2158
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2159
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2160
                                ost->file_index, ost->index);
2161
                        ffmpeg_exit(1);
2162
                    }
2163
                }
2164
            }
2165
            ist = ist_table[ost->source_index];
2166
            ist->discard = 0;
2167
            ost->sync_ist = (nb_stream_maps > 0) ?
2168
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2169
                         stream_maps[n].sync_stream_index] : ist;
2170
        }
2171
    }
2172

    
2173
    /* for each output stream, we compute the right encoding parameters */
2174
    for(i=0;i<nb_ostreams;i++) {
2175
        AVMetadataTag *t = NULL;
2176
        ost = ost_table[i];
2177
        os = output_files[ost->file_index];
2178
        ist = ist_table[ost->source_index];
2179

    
2180
        codec = ost->st->codec;
2181
        icodec = ist->st->codec;
2182

    
2183
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2184
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2185
        }
2186

    
2187
        ost->st->disposition = ist->st->disposition;
2188
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2189
        codec->chroma_sample_location = icodec->chroma_sample_location;
2190

    
2191
        if (ost->st->stream_copy) {
2192
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2193

    
2194
            if (extra_size > INT_MAX)
2195
                goto fail;
2196

    
2197
            /* if stream_copy is selected, no need to decode or encode */
2198
            codec->codec_id = icodec->codec_id;
2199
            codec->codec_type = icodec->codec_type;
2200

    
2201
            if(!codec->codec_tag){
2202
                if(   !os->oformat->codec_tag
2203
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2204
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2205
                    codec->codec_tag = icodec->codec_tag;
2206
            }
2207

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

    
2302
#if !CONFIG_AVFILTER
2303
                    ost->original_height = icodec->height;
2304
                    ost->original_width  = icodec->width;
2305
#endif
2306
                    codec->bits_per_raw_sample= 0;
2307
                }
2308
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2309
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2310
                ost->resample_pix_fmt= icodec->pix_fmt;
2311
                ost->encoding_needed = 1;
2312
                ist->decoding_needed = 1;
2313

    
2314
#if CONFIG_AVFILTER
2315
                if (configure_filters(ist, ost)) {
2316
                    fprintf(stderr, "Error opening filters!\n");
2317
                    exit(1);
2318
                }
2319
#endif
2320
                break;
2321
            case AVMEDIA_TYPE_SUBTITLE:
2322
                ost->encoding_needed = 1;
2323
                ist->decoding_needed = 1;
2324
                break;
2325
            default:
2326
                abort();
2327
                break;
2328
            }
2329
            /* two pass mode */
2330
            if (ost->encoding_needed &&
2331
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2332
                char logfilename[1024];
2333
                FILE *f;
2334

    
2335
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2336
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2337
                         i);
2338
                if (codec->flags & CODEC_FLAG_PASS1) {
2339
                    f = fopen(logfilename, "wb");
2340
                    if (!f) {
2341
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2342
                        ffmpeg_exit(1);
2343
                    }
2344
                    ost->logfile = f;
2345
                } else {
2346
                    char  *logbuffer;
2347
                    size_t logbuffer_size;
2348
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2349
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2350
                        ffmpeg_exit(1);
2351
                    }
2352
                    codec->stats_in = logbuffer;
2353
                }
2354
            }
2355
        }
2356
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2357
            int size= codec->width * codec->height;
2358
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2359
        }
2360
    }
2361

    
2362
    if (!bit_buffer)
2363
        bit_buffer = av_malloc(bit_buffer_size);
2364
    if (!bit_buffer) {
2365
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2366
                bit_buffer_size);
2367
        ret = AVERROR(ENOMEM);
2368
        goto fail;
2369
    }
2370

    
2371
    /* open each encoder */
2372
    for(i=0;i<nb_ostreams;i++) {
2373
        ost = ost_table[i];
2374
        if (ost->encoding_needed) {
2375
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2376
            if (!codec)
2377
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2378
            if (!codec) {
2379
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2380
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2381
                ret = AVERROR(EINVAL);
2382
                goto dump_format;
2383
            }
2384
            if (avcodec_open(ost->st->codec, codec) < 0) {
2385
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2386
                        ost->file_index, ost->index);
2387
                ret = AVERROR(EINVAL);
2388
                goto dump_format;
2389
            }
2390
            extra_size += ost->st->codec->extradata_size;
2391
        }
2392
    }
2393

    
2394
    /* open each decoder */
2395
    for(i=0;i<nb_istreams;i++) {
2396
        ist = ist_table[i];
2397
        if (ist->decoding_needed) {
2398
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2399
            if (!codec)
2400
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2401
            if (!codec) {
2402
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2403
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2404
                ret = AVERROR(EINVAL);
2405
                goto dump_format;
2406
            }
2407
            if (avcodec_open(ist->st->codec, codec) < 0) {
2408
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2409
                        ist->file_index, ist->index);
2410
                ret = AVERROR(EINVAL);
2411
                goto dump_format;
2412
            }
2413
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2414
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2415
        }
2416
    }
2417

    
2418
    /* init pts */
2419
    for(i=0;i<nb_istreams;i++) {
2420
        AVStream *st;
2421
        ist = ist_table[i];
2422
        st= ist->st;
2423
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2424
        ist->next_pts = AV_NOPTS_VALUE;
2425
        init_pts_correction(&ist->pts_ctx);
2426
        ist->is_start = 1;
2427
    }
2428

    
2429
    /* set meta data information from input file if required */
2430
    for (i=0;i<nb_meta_data_maps;i++) {
2431
        AVFormatContext *out_file;
2432
        AVFormatContext *in_file;
2433
        AVMetadataTag *mtag;
2434

    
2435
        int out_file_index = meta_data_maps[i].out_file;
2436
        int in_file_index = meta_data_maps[i].in_file;
2437
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2438
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2439
                     out_file_index, out_file_index, in_file_index);
2440
            ret = AVERROR(EINVAL);
2441
            goto dump_format;
2442
        }
2443
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2444
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2445
                     in_file_index, out_file_index, in_file_index);
2446
            ret = AVERROR(EINVAL);
2447
            goto dump_format;
2448
        }
2449

    
2450
        out_file = output_files[out_file_index];
2451
        in_file = input_files[in_file_index];
2452

    
2453

    
2454
        mtag=NULL;
2455
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2456
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2457
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2458
                                    in_file->iformat->metadata_conv);
2459
    }
2460

    
2461
    /* copy chapters from the first input file that has them*/
2462
    for (i = 0; i < nb_input_files; i++) {
2463
        if (!input_files[i]->nb_chapters)
2464
            continue;
2465

    
2466
        for (j = 0; j < nb_output_files; j++)
2467
            if ((ret = copy_chapters(i, j)) < 0)
2468
                goto dump_format;
2469
    }
2470

    
2471
    /* open files and write file headers */
2472
    for(i=0;i<nb_output_files;i++) {
2473
        os = output_files[i];
2474
        if (av_write_header(os) < 0) {
2475
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2476
            ret = AVERROR(EINVAL);
2477
            goto dump_format;
2478
        }
2479
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2480
            want_sdp = 0;
2481
        }
2482
    }
2483

    
2484
 dump_format:
2485
    /* dump the file output parameters - cannot be done before in case
2486
       of stream copy */
2487
    for(i=0;i<nb_output_files;i++) {
2488
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2489
    }
2490

    
2491
    /* dump the stream mapping */
2492
    if (verbose >= 0) {
2493
        fprintf(stderr, "Stream mapping:\n");
2494
        for(i=0;i<nb_ostreams;i++) {
2495
            ost = ost_table[i];
2496
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2497
                    ist_table[ost->source_index]->file_index,
2498
                    ist_table[ost->source_index]->index,
2499
                    ost->file_index,
2500
                    ost->index);
2501
            if (ost->sync_ist != ist_table[ost->source_index])
2502
                fprintf(stderr, " [sync #%d.%d]",
2503
                        ost->sync_ist->file_index,
2504
                        ost->sync_ist->index);
2505
            fprintf(stderr, "\n");
2506
        }
2507
    }
2508

    
2509
    if (ret) {
2510
        fprintf(stderr, "%s\n", error);
2511
        goto fail;
2512
    }
2513

    
2514
    if (want_sdp) {
2515
        print_sdp(output_files, nb_output_files);
2516
    }
2517

    
2518
    if (!using_stdin && verbose >= 0) {
2519
        fprintf(stderr, "Press [q] to stop encoding\n");
2520
        url_set_interrupt_cb(decode_interrupt_cb);
2521
    }
2522
    term_init();
2523

    
2524
    timer_start = av_gettime();
2525

    
2526
    for(; received_sigterm == 0;) {
2527
        int file_index, ist_index;
2528
        AVPacket pkt;
2529
        double ipts_min;
2530
        double opts_min;
2531

    
2532
    redo:
2533
        ipts_min= 1e100;
2534
        opts_min= 1e100;
2535
        /* if 'q' pressed, exits */
2536
        if (!using_stdin) {
2537
            if (q_pressed)
2538
                break;
2539
            /* read_key() returns 0 on EOF */
2540
            key = read_key();
2541
            if (key == 'q')
2542
                break;
2543
        }
2544

    
2545
        /* select the stream that we must read now by looking at the
2546
           smallest output pts */
2547
        file_index = -1;
2548
        for(i=0;i<nb_ostreams;i++) {
2549
            double ipts, opts;
2550
            ost = ost_table[i];
2551
            os = output_files[ost->file_index];
2552
            ist = ist_table[ost->source_index];
2553
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2554
                continue;
2555
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2556
            ipts = (double)ist->pts;
2557
            if (!file_table[ist->file_index].eof_reached){
2558
                if(ipts < ipts_min) {
2559
                    ipts_min = ipts;
2560
                    if(input_sync ) file_index = ist->file_index;
2561
                }
2562
                if(opts < opts_min) {
2563
                    opts_min = opts;
2564
                    if(!input_sync) file_index = ist->file_index;
2565
                }
2566
            }
2567
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2568
                file_index= -1;
2569
                break;
2570
            }
2571
        }
2572
        /* if none, if is finished */
2573
        if (file_index < 0) {
2574
            if(no_packet_count){
2575
                no_packet_count=0;
2576
                memset(no_packet, 0, sizeof(no_packet));
2577
                usleep(10000);
2578
                continue;
2579
            }
2580
            break;
2581
        }
2582

    
2583
        /* finish if limit size exhausted */
2584
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2585
            break;
2586

    
2587
        /* read a frame from it and output it in the fifo */
2588
        is = input_files[file_index];
2589
        ret= av_read_frame(is, &pkt);
2590
        if(ret == AVERROR(EAGAIN)){
2591
            no_packet[file_index]=1;
2592
            no_packet_count++;
2593
            continue;
2594
        }
2595
        if (ret < 0) {
2596
            file_table[file_index].eof_reached = 1;
2597
            if (opt_shortest)
2598
                break;
2599
            else
2600
                continue;
2601
        }
2602

    
2603
        no_packet_count=0;
2604
        memset(no_packet, 0, sizeof(no_packet));
2605

    
2606
        if (do_pkt_dump) {
2607
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2608
        }
2609
        /* the following test is needed in case new streams appear
2610
           dynamically in stream : we ignore them */
2611
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2612
            goto discard_packet;
2613
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2614
        ist = ist_table[ist_index];
2615
        if (ist->discard)
2616
            goto discard_packet;
2617

    
2618
        if (pkt.dts != AV_NOPTS_VALUE)
2619
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2620
        if (pkt.pts != AV_NOPTS_VALUE)
2621
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2622

    
2623
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2624
            && input_files_ts_scale[file_index][pkt.stream_index]){
2625
            if(pkt.pts != AV_NOPTS_VALUE)
2626
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2627
            if(pkt.dts != AV_NOPTS_VALUE)
2628
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2629
        }
2630

    
2631
//        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);
2632
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2633
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2634
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2635
            int64_t delta= pkt_dts - ist->next_pts;
2636
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2637
                input_files_ts_offset[ist->file_index]-= delta;
2638
                if (verbose > 2)
2639
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2640
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2641
                if(pkt.pts != AV_NOPTS_VALUE)
2642
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2643
            }
2644
        }
2645

    
2646
        /* finish if recording time exhausted */
2647
        if (recording_time != INT64_MAX &&
2648
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2649
            ist->is_past_recording_time = 1;
2650
            goto discard_packet;
2651
        }
2652

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

    
2656
            if (verbose >= 0)
2657
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2658
                        ist->file_index, ist->index);
2659
            if (exit_on_error)
2660
                ffmpeg_exit(1);
2661
            av_free_packet(&pkt);
2662
            goto redo;
2663
        }
2664

    
2665
    discard_packet:
2666
        av_free_packet(&pkt);
2667

    
2668
        /* dump report by using the output first video and audio streams */
2669
        print_report(output_files, ost_table, nb_ostreams, 0);
2670
    }
2671

    
2672
    /* at the end of stream, we must flush the decoder buffers */
2673
    for(i=0;i<nb_istreams;i++) {
2674
        ist = ist_table[i];
2675
        if (ist->decoding_needed) {
2676
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2677
        }
2678
    }
2679

    
2680
    term_exit();
2681

    
2682
    /* write the trailer if needed and close file */
2683
    for(i=0;i<nb_output_files;i++) {
2684
        os = output_files[i];
2685
        av_write_trailer(os);
2686
    }
2687

    
2688
    /* dump report by using the first video and audio streams */
2689
    print_report(output_files, ost_table, nb_ostreams, 1);
2690

    
2691
    /* close each encoder */
2692
    for(i=0;i<nb_ostreams;i++) {
2693
        ost = ost_table[i];
2694
        if (ost->encoding_needed) {
2695
            av_freep(&ost->st->codec->stats_in);
2696
            avcodec_close(ost->st->codec);
2697
        }
2698
    }
2699

    
2700
    /* close each decoder */
2701
    for(i=0;i<nb_istreams;i++) {
2702
        ist = ist_table[i];
2703
        if (ist->decoding_needed) {
2704
            avcodec_close(ist->st->codec);
2705
        }
2706
    }
2707
#if CONFIG_AVFILTER
2708
    if (graph) {
2709
        avfilter_graph_destroy(graph);
2710
        av_freep(&graph);
2711
    }
2712
#endif
2713

    
2714
    /* finished ! */
2715
    ret = 0;
2716

    
2717
 fail:
2718
    av_freep(&bit_buffer);
2719
    av_free(file_table);
2720

    
2721
    if (ist_table) {
2722
        for(i=0;i<nb_istreams;i++) {
2723
            ist = ist_table[i];
2724
            av_free(ist);
2725
        }
2726
        av_free(ist_table);
2727
    }
2728
    if (ost_table) {
2729
        for(i=0;i<nb_ostreams;i++) {
2730
            ost = ost_table[i];
2731
            if (ost) {
2732
                if (ost->st->stream_copy)
2733
                    av_freep(&ost->st->codec->extradata);
2734
                if (ost->logfile) {
2735
                    fclose(ost->logfile);
2736
                    ost->logfile = NULL;
2737
                }
2738
                av_fifo_free(ost->fifo); /* works even if fifo is not
2739
                                             initialized but set to zero */
2740
                av_free(ost->pict_tmp.data[0]);
2741
                if (ost->video_resample)
2742
                    sws_freeContext(ost->img_resample_ctx);
2743
                if (ost->resample)
2744
                    audio_resample_close(ost->resample);
2745
                if (ost->reformat_ctx)
2746
                    av_audio_convert_free(ost->reformat_ctx);
2747
                av_free(ost);
2748
            }
2749
        }
2750
        av_free(ost_table);
2751
    }
2752
    return ret;
2753
}
2754

    
2755
static void opt_format(const char *arg)
2756
{
2757
    /* compatibility stuff for pgmyuv */
2758
    if (!strcmp(arg, "pgmyuv")) {
2759
        pgmyuv_compatibility_hack=1;
2760
//        opt_image_format(arg);
2761
        arg = "image2";
2762
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2763
    }
2764

    
2765
    last_asked_format = arg;
2766
}
2767

    
2768
static void opt_video_rc_override_string(const char *arg)
2769
{
2770
    video_rc_override_string = arg;
2771
}
2772

    
2773
static int opt_me_threshold(const char *opt, const char *arg)
2774
{
2775
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2776
    return 0;
2777
}
2778

    
2779
static int opt_verbose(const char *opt, const char *arg)
2780
{
2781
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2782
    return 0;
2783
}
2784

    
2785
static int opt_frame_rate(const char *opt, const char *arg)
2786
{
2787
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2788
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2789
        ffmpeg_exit(1);
2790
    }
2791
    return 0;
2792
}
2793

    
2794
static int opt_bitrate(const char *opt, const char *arg)
2795
{
2796
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2797

    
2798
    opt_default(opt, arg);
2799

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

    
2803
    return 0;
2804
}
2805

    
2806
static void opt_frame_crop_top(const char *arg)
2807
{
2808
    frame_topBand = atoi(arg);
2809
    if (frame_topBand < 0) {
2810
        fprintf(stderr, "Incorrect top crop size\n");
2811
        ffmpeg_exit(1);
2812
    }
2813
    if ((frame_topBand) >= 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_topBand;
2819
}
2820

    
2821
static void opt_frame_crop_bottom(const char *arg)
2822
{
2823
    frame_bottomBand = atoi(arg);
2824
    if (frame_bottomBand < 0) {
2825
        fprintf(stderr, "Incorrect bottom crop size\n");
2826
        ffmpeg_exit(1);
2827
    }
2828
    if ((frame_bottomBand) >= frame_height){
2829
        fprintf(stderr, "Vertical 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_height -= frame_bottomBand;
2834
}
2835

    
2836
static void opt_frame_crop_left(const char *arg)
2837
{
2838
    frame_leftBand = atoi(arg);
2839
    if (frame_leftBand < 0) {
2840
        fprintf(stderr, "Incorrect left crop size\n");
2841
        ffmpeg_exit(1);
2842
    }
2843
    if ((frame_leftBand) >= 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_leftBand;
2849
}
2850

    
2851
static void opt_frame_crop_right(const char *arg)
2852
{
2853
    frame_rightBand = atoi(arg);
2854
    if (frame_rightBand < 0) {
2855
        fprintf(stderr, "Incorrect right crop size\n");
2856
        ffmpeg_exit(1);
2857
    }
2858
    if ((frame_rightBand) >= frame_width){
2859
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2860
        ffmpeg_exit(1);
2861
    }
2862
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2863
    frame_width -= frame_rightBand;
2864
}
2865

    
2866
static void opt_frame_size(const char *arg)
2867
{
2868
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2869
        fprintf(stderr, "Incorrect frame size\n");
2870
        ffmpeg_exit(1);
2871
    }
2872
}
2873

    
2874
static int opt_pad(const char *opt, const char *arg) {
2875
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2876
    return -1;
2877
}
2878

    
2879
static void opt_frame_pix_fmt(const char *arg)
2880
{
2881
    if (strcmp(arg, "list")) {
2882
        frame_pix_fmt = av_get_pix_fmt(arg);
2883
        if (frame_pix_fmt == PIX_FMT_NONE) {
2884
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2885
            ffmpeg_exit(1);
2886
        }
2887
    } else {
2888
        show_pix_fmts();
2889
        ffmpeg_exit(0);
2890
    }
2891
}
2892

    
2893
static void opt_frame_aspect_ratio(const char *arg)
2894
{
2895
    int x = 0, y = 0;
2896
    double ar = 0;
2897
    const char *p;
2898
    char *end;
2899

    
2900
    p = strchr(arg, ':');
2901
    if (p) {
2902
        x = strtol(arg, &end, 10);
2903
        if (end == p)
2904
            y = strtol(end+1, &end, 10);
2905
        if (x > 0 && y > 0)
2906
            ar = (double)x / (double)y;
2907
    } else
2908
        ar = strtod(arg, NULL);
2909

    
2910
    if (!ar) {
2911
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2912
        ffmpeg_exit(1);
2913
    }
2914
    frame_aspect_ratio = ar;
2915
}
2916

    
2917
static int opt_metadata(const char *opt, const char *arg)
2918
{
2919
    char *mid= strchr(arg, '=');
2920

    
2921
    if(!mid){
2922
        fprintf(stderr, "Missing =\n");
2923
        ffmpeg_exit(1);
2924
    }
2925
    *mid++= 0;
2926

    
2927
    metadata_count++;
2928
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2929
    metadata[metadata_count-1].key  = av_strdup(arg);
2930
    metadata[metadata_count-1].value= av_strdup(mid);
2931

    
2932
    return 0;
2933
}
2934

    
2935
static void opt_qscale(const char *arg)
2936
{
2937
    video_qscale = atof(arg);
2938
    if (video_qscale <= 0 ||
2939
        video_qscale > 255) {
2940
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2941
        ffmpeg_exit(1);
2942
    }
2943
}
2944

    
2945
static void opt_top_field_first(const char *arg)
2946
{
2947
    top_field_first= atoi(arg);
2948
}
2949

    
2950
static int opt_thread_count(const char *opt, const char *arg)
2951
{
2952
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2953
#if !HAVE_THREADS
2954
    if (verbose >= 0)
2955
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2956
#endif
2957
    return 0;
2958
}
2959

    
2960
static void opt_audio_sample_fmt(const char *arg)
2961
{
2962
    if (strcmp(arg, "list"))
2963
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2964
    else {
2965
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2966
        ffmpeg_exit(0);
2967
    }
2968
}
2969

    
2970
static int opt_audio_rate(const char *opt, const char *arg)
2971
{
2972
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2973
    return 0;
2974
}
2975

    
2976
static int opt_audio_channels(const char *opt, const char *arg)
2977
{
2978
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2979
    return 0;
2980
}
2981

    
2982
static void opt_video_channel(const char *arg)
2983
{
2984
    video_channel = strtol(arg, NULL, 0);
2985
}
2986

    
2987
static void opt_video_standard(const char *arg)
2988
{
2989
    video_standard = av_strdup(arg);
2990
}
2991

    
2992
static void opt_codec(int *pstream_copy, char **pcodec_name,
2993
                      int codec_type, const char *arg)
2994
{
2995
    av_freep(pcodec_name);
2996
    if (!strcmp(arg, "copy")) {
2997
        *pstream_copy = 1;
2998
    } else {
2999
        *pcodec_name = av_strdup(arg);
3000
    }
3001
}
3002

    
3003
static void opt_audio_codec(const char *arg)
3004
{
3005
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3006
}
3007

    
3008
static void opt_audio_tag(const char *arg)
3009
{
3010
    char *tail;
3011
    audio_codec_tag= strtol(arg, &tail, 0);
3012

    
3013
    if(!tail || *tail)
3014
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3015
}
3016

    
3017
static void opt_video_tag(const char *arg)
3018
{
3019
    char *tail;
3020
    video_codec_tag= strtol(arg, &tail, 0);
3021

    
3022
    if(!tail || *tail)
3023
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3024
}
3025

    
3026
static void opt_video_codec(const char *arg)
3027
{
3028
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3029
}
3030

    
3031
static void opt_subtitle_codec(const char *arg)
3032
{
3033
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3034
}
3035

    
3036
static void opt_subtitle_tag(const char *arg)
3037
{
3038
    char *tail;
3039
    subtitle_codec_tag= strtol(arg, &tail, 0);
3040

    
3041
    if(!tail || *tail)
3042
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3043
}
3044

    
3045
static void opt_map(const char *arg)
3046
{
3047
    AVStreamMap *m;
3048
    char *p;
3049

    
3050
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3051
    m = &stream_maps[nb_stream_maps-1];
3052

    
3053
    m->file_index = strtol(arg, &p, 0);
3054
    if (*p)
3055
        p++;
3056

    
3057
    m->stream_index = strtol(p, &p, 0);
3058
    if (*p) {
3059
        p++;
3060
        m->sync_file_index = strtol(p, &p, 0);
3061
        if (*p)
3062
            p++;
3063
        m->sync_stream_index = strtol(p, &p, 0);
3064
    } else {
3065
        m->sync_file_index = m->file_index;
3066
        m->sync_stream_index = m->stream_index;
3067
    }
3068
}
3069

    
3070
static void opt_map_meta_data(const char *arg)
3071
{
3072
    AVMetaDataMap *m;
3073
    char *p;
3074

    
3075
    m = &meta_data_maps[nb_meta_data_maps++];
3076

    
3077
    m->out_file = strtol(arg, &p, 0);
3078
    if (*p)
3079
        p++;
3080

    
3081
    m->in_file = strtol(p, &p, 0);
3082
}
3083

    
3084
static void opt_input_ts_scale(const char *arg)
3085
{
3086
    unsigned int stream;
3087
    double scale;
3088
    char *p;
3089

    
3090
    stream = strtol(arg, &p, 0);
3091
    if (*p)
3092
        p++;
3093
    scale= strtod(p, &p);
3094

    
3095
    if(stream >= MAX_STREAMS)
3096
        ffmpeg_exit(1);
3097

    
3098
    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);
3099
    input_files_ts_scale[nb_input_files][stream]= scale;
3100
}
3101

    
3102
static int opt_recording_time(const char *opt, const char *arg)
3103
{
3104
    recording_time = parse_time_or_die(opt, arg, 1);
3105
    return 0;
3106
}
3107

    
3108
static int opt_start_time(const char *opt, const char *arg)
3109
{
3110
    start_time = parse_time_or_die(opt, arg, 1);
3111
    return 0;
3112
}
3113

    
3114
static int opt_recording_timestamp(const char *opt, const char *arg)
3115
{
3116
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3117
    return 0;
3118
}
3119

    
3120
static int opt_input_ts_offset(const char *opt, const char *arg)
3121
{
3122
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3123
    return 0;
3124
}
3125

    
3126
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3127
{
3128
    const char *codec_string = encoder ? "encoder" : "decoder";
3129
    AVCodec *codec;
3130

    
3131
    if(!name)
3132
        return CODEC_ID_NONE;
3133
    codec = encoder ?
3134
        avcodec_find_encoder_by_name(name) :
3135
        avcodec_find_decoder_by_name(name);
3136
    if(!codec) {
3137
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3138
        ffmpeg_exit(1);
3139
    }
3140
    if(codec->type != type) {
3141
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3142
        ffmpeg_exit(1);
3143
    }
3144
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3145
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3146
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3147
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3148
                codec_string, codec->name);
3149
        codec = encoder ?
3150
            avcodec_find_encoder(codec->id) :
3151
            avcodec_find_decoder(codec->id);
3152
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3153
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3154
                    codec_string, codec->name);
3155
        ffmpeg_exit(1);
3156
    }
3157
    return codec->id;
3158
}
3159

    
3160
static void opt_input_file(const char *filename)
3161
{
3162
    AVFormatContext *ic;
3163
    AVFormatParameters params, *ap = &params;
3164
    AVInputFormat *file_iformat = NULL;
3165
    int err, i, ret, rfps, rfps_base;
3166
    int64_t timestamp;
3167

    
3168
    if (last_asked_format) {
3169
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3170
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3171
            ffmpeg_exit(1);
3172
        }
3173
        last_asked_format = NULL;
3174
    }
3175

    
3176
    if (!strcmp(filename, "-"))
3177
        filename = "pipe:";
3178

    
3179
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3180
                    !strcmp(filename, "/dev/stdin");
3181

    
3182
    /* get default parameters from command line */
3183
    ic = avformat_alloc_context();
3184
    if (!ic) {
3185
        print_error(filename, AVERROR(ENOMEM));
3186
        ffmpeg_exit(1);
3187
    }
3188

    
3189
    memset(ap, 0, sizeof(*ap));
3190
    ap->prealloced_context = 1;
3191
    ap->sample_rate = audio_sample_rate;
3192
    ap->channels = audio_channels;
3193
    ap->time_base.den = frame_rate.num;
3194
    ap->time_base.num = frame_rate.den;
3195
    ap->width = frame_width;
3196
    ap->height = frame_height;
3197
    ap->pix_fmt = frame_pix_fmt;
3198
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3199
    ap->channel = video_channel;
3200
    ap->standard = video_standard;
3201

    
3202
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3203

    
3204
    ic->video_codec_id   =
3205
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3206
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3207
    ic->audio_codec_id   =
3208
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3209
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3210
    ic->subtitle_codec_id=
3211
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3212
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3213
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3214

    
3215
    if(pgmyuv_compatibility_hack)
3216
        ic->video_codec_id= CODEC_ID_PGMYUV;
3217

    
3218
    /* open the input file with generic libav function */
3219
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3220
    if (err < 0) {
3221
        print_error(filename, err);
3222
        ffmpeg_exit(1);
3223
    }
3224
    if(opt_programid) {
3225
        int i, j;
3226
        int found=0;
3227
        for(i=0; i<ic->nb_streams; i++){
3228
            ic->streams[i]->discard= AVDISCARD_ALL;
3229
        }
3230
        for(i=0; i<ic->nb_programs; i++){
3231
            AVProgram *p= ic->programs[i];
3232
            if(p->id != opt_programid){
3233
                p->discard = AVDISCARD_ALL;
3234
            }else{
3235
                found=1;
3236
                for(j=0; j<p->nb_stream_indexes; j++){
3237
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3238
                }
3239
            }
3240
        }
3241
        if(!found){
3242
            fprintf(stderr, "Specified program id not found\n");
3243
            ffmpeg_exit(1);
3244
        }
3245
        opt_programid=0;
3246
    }
3247

    
3248
    ic->loop_input = loop_input;
3249

    
3250
    /* If not enough info to get the stream parameters, we decode the
3251
       first frames to get it. (used in mpeg case for example) */
3252
    ret = av_find_stream_info(ic);
3253
    if (ret < 0 && verbose >= 0) {
3254
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3255
        av_close_input_file(ic);
3256
        ffmpeg_exit(1);
3257
    }
3258

    
3259
    timestamp = start_time;
3260
    /* add the stream start time */
3261
    if (ic->start_time != AV_NOPTS_VALUE)
3262
        timestamp += ic->start_time;
3263

    
3264
    /* if seeking requested, we execute it */
3265
    if (start_time != 0) {
3266
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3267
        if (ret < 0) {
3268
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3269
                    filename, (double)timestamp / AV_TIME_BASE);
3270
        }
3271
        /* reset seek info */
3272
        start_time = 0;
3273
    }
3274

    
3275
    /* update the current parameters so that they match the one of the input stream */
3276
    for(i=0;i<ic->nb_streams;i++) {
3277
        AVStream *st = ic->streams[i];
3278
        AVCodecContext *dec = st->codec;
3279
        avcodec_thread_init(dec, thread_count);
3280
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3281
        switch (dec->codec_type) {
3282
        case AVMEDIA_TYPE_AUDIO:
3283
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3284
            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]);
3285
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3286
            channel_layout    = dec->channel_layout;
3287
            audio_channels    = dec->channels;
3288
            audio_sample_rate = dec->sample_rate;
3289
            audio_sample_fmt  = dec->sample_fmt;
3290
            if(audio_disable)
3291
                st->discard= AVDISCARD_ALL;
3292
            /* Note that av_find_stream_info can add more streams, and we
3293
             * currently have no chance of setting up lowres decoding
3294
             * early enough for them. */
3295
            if (dec->lowres)
3296
                audio_sample_rate >>= dec->lowres;
3297
            break;
3298
        case AVMEDIA_TYPE_VIDEO:
3299
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3300
            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]);
3301
            frame_height = dec->height;
3302
            frame_width  = dec->width;
3303
            if(ic->streams[i]->sample_aspect_ratio.num)
3304
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3305
            else
3306
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3307
            frame_aspect_ratio *= (float) dec->width / dec->height;
3308
            frame_pix_fmt = dec->pix_fmt;
3309
            rfps      = ic->streams[i]->r_frame_rate.num;
3310
            rfps_base = ic->streams[i]->r_frame_rate.den;
3311
            if (dec->lowres) {
3312
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3313
                frame_height >>= dec->lowres;
3314
                frame_width  >>= dec->lowres;
3315
            }
3316
            if(me_threshold)
3317
                dec->debug |= FF_DEBUG_MV;
3318

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

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

    
3325
                    (float)rfps / rfps_base, rfps, rfps_base);
3326
            }
3327
            /* update the current frame rate to match the stream frame rate */
3328
            frame_rate.num = rfps;
3329
            frame_rate.den = rfps_base;
3330

    
3331
            if(video_disable)
3332
                st->discard= AVDISCARD_ALL;
3333
            else if(video_discard)
3334
                st->discard= video_discard;
3335
            break;
3336
        case AVMEDIA_TYPE_DATA:
3337
            break;
3338
        case AVMEDIA_TYPE_SUBTITLE:
3339
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3340
            if(subtitle_disable)
3341
                st->discard = AVDISCARD_ALL;
3342
            break;
3343
        case AVMEDIA_TYPE_ATTACHMENT:
3344
        case AVMEDIA_TYPE_UNKNOWN:
3345
            break;
3346
        default:
3347
            abort();
3348
        }
3349
    }
3350

    
3351
    input_files[nb_input_files] = ic;
3352
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3353
    /* dump the file content */
3354
    if (verbose >= 0)
3355
        dump_format(ic, nb_input_files, filename, 0);
3356

    
3357
    nb_input_files++;
3358

    
3359
    video_channel = 0;
3360

    
3361
    av_freep(&video_codec_name);
3362
    av_freep(&audio_codec_name);
3363
    av_freep(&subtitle_codec_name);
3364
}
3365

    
3366
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3367
                                         int *has_subtitle_ptr)
3368
{
3369
    int has_video, has_audio, has_subtitle, i, j;
3370
    AVFormatContext *ic;
3371

    
3372
    has_video = 0;
3373
    has_audio = 0;
3374
    has_subtitle = 0;
3375
    for(j=0;j<nb_input_files;j++) {
3376
        ic = input_files[j];
3377
        for(i=0;i<ic->nb_streams;i++) {
3378
            AVCodecContext *enc = ic->streams[i]->codec;
3379
            switch(enc->codec_type) {
3380
            case AVMEDIA_TYPE_AUDIO:
3381
                has_audio = 1;
3382
                break;
3383
            case AVMEDIA_TYPE_VIDEO:
3384
                has_video = 1;
3385
                break;
3386
            case AVMEDIA_TYPE_SUBTITLE:
3387
                has_subtitle = 1;
3388
                break;
3389
            case AVMEDIA_TYPE_DATA:
3390
            case AVMEDIA_TYPE_ATTACHMENT:
3391
            case AVMEDIA_TYPE_UNKNOWN:
3392
                break;
3393
            default:
3394
                abort();
3395
            }
3396
        }
3397
    }
3398
    *has_video_ptr = has_video;
3399
    *has_audio_ptr = has_audio;
3400
    *has_subtitle_ptr = has_subtitle;
3401
}
3402

    
3403
static void new_video_stream(AVFormatContext *oc, int file_idx)
3404
{
3405
    AVStream *st;
3406
    AVCodecContext *video_enc;
3407
    enum CodecID codec_id;
3408
    AVCodec *codec= NULL;
3409

    
3410
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3411
    if (!st) {
3412
        fprintf(stderr, "Could not alloc stream\n");
3413
        ffmpeg_exit(1);
3414
    }
3415

    
3416
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3417
    if(!video_stream_copy){
3418
        if (video_codec_name) {
3419
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3420
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3421
            codec = avcodec_find_encoder_by_name(video_codec_name);
3422
            output_codecs[nb_output_codecs-1] = codec;
3423
        } else {
3424
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3425
            codec = avcodec_find_encoder(codec_id);
3426
        }
3427
    }
3428

    
3429
    avcodec_get_context_defaults3(st->codec, codec);
3430
    bitstream_filters[file_idx] =
3431
        grow_array(bitstream_filters[file_idx],
3432
                   sizeof(*bitstream_filters[file_idx]),
3433
                   &nb_bitstream_filters[file_idx], oc->nb_streams);
3434
    bitstream_filters[file_idx][oc->nb_streams - 1]= video_bitstream_filters;
3435
    video_bitstream_filters= NULL;
3436

    
3437
    avcodec_thread_init(st->codec, thread_count);
3438

    
3439
    video_enc = st->codec;
3440

    
3441
    if(video_codec_tag)
3442
        video_enc->codec_tag= video_codec_tag;
3443

    
3444
    if(   (video_global_header&1)
3445
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3446
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3447
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3448
    }
3449
    if(video_global_header&2){
3450
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3451
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3452
    }
3453

    
3454
    if (video_stream_copy) {
3455
        st->stream_copy = 1;
3456
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3457
        video_enc->sample_aspect_ratio =
3458
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3459
    } else {
3460
        const char *p;
3461
        int i;
3462
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3463

    
3464
        video_enc->codec_id = codec_id;
3465
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3466

    
3467
        if (codec && codec->supported_framerates && !force_fps)
3468
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3469
        video_enc->time_base.den = fps.num;
3470
        video_enc->time_base.num = fps.den;
3471

    
3472
        video_enc->width = frame_width;
3473
        video_enc->height = frame_height;
3474
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3475
        video_enc->pix_fmt = frame_pix_fmt;
3476
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3477

    
3478
        choose_pixel_fmt(st, codec);
3479

    
3480
        if (intra_only)
3481
            video_enc->gop_size = 0;
3482
        if (video_qscale || same_quality) {
3483
            video_enc->flags |= CODEC_FLAG_QSCALE;
3484
            video_enc->global_quality=
3485
                st->quality = FF_QP2LAMBDA * video_qscale;
3486
        }
3487

    
3488
        if(intra_matrix)
3489
            video_enc->intra_matrix = intra_matrix;
3490
        if(inter_matrix)
3491
            video_enc->inter_matrix = inter_matrix;
3492

    
3493
        p= video_rc_override_string;
3494
        for(i=0; p; i++){
3495
            int start, end, q;
3496
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3497
            if(e!=3){
3498
                fprintf(stderr, "error parsing rc_override\n");
3499
                ffmpeg_exit(1);
3500
            }
3501
            video_enc->rc_override=
3502
                av_realloc(video_enc->rc_override,
3503
                           sizeof(RcOverride)*(i+1));
3504
            video_enc->rc_override[i].start_frame= start;
3505
            video_enc->rc_override[i].end_frame  = end;
3506
            if(q>0){
3507
                video_enc->rc_override[i].qscale= q;
3508
                video_enc->rc_override[i].quality_factor= 1.0;
3509
            }
3510
            else{
3511
                video_enc->rc_override[i].qscale= 0;
3512
                video_enc->rc_override[i].quality_factor= -q/100.0;
3513
            }
3514
            p= strchr(p, '/');
3515
            if(p) p++;
3516
        }
3517
        video_enc->rc_override_count=i;
3518
        if (!video_enc->rc_initial_buffer_occupancy)
3519
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3520
        video_enc->me_threshold= me_threshold;
3521
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3522

    
3523
        if (do_psnr)
3524
            video_enc->flags|= CODEC_FLAG_PSNR;
3525

    
3526
        /* two pass mode */
3527
        if (do_pass) {
3528
            if (do_pass == 1) {
3529
                video_enc->flags |= CODEC_FLAG_PASS1;
3530
            } else {
3531
                video_enc->flags |= CODEC_FLAG_PASS2;
3532
            }
3533
        }
3534
    }
3535
    if (video_language) {
3536
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3537
        av_freep(&video_language);
3538
    }
3539

    
3540
    /* reset some key parameters */
3541
    video_disable = 0;
3542
    av_freep(&video_codec_name);
3543
    video_stream_copy = 0;
3544
    frame_pix_fmt = PIX_FMT_NONE;
3545
}
3546

    
3547
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3548
{
3549
    AVStream *st;
3550
    AVCodec *codec= NULL;
3551
    AVCodecContext *audio_enc;
3552
    enum CodecID codec_id;
3553

    
3554
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3555
    if (!st) {
3556
        fprintf(stderr, "Could not alloc stream\n");
3557
        ffmpeg_exit(1);
3558
    }
3559

    
3560
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3561
    if(!audio_stream_copy){
3562
        if (audio_codec_name) {
3563
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3564
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3565
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3566
            output_codecs[nb_output_codecs-1] = codec;
3567
        } else {
3568
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3569
            codec = avcodec_find_encoder(codec_id);
3570
        }
3571
    }
3572

    
3573
    avcodec_get_context_defaults3(st->codec, codec);
3574

    
3575
    bitstream_filters[file_idx] =
3576
        grow_array(bitstream_filters[file_idx],
3577
                   sizeof(*bitstream_filters[file_idx]),
3578
                   &nb_bitstream_filters[file_idx], oc->nb_streams);
3579
    bitstream_filters[file_idx][oc->nb_streams - 1]= audio_bitstream_filters;
3580
    audio_bitstream_filters= NULL;
3581

    
3582
    avcodec_thread_init(st->codec, thread_count);
3583

    
3584
    audio_enc = st->codec;
3585
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3586

    
3587
    if(audio_codec_tag)
3588
        audio_enc->codec_tag= audio_codec_tag;
3589

    
3590
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3591
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3592
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3593
    }
3594
    if (audio_stream_copy) {
3595
        st->stream_copy = 1;
3596
        audio_enc->channels = audio_channels;
3597
        audio_enc->sample_rate = audio_sample_rate;
3598
    } else {
3599
        audio_enc->codec_id = codec_id;
3600
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3601

    
3602
        if (audio_qscale > QSCALE_NONE) {
3603
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3604
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3605
        }
3606
        audio_enc->channels = audio_channels;
3607
        audio_enc->sample_fmt = audio_sample_fmt;
3608
        audio_enc->sample_rate = audio_sample_rate;
3609
        audio_enc->channel_layout = channel_layout;
3610
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3611
            audio_enc->channel_layout = 0;
3612
        choose_sample_fmt(st, codec);
3613
        choose_sample_rate(st, codec);
3614
    }
3615
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3616
    if (audio_language) {
3617
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3618
        av_freep(&audio_language);
3619
    }
3620

    
3621
    /* reset some key parameters */
3622
    audio_disable = 0;
3623
    av_freep(&audio_codec_name);
3624
    audio_stream_copy = 0;
3625
}
3626

    
3627
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3628
{
3629
    AVStream *st;
3630
    AVCodec *codec=NULL;
3631
    AVCodecContext *subtitle_enc;
3632

    
3633
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3634
    if (!st) {
3635
        fprintf(stderr, "Could not alloc stream\n");
3636
        ffmpeg_exit(1);
3637
    }
3638
    subtitle_enc = st->codec;
3639
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3640
    if(!subtitle_stream_copy){
3641
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3642
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3643
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3644
    }
3645
    avcodec_get_context_defaults3(st->codec, codec);
3646

    
3647
    bitstream_filters[file_idx] =
3648
        grow_array(bitstream_filters[file_idx],
3649
                   sizeof(*bitstream_filters[file_idx]),
3650
                   &nb_bitstream_filters[file_idx], oc->nb_streams);
3651
    bitstream_filters[file_idx][oc->nb_streams - 1]= subtitle_bitstream_filters;
3652
    subtitle_bitstream_filters= NULL;
3653

    
3654
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3655

    
3656
    if(subtitle_codec_tag)
3657
        subtitle_enc->codec_tag= subtitle_codec_tag;
3658

    
3659
    if (subtitle_stream_copy) {
3660
        st->stream_copy = 1;
3661
    } else {
3662
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3663
    }
3664

    
3665
    if (subtitle_language) {
3666
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3667
        av_freep(&subtitle_language);
3668
    }
3669

    
3670
    subtitle_disable = 0;
3671
    av_freep(&subtitle_codec_name);
3672
    subtitle_stream_copy = 0;
3673
}
3674

    
3675
static int opt_new_stream(const char *opt, const char *arg)
3676
{
3677
    AVFormatContext *oc;
3678
    int file_idx = nb_output_files - 1;
3679
    if (nb_output_files <= 0) {
3680
        fprintf(stderr, "At least one output file must be specified\n");
3681
        ffmpeg_exit(1);
3682
    }
3683
    oc = output_files[file_idx];
3684

    
3685
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3686
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3687
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3688
    else av_assert0(0);
3689
    return 0;
3690
}
3691

    
3692
/* arg format is "output-stream-index:streamid-value". */
3693
static int opt_streamid(const char *opt, const char *arg)
3694
{
3695
    int idx;
3696
    char *p;
3697
    char idx_str[16];
3698

    
3699
    strncpy(idx_str, arg, sizeof(idx_str));
3700
    idx_str[sizeof(idx_str)-1] = '\0';
3701
    p = strchr(idx_str, ':');
3702
    if (!p) {
3703
        fprintf(stderr,
3704
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3705
                arg, opt);
3706
        ffmpeg_exit(1);
3707
    }
3708
    *p++ = '\0';
3709
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3710
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3711
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3712
    return 0;
3713
}
3714

    
3715
static void opt_output_file(const char *filename)
3716
{
3717
    AVFormatContext *oc;
3718
    int err, use_video, use_audio, use_subtitle;
3719
    int input_has_video, input_has_audio, input_has_subtitle;
3720
    AVFormatParameters params, *ap = &params;
3721
    AVOutputFormat *file_oformat;
3722

    
3723
    if (!strcmp(filename, "-"))
3724
        filename = "pipe:";
3725

    
3726
    oc = avformat_alloc_context();
3727
    if (!oc) {
3728
        print_error(filename, AVERROR(ENOMEM));
3729
        ffmpeg_exit(1);
3730
    }
3731

    
3732
    if (last_asked_format) {
3733
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3734
        if (!file_oformat) {
3735
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3736
            ffmpeg_exit(1);
3737
        }
3738
        last_asked_format = NULL;
3739
    } else {
3740
        file_oformat = av_guess_format(NULL, filename, NULL);
3741
        if (!file_oformat) {
3742
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3743
                    filename);
3744
            ffmpeg_exit(1);
3745
        }
3746
    }
3747

    
3748
    oc->oformat = file_oformat;
3749
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3750

    
3751
    if (!strcmp(file_oformat->name, "ffm") &&
3752
        av_strstart(filename, "http:", NULL)) {
3753
        /* special case for files sent to ffserver: we get the stream
3754
           parameters from ffserver */
3755
        int err = read_ffserver_streams(oc, filename);
3756
        if (err < 0) {
3757
            print_error(filename, err);
3758
            ffmpeg_exit(1);
3759
        }
3760
    } else {
3761
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3762
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3763
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3764

    
3765
        /* disable if no corresponding type found and at least one
3766
           input file */
3767
        if (nb_input_files > 0) {
3768
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3769
                                         &input_has_subtitle);
3770
            if (!input_has_video)
3771
                use_video = 0;
3772
            if (!input_has_audio)
3773
                use_audio = 0;
3774
            if (!input_has_subtitle)
3775
                use_subtitle = 0;
3776
        }
3777

    
3778
        /* manual disable */
3779
        if (audio_disable) {
3780
            use_audio = 0;
3781
        }
3782
        if (video_disable) {
3783
            use_video = 0;
3784
        }
3785
        if (subtitle_disable) {
3786
            use_subtitle = 0;
3787
        }
3788

    
3789
        if (use_video) {
3790
            new_video_stream(oc, nb_output_files);
3791
        }
3792

    
3793
        if (use_audio) {
3794
            new_audio_stream(oc, nb_output_files);
3795
        }
3796

    
3797
        if (use_subtitle) {
3798
            new_subtitle_stream(oc, nb_output_files);
3799
        }
3800

    
3801
        oc->timestamp = recording_timestamp;
3802

    
3803
        for(; metadata_count>0; metadata_count--){
3804
            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3805
                                            metadata[metadata_count-1].value, 0);
3806
        }
3807
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3808
    }
3809

    
3810
    output_files[nb_output_files++] = oc;
3811

    
3812
    /* check filename in case of an image number is expected */
3813
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3814
        if (!av_filename_number_test(oc->filename)) {
3815
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3816
            ffmpeg_exit(1);
3817
        }
3818
    }
3819

    
3820
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3821
        /* test if it already exists to avoid loosing precious files */
3822
        if (!file_overwrite &&
3823
            (strchr(filename, ':') == NULL ||
3824
             filename[1] == ':' ||
3825
             av_strstart(filename, "file:", NULL))) {
3826
            if (url_exist(filename)) {
3827
                if (!using_stdin) {
3828
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3829
                    fflush(stderr);
3830
                    if (!read_yesno()) {
3831
                        fprintf(stderr, "Not overwriting - exiting\n");
3832
                        ffmpeg_exit(1);
3833
                    }
3834
                }
3835
                else {
3836
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3837
                    ffmpeg_exit(1);
3838
                }
3839
            }
3840
        }
3841

    
3842
        /* open the file */
3843
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3844
            print_error(filename, err);
3845
            ffmpeg_exit(1);
3846
        }
3847
    }
3848

    
3849
    memset(ap, 0, sizeof(*ap));
3850
    if (av_set_parameters(oc, ap) < 0) {
3851
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3852
                oc->filename);
3853
        ffmpeg_exit(1);
3854
    }
3855

    
3856
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3857
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3858
    oc->loop_output = loop_output;
3859
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3860

    
3861
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3862

    
3863
    nb_streamid_map = 0;
3864
}
3865

    
3866
/* same option as mencoder */
3867
static void opt_pass(const char *pass_str)
3868
{
3869
    int pass;
3870
    pass = atoi(pass_str);
3871
    if (pass != 1 && pass != 2) {
3872
        fprintf(stderr, "pass number can be only 1 or 2\n");
3873
        ffmpeg_exit(1);
3874
    }
3875
    do_pass = pass;
3876
}
3877

    
3878
static int64_t getutime(void)
3879
{
3880
#if HAVE_GETRUSAGE
3881
    struct rusage rusage;
3882

    
3883
    getrusage(RUSAGE_SELF, &rusage);
3884
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3885
#elif HAVE_GETPROCESSTIMES
3886
    HANDLE proc;
3887
    FILETIME c, e, k, u;
3888
    proc = GetCurrentProcess();
3889
    GetProcessTimes(proc, &c, &e, &k, &u);
3890
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3891
#else
3892
    return av_gettime();
3893
#endif
3894
}
3895

    
3896
static int64_t getmaxrss(void)
3897
{
3898
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3899
    struct rusage rusage;
3900
    getrusage(RUSAGE_SELF, &rusage);
3901
    return (int64_t)rusage.ru_maxrss * 1024;
3902
#elif HAVE_GETPROCESSMEMORYINFO
3903
    HANDLE proc;
3904
    PROCESS_MEMORY_COUNTERS memcounters;
3905
    proc = GetCurrentProcess();
3906
    memcounters.cb = sizeof(memcounters);
3907
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3908
    return memcounters.PeakPagefileUsage;
3909
#else
3910
    return 0;
3911
#endif
3912
}
3913

    
3914
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3915
{
3916
    int i;
3917
    const char *p = str;
3918
    for(i = 0;; i++) {
3919
        dest[i] = atoi(p);
3920
        if(i == 63)
3921
            break;
3922
        p = strchr(p, ',');
3923
        if(!p) {
3924
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3925
            ffmpeg_exit(1);
3926
        }
3927
        p++;
3928
    }
3929
}
3930

    
3931
static void opt_inter_matrix(const char *arg)
3932
{
3933
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3934
    parse_matrix_coeffs(inter_matrix, arg);
3935
}
3936

    
3937
static void opt_intra_matrix(const char *arg)
3938
{
3939
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3940
    parse_matrix_coeffs(intra_matrix, arg);
3941
}
3942

    
3943
static void show_usage(void)
3944
{
3945
    printf("Hyper fast Audio and Video encoder\n");
3946
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3947
    printf("\n");
3948
}
3949

    
3950
static void show_help(void)
3951
{
3952
    av_log_set_callback(log_callback_help);
3953
    show_usage();
3954
    show_help_options(options, "Main options:\n",
3955
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3956
    show_help_options(options, "\nAdvanced options:\n",
3957
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3958
                      OPT_EXPERT);
3959
    show_help_options(options, "\nVideo options:\n",
3960
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3961
                      OPT_VIDEO);
3962
    show_help_options(options, "\nAdvanced Video options:\n",
3963
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3964
                      OPT_VIDEO | OPT_EXPERT);
3965
    show_help_options(options, "\nAudio options:\n",
3966
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3967
                      OPT_AUDIO);
3968
    show_help_options(options, "\nAdvanced Audio options:\n",
3969
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3970
                      OPT_AUDIO | OPT_EXPERT);
3971
    show_help_options(options, "\nSubtitle options:\n",
3972
                      OPT_SUBTITLE | OPT_GRAB,
3973
                      OPT_SUBTITLE);
3974
    show_help_options(options, "\nAudio/Video grab options:\n",
3975
                      OPT_GRAB,
3976
                      OPT_GRAB);
3977
    printf("\n");
3978
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3979
    printf("\n");
3980
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3981
    printf("\n");
3982
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3983
}
3984

    
3985
static void opt_target(const char *arg)
3986
{
3987
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3988
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3989

    
3990
    if(!strncmp(arg, "pal-", 4)) {
3991
        norm = PAL;
3992
        arg += 4;
3993
    } else if(!strncmp(arg, "ntsc-", 5)) {
3994
        norm = NTSC;
3995
        arg += 5;
3996
    } else if(!strncmp(arg, "film-", 5)) {
3997
        norm = FILM;
3998
        arg += 5;
3999
    } else {
4000
        int fr;
4001
        /* Calculate FR via float to avoid int overflow */
4002
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4003
        if(fr == 25000) {
4004
            norm = PAL;
4005
        } else if((fr == 29970) || (fr == 23976)) {
4006
            norm = NTSC;
4007
        } else {
4008
            /* Try to determine PAL/NTSC by peeking in the input files */
4009
            if(nb_input_files) {
4010
                int i, j;
4011
                for(j = 0; j < nb_input_files; j++) {
4012
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4013
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4014
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4015
                            continue;
4016
                        fr = c->time_base.den * 1000 / c->time_base.num;
4017
                        if(fr == 25000) {
4018
                            norm = PAL;
4019
                            break;
4020
                        } else if((fr == 29970) || (fr == 23976)) {
4021
                            norm = NTSC;
4022
                            break;
4023
                        }
4024
                    }
4025
                    if(norm != UNKNOWN)
4026
                        break;
4027
                }
4028
            }
4029
        }
4030
        if(verbose && norm != UNKNOWN)
4031
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4032
    }
4033

    
4034
    if(norm == UNKNOWN) {
4035
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4036
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4037
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4038
        ffmpeg_exit(1);
4039
    }
4040

    
4041
    if(!strcmp(arg, "vcd")) {
4042

    
4043
        opt_video_codec("mpeg1video");
4044
        opt_audio_codec("mp2");
4045
        opt_format("vcd");
4046

    
4047
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4048
        opt_frame_rate(NULL, frame_rates[norm]);
4049
        opt_default("g", norm == PAL ? "15" : "18");
4050

    
4051
        opt_default("b", "1150000");
4052
        opt_default("maxrate", "1150000");
4053
        opt_default("minrate", "1150000");
4054
        opt_default("bufsize", "327680"); // 40*1024*8;
4055

    
4056
        opt_default("ab", "224000");
4057
        audio_sample_rate = 44100;
4058
        audio_channels = 2;
4059

    
4060
        opt_default("packetsize", "2324");
4061
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4062

    
4063
        /* We have to offset the PTS, so that it is consistent with the SCR.
4064
           SCR starts at 36000, but the first two packs contain only padding
4065
           and the first pack from the other stream, respectively, may also have
4066
           been written before.
4067
           So the real data starts at SCR 36000+3*1200. */
4068
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4069
    } else if(!strcmp(arg, "svcd")) {
4070

    
4071
        opt_video_codec("mpeg2video");
4072
        opt_audio_codec("mp2");
4073
        opt_format("svcd");
4074

    
4075
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4076
        opt_frame_rate(NULL, frame_rates[norm]);
4077
        opt_default("g", norm == PAL ? "15" : "18");
4078

    
4079
        opt_default("b", "2040000");
4080
        opt_default("maxrate", "2516000");
4081
        opt_default("minrate", "0"); //1145000;
4082
        opt_default("bufsize", "1835008"); //224*1024*8;
4083
        opt_default("flags", "+scan_offset");
4084

    
4085

    
4086
        opt_default("ab", "224000");
4087
        audio_sample_rate = 44100;
4088

    
4089
        opt_default("packetsize", "2324");
4090

    
4091
    } else if(!strcmp(arg, "dvd")) {
4092

    
4093
        opt_video_codec("mpeg2video");
4094
        opt_audio_codec("ac3");
4095
        opt_format("dvd");
4096

    
4097
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4098
        opt_frame_rate(NULL, frame_rates[norm]);
4099
        opt_default("g", norm == PAL ? "15" : "18");
4100

    
4101
        opt_default("b", "6000000");
4102
        opt_default("maxrate", "9000000");
4103
        opt_default("minrate", "0"); //1500000;
4104
        opt_default("bufsize", "1835008"); //224*1024*8;
4105

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

    
4109
        opt_default("ab", "448000");
4110
        audio_sample_rate = 48000;
4111

    
4112
    } else if(!strncmp(arg, "dv", 2)) {
4113

    
4114
        opt_format("dv");
4115

    
4116
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4117
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4118
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4119
        opt_frame_rate(NULL, frame_rates[norm]);
4120

    
4121
        audio_sample_rate = 48000;
4122
        audio_channels = 2;
4123

    
4124
    } else {
4125
        fprintf(stderr, "Unknown target: %s\n", arg);
4126
        ffmpeg_exit(1);
4127
    }
4128
}
4129

    
4130
static void opt_vstats_file (const char *arg)
4131
{
4132
    av_free (vstats_filename);
4133
    vstats_filename=av_strdup (arg);
4134
}
4135

    
4136
static void opt_vstats (void)
4137
{
4138
    char filename[40];
4139
    time_t today2 = time(NULL);
4140
    struct tm *today = localtime(&today2);
4141

    
4142
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4143
             today->tm_sec);
4144
    opt_vstats_file(filename);
4145
}
4146

    
4147
static int opt_bsf(const char *opt, const char *arg)
4148
{
4149
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4150
    AVBitStreamFilterContext **bsfp;
4151

    
4152
    if(!bsfc){
4153
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4154
        ffmpeg_exit(1);
4155
    }
4156

    
4157
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4158
          *opt == 'a' ? &audio_bitstream_filters :
4159
                        &subtitle_bitstream_filters;
4160
    while(*bsfp)
4161
        bsfp= &(*bsfp)->next;
4162

    
4163
    *bsfp= bsfc;
4164

    
4165
    return 0;
4166
}
4167

    
4168
static int opt_preset(const char *opt, const char *arg)
4169
{
4170
    FILE *f=NULL;
4171
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4172
    int i;
4173
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
4174
                           getenv("HOME"),
4175
                           FFMPEG_DATADIR,
4176
                         };
4177

    
4178
    if (*opt != 'f') {
4179
        for(i=0; i<3 && !f; i++){
4180
            if(!base[i])
4181
                continue;
4182
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4183
            f= fopen(filename, "r");
4184
            if(!f){
4185
                char *codec_name= *opt == 'v' ? video_codec_name :
4186
                                  *opt == 'a' ? audio_codec_name :
4187
                                                subtitle_codec_name;
4188
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4189
                f= fopen(filename, "r");
4190
            }
4191
        }
4192
    } else {
4193
        av_strlcpy(filename, arg, sizeof(filename));
4194
        f= fopen(filename, "r");
4195
    }
4196

    
4197
    if(!f){
4198
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4199
        ffmpeg_exit(1);
4200
    }
4201

    
4202
    while(!feof(f)){
4203
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4204
        if(line[0] == '#' && !e)
4205
            continue;
4206
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4207
        if(e){
4208
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4209
            ffmpeg_exit(1);
4210
        }
4211
        if(!strcmp(tmp, "acodec")){
4212
            opt_audio_codec(tmp2);
4213
        }else if(!strcmp(tmp, "vcodec")){
4214
            opt_video_codec(tmp2);
4215
        }else if(!strcmp(tmp, "scodec")){
4216
            opt_subtitle_codec(tmp2);
4217
        }else if(opt_default(tmp, tmp2) < 0){
4218
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4219
            ffmpeg_exit(1);
4220
        }
4221
    }
4222

    
4223
    fclose(f);
4224

    
4225
    return 0;
4226
}
4227

    
4228
static const OptionDef options[] = {
4229
    /* main options */
4230
#include "cmdutils_common_opts.h"
4231
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4232
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4233
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4234
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4235
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4236
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4237
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4238
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4239
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4240
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4241
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4242
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4243
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4244
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4245
      "add timings for benchmarking" },
4246
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4247
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4248
      "dump each input packet" },
4249
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4250
      "when dumping packets, also dump the payload" },
4251
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4252
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4253
    { "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)", "" },
4254
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4255
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4256
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4257
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4258
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4259
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4260
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4261
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4262
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4263
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4264
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4265
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4266
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4267

    
4268
    /* video options */
4269
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4270
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4271
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4272
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4273
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4274
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4275
    { "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" },
4276
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "Deprecated, please use the crop avfilter", "size" },
4277
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "Deprecated, please use the crop avfilter", "size" },
4278
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "Deprecated, please use the crop avfilter", "size" },
4279
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "Deprecated, please use the crop avfilter", "size" },
4280
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4281
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4282
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4283
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4284
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4285
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4286
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4287
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4288
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4289
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4290
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4291
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4292
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4293
      "use same video quality as source (implies VBR)" },
4294
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4295
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4296
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4297
      "deinterlace pictures" },
4298
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4299
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4300
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4301
#if CONFIG_AVFILTER
4302
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4303
#endif
4304
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4305
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4306
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4307
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4308
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4309
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4310
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4311
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4312
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4313
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4314

    
4315
    /* audio options */
4316
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4317
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4318
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4319
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4320
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4321
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4322
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4323
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4324
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4325
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4326
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4327
    { "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" },
4328

    
4329
    /* subtitle options */
4330
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4331
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4332
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4333
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4334
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4335

    
4336
    /* grab options */
4337
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4338
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4339
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4340

    
4341
    /* muxer options */
4342
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4343
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4344

    
4345
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4346
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4347
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4348

    
4349
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4350
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4351
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4352
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4353

    
4354
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4355
    { NULL, },
4356
};
4357

    
4358
int main(int argc, char **argv)
4359
{
4360
    int64_t ti;
4361

    
4362
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4363

    
4364
    avcodec_register_all();
4365
#if CONFIG_AVDEVICE
4366
    avdevice_register_all();
4367
#endif
4368
#if CONFIG_AVFILTER
4369
    avfilter_register_all();
4370
#endif
4371
    av_register_all();
4372

    
4373
#if HAVE_ISATTY
4374
    if(isatty(STDIN_FILENO))
4375
        url_set_interrupt_cb(decode_interrupt_cb);
4376
#endif
4377

    
4378
    init_opts();
4379

    
4380
    show_banner();
4381

    
4382
    /* parse options */
4383
    parse_options(argc, argv, options, opt_output_file);
4384

    
4385
    if(nb_output_files <= 0 && nb_input_files == 0) {
4386
        show_usage();
4387
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4388
        ffmpeg_exit(1);
4389
    }
4390

    
4391
    /* file converter / grab */
4392
    if (nb_output_files <= 0) {
4393
        fprintf(stderr, "At least one output file must be specified\n");
4394
        ffmpeg_exit(1);
4395
    }
4396

    
4397
    if (nb_input_files == 0) {
4398
        fprintf(stderr, "At least one input file must be specified\n");
4399
        ffmpeg_exit(1);
4400
    }
4401

    
4402
    ti = getutime();
4403
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4404
                  stream_maps, nb_stream_maps) < 0)
4405
        ffmpeg_exit(1);
4406
    ti = getutime() - ti;
4407
    if (do_benchmark) {
4408
        int maxrss = getmaxrss() / 1024;
4409
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4410
    }
4411

    
4412
    return ffmpeg_exit(0);
4413
}