Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0ff4f0c0

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", ist->st->codec->width,
428
             ist->st->codec->height, ist->st->codec->pix_fmt);
429
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
430
        return ret;
431
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &codec->pix_fmt)) < 0)
432
        return ret;
433

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

    
438
    last_filter = ist->input_video_filter;
439

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

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

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

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

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

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

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

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

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

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

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

    
519
static volatile int received_sigterm = 0;
520

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
639
    av_free(video_standard);
640

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
816
        bsfc= bsfc->next;
817
    }
818

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

    
826
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
827

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1182
    *frame_size = 0;
1183

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1437

    
1438
    oc = output_files[0];
1439

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

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

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

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

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

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

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

    
1518
        fflush(stderr);
1519
    }
1520

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1762
                        av_init_packet(&opkt);
1763

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1952

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2452

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

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

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

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

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

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

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

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

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

    
2523
    timer_start = av_gettime();
2524

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2664
    discard_packet:
2665
        av_free_packet(&pkt);
2666

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

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

    
2679
    term_exit();
2680

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

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

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

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

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

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

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

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

    
2764
    last_asked_format = arg;
2765
}
2766

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

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

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

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

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

    
2797
    opt_default(opt, arg);
2798

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

    
2802
    return 0;
2803
}
2804

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2931
    return 0;
2932
}
2933

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3247
    ic->loop_input = loop_input;
3248

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

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

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

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

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

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

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

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

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

    
3356
    nb_input_files++;
3357

    
3358
    video_channel = 0;
3359

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

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

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

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

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

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

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

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

    
3438
    video_enc = st->codec;
3439

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

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

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

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

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

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

    
3477
        choose_pixel_fmt(st, codec);
3478

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3653
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3654

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3800
        oc->timestamp = recording_timestamp;
3801

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

    
3809
    output_files[nb_output_files++] = oc;
3810

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

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

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

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

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

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

    
3862
    nb_streamid_map = 0;
3863
}
3864

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4084

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

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

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

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

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

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

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

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

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

    
4113
        opt_format("dv");
4114

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

    
4120
        audio_sample_rate = 48000;
4121
        audio_channels = 2;
4122

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

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

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

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

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

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

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

    
4162
    *bsfp= bsfc;
4163

    
4164
    return 0;
4165
}
4166

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

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

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

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

    
4222
    fclose(f);
4223

    
4224
    return 0;
4225
}
4226

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

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

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

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

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

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

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

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

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

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

    
4361
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4362

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

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

    
4377
    init_opts();
4378

    
4379
    show_banner();
4380

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

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

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

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

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

    
4411
    return ffmpeg_exit(0);
4412
}