Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ dbabc277

History | View | Annotate | Download (159 KB)

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

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

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

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

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

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

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

    
80
#include "cmdutils.h"
81

    
82
#include "libavutil/avassert.h"
83

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

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

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

    
103
static const OptionDef options[];
104

    
105
#define MAX_FILES 100
106
#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 AVMetadata *metadata;
192
static int do_benchmark = 0;
193
static int do_hex_dump = 0;
194
static int do_pkt_dump = 0;
195
static int do_psnr = 0;
196
static int do_pass = 0;
197
static char *pass_logfilename_prefix = NULL;
198
static int audio_stream_copy = 0;
199
static int video_stream_copy = 0;
200
static int subtitle_stream_copy = 0;
201
static int video_sync_method= -1;
202
static int audio_sync_method= 0;
203
static float audio_drift_threshold= 0.1;
204
static int copy_ts= 0;
205
static int opt_shortest = 0;
206
static int video_global_header = 0;
207
static char *vstats_filename;
208
static FILE *vstats_file;
209
static int opt_programid = 0;
210
static int copy_initial_nonkeyframes = 0;
211

    
212
static int rate_emu = 0;
213

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

    
217
static int audio_volume = 256;
218

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

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

    
236
static unsigned int sws_flags = SWS_BICUBIC;
237

    
238
static int64_t timer_start;
239

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

    
244
static short *samples;
245

    
246
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
247
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
248
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
249

    
250
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
251

    
252
struct AVInputStream;
253

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

    
275
    /* full frame size of first frame */
276
    int original_height;
277
    int original_width;
278

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

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

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

    
301
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
302
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
303

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

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

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

    
336
#if HAVE_TERMIOS_H
337

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

    
342
#if CONFIG_AVFILTER
343

    
344
static int get_filtered_video_pic(AVFilterContext *ctx,
345
                                  AVFilterBufferRef **picref, AVFrame *pic2,
346
                                  uint64_t *pts)
347
{
348
    AVFilterBufferRef *pic;
349

    
350
    if(avfilter_request_frame(ctx->inputs[0]))
351
        return -1;
352
    if(!(pic = ctx->inputs[0]->cur_buf))
353
        return -1;
354
    *picref = pic;
355
    ctx->inputs[0]->cur_buf = NULL;
356

    
357
    *pts          = pic->pts;
358

    
359
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
360
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
361
    pic2->interlaced_frame = pic->video->interlaced;
362
    pic2->top_field_first  = pic->video->top_field_first;
363

    
364
    return 1;
365
}
366

    
367
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
368
{
369
    AVFilterContext *last_filter, *filter;
370
    /** filter graph containing all filters including input & output */
371
    AVCodecContext *codec = ost->st->codec;
372
    AVCodecContext *icodec = ist->st->codec;
373
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
374
    char args[255];
375
    int ret;
376

    
377
    graph = av_mallocz(sizeof(AVFilterGraph));
378

    
379
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
380
        return ret;
381
    if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
382
        return ret;
383

    
384
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
385
             ist->st->codec->height, ist->st->codec->pix_fmt,
386
             ist->st->time_base.num, ist->st->time_base.den);
387
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
388
        return ret;
389
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
390
        return ret;
391

    
392
    /* add input and output filters to the overall graph */
393
    avfilter_graph_add_filter(graph, ist->input_video_filter);
394
    avfilter_graph_add_filter(graph, ist->output_video_filter);
395

    
396
    last_filter = ist->input_video_filter;
397

    
398
    if (ost->video_crop) {
399
        snprintf(args, 255, "%d:%d:%d:%d",
400
                 codec->width, codec->height,
401
                 ost->leftBand, ost->topBand);
402
        if ((ret = avfilter_open(&filter, avfilter_get_by_name("crop"), NULL)) < 0)
403
            return ret;
404
        if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
405
            return ret;
406
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
407
            return ret;
408
        last_filter = filter;
409
        avfilter_graph_add_filter(graph, last_filter);
410
    }
411

    
412
    if((codec->width !=
413
        icodec->width - (frame_leftBand + frame_rightBand)) ||
414
       (codec->height != icodec->height - (frame_topBand  + frame_bottomBand))) {
415
        snprintf(args, 255, "%d:%d:flags=0x%X",
416
                 codec->width,
417
                 codec->height,
418
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
419
        if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
420
            return ret;
421
        if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
422
            return ret;
423
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
424
            return ret;
425
        last_filter = filter;
426
        avfilter_graph_add_filter(graph, last_filter);
427
    }
428

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

    
432
    if (vfilters) {
433
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
434
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
435

    
436
        outputs->name    = av_strdup("in");
437
        outputs->filter  = last_filter;
438
        outputs->pad_idx = 0;
439
        outputs->next    = NULL;
440

    
441
        inputs->name    = av_strdup("out");
442
        inputs->filter  = ist->output_video_filter;
443
        inputs->pad_idx = 0;
444
        inputs->next    = NULL;
445

    
446
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
447
            return ret;
448
        av_freep(&vfilters);
449
    } else {
450
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
451
            return ret;
452
    }
453

    
454
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
455
        return ret;
456

    
457
    codec->width  = ist->output_video_filter->inputs[0]->w;
458
    codec->height = ist->output_video_filter->inputs[0]->h;
459

    
460
    return 0;
461
}
462
#endif /* CONFIG_AVFILTER */
463

    
464
static void term_exit(void)
465
{
466
    av_log(NULL, AV_LOG_QUIET, "");
467
#if HAVE_TERMIOS_H
468
    tcsetattr (0, TCSANOW, &oldtty);
469
#endif
470
}
471

    
472
static volatile int received_sigterm = 0;
473

    
474
static void
475
sigterm_handler(int sig)
476
{
477
    received_sigterm = sig;
478
    term_exit();
479
}
480

    
481
static void term_init(void)
482
{
483
#if HAVE_TERMIOS_H
484
    struct termios tty;
485

    
486
    tcgetattr (0, &tty);
487
    oldtty = tty;
488
    atexit(term_exit);
489

    
490
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
491
                          |INLCR|IGNCR|ICRNL|IXON);
492
    tty.c_oflag |= OPOST;
493
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
494
    tty.c_cflag &= ~(CSIZE|PARENB);
495
    tty.c_cflag |= CS8;
496
    tty.c_cc[VMIN] = 1;
497
    tty.c_cc[VTIME] = 0;
498

    
499
    tcsetattr (0, TCSANOW, &tty);
500
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
501
#endif
502

    
503
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
504
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
505
#ifdef SIGXCPU
506
    signal(SIGXCPU, sigterm_handler);
507
#endif
508
}
509

    
510
/* read a key without blocking */
511
static int read_key(void)
512
{
513
#if HAVE_TERMIOS_H
514
    int n = 1;
515
    unsigned char ch;
516
    struct timeval tv;
517
    fd_set rfds;
518

    
519
    FD_ZERO(&rfds);
520
    FD_SET(0, &rfds);
521
    tv.tv_sec = 0;
522
    tv.tv_usec = 0;
523
    n = select(1, &rfds, NULL, NULL, &tv);
524
    if (n > 0) {
525
        n = read(0, &ch, 1);
526
        if (n == 1)
527
            return ch;
528

    
529
        return n;
530
    }
531
#elif HAVE_CONIO_H
532
    if(kbhit())
533
        return(getch());
534
#endif
535
    return -1;
536
}
537

    
538
static int decode_interrupt_cb(void)
539
{
540
    return q_pressed || (q_pressed = read_key() == 'q');
541
}
542

    
543
static int ffmpeg_exit(int ret)
544
{
545
    int i;
546

    
547
    /* close files */
548
    for(i=0;i<nb_output_files;i++) {
549
        /* maybe av_close_output_file ??? */
550
        AVFormatContext *s = output_files[i];
551
        int j;
552
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
553
            url_fclose(s->pb);
554
        for(j=0;j<s->nb_streams;j++) {
555
            av_metadata_free(&s->streams[j]->metadata);
556
            av_free(s->streams[j]->codec);
557
            av_free(s->streams[j]->info);
558
            av_free(s->streams[j]);
559
        }
560
        for(j=0;j<s->nb_programs;j++) {
561
            av_metadata_free(&s->programs[j]->metadata);
562
        }
563
        for(j=0;j<s->nb_chapters;j++) {
564
            av_metadata_free(&s->chapters[j]->metadata);
565
        }
566
        av_metadata_free(&s->metadata);
567
        av_free(s);
568
        av_free(output_streams_for_file[i]);
569
    }
570
    for(i=0;i<nb_input_files;i++) {
571
        av_close_input_file(input_files[i]);
572
        av_free(input_files_ts_scale[i]);
573
    }
574

    
575
    av_free(intra_matrix);
576
    av_free(inter_matrix);
577

    
578
    if (vstats_file)
579
        fclose(vstats_file);
580
    av_free(vstats_filename);
581

    
582
    av_free(opt_names);
583
    av_free(streamid_map);
584
    av_free(input_codecs);
585
    av_free(output_codecs);
586
    av_free(stream_maps);
587

    
588
    av_free(video_codec_name);
589
    av_free(audio_codec_name);
590
    av_free(subtitle_codec_name);
591

    
592
    av_free(video_standard);
593

    
594
    uninit_opts();
595
    av_free(audio_buf);
596
    av_free(audio_out);
597
    allocated_audio_buf_size= allocated_audio_out_size= 0;
598
    av_free(samples);
599

    
600
#if CONFIG_AVFILTER
601
    avfilter_uninit();
602
#endif
603

    
604
    if (received_sigterm) {
605
        fprintf(stderr,
606
            "Received signal %d: terminating.\n",
607
            (int) received_sigterm);
608
        exit (255);
609
    }
610

    
611
    exit(ret); /* not all OS-es handle main() return value */
612
    return ret;
613
}
614

    
615
/* similar to ff_dynarray_add() and av_fast_realloc() */
616
static void *grow_array(void *array, int elem_size, int *size, int new_size)
617
{
618
    if (new_size >= INT_MAX / elem_size) {
619
        fprintf(stderr, "Array too big.\n");
620
        ffmpeg_exit(1);
621
    }
622
    if (*size < new_size) {
623
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
624
        if (!tmp) {
625
            fprintf(stderr, "Could not alloc buffer.\n");
626
            ffmpeg_exit(1);
627
        }
628
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
629
        *size = new_size;
630
        return tmp;
631
    }
632
    return array;
633
}
634

    
635
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
636
{
637
    if(codec && codec->sample_fmts){
638
        const enum SampleFormat *p= codec->sample_fmts;
639
        for(; *p!=-1; p++){
640
            if(*p == st->codec->sample_fmt)
641
                break;
642
        }
643
        if(*p == -1)
644
            st->codec->sample_fmt = codec->sample_fmts[0];
645
    }
646
}
647

    
648
static void choose_sample_rate(AVStream *st, AVCodec *codec)
649
{
650
    if(codec && codec->supported_samplerates){
651
        const int *p= codec->supported_samplerates;
652
        int best=0;
653
        int best_dist=INT_MAX;
654
        for(; *p; p++){
655
            int dist= abs(st->codec->sample_rate - *p);
656
            if(dist < best_dist){
657
                best_dist= dist;
658
                best= *p;
659
            }
660
        }
661
        if(best_dist){
662
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
663
        }
664
        st->codec->sample_rate= best;
665
    }
666
}
667

    
668
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
669
{
670
    if(codec && codec->pix_fmts){
671
        const enum PixelFormat *p= codec->pix_fmts;
672
        for(; *p!=-1; p++){
673
            if(*p == st->codec->pix_fmt)
674
                break;
675
        }
676
        if(*p == -1
677
           && !(   st->codec->codec_id==CODEC_ID_MJPEG
678
                && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
679
                && (   st->codec->pix_fmt == PIX_FMT_YUV420P
680
                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))
681
            st->codec->pix_fmt = codec->pix_fmts[0];
682
    }
683
}
684

    
685
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
686
{
687
    int i, err;
688
    AVFormatContext *ic;
689
    int nopts = 0;
690

    
691
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
692
    if (err < 0)
693
        return err;
694
    /* copy stream format */
695
    s->nb_streams = ic->nb_streams;
696
    for(i=0;i<ic->nb_streams;i++) {
697
        AVStream *st;
698
        AVCodec *codec;
699

    
700
        // FIXME: a more elegant solution is needed
701
        st = av_mallocz(sizeof(AVStream));
702
        memcpy(st, ic->streams[i], sizeof(AVStream));
703
        st->codec = avcodec_alloc_context();
704
        if (!st->codec) {
705
            print_error(filename, AVERROR(ENOMEM));
706
            ffmpeg_exit(1);
707
        }
708
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
709
        s->streams[i] = st;
710

    
711
        codec = avcodec_find_encoder(st->codec->codec_id);
712
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
713
            if (audio_stream_copy) {
714
                st->stream_copy = 1;
715
            } else
716
                choose_sample_fmt(st, codec);
717
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
718
            if (video_stream_copy) {
719
                st->stream_copy = 1;
720
            } else
721
                choose_pixel_fmt(st, codec);
722
        }
723

    
724
        if(!st->codec->thread_count)
725
            st->codec->thread_count = 1;
726
        if(st->codec->thread_count>1)
727
            avcodec_thread_init(st->codec, st->codec->thread_count);
728

    
729
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
730
            nopts = 1;
731
    }
732

    
733
    if (!nopts)
734
        s->timestamp = av_gettime();
735

    
736
    av_close_input_file(ic);
737
    return 0;
738
}
739

    
740
static double
741
get_sync_ipts(const AVOutputStream *ost)
742
{
743
    const AVInputStream *ist = ost->sync_ist;
744
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
745
}
746

    
747
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
748
    int ret;
749

    
750
    while(bsfc){
751
        AVPacket new_pkt= *pkt;
752
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
753
                                          &new_pkt.data, &new_pkt.size,
754
                                          pkt->data, pkt->size,
755
                                          pkt->flags & AV_PKT_FLAG_KEY);
756
        if(a>0){
757
            av_free_packet(pkt);
758
            new_pkt.destruct= av_destruct_packet;
759
        } else if(a<0){
760
            fprintf(stderr, "%s failed for stream %d, codec %s",
761
                    bsfc->filter->name, pkt->stream_index,
762
                    avctx->codec ? avctx->codec->name : "copy");
763
            print_error("", a);
764
            if (exit_on_error)
765
                ffmpeg_exit(1);
766
        }
767
        *pkt= new_pkt;
768

    
769
        bsfc= bsfc->next;
770
    }
771

    
772
    ret= av_interleaved_write_frame(s, pkt);
773
    if(ret < 0){
774
        print_error("av_interleaved_write_frame()", ret);
775
        ffmpeg_exit(1);
776
    }
777
}
778

    
779
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
780

    
781
static void do_audio_out(AVFormatContext *s,
782
                         AVOutputStream *ost,
783
                         AVInputStream *ist,
784
                         unsigned char *buf, int size)
785
{
786
    uint8_t *buftmp;
787
    int64_t audio_out_size, audio_buf_size;
788
    int64_t allocated_for_size= size;
789

    
790
    int size_out, frame_bytes, ret;
791
    AVCodecContext *enc= ost->st->codec;
792
    AVCodecContext *dec= ist->st->codec;
793
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
794
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
795
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
796

    
797
need_realloc:
798
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
799
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
800
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
801
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
802
    audio_buf_size*= osize*enc->channels;
803

    
804
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
805
    if(coded_bps > 8*osize)
806
        audio_out_size= audio_out_size * coded_bps / (8*osize);
807
    audio_out_size += FF_MIN_BUFFER_SIZE;
808

    
809
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
810
        fprintf(stderr, "Buffer sizes too large\n");
811
        ffmpeg_exit(1);
812
    }
813

    
814
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
815
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
816
    if (!audio_buf || !audio_out){
817
        fprintf(stderr, "Out of memory in do_audio_out\n");
818
        ffmpeg_exit(1);
819
    }
820

    
821
    if (enc->channels != dec->channels)
822
        ost->audio_resample = 1;
823

    
824
    if (ost->audio_resample && !ost->resample) {
825
        if (dec->sample_fmt != SAMPLE_FMT_S16)
826
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
827
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
828
                                               enc->sample_rate, dec->sample_rate,
829
                                               enc->sample_fmt,  dec->sample_fmt,
830
                                               16, 10, 0, 0.8);
831
        if (!ost->resample) {
832
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
833
                    dec->channels, dec->sample_rate,
834
                    enc->channels, enc->sample_rate);
835
            ffmpeg_exit(1);
836
        }
837
    }
838

    
839
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
840
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
841
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
842
        if (ost->reformat_ctx)
843
            av_audio_convert_free(ost->reformat_ctx);
844
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
845
                                                   dec->sample_fmt, 1, NULL, 0);
846
        if (!ost->reformat_ctx) {
847
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
848
                avcodec_get_sample_fmt_name(dec->sample_fmt),
849
                avcodec_get_sample_fmt_name(enc->sample_fmt));
850
            ffmpeg_exit(1);
851
        }
852
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
853
    }
854

    
855
    if(audio_sync_method){
856
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
857
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
858
        double idelta= delta*dec->sample_rate / enc->sample_rate;
859
        int byte_delta= ((int)idelta)*2*dec->channels;
860

    
861
        //FIXME resample delay
862
        if(fabs(delta) > 50){
863
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
864
                if(byte_delta < 0){
865
                    byte_delta= FFMAX(byte_delta, -size);
866
                    size += byte_delta;
867
                    buf  -= byte_delta;
868
                    if(verbose > 2)
869
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
870
                    if(!size)
871
                        return;
872
                    ist->is_start=0;
873
                }else{
874
                    static uint8_t *input_tmp= NULL;
875
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
876

    
877
                    if(byte_delta > allocated_for_size - size){
878
                        allocated_for_size= byte_delta + (int64_t)size;
879
                        goto need_realloc;
880
                    }
881
                    ist->is_start=0;
882

    
883
                    memset(input_tmp, 0, byte_delta);
884
                    memcpy(input_tmp + byte_delta, buf, size);
885
                    buf= input_tmp;
886
                    size += byte_delta;
887
                    if(verbose > 2)
888
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
889
                }
890
            }else if(audio_sync_method>1){
891
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
892
                av_assert0(ost->audio_resample);
893
                if(verbose > 2)
894
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
895
//                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));
896
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
897
            }
898
        }
899
    }else
900
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
901
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
902

    
903
    if (ost->audio_resample) {
904
        buftmp = audio_buf;
905
        size_out = audio_resample(ost->resample,
906
                                  (short *)buftmp, (short *)buf,
907
                                  size / (dec->channels * isize));
908
        size_out = size_out * enc->channels * osize;
909
    } else {
910
        buftmp = buf;
911
        size_out = size;
912
    }
913

    
914
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
915
        const void *ibuf[6]= {buftmp};
916
        void *obuf[6]= {audio_buf};
917
        int istride[6]= {isize};
918
        int ostride[6]= {osize};
919
        int len= size_out/istride[0];
920
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
921
            printf("av_audio_convert() failed\n");
922
            if (exit_on_error)
923
                ffmpeg_exit(1);
924
            return;
925
        }
926
        buftmp = audio_buf;
927
        size_out = len*osize;
928
    }
929

    
930
    /* now encode as many frames as possible */
931
    if (enc->frame_size > 1) {
932
        /* output resampled raw samples */
933
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
934
            fprintf(stderr, "av_fifo_realloc2() failed\n");
935
            ffmpeg_exit(1);
936
        }
937
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
938

    
939
        frame_bytes = enc->frame_size * osize * enc->channels;
940

    
941
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
942
            AVPacket pkt;
943
            av_init_packet(&pkt);
944

    
945
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
946

    
947
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
948

    
949
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
950
                                       (short *)audio_buf);
951
            if (ret < 0) {
952
                fprintf(stderr, "Audio encoding failed\n");
953
                ffmpeg_exit(1);
954
            }
955
            audio_size += ret;
956
            pkt.stream_index= ost->index;
957
            pkt.data= audio_out;
958
            pkt.size= ret;
959
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
960
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
961
            pkt.flags |= AV_PKT_FLAG_KEY;
962
            write_frame(s, &pkt, enc, ost->bitstream_filters);
963

    
964
            ost->sync_opts += enc->frame_size;
965
        }
966
    } else {
967
        AVPacket pkt;
968
        av_init_packet(&pkt);
969

    
970
        ost->sync_opts += size_out / (osize * enc->channels);
971

    
972
        /* output a pcm frame */
973
        /* determine the size of the coded buffer */
974
        size_out /= osize;
975
        if (coded_bps)
976
            size_out = size_out*coded_bps/8;
977

    
978
        if(size_out > audio_out_size){
979
            fprintf(stderr, "Internal error, buffer size too small\n");
980
            ffmpeg_exit(1);
981
        }
982

    
983
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
984
        ret = avcodec_encode_audio(enc, audio_out, size_out,
985
                                   (short *)buftmp);
986
        if (ret < 0) {
987
            fprintf(stderr, "Audio encoding failed\n");
988
            ffmpeg_exit(1);
989
        }
990
        audio_size += ret;
991
        pkt.stream_index= ost->index;
992
        pkt.data= audio_out;
993
        pkt.size= ret;
994
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
995
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
996
        pkt.flags |= AV_PKT_FLAG_KEY;
997
        write_frame(s, &pkt, enc, ost->bitstream_filters);
998
    }
999
}
1000

    
1001
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1002
{
1003
    AVCodecContext *dec;
1004
    AVPicture *picture2;
1005
    AVPicture picture_tmp;
1006
    uint8_t *buf = 0;
1007

    
1008
    dec = ist->st->codec;
1009

    
1010
    /* deinterlace : must be done before any resize */
1011
    if (do_deinterlace) {
1012
        int size;
1013

    
1014
        /* create temporary picture */
1015
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1016
        buf = av_malloc(size);
1017
        if (!buf)
1018
            return;
1019

    
1020
        picture2 = &picture_tmp;
1021
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1022

    
1023
        if(avpicture_deinterlace(picture2, picture,
1024
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1025
            /* if error, do not deinterlace */
1026
            fprintf(stderr, "Deinterlacing failed\n");
1027
            av_free(buf);
1028
            buf = NULL;
1029
            picture2 = picture;
1030
        }
1031
    } else {
1032
        picture2 = picture;
1033
    }
1034

    
1035
    if (picture != picture2)
1036
        *picture = *picture2;
1037
    *bufp = buf;
1038
}
1039

    
1040
/* we begin to correct av delay at this threshold */
1041
#define AV_DELAY_MAX 0.100
1042

    
1043
static void do_subtitle_out(AVFormatContext *s,
1044
                            AVOutputStream *ost,
1045
                            AVInputStream *ist,
1046
                            AVSubtitle *sub,
1047
                            int64_t pts)
1048
{
1049
    static uint8_t *subtitle_out = NULL;
1050
    int subtitle_out_max_size = 1024 * 1024;
1051
    int subtitle_out_size, nb, i;
1052
    AVCodecContext *enc;
1053
    AVPacket pkt;
1054

    
1055
    if (pts == AV_NOPTS_VALUE) {
1056
        fprintf(stderr, "Subtitle packets must have a pts\n");
1057
        if (exit_on_error)
1058
            ffmpeg_exit(1);
1059
        return;
1060
    }
1061

    
1062
    enc = ost->st->codec;
1063

    
1064
    if (!subtitle_out) {
1065
        subtitle_out = av_malloc(subtitle_out_max_size);
1066
    }
1067

    
1068
    /* Note: DVB subtitle need one packet to draw them and one other
1069
       packet to clear them */
1070
    /* XXX: signal it in the codec context ? */
1071
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1072
        nb = 2;
1073
    else
1074
        nb = 1;
1075

    
1076
    for(i = 0; i < nb; i++) {
1077
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1078
        // start_display_time is required to be 0
1079
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1080
        sub->end_display_time -= sub->start_display_time;
1081
        sub->start_display_time = 0;
1082
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1083
                                                    subtitle_out_max_size, sub);
1084
        if (subtitle_out_size < 0) {
1085
            fprintf(stderr, "Subtitle encoding failed\n");
1086
            ffmpeg_exit(1);
1087
        }
1088

    
1089
        av_init_packet(&pkt);
1090
        pkt.stream_index = ost->index;
1091
        pkt.data = subtitle_out;
1092
        pkt.size = subtitle_out_size;
1093
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1094
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1095
            /* XXX: the pts correction is handled here. Maybe handling
1096
               it in the codec would be better */
1097
            if (i == 0)
1098
                pkt.pts += 90 * sub->start_display_time;
1099
            else
1100
                pkt.pts += 90 * sub->end_display_time;
1101
        }
1102
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1103
    }
1104
}
1105

    
1106
static int bit_buffer_size= 1024*256;
1107
static uint8_t *bit_buffer= NULL;
1108

    
1109
static void do_video_out(AVFormatContext *s,
1110
                         AVOutputStream *ost,
1111
                         AVInputStream *ist,
1112
                         AVFrame *in_picture,
1113
                         int *frame_size)
1114
{
1115
    int nb_frames, i, ret;
1116
#if !CONFIG_AVFILTER
1117
    int64_t topBand, bottomBand, leftBand, rightBand;
1118
#endif
1119
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1120
    AVFrame picture_crop_temp, picture_pad_temp;
1121
    AVCodecContext *enc, *dec;
1122
    double sync_ipts;
1123

    
1124
    avcodec_get_frame_defaults(&picture_crop_temp);
1125
    avcodec_get_frame_defaults(&picture_pad_temp);
1126

    
1127
    enc = ost->st->codec;
1128
    dec = ist->st->codec;
1129

    
1130
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1131

    
1132
    /* by default, we output a single frame */
1133
    nb_frames = 1;
1134

    
1135
    *frame_size = 0;
1136

    
1137
    if(video_sync_method){
1138
        double vdelta = sync_ipts - ost->sync_opts;
1139
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1140
        if (vdelta < -1.1)
1141
            nb_frames = 0;
1142
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1143
            if(vdelta<=-0.6){
1144
                nb_frames=0;
1145
            }else if(vdelta>0.6)
1146
            ost->sync_opts= lrintf(sync_ipts);
1147
        }else if (vdelta > 1.1)
1148
            nb_frames = lrintf(vdelta);
1149
//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);
1150
        if (nb_frames == 0){
1151
            ++nb_frames_drop;
1152
            if (verbose>2)
1153
                fprintf(stderr, "*** drop!\n");
1154
        }else if (nb_frames > 1) {
1155
            nb_frames_dup += nb_frames - 1;
1156
            if (verbose>2)
1157
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1158
        }
1159
    }else
1160
        ost->sync_opts= lrintf(sync_ipts);
1161

    
1162
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1163
    if (nb_frames <= 0)
1164
        return;
1165

    
1166
#if CONFIG_AVFILTER
1167
    formatted_picture = in_picture;
1168
#else
1169
    if (ost->video_crop) {
1170
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1171
            fprintf(stderr, "error cropping picture\n");
1172
            if (exit_on_error)
1173
                ffmpeg_exit(1);
1174
            return;
1175
        }
1176
        formatted_picture = &picture_crop_temp;
1177
    } else {
1178
        formatted_picture = in_picture;
1179
    }
1180
#endif
1181

    
1182
    final_picture = formatted_picture;
1183
    padding_src = formatted_picture;
1184
    resampling_dst = &ost->pict_tmp;
1185

    
1186
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1187
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1188
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1189

    
1190
        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));
1191
        if(!ost->video_resample)
1192
            ffmpeg_exit(1);
1193
    }
1194

    
1195
#if !CONFIG_AVFILTER
1196
    if (ost->video_resample) {
1197
        padding_src = NULL;
1198
        final_picture = &ost->pict_tmp;
1199
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1200
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1201
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1202

    
1203
            /* keep bands proportional to the frame size */
1204
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
1205
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1206
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
1207
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
1208

    
1209
            /* sanity check to ensure no bad band sizes sneak in */
1210
            av_assert0(topBand    <= INT_MAX && topBand    >= 0);
1211
            av_assert0(bottomBand <= INT_MAX && bottomBand >= 0);
1212
            av_assert0(leftBand   <= INT_MAX && leftBand   >= 0);
1213
            av_assert0(rightBand  <= INT_MAX && rightBand  >= 0);
1214

    
1215
            ost->topBand    = topBand;
1216
            ost->bottomBand = bottomBand;
1217
            ost->leftBand   = leftBand;
1218
            ost->rightBand  = rightBand;
1219

    
1220
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1221
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1222
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1223

    
1224
            /* initialize a new scaler context */
1225
            sws_freeContext(ost->img_resample_ctx);
1226
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1227
            ost->img_resample_ctx = sws_getContext(
1228
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1229
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1230
                ist->st->codec->pix_fmt,
1231
                ost->st->codec->width,
1232
                ost->st->codec->height,
1233
                ost->st->codec->pix_fmt,
1234
                sws_flags, NULL, NULL, NULL);
1235
            if (ost->img_resample_ctx == NULL) {
1236
                fprintf(stderr, "Cannot get resampling context\n");
1237
                ffmpeg_exit(1);
1238
            }
1239
        }
1240
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1241
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1242
    }
1243
#endif
1244

    
1245
    /* duplicates frame if needed */
1246
    for(i=0;i<nb_frames;i++) {
1247
        AVPacket pkt;
1248
        av_init_packet(&pkt);
1249
        pkt.stream_index= ost->index;
1250

    
1251
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1252
            /* raw pictures are written as AVPicture structure to
1253
               avoid any copies. We support temorarily the older
1254
               method. */
1255
            AVFrame* old_frame = enc->coded_frame;
1256
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1257
            pkt.data= (uint8_t *)final_picture;
1258
            pkt.size=  sizeof(AVPicture);
1259
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1260
            pkt.flags |= AV_PKT_FLAG_KEY;
1261

    
1262
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1263
            enc->coded_frame = old_frame;
1264
        } else {
1265
            AVFrame big_picture;
1266

    
1267
            big_picture= *final_picture;
1268
            /* better than nothing: use input picture interlaced
1269
               settings */
1270
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1271
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1272
                if(top_field_first == -1)
1273
                    big_picture.top_field_first = in_picture->top_field_first;
1274
                else
1275
                    big_picture.top_field_first = top_field_first;
1276
            }
1277

    
1278
            /* handles sameq here. This is not correct because it may
1279
               not be a global option */
1280
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1281
            if(!me_threshold)
1282
                big_picture.pict_type = 0;
1283
//            big_picture.pts = AV_NOPTS_VALUE;
1284
            big_picture.pts= ost->sync_opts;
1285
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1286
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1287
            ret = avcodec_encode_video(enc,
1288
                                       bit_buffer, bit_buffer_size,
1289
                                       &big_picture);
1290
            if (ret < 0) {
1291
                fprintf(stderr, "Video encoding failed\n");
1292
                ffmpeg_exit(1);
1293
            }
1294

    
1295
            if(ret>0){
1296
                pkt.data= bit_buffer;
1297
                pkt.size= ret;
1298
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1299
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1300
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1301
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1302
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1303

    
1304
                if(enc->coded_frame->key_frame)
1305
                    pkt.flags |= AV_PKT_FLAG_KEY;
1306
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1307
                *frame_size = ret;
1308
                video_size += ret;
1309
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1310
                //        enc->frame_number-1, ret, enc->pict_type);
1311
                /* if two pass, output log */
1312
                if (ost->logfile && enc->stats_out) {
1313
                    fprintf(ost->logfile, "%s", enc->stats_out);
1314
                }
1315
            }
1316
        }
1317
        ost->sync_opts++;
1318
        ost->frame_number++;
1319
    }
1320
}
1321

    
1322
static double psnr(double d){
1323
    return -10.0*log(d)/log(10.0);
1324
}
1325

    
1326
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1327
                           int frame_size)
1328
{
1329
    AVCodecContext *enc;
1330
    int frame_number;
1331
    double ti1, bitrate, avg_bitrate;
1332

    
1333
    /* this is executed just the first time do_video_stats is called */
1334
    if (!vstats_file) {
1335
        vstats_file = fopen(vstats_filename, "w");
1336
        if (!vstats_file) {
1337
            perror("fopen");
1338
            ffmpeg_exit(1);
1339
        }
1340
    }
1341

    
1342
    enc = ost->st->codec;
1343
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1344
        frame_number = ost->frame_number;
1345
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1346
        if (enc->flags&CODEC_FLAG_PSNR)
1347
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1348

    
1349
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1350
        /* compute pts value */
1351
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1352
        if (ti1 < 0.01)
1353
            ti1 = 0.01;
1354

    
1355
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1356
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1357
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1358
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1359
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1360
    }
1361
}
1362

    
1363
static void print_report(AVFormatContext **output_files,
1364
                         AVOutputStream **ost_table, int nb_ostreams,
1365
                         int is_last_report)
1366
{
1367
    char buf[1024];
1368
    AVOutputStream *ost;
1369
    AVFormatContext *oc;
1370
    int64_t total_size;
1371
    AVCodecContext *enc;
1372
    int frame_number, vid, i;
1373
    double bitrate, ti1, pts;
1374
    static int64_t last_time = -1;
1375
    static int qp_histogram[52];
1376

    
1377
    if (!is_last_report) {
1378
        int64_t cur_time;
1379
        /* display the report every 0.5 seconds */
1380
        cur_time = av_gettime();
1381
        if (last_time == -1) {
1382
            last_time = cur_time;
1383
            return;
1384
        }
1385
        if ((cur_time - last_time) < 500000)
1386
            return;
1387
        last_time = cur_time;
1388
    }
1389

    
1390

    
1391
    oc = output_files[0];
1392

    
1393
    total_size = url_fsize(oc->pb);
1394
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1395
        total_size= url_ftell(oc->pb);
1396

    
1397
    buf[0] = '\0';
1398
    ti1 = 1e10;
1399
    vid = 0;
1400
    for(i=0;i<nb_ostreams;i++) {
1401
        ost = ost_table[i];
1402
        enc = ost->st->codec;
1403
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1404
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1405
                     !ost->st->stream_copy ?
1406
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1407
        }
1408
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1409
            float t = (av_gettime()-timer_start) / 1000000.0;
1410

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

    
1457
    if (verbose || is_last_report) {
1458
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1459

    
1460
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1461
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1462
            (double)total_size / 1024, ti1, bitrate);
1463

    
1464
        if (nb_frames_dup || nb_frames_drop)
1465
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1466
                  nb_frames_dup, nb_frames_drop);
1467

    
1468
        if (verbose >= 0)
1469
            fprintf(stderr, "%s    \r", buf);
1470

    
1471
        fflush(stderr);
1472
    }
1473

    
1474
    if (is_last_report && verbose >= 0){
1475
        int64_t raw= audio_size + video_size + extra_size;
1476
        fprintf(stderr, "\n");
1477
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1478
                video_size/1024.0,
1479
                audio_size/1024.0,
1480
                extra_size/1024.0,
1481
                100.0*(total_size - raw)/raw
1482
        );
1483
    }
1484
}
1485

    
1486
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1487
static int output_packet(AVInputStream *ist, int ist_index,
1488
                         AVOutputStream **ost_table, int nb_ostreams,
1489
                         const AVPacket *pkt)
1490
{
1491
    AVFormatContext *os;
1492
    AVOutputStream *ost;
1493
    int ret, i;
1494
    int got_picture;
1495
    AVFrame picture;
1496
    void *buffer_to_free;
1497
    static unsigned int samples_size= 0;
1498
    AVSubtitle subtitle, *subtitle_to_free;
1499
    int64_t pkt_pts = AV_NOPTS_VALUE;
1500
#if CONFIG_AVFILTER
1501
    int frame_available;
1502
#endif
1503

    
1504
    AVPacket avpkt;
1505
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1506

    
1507
    if(ist->next_pts == AV_NOPTS_VALUE)
1508
        ist->next_pts= ist->pts;
1509

    
1510
    if (pkt == NULL) {
1511
        /* EOF handling */
1512
        av_init_packet(&avpkt);
1513
        avpkt.data = NULL;
1514
        avpkt.size = 0;
1515
        goto handle_eof;
1516
    } else {
1517
        avpkt = *pkt;
1518
    }
1519

    
1520
    if(pkt->dts != AV_NOPTS_VALUE)
1521
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1522
    if(pkt->pts != AV_NOPTS_VALUE)
1523
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1524

    
1525
    //while we have more to decode or while the decoder did output something on EOF
1526
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1527
        uint8_t *data_buf, *decoded_data_buf;
1528
        int data_size, decoded_data_size;
1529
    handle_eof:
1530
        ist->pts= ist->next_pts;
1531

    
1532
        if(avpkt.size && avpkt.size != pkt->size &&
1533
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1534
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1535
            ist->showed_multi_packet_warning=1;
1536
        }
1537

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

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

    
1630
        buffer_to_free = NULL;
1631
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1632
            pre_process_video_frame(ist, (AVPicture *)&picture,
1633
                                    &buffer_to_free);
1634
        }
1635

    
1636
#if CONFIG_AVFILTER
1637
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1638
            // add it to be filtered
1639
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1640
                                     ist->pts,
1641
                                     ist->st->codec->sample_aspect_ratio);
1642
        }
1643
#endif
1644

    
1645
        // preprocess audio (volume)
1646
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1647
            if (audio_volume != 256) {
1648
                short *volp;
1649
                volp = samples;
1650
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1651
                    int v = ((*volp) * audio_volume + 128) >> 8;
1652
                    if (v < -32768) v = -32768;
1653
                    if (v >  32767) v = 32767;
1654
                    *volp++ = v;
1655
                }
1656
            }
1657
        }
1658

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

    
1681
                ost = ost_table[i];
1682
                if (ost->source_index == ist_index) {
1683
                    os = output_files[ost->file_index];
1684

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

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

    
1715
                        av_init_packet(&opkt);
1716

    
1717
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1718
                            continue;
1719

    
1720
                        /* no reencoding needed : output the packet directly */
1721
                        /* force the input stream PTS */
1722

    
1723
                        avcodec_get_frame_defaults(&avframe);
1724
                        ost->st->codec->coded_frame= &avframe;
1725
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1726

    
1727
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1728
                            audio_size += data_size;
1729
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1730
                            video_size += data_size;
1731
                            ost->sync_opts++;
1732
                        }
1733

    
1734
                        opkt.stream_index= ost->index;
1735
                        if(pkt->pts != AV_NOPTS_VALUE)
1736
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1737
                        else
1738
                            opkt.pts= AV_NOPTS_VALUE;
1739

    
1740
                        if (pkt->dts == AV_NOPTS_VALUE)
1741
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1742
                        else
1743
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1744
                        opkt.dts -= ost_tb_start_time;
1745

    
1746
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1747
                        opkt.flags= pkt->flags;
1748

    
1749
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1750
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1751
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1752
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1753
                           ) {
1754
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1755
                                opkt.destruct= av_destruct_packet;
1756
                        } else {
1757
                            opkt.data = data_buf;
1758
                            opkt.size = data_size;
1759
                        }
1760

    
1761
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1762
                        ost->st->codec->frame_number++;
1763
                        ost->frame_number++;
1764
                        av_free_packet(&opkt);
1765
                    }
1766
                }
1767
            }
1768

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

    
1795
        for(i=0;i<nb_ostreams;i++) {
1796
            ost = ost_table[i];
1797
            if (ost->source_index == ist_index) {
1798
                AVCodecContext *enc= ost->st->codec;
1799
                os = output_files[ost->file_index];
1800

    
1801
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1802
                    continue;
1803
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1804
                    continue;
1805

    
1806
                if (ost->encoding_needed) {
1807
                    for(;;) {
1808
                        AVPacket pkt;
1809
                        int fifo_bytes;
1810
                        av_init_packet(&pkt);
1811
                        pkt.stream_index= ost->index;
1812

    
1813
                        switch(ost->st->codec->codec_type) {
1814
                        case AVMEDIA_TYPE_AUDIO:
1815
                            fifo_bytes = av_fifo_size(ost->fifo);
1816
                            ret = 0;
1817
                            /* encode any samples remaining in fifo */
1818
                            if (fifo_bytes > 0) {
1819
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1820
                                int fs_tmp = enc->frame_size;
1821

    
1822
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1823
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1824
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1825
                                } else { /* pad */
1826
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1827
                                    if (allocated_audio_buf_size < frame_bytes)
1828
                                        ffmpeg_exit(1);
1829
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1830
                                }
1831

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

    
1864
                        if(ret<=0)
1865
                            break;
1866
                        pkt.data= bit_buffer;
1867
                        pkt.size= ret;
1868
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1869
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1870
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1871
                    }
1872
                }
1873
            }
1874
        }
1875
    }
1876

    
1877
    return 0;
1878
 fail_decode:
1879
    return -1;
1880
}
1881

    
1882
static void print_sdp(AVFormatContext **avc, int n)
1883
{
1884
    char sdp[2048];
1885

    
1886
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1887
    printf("SDP:\n%s\n", sdp);
1888
    fflush(stdout);
1889
}
1890

    
1891
static int copy_chapters(int infile, int outfile)
1892
{
1893
    AVFormatContext *is = input_files[infile];
1894
    AVFormatContext *os = output_files[outfile];
1895
    int i;
1896

    
1897
    for (i = 0; i < is->nb_chapters; i++) {
1898
        AVChapter *in_ch = is->chapters[i], *out_ch;
1899
        AVMetadataTag *t = NULL;
1900
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1901
                                      AV_TIME_BASE_Q, in_ch->time_base);
1902
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1903
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1904

    
1905

    
1906
        if (in_ch->end < ts_off)
1907
            continue;
1908
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1909
            break;
1910

    
1911
        out_ch = av_mallocz(sizeof(AVChapter));
1912
        if (!out_ch)
1913
            return AVERROR(ENOMEM);
1914

    
1915
        out_ch->id        = in_ch->id;
1916
        out_ch->time_base = in_ch->time_base;
1917
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1918
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1919

    
1920
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1921
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1922

    
1923
        os->nb_chapters++;
1924
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1925
        if (!os->chapters)
1926
            return AVERROR(ENOMEM);
1927
        os->chapters[os->nb_chapters - 1] = out_ch;
1928
    }
1929
    return 0;
1930
}
1931

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

    
1953
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1954
    if (!file_table)
1955
        goto fail;
1956

    
1957
    /* input stream init */
1958
    j = 0;
1959
    for(i=0;i<nb_input_files;i++) {
1960
        is = input_files[i];
1961
        file_table[i].ist_index = j;
1962
        file_table[i].nb_streams = is->nb_streams;
1963
        j += is->nb_streams;
1964
    }
1965
    nb_istreams = j;
1966

    
1967
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1968
    if (!ist_table)
1969
        goto fail;
1970

    
1971
    for(i=0;i<nb_istreams;i++) {
1972
        ist = av_mallocz(sizeof(AVInputStream));
1973
        if (!ist)
1974
            goto fail;
1975
        ist_table[i] = ist;
1976
    }
1977
    j = 0;
1978
    for(i=0;i<nb_input_files;i++) {
1979
        is = input_files[i];
1980
        for(k=0;k<is->nb_streams;k++) {
1981
            ist = ist_table[j++];
1982
            ist->st = is->streams[k];
1983
            ist->file_index = i;
1984
            ist->index = k;
1985
            ist->discard = 1; /* the stream is discarded by default
1986
                                 (changed later) */
1987

    
1988
            if (rate_emu) {
1989
                ist->start = av_gettime();
1990
            }
1991
        }
1992
    }
1993

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

    
2012
    /* Sanity check the mapping args -- do the input files & streams exist? */
2013
    for(i=0;i<nb_stream_maps;i++) {
2014
        int fi = stream_maps[i].file_index;
2015
        int si = stream_maps[i].stream_index;
2016

    
2017
        if (fi < 0 || fi > nb_input_files - 1 ||
2018
            si < 0 || si > file_table[fi].nb_streams - 1) {
2019
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2020
            ret = AVERROR(EINVAL);
2021
            goto fail;
2022
        }
2023
        fi = stream_maps[i].sync_file_index;
2024
        si = stream_maps[i].sync_stream_index;
2025
        if (fi < 0 || fi > nb_input_files - 1 ||
2026
            si < 0 || si > file_table[fi].nb_streams - 1) {
2027
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2028
            ret = AVERROR(EINVAL);
2029
            goto fail;
2030
        }
2031
    }
2032

    
2033
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2034
    if (!ost_table)
2035
        goto fail;
2036
    n = 0;
2037
    for(k=0;k<nb_output_files;k++) {
2038
        os = output_files[k];
2039
        for(i=0;i<os->nb_streams;i++,n++) {
2040
            int found;
2041
            ost = ost_table[n] = output_streams_for_file[k][i];
2042
            ost->st = os->streams[i];
2043
            if (nb_stream_maps > 0) {
2044
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2045
                    stream_maps[n].stream_index;
2046

    
2047
                /* Sanity check that the stream types match */
2048
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2049
                    int i= ost->file_index;
2050
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2051
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2052
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2053
                        ost->file_index, ost->index);
2054
                    ffmpeg_exit(1);
2055
                }
2056

    
2057
            } else {
2058
                int best_nb_frames=-1;
2059
                /* get corresponding input stream index : we select the first one with the right type */
2060
                found = 0;
2061
                for(j=0;j<nb_istreams;j++) {
2062
                    int skip=0;
2063
                    ist = ist_table[j];
2064
                    if(opt_programid){
2065
                        int pi,si;
2066
                        AVFormatContext *f= input_files[ ist->file_index ];
2067
                        skip=1;
2068
                        for(pi=0; pi<f->nb_programs; pi++){
2069
                            AVProgram *p= f->programs[pi];
2070
                            if(p->id == opt_programid)
2071
                                for(si=0; si<p->nb_stream_indexes; si++){
2072
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2073
                                        skip=0;
2074
                                }
2075
                        }
2076
                    }
2077
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2078
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2079
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2080
                            best_nb_frames= ist->st->codec_info_nb_frames;
2081
                            ost->source_index = j;
2082
                            found = 1;
2083
                        }
2084
                    }
2085
                }
2086

    
2087
                if (!found) {
2088
                    if(! opt_programid) {
2089
                        /* try again and reuse existing stream */
2090
                        for(j=0;j<nb_istreams;j++) {
2091
                            ist = ist_table[j];
2092
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2093
                                && ist->st->discard != AVDISCARD_ALL) {
2094
                                ost->source_index = j;
2095
                                found = 1;
2096
                            }
2097
                        }
2098
                    }
2099
                    if (!found) {
2100
                        int i= ost->file_index;
2101
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2102
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2103
                                ost->file_index, ost->index);
2104
                        ffmpeg_exit(1);
2105
                    }
2106
                }
2107
            }
2108
            ist = ist_table[ost->source_index];
2109
            ist->discard = 0;
2110
            ost->sync_ist = (nb_stream_maps > 0) ?
2111
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2112
                         stream_maps[n].sync_stream_index] : ist;
2113
        }
2114
    }
2115

    
2116
    /* for each output stream, we compute the right encoding parameters */
2117
    for(i=0;i<nb_ostreams;i++) {
2118
        AVMetadataTag *t = NULL;
2119
        ost = ost_table[i];
2120
        os = output_files[ost->file_index];
2121
        ist = ist_table[ost->source_index];
2122

    
2123
        codec = ost->st->codec;
2124
        icodec = ist->st->codec;
2125

    
2126
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2127
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2128
        }
2129

    
2130
        ost->st->disposition = ist->st->disposition;
2131
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2132
        codec->chroma_sample_location = icodec->chroma_sample_location;
2133

    
2134
        if (ost->st->stream_copy) {
2135
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2136

    
2137
            if (extra_size > INT_MAX)
2138
                goto fail;
2139

    
2140
            /* if stream_copy is selected, no need to decode or encode */
2141
            codec->codec_id = icodec->codec_id;
2142
            codec->codec_type = icodec->codec_type;
2143

    
2144
            if(!codec->codec_tag){
2145
                if(   !os->oformat->codec_tag
2146
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2147
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2148
                    codec->codec_tag = icodec->codec_tag;
2149
            }
2150

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

    
2245
#if !CONFIG_AVFILTER
2246
                    ost->original_height = icodec->height;
2247
                    ost->original_width  = icodec->width;
2248
#endif
2249
                    codec->bits_per_raw_sample= 0;
2250
                }
2251
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2252
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2253
                ost->resample_pix_fmt= icodec->pix_fmt;
2254
                ost->encoding_needed = 1;
2255
                ist->decoding_needed = 1;
2256

    
2257
#if CONFIG_AVFILTER
2258
                if (configure_filters(ist, ost)) {
2259
                    fprintf(stderr, "Error opening filters!\n");
2260
                    exit(1);
2261
                }
2262
#endif
2263
                break;
2264
            case AVMEDIA_TYPE_SUBTITLE:
2265
                ost->encoding_needed = 1;
2266
                ist->decoding_needed = 1;
2267
                break;
2268
            default:
2269
                abort();
2270
                break;
2271
            }
2272
            /* two pass mode */
2273
            if (ost->encoding_needed &&
2274
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2275
                char logfilename[1024];
2276
                FILE *f;
2277

    
2278
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2279
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2280
                         i);
2281
                if (codec->flags & CODEC_FLAG_PASS1) {
2282
                    f = fopen(logfilename, "wb");
2283
                    if (!f) {
2284
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2285
                        ffmpeg_exit(1);
2286
                    }
2287
                    ost->logfile = f;
2288
                } else {
2289
                    char  *logbuffer;
2290
                    size_t logbuffer_size;
2291
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2292
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2293
                        ffmpeg_exit(1);
2294
                    }
2295
                    codec->stats_in = logbuffer;
2296
                }
2297
            }
2298
        }
2299
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2300
            int size= codec->width * codec->height;
2301
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2302
        }
2303
    }
2304

    
2305
    if (!bit_buffer)
2306
        bit_buffer = av_malloc(bit_buffer_size);
2307
    if (!bit_buffer) {
2308
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2309
                bit_buffer_size);
2310
        ret = AVERROR(ENOMEM);
2311
        goto fail;
2312
    }
2313

    
2314
    /* open each encoder */
2315
    for(i=0;i<nb_ostreams;i++) {
2316
        ost = ost_table[i];
2317
        if (ost->encoding_needed) {
2318
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2319
            if (!codec)
2320
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2321
            if (!codec) {
2322
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2323
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2324
                ret = AVERROR(EINVAL);
2325
                goto dump_format;
2326
            }
2327
            if (avcodec_open(ost->st->codec, codec) < 0) {
2328
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2329
                        ost->file_index, ost->index);
2330
                ret = AVERROR(EINVAL);
2331
                goto dump_format;
2332
            }
2333
            extra_size += ost->st->codec->extradata_size;
2334
        }
2335
    }
2336

    
2337
    /* open each decoder */
2338
    for(i=0;i<nb_istreams;i++) {
2339
        ist = ist_table[i];
2340
        if (ist->decoding_needed) {
2341
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2342
            if (!codec)
2343
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2344
            if (!codec) {
2345
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2346
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2347
                ret = AVERROR(EINVAL);
2348
                goto dump_format;
2349
            }
2350
            if (avcodec_open(ist->st->codec, codec) < 0) {
2351
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2352
                        ist->file_index, ist->index);
2353
                ret = AVERROR(EINVAL);
2354
                goto dump_format;
2355
            }
2356
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2357
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2358
        }
2359
    }
2360

    
2361
    /* init pts */
2362
    for(i=0;i<nb_istreams;i++) {
2363
        AVStream *st;
2364
        ist = ist_table[i];
2365
        st= ist->st;
2366
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2367
        ist->next_pts = AV_NOPTS_VALUE;
2368
        init_pts_correction(&ist->pts_ctx);
2369
        ist->is_start = 1;
2370
    }
2371

    
2372
    /* set meta data information from input file if required */
2373
    for (i=0;i<nb_meta_data_maps;i++) {
2374
        AVFormatContext *out_file;
2375
        AVFormatContext *in_file;
2376
        AVMetadataTag *mtag;
2377

    
2378
        int out_file_index = meta_data_maps[i].out_file;
2379
        int in_file_index = meta_data_maps[i].in_file;
2380
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2381
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2382
                     out_file_index, out_file_index, in_file_index);
2383
            ret = AVERROR(EINVAL);
2384
            goto dump_format;
2385
        }
2386
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2387
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2388
                     in_file_index, out_file_index, in_file_index);
2389
            ret = AVERROR(EINVAL);
2390
            goto dump_format;
2391
        }
2392

    
2393
        out_file = output_files[out_file_index];
2394
        in_file = input_files[in_file_index];
2395

    
2396

    
2397
        mtag=NULL;
2398
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2399
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2400
    }
2401

    
2402
    /* copy chapters from the first input file that has them*/
2403
    for (i = 0; i < nb_input_files; i++) {
2404
        if (!input_files[i]->nb_chapters)
2405
            continue;
2406

    
2407
        for (j = 0; j < nb_output_files; j++)
2408
            if ((ret = copy_chapters(i, j)) < 0)
2409
                goto dump_format;
2410
    }
2411

    
2412
    /* open files and write file headers */
2413
    for(i=0;i<nb_output_files;i++) {
2414
        os = output_files[i];
2415
        if (av_write_header(os) < 0) {
2416
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2417
            ret = AVERROR(EINVAL);
2418
            goto dump_format;
2419
        }
2420
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2421
            want_sdp = 0;
2422
        }
2423
    }
2424

    
2425
 dump_format:
2426
    /* dump the file output parameters - cannot be done before in case
2427
       of stream copy */
2428
    for(i=0;i<nb_output_files;i++) {
2429
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2430
    }
2431

    
2432
    /* dump the stream mapping */
2433
    if (verbose >= 0) {
2434
        fprintf(stderr, "Stream mapping:\n");
2435
        for(i=0;i<nb_ostreams;i++) {
2436
            ost = ost_table[i];
2437
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2438
                    ist_table[ost->source_index]->file_index,
2439
                    ist_table[ost->source_index]->index,
2440
                    ost->file_index,
2441
                    ost->index);
2442
            if (ost->sync_ist != ist_table[ost->source_index])
2443
                fprintf(stderr, " [sync #%d.%d]",
2444
                        ost->sync_ist->file_index,
2445
                        ost->sync_ist->index);
2446
            fprintf(stderr, "\n");
2447
        }
2448
    }
2449

    
2450
    if (ret) {
2451
        fprintf(stderr, "%s\n", error);
2452
        goto fail;
2453
    }
2454

    
2455
    if (want_sdp) {
2456
        print_sdp(output_files, nb_output_files);
2457
    }
2458

    
2459
    if (!using_stdin && verbose >= 0) {
2460
        fprintf(stderr, "Press [q] to stop encoding\n");
2461
        url_set_interrupt_cb(decode_interrupt_cb);
2462
    }
2463
    term_init();
2464

    
2465
    timer_start = av_gettime();
2466

    
2467
    for(; received_sigterm == 0;) {
2468
        int file_index, ist_index;
2469
        AVPacket pkt;
2470
        double ipts_min;
2471
        double opts_min;
2472

    
2473
    redo:
2474
        ipts_min= 1e100;
2475
        opts_min= 1e100;
2476
        /* if 'q' pressed, exits */
2477
        if (!using_stdin) {
2478
            if (q_pressed)
2479
                break;
2480
            /* read_key() returns 0 on EOF */
2481
            key = read_key();
2482
            if (key == 'q')
2483
                break;
2484
        }
2485

    
2486
        /* select the stream that we must read now by looking at the
2487
           smallest output pts */
2488
        file_index = -1;
2489
        for(i=0;i<nb_ostreams;i++) {
2490
            double ipts, opts;
2491
            ost = ost_table[i];
2492
            os = output_files[ost->file_index];
2493
            ist = ist_table[ost->source_index];
2494
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2495
                continue;
2496
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2497
            ipts = (double)ist->pts;
2498
            if (!file_table[ist->file_index].eof_reached){
2499
                if(ipts < ipts_min) {
2500
                    ipts_min = ipts;
2501
                    if(input_sync ) file_index = ist->file_index;
2502
                }
2503
                if(opts < opts_min) {
2504
                    opts_min = opts;
2505
                    if(!input_sync) file_index = ist->file_index;
2506
                }
2507
            }
2508
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2509
                file_index= -1;
2510
                break;
2511
            }
2512
        }
2513
        /* if none, if is finished */
2514
        if (file_index < 0) {
2515
            if(no_packet_count){
2516
                no_packet_count=0;
2517
                memset(no_packet, 0, sizeof(no_packet));
2518
                usleep(10000);
2519
                continue;
2520
            }
2521
            break;
2522
        }
2523

    
2524
        /* finish if limit size exhausted */
2525
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2526
            break;
2527

    
2528
        /* read a frame from it and output it in the fifo */
2529
        is = input_files[file_index];
2530
        ret= av_read_frame(is, &pkt);
2531
        if(ret == AVERROR(EAGAIN)){
2532
            no_packet[file_index]=1;
2533
            no_packet_count++;
2534
            continue;
2535
        }
2536
        if (ret < 0) {
2537
            file_table[file_index].eof_reached = 1;
2538
            if (opt_shortest)
2539
                break;
2540
            else
2541
                continue;
2542
        }
2543

    
2544
        no_packet_count=0;
2545
        memset(no_packet, 0, sizeof(no_packet));
2546

    
2547
        if (do_pkt_dump) {
2548
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2549
        }
2550
        /* the following test is needed in case new streams appear
2551
           dynamically in stream : we ignore them */
2552
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2553
            goto discard_packet;
2554
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2555
        ist = ist_table[ist_index];
2556
        if (ist->discard)
2557
            goto discard_packet;
2558

    
2559
        if (pkt.dts != AV_NOPTS_VALUE)
2560
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2561
        if (pkt.pts != AV_NOPTS_VALUE)
2562
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2563

    
2564
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2565
            && input_files_ts_scale[file_index][pkt.stream_index]){
2566
            if(pkt.pts != AV_NOPTS_VALUE)
2567
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2568
            if(pkt.dts != AV_NOPTS_VALUE)
2569
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2570
        }
2571

    
2572
//        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);
2573
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2574
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2575
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2576
            int64_t delta= pkt_dts - ist->next_pts;
2577
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2578
                input_files_ts_offset[ist->file_index]-= delta;
2579
                if (verbose > 2)
2580
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2581
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2582
                if(pkt.pts != AV_NOPTS_VALUE)
2583
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2584
            }
2585
        }
2586

    
2587
        /* finish if recording time exhausted */
2588
        if (recording_time != INT64_MAX &&
2589
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2590
            ist->is_past_recording_time = 1;
2591
            goto discard_packet;
2592
        }
2593

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

    
2597
            if (verbose >= 0)
2598
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2599
                        ist->file_index, ist->index);
2600
            if (exit_on_error)
2601
                ffmpeg_exit(1);
2602
            av_free_packet(&pkt);
2603
            goto redo;
2604
        }
2605

    
2606
    discard_packet:
2607
        av_free_packet(&pkt);
2608

    
2609
        /* dump report by using the output first video and audio streams */
2610
        print_report(output_files, ost_table, nb_ostreams, 0);
2611
    }
2612

    
2613
    /* at the end of stream, we must flush the decoder buffers */
2614
    for(i=0;i<nb_istreams;i++) {
2615
        ist = ist_table[i];
2616
        if (ist->decoding_needed) {
2617
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2618
        }
2619
    }
2620

    
2621
    term_exit();
2622

    
2623
    /* write the trailer if needed and close file */
2624
    for(i=0;i<nb_output_files;i++) {
2625
        os = output_files[i];
2626
        av_write_trailer(os);
2627
    }
2628

    
2629
    /* dump report by using the first video and audio streams */
2630
    print_report(output_files, ost_table, nb_ostreams, 1);
2631

    
2632
    /* close each encoder */
2633
    for(i=0;i<nb_ostreams;i++) {
2634
        ost = ost_table[i];
2635
        if (ost->encoding_needed) {
2636
            av_freep(&ost->st->codec->stats_in);
2637
            avcodec_close(ost->st->codec);
2638
        }
2639
    }
2640

    
2641
    /* close each decoder */
2642
    for(i=0;i<nb_istreams;i++) {
2643
        ist = ist_table[i];
2644
        if (ist->decoding_needed) {
2645
            avcodec_close(ist->st->codec);
2646
        }
2647
    }
2648
#if CONFIG_AVFILTER
2649
    if (graph) {
2650
        avfilter_graph_destroy(graph);
2651
        av_freep(&graph);
2652
    }
2653
#endif
2654

    
2655
    /* finished ! */
2656
    ret = 0;
2657

    
2658
 fail:
2659
    av_freep(&bit_buffer);
2660
    av_free(file_table);
2661

    
2662
    if (ist_table) {
2663
        for(i=0;i<nb_istreams;i++) {
2664
            ist = ist_table[i];
2665
            av_free(ist);
2666
        }
2667
        av_free(ist_table);
2668
    }
2669
    if (ost_table) {
2670
        for(i=0;i<nb_ostreams;i++) {
2671
            ost = ost_table[i];
2672
            if (ost) {
2673
                if (ost->st->stream_copy)
2674
                    av_freep(&ost->st->codec->extradata);
2675
                if (ost->logfile) {
2676
                    fclose(ost->logfile);
2677
                    ost->logfile = NULL;
2678
                }
2679
                av_fifo_free(ost->fifo); /* works even if fifo is not
2680
                                             initialized but set to zero */
2681
                av_free(ost->pict_tmp.data[0]);
2682
                if (ost->video_resample)
2683
                    sws_freeContext(ost->img_resample_ctx);
2684
                if (ost->resample)
2685
                    audio_resample_close(ost->resample);
2686
                if (ost->reformat_ctx)
2687
                    av_audio_convert_free(ost->reformat_ctx);
2688
                av_free(ost);
2689
            }
2690
        }
2691
        av_free(ost_table);
2692
    }
2693
    return ret;
2694
}
2695

    
2696
static void opt_format(const char *arg)
2697
{
2698
    /* compatibility stuff for pgmyuv */
2699
    if (!strcmp(arg, "pgmyuv")) {
2700
        pgmyuv_compatibility_hack=1;
2701
//        opt_image_format(arg);
2702
        arg = "image2";
2703
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2704
    }
2705

    
2706
    last_asked_format = arg;
2707
}
2708

    
2709
static void opt_video_rc_override_string(const char *arg)
2710
{
2711
    video_rc_override_string = arg;
2712
}
2713

    
2714
static int opt_me_threshold(const char *opt, const char *arg)
2715
{
2716
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2717
    return 0;
2718
}
2719

    
2720
static int opt_verbose(const char *opt, const char *arg)
2721
{
2722
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2723
    return 0;
2724
}
2725

    
2726
static int opt_frame_rate(const char *opt, const char *arg)
2727
{
2728
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2729
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2730
        ffmpeg_exit(1);
2731
    }
2732
    return 0;
2733
}
2734

    
2735
static int opt_bitrate(const char *opt, const char *arg)
2736
{
2737
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2738

    
2739
    opt_default(opt, arg);
2740

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

    
2744
    return 0;
2745
}
2746

    
2747
static void opt_frame_crop_top(const char *arg)
2748
{
2749
    frame_topBand = atoi(arg);
2750
    if (frame_topBand < 0) {
2751
        fprintf(stderr, "Incorrect top crop size\n");
2752
        ffmpeg_exit(1);
2753
    }
2754
    if ((frame_topBand) >= frame_height){
2755
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2756
        ffmpeg_exit(1);
2757
    }
2758
    fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2759
    frame_height -= frame_topBand;
2760
}
2761

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

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

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

    
2807
static void opt_frame_size(const char *arg)
2808
{
2809
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2810
        fprintf(stderr, "Incorrect frame size\n");
2811
        ffmpeg_exit(1);
2812
    }
2813
}
2814

    
2815
static int opt_pad(const char *opt, const char *arg) {
2816
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2817
    return -1;
2818
}
2819

    
2820
static void opt_frame_pix_fmt(const char *arg)
2821
{
2822
    if (strcmp(arg, "list")) {
2823
        frame_pix_fmt = av_get_pix_fmt(arg);
2824
        if (frame_pix_fmt == PIX_FMT_NONE) {
2825
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2826
            ffmpeg_exit(1);
2827
        }
2828
    } else {
2829
        show_pix_fmts();
2830
        ffmpeg_exit(0);
2831
    }
2832
}
2833

    
2834
static void opt_frame_aspect_ratio(const char *arg)
2835
{
2836
    int x = 0, y = 0;
2837
    double ar = 0;
2838
    const char *p;
2839
    char *end;
2840

    
2841
    p = strchr(arg, ':');
2842
    if (p) {
2843
        x = strtol(arg, &end, 10);
2844
        if (end == p)
2845
            y = strtol(end+1, &end, 10);
2846
        if (x > 0 && y > 0)
2847
            ar = (double)x / (double)y;
2848
    } else
2849
        ar = strtod(arg, NULL);
2850

    
2851
    if (!ar) {
2852
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2853
        ffmpeg_exit(1);
2854
    }
2855
    frame_aspect_ratio = ar;
2856
}
2857

    
2858
static int opt_metadata(const char *opt, const char *arg)
2859
{
2860
    char *mid= strchr(arg, '=');
2861

    
2862
    if(!mid){
2863
        fprintf(stderr, "Missing =\n");
2864
        ffmpeg_exit(1);
2865
    }
2866
    *mid++= 0;
2867

    
2868
    av_metadata_set2(&metadata, arg, mid, 0);
2869

    
2870
    return 0;
2871
}
2872

    
2873
static void opt_qscale(const char *arg)
2874
{
2875
    video_qscale = atof(arg);
2876
    if (video_qscale <= 0 ||
2877
        video_qscale > 255) {
2878
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2879
        ffmpeg_exit(1);
2880
    }
2881
}
2882

    
2883
static void opt_top_field_first(const char *arg)
2884
{
2885
    top_field_first= atoi(arg);
2886
}
2887

    
2888
static int opt_thread_count(const char *opt, const char *arg)
2889
{
2890
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2891
#if !HAVE_THREADS
2892
    if (verbose >= 0)
2893
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2894
#endif
2895
    return 0;
2896
}
2897

    
2898
static void opt_audio_sample_fmt(const char *arg)
2899
{
2900
    if (strcmp(arg, "list"))
2901
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2902
    else {
2903
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2904
        ffmpeg_exit(0);
2905
    }
2906
}
2907

    
2908
static int opt_audio_rate(const char *opt, const char *arg)
2909
{
2910
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2911
    return 0;
2912
}
2913

    
2914
static int opt_audio_channels(const char *opt, const char *arg)
2915
{
2916
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2917
    return 0;
2918
}
2919

    
2920
static void opt_video_channel(const char *arg)
2921
{
2922
    video_channel = strtol(arg, NULL, 0);
2923
}
2924

    
2925
static void opt_video_standard(const char *arg)
2926
{
2927
    video_standard = av_strdup(arg);
2928
}
2929

    
2930
static void opt_codec(int *pstream_copy, char **pcodec_name,
2931
                      int codec_type, const char *arg)
2932
{
2933
    av_freep(pcodec_name);
2934
    if (!strcmp(arg, "copy")) {
2935
        *pstream_copy = 1;
2936
    } else {
2937
        *pcodec_name = av_strdup(arg);
2938
    }
2939
}
2940

    
2941
static void opt_audio_codec(const char *arg)
2942
{
2943
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2944
}
2945

    
2946
static void opt_audio_tag(const char *arg)
2947
{
2948
    char *tail;
2949
    audio_codec_tag= strtol(arg, &tail, 0);
2950

    
2951
    if(!tail || *tail)
2952
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2953
}
2954

    
2955
static void opt_video_tag(const char *arg)
2956
{
2957
    char *tail;
2958
    video_codec_tag= strtol(arg, &tail, 0);
2959

    
2960
    if(!tail || *tail)
2961
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2962
}
2963

    
2964
static void opt_video_codec(const char *arg)
2965
{
2966
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2967
}
2968

    
2969
static void opt_subtitle_codec(const char *arg)
2970
{
2971
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2972
}
2973

    
2974
static void opt_subtitle_tag(const char *arg)
2975
{
2976
    char *tail;
2977
    subtitle_codec_tag= strtol(arg, &tail, 0);
2978

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

    
2983
static void opt_map(const char *arg)
2984
{
2985
    AVStreamMap *m;
2986
    char *p;
2987

    
2988
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2989
    m = &stream_maps[nb_stream_maps-1];
2990

    
2991
    m->file_index = strtol(arg, &p, 0);
2992
    if (*p)
2993
        p++;
2994

    
2995
    m->stream_index = strtol(p, &p, 0);
2996
    if (*p) {
2997
        p++;
2998
        m->sync_file_index = strtol(p, &p, 0);
2999
        if (*p)
3000
            p++;
3001
        m->sync_stream_index = strtol(p, &p, 0);
3002
    } else {
3003
        m->sync_file_index = m->file_index;
3004
        m->sync_stream_index = m->stream_index;
3005
    }
3006
}
3007

    
3008
static void opt_map_meta_data(const char *arg)
3009
{
3010
    AVMetaDataMap *m;
3011
    char *p;
3012

    
3013
    m = &meta_data_maps[nb_meta_data_maps++];
3014

    
3015
    m->out_file = strtol(arg, &p, 0);
3016
    if (*p)
3017
        p++;
3018

    
3019
    m->in_file = strtol(p, &p, 0);
3020
}
3021

    
3022
static void opt_input_ts_scale(const char *arg)
3023
{
3024
    unsigned int stream;
3025
    double scale;
3026
    char *p;
3027

    
3028
    stream = strtol(arg, &p, 0);
3029
    if (*p)
3030
        p++;
3031
    scale= strtod(p, &p);
3032

    
3033
    if(stream >= MAX_STREAMS)
3034
        ffmpeg_exit(1);
3035

    
3036
    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);
3037
    input_files_ts_scale[nb_input_files][stream]= scale;
3038
}
3039

    
3040
static int opt_recording_time(const char *opt, const char *arg)
3041
{
3042
    recording_time = parse_time_or_die(opt, arg, 1);
3043
    return 0;
3044
}
3045

    
3046
static int opt_start_time(const char *opt, const char *arg)
3047
{
3048
    start_time = parse_time_or_die(opt, arg, 1);
3049
    return 0;
3050
}
3051

    
3052
static int opt_recording_timestamp(const char *opt, const char *arg)
3053
{
3054
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3055
    return 0;
3056
}
3057

    
3058
static int opt_input_ts_offset(const char *opt, const char *arg)
3059
{
3060
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3061
    return 0;
3062
}
3063

    
3064
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3065
{
3066
    const char *codec_string = encoder ? "encoder" : "decoder";
3067
    AVCodec *codec;
3068

    
3069
    if(!name)
3070
        return CODEC_ID_NONE;
3071
    codec = encoder ?
3072
        avcodec_find_encoder_by_name(name) :
3073
        avcodec_find_decoder_by_name(name);
3074
    if(!codec) {
3075
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3076
        ffmpeg_exit(1);
3077
    }
3078
    if(codec->type != type) {
3079
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3080
        ffmpeg_exit(1);
3081
    }
3082
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3083
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3084
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3085
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3086
                codec_string, codec->name);
3087
        codec = encoder ?
3088
            avcodec_find_encoder(codec->id) :
3089
            avcodec_find_decoder(codec->id);
3090
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3091
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3092
                    codec_string, codec->name);
3093
        ffmpeg_exit(1);
3094
    }
3095
    return codec->id;
3096
}
3097

    
3098
static void opt_input_file(const char *filename)
3099
{
3100
    AVFormatContext *ic;
3101
    AVFormatParameters params, *ap = &params;
3102
    AVInputFormat *file_iformat = NULL;
3103
    int err, i, ret, rfps, rfps_base;
3104
    int64_t timestamp;
3105

    
3106
    if (last_asked_format) {
3107
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3108
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3109
            ffmpeg_exit(1);
3110
        }
3111
        last_asked_format = NULL;
3112
    }
3113

    
3114
    if (!strcmp(filename, "-"))
3115
        filename = "pipe:";
3116

    
3117
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3118
                    !strcmp(filename, "/dev/stdin");
3119

    
3120
    /* get default parameters from command line */
3121
    ic = avformat_alloc_context();
3122
    if (!ic) {
3123
        print_error(filename, AVERROR(ENOMEM));
3124
        ffmpeg_exit(1);
3125
    }
3126

    
3127
    memset(ap, 0, sizeof(*ap));
3128
    ap->prealloced_context = 1;
3129
    ap->sample_rate = audio_sample_rate;
3130
    ap->channels = audio_channels;
3131
    ap->time_base.den = frame_rate.num;
3132
    ap->time_base.num = frame_rate.den;
3133
    ap->width = frame_width;
3134
    ap->height = frame_height;
3135
    ap->pix_fmt = frame_pix_fmt;
3136
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3137
    ap->channel = video_channel;
3138
    ap->standard = video_standard;
3139

    
3140
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3141

    
3142
    ic->video_codec_id   =
3143
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3144
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3145
    ic->audio_codec_id   =
3146
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3147
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3148
    ic->subtitle_codec_id=
3149
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3150
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3151
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3152

    
3153
    if(pgmyuv_compatibility_hack)
3154
        ic->video_codec_id= CODEC_ID_PGMYUV;
3155

    
3156
    /* open the input file with generic libav function */
3157
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3158
    if (err < 0) {
3159
        print_error(filename, err);
3160
        ffmpeg_exit(1);
3161
    }
3162
    if(opt_programid) {
3163
        int i, j;
3164
        int found=0;
3165
        for(i=0; i<ic->nb_streams; i++){
3166
            ic->streams[i]->discard= AVDISCARD_ALL;
3167
        }
3168
        for(i=0; i<ic->nb_programs; i++){
3169
            AVProgram *p= ic->programs[i];
3170
            if(p->id != opt_programid){
3171
                p->discard = AVDISCARD_ALL;
3172
            }else{
3173
                found=1;
3174
                for(j=0; j<p->nb_stream_indexes; j++){
3175
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3176
                }
3177
            }
3178
        }
3179
        if(!found){
3180
            fprintf(stderr, "Specified program id not found\n");
3181
            ffmpeg_exit(1);
3182
        }
3183
        opt_programid=0;
3184
    }
3185

    
3186
    ic->loop_input = loop_input;
3187

    
3188
    /* If not enough info to get the stream parameters, we decode the
3189
       first frames to get it. (used in mpeg case for example) */
3190
    ret = av_find_stream_info(ic);
3191
    if (ret < 0 && verbose >= 0) {
3192
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3193
        av_close_input_file(ic);
3194
        ffmpeg_exit(1);
3195
    }
3196

    
3197
    timestamp = start_time;
3198
    /* add the stream start time */
3199
    if (ic->start_time != AV_NOPTS_VALUE)
3200
        timestamp += ic->start_time;
3201

    
3202
    /* if seeking requested, we execute it */
3203
    if (start_time != 0) {
3204
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3205
        if (ret < 0) {
3206
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3207
                    filename, (double)timestamp / AV_TIME_BASE);
3208
        }
3209
        /* reset seek info */
3210
        start_time = 0;
3211
    }
3212

    
3213
    /* update the current parameters so that they match the one of the input stream */
3214
    for(i=0;i<ic->nb_streams;i++) {
3215
        AVStream *st = ic->streams[i];
3216
        AVCodecContext *dec = st->codec;
3217
        avcodec_thread_init(dec, thread_count);
3218
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3219
        switch (dec->codec_type) {
3220
        case AVMEDIA_TYPE_AUDIO:
3221
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3222
            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]);
3223
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3224
            channel_layout    = dec->channel_layout;
3225
            audio_channels    = dec->channels;
3226
            audio_sample_rate = dec->sample_rate;
3227
            audio_sample_fmt  = dec->sample_fmt;
3228
            if(audio_disable)
3229
                st->discard= AVDISCARD_ALL;
3230
            /* Note that av_find_stream_info can add more streams, and we
3231
             * currently have no chance of setting up lowres decoding
3232
             * early enough for them. */
3233
            if (dec->lowres)
3234
                audio_sample_rate >>= dec->lowres;
3235
            break;
3236
        case AVMEDIA_TYPE_VIDEO:
3237
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3238
            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]);
3239
            frame_height = dec->height;
3240
            frame_width  = dec->width;
3241
            if(ic->streams[i]->sample_aspect_ratio.num)
3242
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3243
            else
3244
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3245
            frame_aspect_ratio *= (float) dec->width / dec->height;
3246
            frame_pix_fmt = dec->pix_fmt;
3247
            rfps      = ic->streams[i]->r_frame_rate.num;
3248
            rfps_base = ic->streams[i]->r_frame_rate.den;
3249
            if (dec->lowres) {
3250
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3251
                frame_height >>= dec->lowres;
3252
                frame_width  >>= dec->lowres;
3253
            }
3254
            if(me_threshold)
3255
                dec->debug |= FF_DEBUG_MV;
3256

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

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

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

    
3269
            if(video_disable)
3270
                st->discard= AVDISCARD_ALL;
3271
            else if(video_discard)
3272
                st->discard= video_discard;
3273
            break;
3274
        case AVMEDIA_TYPE_DATA:
3275
            break;
3276
        case AVMEDIA_TYPE_SUBTITLE:
3277
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3278
            if(subtitle_disable)
3279
                st->discard = AVDISCARD_ALL;
3280
            break;
3281
        case AVMEDIA_TYPE_ATTACHMENT:
3282
        case AVMEDIA_TYPE_UNKNOWN:
3283
            break;
3284
        default:
3285
            abort();
3286
        }
3287
    }
3288

    
3289
    input_files[nb_input_files] = ic;
3290
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3291
    /* dump the file content */
3292
    if (verbose >= 0)
3293
        dump_format(ic, nb_input_files, filename, 0);
3294

    
3295
    nb_input_files++;
3296

    
3297
    video_channel = 0;
3298

    
3299
    av_freep(&video_codec_name);
3300
    av_freep(&audio_codec_name);
3301
    av_freep(&subtitle_codec_name);
3302
}
3303

    
3304
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3305
                                         int *has_subtitle_ptr)
3306
{
3307
    int has_video, has_audio, has_subtitle, i, j;
3308
    AVFormatContext *ic;
3309

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

    
3341
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
3342
{
3343
    int idx = oc->nb_streams - 1;
3344
    AVOutputStream *ost;
3345

    
3346
    output_streams_for_file[file_idx] =
3347
        grow_array(output_streams_for_file[file_idx],
3348
                   sizeof(*output_streams_for_file[file_idx]),
3349
                   &nb_output_streams_for_file[file_idx],
3350
                   oc->nb_streams);
3351
    ost = output_streams_for_file[file_idx][idx] =
3352
        av_mallocz(sizeof(AVOutputStream));
3353
    if (!ost) {
3354
        fprintf(stderr, "Could not alloc output stream\n");
3355
        ffmpeg_exit(1);
3356
    }
3357
    ost->file_index = file_idx;
3358
    ost->index = idx;
3359
    return ost;
3360
}
3361

    
3362
static void new_video_stream(AVFormatContext *oc, int file_idx)
3363
{
3364
    AVStream *st;
3365
    AVOutputStream *ost;
3366
    AVCodecContext *video_enc;
3367
    enum CodecID codec_id;
3368
    AVCodec *codec= NULL;
3369

    
3370
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3371
    if (!st) {
3372
        fprintf(stderr, "Could not alloc stream\n");
3373
        ffmpeg_exit(1);
3374
    }
3375
    ost = new_output_stream(oc, file_idx);
3376

    
3377
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3378
    if(!video_stream_copy){
3379
        if (video_codec_name) {
3380
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3381
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3382
            codec = avcodec_find_encoder_by_name(video_codec_name);
3383
            output_codecs[nb_output_codecs-1] = codec;
3384
        } else {
3385
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3386
            codec = avcodec_find_encoder(codec_id);
3387
        }
3388
    }
3389

    
3390
    avcodec_get_context_defaults3(st->codec, codec);
3391
    ost->bitstream_filters = video_bitstream_filters;
3392
    video_bitstream_filters= NULL;
3393

    
3394
    avcodec_thread_init(st->codec, thread_count);
3395

    
3396
    video_enc = st->codec;
3397

    
3398
    if(video_codec_tag)
3399
        video_enc->codec_tag= video_codec_tag;
3400

    
3401
    if(   (video_global_header&1)
3402
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3403
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3404
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3405
    }
3406
    if(video_global_header&2){
3407
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3408
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3409
    }
3410

    
3411
    if (video_stream_copy) {
3412
        st->stream_copy = 1;
3413
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3414
        video_enc->sample_aspect_ratio =
3415
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3416
    } else {
3417
        const char *p;
3418
        int i;
3419
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3420

    
3421
        video_enc->codec_id = codec_id;
3422
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3423

    
3424
        if (codec && codec->supported_framerates && !force_fps)
3425
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3426
        video_enc->time_base.den = fps.num;
3427
        video_enc->time_base.num = fps.den;
3428

    
3429
        video_enc->width = frame_width;
3430
        video_enc->height = frame_height;
3431
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3432
        video_enc->pix_fmt = frame_pix_fmt;
3433
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3434

    
3435
        choose_pixel_fmt(st, codec);
3436

    
3437
        if (intra_only)
3438
            video_enc->gop_size = 0;
3439
        if (video_qscale || same_quality) {
3440
            video_enc->flags |= CODEC_FLAG_QSCALE;
3441
            video_enc->global_quality=
3442
                st->quality = FF_QP2LAMBDA * video_qscale;
3443
        }
3444

    
3445
        if(intra_matrix)
3446
            video_enc->intra_matrix = intra_matrix;
3447
        if(inter_matrix)
3448
            video_enc->inter_matrix = inter_matrix;
3449

    
3450
        p= video_rc_override_string;
3451
        for(i=0; p; i++){
3452
            int start, end, q;
3453
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3454
            if(e!=3){
3455
                fprintf(stderr, "error parsing rc_override\n");
3456
                ffmpeg_exit(1);
3457
            }
3458
            video_enc->rc_override=
3459
                av_realloc(video_enc->rc_override,
3460
                           sizeof(RcOverride)*(i+1));
3461
            video_enc->rc_override[i].start_frame= start;
3462
            video_enc->rc_override[i].end_frame  = end;
3463
            if(q>0){
3464
                video_enc->rc_override[i].qscale= q;
3465
                video_enc->rc_override[i].quality_factor= 1.0;
3466
            }
3467
            else{
3468
                video_enc->rc_override[i].qscale= 0;
3469
                video_enc->rc_override[i].quality_factor= -q/100.0;
3470
            }
3471
            p= strchr(p, '/');
3472
            if(p) p++;
3473
        }
3474
        video_enc->rc_override_count=i;
3475
        if (!video_enc->rc_initial_buffer_occupancy)
3476
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3477
        video_enc->me_threshold= me_threshold;
3478
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3479

    
3480
        if (do_psnr)
3481
            video_enc->flags|= CODEC_FLAG_PSNR;
3482

    
3483
        /* two pass mode */
3484
        if (do_pass) {
3485
            if (do_pass == 1) {
3486
                video_enc->flags |= CODEC_FLAG_PASS1;
3487
            } else {
3488
                video_enc->flags |= CODEC_FLAG_PASS2;
3489
            }
3490
        }
3491
    }
3492
    if (video_language) {
3493
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3494
        av_freep(&video_language);
3495
    }
3496

    
3497
    /* reset some key parameters */
3498
    video_disable = 0;
3499
    av_freep(&video_codec_name);
3500
    video_stream_copy = 0;
3501
    frame_pix_fmt = PIX_FMT_NONE;
3502
}
3503

    
3504
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3505
{
3506
    AVStream *st;
3507
    AVOutputStream *ost;
3508
    AVCodec *codec= NULL;
3509
    AVCodecContext *audio_enc;
3510
    enum CodecID codec_id;
3511

    
3512
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3513
    if (!st) {
3514
        fprintf(stderr, "Could not alloc stream\n");
3515
        ffmpeg_exit(1);
3516
    }
3517
    ost = new_output_stream(oc, file_idx);
3518

    
3519
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3520
    if(!audio_stream_copy){
3521
        if (audio_codec_name) {
3522
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3523
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3524
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3525
            output_codecs[nb_output_codecs-1] = codec;
3526
        } else {
3527
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3528
            codec = avcodec_find_encoder(codec_id);
3529
        }
3530
    }
3531

    
3532
    avcodec_get_context_defaults3(st->codec, codec);
3533

    
3534
    ost->bitstream_filters = audio_bitstream_filters;
3535
    audio_bitstream_filters= NULL;
3536

    
3537
    avcodec_thread_init(st->codec, thread_count);
3538

    
3539
    audio_enc = st->codec;
3540
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3541

    
3542
    if(audio_codec_tag)
3543
        audio_enc->codec_tag= audio_codec_tag;
3544

    
3545
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3546
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3547
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3548
    }
3549
    if (audio_stream_copy) {
3550
        st->stream_copy = 1;
3551
        audio_enc->channels = audio_channels;
3552
        audio_enc->sample_rate = audio_sample_rate;
3553
    } else {
3554
        audio_enc->codec_id = codec_id;
3555
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3556

    
3557
        if (audio_qscale > QSCALE_NONE) {
3558
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3559
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3560
        }
3561
        audio_enc->channels = audio_channels;
3562
        audio_enc->sample_fmt = audio_sample_fmt;
3563
        audio_enc->sample_rate = audio_sample_rate;
3564
        audio_enc->channel_layout = channel_layout;
3565
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3566
            audio_enc->channel_layout = 0;
3567
        choose_sample_fmt(st, codec);
3568
        choose_sample_rate(st, codec);
3569
    }
3570
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3571
    if (audio_language) {
3572
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3573
        av_freep(&audio_language);
3574
    }
3575

    
3576
    /* reset some key parameters */
3577
    audio_disable = 0;
3578
    av_freep(&audio_codec_name);
3579
    audio_stream_copy = 0;
3580
}
3581

    
3582
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3583
{
3584
    AVStream *st;
3585
    AVOutputStream *ost;
3586
    AVCodec *codec=NULL;
3587
    AVCodecContext *subtitle_enc;
3588

    
3589
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3590
    if (!st) {
3591
        fprintf(stderr, "Could not alloc stream\n");
3592
        ffmpeg_exit(1);
3593
    }
3594
    ost = new_output_stream(oc, file_idx);
3595
    subtitle_enc = st->codec;
3596
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3597
    if(!subtitle_stream_copy){
3598
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3599
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3600
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3601
    }
3602
    avcodec_get_context_defaults3(st->codec, codec);
3603

    
3604
    ost->bitstream_filters = subtitle_bitstream_filters;
3605
    subtitle_bitstream_filters= NULL;
3606

    
3607
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3608

    
3609
    if(subtitle_codec_tag)
3610
        subtitle_enc->codec_tag= subtitle_codec_tag;
3611

    
3612
    if (subtitle_stream_copy) {
3613
        st->stream_copy = 1;
3614
    } else {
3615
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3616
    }
3617

    
3618
    if (subtitle_language) {
3619
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3620
        av_freep(&subtitle_language);
3621
    }
3622

    
3623
    subtitle_disable = 0;
3624
    av_freep(&subtitle_codec_name);
3625
    subtitle_stream_copy = 0;
3626
}
3627

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

    
3638
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3639
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3640
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3641
    else av_assert0(0);
3642
    return 0;
3643
}
3644

    
3645
/* arg format is "output-stream-index:streamid-value". */
3646
static int opt_streamid(const char *opt, const char *arg)
3647
{
3648
    int idx;
3649
    char *p;
3650
    char idx_str[16];
3651

    
3652
    strncpy(idx_str, arg, sizeof(idx_str));
3653
    idx_str[sizeof(idx_str)-1] = '\0';
3654
    p = strchr(idx_str, ':');
3655
    if (!p) {
3656
        fprintf(stderr,
3657
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3658
                arg, opt);
3659
        ffmpeg_exit(1);
3660
    }
3661
    *p++ = '\0';
3662
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3663
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3664
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3665
    return 0;
3666
}
3667

    
3668
static void opt_output_file(const char *filename)
3669
{
3670
    AVFormatContext *oc;
3671
    int err, use_video, use_audio, use_subtitle;
3672
    int input_has_video, input_has_audio, input_has_subtitle;
3673
    AVFormatParameters params, *ap = &params;
3674
    AVOutputFormat *file_oformat;
3675
    AVMetadataTag *tag = NULL;
3676

    
3677
    if (!strcmp(filename, "-"))
3678
        filename = "pipe:";
3679

    
3680
    oc = avformat_alloc_context();
3681
    if (!oc) {
3682
        print_error(filename, AVERROR(ENOMEM));
3683
        ffmpeg_exit(1);
3684
    }
3685

    
3686
    if (last_asked_format) {
3687
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3688
        if (!file_oformat) {
3689
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3690
            ffmpeg_exit(1);
3691
        }
3692
        last_asked_format = NULL;
3693
    } else {
3694
        file_oformat = av_guess_format(NULL, filename, NULL);
3695
        if (!file_oformat) {
3696
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3697
                    filename);
3698
            ffmpeg_exit(1);
3699
        }
3700
    }
3701

    
3702
    oc->oformat = file_oformat;
3703
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3704

    
3705
    if (!strcmp(file_oformat->name, "ffm") &&
3706
        av_strstart(filename, "http:", NULL)) {
3707
        /* special case for files sent to ffserver: we get the stream
3708
           parameters from ffserver */
3709
        int err = read_ffserver_streams(oc, filename);
3710
        if (err < 0) {
3711
            print_error(filename, err);
3712
            ffmpeg_exit(1);
3713
        }
3714
    } else {
3715
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3716
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3717
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3718

    
3719
        /* disable if no corresponding type found and at least one
3720
           input file */
3721
        if (nb_input_files > 0) {
3722
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3723
                                         &input_has_subtitle);
3724
            if (!input_has_video)
3725
                use_video = 0;
3726
            if (!input_has_audio)
3727
                use_audio = 0;
3728
            if (!input_has_subtitle)
3729
                use_subtitle = 0;
3730
        }
3731

    
3732
        /* manual disable */
3733
        if (audio_disable) {
3734
            use_audio = 0;
3735
        }
3736
        if (video_disable) {
3737
            use_video = 0;
3738
        }
3739
        if (subtitle_disable) {
3740
            use_subtitle = 0;
3741
        }
3742

    
3743
        if (use_video) {
3744
            new_video_stream(oc, nb_output_files);
3745
        }
3746

    
3747
        if (use_audio) {
3748
            new_audio_stream(oc, nb_output_files);
3749
        }
3750

    
3751
        if (use_subtitle) {
3752
            new_subtitle_stream(oc, nb_output_files);
3753
        }
3754

    
3755
        oc->timestamp = recording_timestamp;
3756

    
3757
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3758
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3759
        av_metadata_free(&metadata);
3760
    }
3761

    
3762
    output_files[nb_output_files++] = oc;
3763

    
3764
    /* check filename in case of an image number is expected */
3765
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3766
        if (!av_filename_number_test(oc->filename)) {
3767
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3768
            ffmpeg_exit(1);
3769
        }
3770
    }
3771

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

    
3794
        /* open the file */
3795
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3796
            print_error(filename, err);
3797
            ffmpeg_exit(1);
3798
        }
3799
    }
3800

    
3801
    memset(ap, 0, sizeof(*ap));
3802
    if (av_set_parameters(oc, ap) < 0) {
3803
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3804
                oc->filename);
3805
        ffmpeg_exit(1);
3806
    }
3807

    
3808
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3809
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3810
    oc->loop_output = loop_output;
3811
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3812

    
3813
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3814

    
3815
    nb_streamid_map = 0;
3816
}
3817

    
3818
/* same option as mencoder */
3819
static void opt_pass(const char *pass_str)
3820
{
3821
    int pass;
3822
    pass = atoi(pass_str);
3823
    if (pass != 1 && pass != 2) {
3824
        fprintf(stderr, "pass number can be only 1 or 2\n");
3825
        ffmpeg_exit(1);
3826
    }
3827
    do_pass = pass;
3828
}
3829

    
3830
static int64_t getutime(void)
3831
{
3832
#if HAVE_GETRUSAGE
3833
    struct rusage rusage;
3834

    
3835
    getrusage(RUSAGE_SELF, &rusage);
3836
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3837
#elif HAVE_GETPROCESSTIMES
3838
    HANDLE proc;
3839
    FILETIME c, e, k, u;
3840
    proc = GetCurrentProcess();
3841
    GetProcessTimes(proc, &c, &e, &k, &u);
3842
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3843
#else
3844
    return av_gettime();
3845
#endif
3846
}
3847

    
3848
static int64_t getmaxrss(void)
3849
{
3850
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3851
    struct rusage rusage;
3852
    getrusage(RUSAGE_SELF, &rusage);
3853
    return (int64_t)rusage.ru_maxrss * 1024;
3854
#elif HAVE_GETPROCESSMEMORYINFO
3855
    HANDLE proc;
3856
    PROCESS_MEMORY_COUNTERS memcounters;
3857
    proc = GetCurrentProcess();
3858
    memcounters.cb = sizeof(memcounters);
3859
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3860
    return memcounters.PeakPagefileUsage;
3861
#else
3862
    return 0;
3863
#endif
3864
}
3865

    
3866
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3867
{
3868
    int i;
3869
    const char *p = str;
3870
    for(i = 0;; i++) {
3871
        dest[i] = atoi(p);
3872
        if(i == 63)
3873
            break;
3874
        p = strchr(p, ',');
3875
        if(!p) {
3876
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3877
            ffmpeg_exit(1);
3878
        }
3879
        p++;
3880
    }
3881
}
3882

    
3883
static void opt_inter_matrix(const char *arg)
3884
{
3885
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3886
    parse_matrix_coeffs(inter_matrix, arg);
3887
}
3888

    
3889
static void opt_intra_matrix(const char *arg)
3890
{
3891
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3892
    parse_matrix_coeffs(intra_matrix, arg);
3893
}
3894

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4037

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

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

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

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

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

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

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

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

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

    
4066
        opt_format("dv");
4067

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

    
4073
        audio_sample_rate = 48000;
4074
        audio_channels = 2;
4075

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

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

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

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

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

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

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

    
4115
    *bsfp= bsfc;
4116

    
4117
    return 0;
4118
}
4119

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

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

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

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

    
4175
    fclose(f);
4176

    
4177
    return 0;
4178
}
4179

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

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

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

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

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

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

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

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

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

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

    
4314
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4315

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

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

    
4330
    init_opts();
4331

    
4332
    show_banner();
4333

    
4334
    /* parse options */
4335
    parse_options(argc, argv, options, opt_output_file);
4336

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

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

    
4349
    if (nb_input_files == 0) {
4350
        fprintf(stderr, "At least one input file must be specified\n");
4351
        ffmpeg_exit(1);
4352
    }
4353

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

    
4364
    return ffmpeg_exit(0);
4365
}