Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 6c18f1cd

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/audioconvert.h"
40
#include "libavcore/parseutils.h"
41
#include "libavcore/samplefmt.h"
42
#include "libavutil/colorspace.h"
43
#include "libavutil/fifo.h"
44
#include "libavutil/intreadwrite.h"
45
#include "libavutil/pixdesc.h"
46
#include "libavutil/avstring.h"
47
#include "libavutil/libm.h"
48
#include "libavformat/os_support.h"
49

    
50
#if CONFIG_AVFILTER
51
# include "libavfilter/avfilter.h"
52
# include "libavfilter/avfiltergraph.h"
53
# include "libavfilter/vsrc_buffer.h"
54
#endif
55

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

    
68
#if HAVE_SYS_SELECT_H
69
#include <sys/select.h>
70
#endif
71

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

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

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

    
97
/**
98
 * select an input file for an output file
99
 */
100
typedef struct AVMetaDataMap {
101
    int  file;      //< file index
102
    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103
    int  index;     //< stream/chapter/program number
104
} AVMetaDataMap;
105

    
106
typedef struct AVChapterMap {
107
    int in_file;
108
    int out_file;
109
} AVChapterMap;
110

    
111
static const OptionDef options[];
112

    
113
#define MAX_FILES 100
114
#if !FF_API_MAX_STREAMS
115
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
116
#endif
117

    
118
static const char *last_asked_format = NULL;
119
static AVFormatContext *input_files[MAX_FILES];
120
static int64_t input_files_ts_offset[MAX_FILES];
121
static double *input_files_ts_scale[MAX_FILES] = {NULL};
122
static AVCodec **input_codecs = NULL;
123
static int nb_input_files = 0;
124
static int nb_input_codecs = 0;
125
static int nb_input_files_ts_scale[MAX_FILES] = {0};
126

    
127
static AVFormatContext *output_files[MAX_FILES];
128
static AVCodec **output_codecs = NULL;
129
static int nb_output_files = 0;
130
static int nb_output_codecs = 0;
131

    
132
static AVStreamMap *stream_maps = NULL;
133
static int nb_stream_maps;
134

    
135
/* first item specifies output metadata, second is input */
136
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137
static int nb_meta_data_maps;
138
static int metadata_global_autocopy   = 1;
139
static int metadata_streams_autocopy  = 1;
140
static int metadata_chapters_autocopy = 1;
141

    
142
static AVChapterMap *chapter_maps = NULL;
143
static int nb_chapter_maps;
144

    
145
/* indexed by output file stream index */
146
static int *streamid_map = NULL;
147
static int nb_streamid_map = 0;
148

    
149
static int frame_width  = 0;
150
static int frame_height = 0;
151
static float frame_aspect_ratio = 0;
152
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153
static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155
static AVRational frame_rate;
156
static float video_qscale = 0;
157
static uint16_t *intra_matrix = NULL;
158
static uint16_t *inter_matrix = NULL;
159
static const char *video_rc_override_string=NULL;
160
static int video_disable = 0;
161
static int video_discard = 0;
162
static char *video_codec_name = NULL;
163
static unsigned int video_codec_tag = 0;
164
static char *video_language = NULL;
165
static int same_quality = 0;
166
static int do_deinterlace = 0;
167
static int top_field_first = -1;
168
static int me_threshold = 0;
169
static int intra_dc_precision = 8;
170
static int loop_input = 0;
171
static int loop_output = AVFMT_NOOUTPUTLOOP;
172
static int qp_hist = 0;
173
#if CONFIG_AVFILTER
174
static char *vfilters = NULL;
175
AVFilterGraph *graph = NULL;
176
#endif
177

    
178
static int intra_only = 0;
179
static int audio_sample_rate = 44100;
180
static int64_t channel_layout = 0;
181
#define QSCALE_NONE -99999
182
static float audio_qscale = QSCALE_NONE;
183
static int audio_disable = 0;
184
static int audio_channels = 1;
185
static char  *audio_codec_name = NULL;
186
static unsigned int audio_codec_tag = 0;
187
static char *audio_language = NULL;
188

    
189
static int subtitle_disable = 0;
190
static char *subtitle_codec_name = NULL;
191
static char *subtitle_language = NULL;
192
static unsigned int subtitle_codec_tag = 0;
193

    
194
static float mux_preload= 0.5;
195
static float mux_max_delay= 0.7;
196

    
197
static int64_t recording_time = INT64_MAX;
198
static int64_t start_time = 0;
199
static int64_t recording_timestamp = 0;
200
static int64_t input_ts_offset = 0;
201
static int file_overwrite = 0;
202
static AVMetadata *metadata;
203
static int do_benchmark = 0;
204
static int do_hex_dump = 0;
205
static int do_pkt_dump = 0;
206
static int do_psnr = 0;
207
static int do_pass = 0;
208
static char *pass_logfilename_prefix = NULL;
209
static int audio_stream_copy = 0;
210
static int video_stream_copy = 0;
211
static int subtitle_stream_copy = 0;
212
static int video_sync_method= -1;
213
static int audio_sync_method= 0;
214
static float audio_drift_threshold= 0.1;
215
static int copy_ts= 0;
216
static int opt_shortest = 0;
217
static int video_global_header = 0;
218
static char *vstats_filename;
219
static FILE *vstats_file;
220
static int opt_programid = 0;
221
static int copy_initial_nonkeyframes = 0;
222

    
223
static int rate_emu = 0;
224

    
225
static int  video_channel = 0;
226
static char *video_standard;
227

    
228
static int audio_volume = 256;
229

    
230
static int exit_on_error = 0;
231
static int using_stdin = 0;
232
static int verbose = 1;
233
static int thread_count= 1;
234
static int q_pressed = 0;
235
static int64_t video_size = 0;
236
static int64_t audio_size = 0;
237
static int64_t extra_size = 0;
238
static int nb_frames_dup = 0;
239
static int nb_frames_drop = 0;
240
static int input_sync;
241
static uint64_t limit_filesize = 0;
242
static int force_fps = 0;
243
static char *forced_key_frames = NULL;
244

    
245
static float dts_delta_threshold = 10;
246

    
247
static unsigned int sws_flags = SWS_BICUBIC;
248

    
249
static int64_t timer_start;
250

    
251
static uint8_t *audio_buf;
252
static uint8_t *audio_out;
253
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
254

    
255
static short *samples;
256

    
257
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
258
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
259
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
260

    
261
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
262

    
263
struct AVInputStream;
264

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

    
286
    /* full frame size of first frame */
287
    int original_height;
288
    int original_width;
289

    
290
    /* forced key frames */
291
    int64_t *forced_kf_pts;
292
    int forced_kf_count;
293
    int forced_kf_index;
294

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

    
307
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
308
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
309

    
310
typedef struct AVInputStream {
311
    int file_index;
312
    int index;
313
    AVStream *st;
314
    int discard;             /* true if stream data should be discarded */
315
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
316
    int64_t sample_index;      /* current sample */
317

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

    
335
typedef struct AVInputFile {
336
    int eof_reached;      /* true if eof reached */
337
    int ist_index;        /* index of first stream in ist_table */
338
    int buffer_size;      /* current total buffer size */
339
    int nb_streams;       /* nb streams we are aware of */
340
} AVInputFile;
341

    
342
#if HAVE_TERMIOS_H
343

    
344
/* init terminal so that we can grab keys */
345
static struct termios oldtty;
346
#endif
347

    
348
#if CONFIG_AVFILTER
349

    
350
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
351
{
352
    AVFilterContext *last_filter, *filter;
353
    /** filter graph containing all filters including input & output */
354
    AVCodecContext *codec = ost->st->codec;
355
    AVCodecContext *icodec = ist->st->codec;
356
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
357
    char args[255];
358
    int ret;
359

    
360
    graph = avfilter_graph_alloc();
361

    
362
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
363
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
364
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
365
                                       "src", args, NULL, graph);
366
    if (ret < 0)
367
        return ret;
368
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
369
                                       "out", NULL, &ffsink_ctx, graph);
370
    if (ret < 0)
371
        return ret;
372
    last_filter = ist->input_video_filter;
373

    
374
    if (codec->width  != icodec->width || codec->height != icodec->height) {
375
        snprintf(args, 255, "%d:%d:flags=0x%X",
376
                 codec->width,
377
                 codec->height,
378
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
379
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
380
                                                NULL, args, NULL, graph)) < 0)
381
            return ret;
382
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
383
            return ret;
384
        last_filter = filter;
385
    }
386

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

    
390
    if (vfilters) {
391
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
392
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
393

    
394
        outputs->name    = av_strdup("in");
395
        outputs->filter_ctx = last_filter;
396
        outputs->pad_idx = 0;
397
        outputs->next    = NULL;
398

    
399
        inputs->name    = av_strdup("out");
400
        inputs->filter_ctx = ist->output_video_filter;
401
        inputs->pad_idx = 0;
402
        inputs->next    = NULL;
403

    
404
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
405
            return ret;
406
        av_freep(&vfilters);
407
    } else {
408
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
409
            return ret;
410
    }
411

    
412
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
413
        return ret;
414

    
415
    codec->width  = ist->output_video_filter->inputs[0]->w;
416
    codec->height = ist->output_video_filter->inputs[0]->h;
417

    
418
    return 0;
419
}
420
#endif /* CONFIG_AVFILTER */
421

    
422
static void term_exit(void)
423
{
424
    av_log(NULL, AV_LOG_QUIET, "");
425
#if HAVE_TERMIOS_H
426
    tcsetattr (0, TCSANOW, &oldtty);
427
#endif
428
}
429

    
430
static volatile int received_sigterm = 0;
431

    
432
static void
433
sigterm_handler(int sig)
434
{
435
    received_sigterm = sig;
436
    term_exit();
437
}
438

    
439
static void term_init(void)
440
{
441
#if HAVE_TERMIOS_H
442
    struct termios tty;
443

    
444
    tcgetattr (0, &tty);
445
    oldtty = tty;
446
    atexit(term_exit);
447

    
448
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
449
                          |INLCR|IGNCR|ICRNL|IXON);
450
    tty.c_oflag |= OPOST;
451
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
452
    tty.c_cflag &= ~(CSIZE|PARENB);
453
    tty.c_cflag |= CS8;
454
    tty.c_cc[VMIN] = 1;
455
    tty.c_cc[VTIME] = 0;
456

    
457
    tcsetattr (0, TCSANOW, &tty);
458
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
459
#endif
460

    
461
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
462
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
463
#ifdef SIGXCPU
464
    signal(SIGXCPU, sigterm_handler);
465
#endif
466
}
467

    
468
/* read a key without blocking */
469
static int read_key(void)
470
{
471
#if HAVE_TERMIOS_H
472
    int n = 1;
473
    unsigned char ch;
474
    struct timeval tv;
475
    fd_set rfds;
476

    
477
    FD_ZERO(&rfds);
478
    FD_SET(0, &rfds);
479
    tv.tv_sec = 0;
480
    tv.tv_usec = 0;
481
    n = select(1, &rfds, NULL, NULL, &tv);
482
    if (n > 0) {
483
        n = read(0, &ch, 1);
484
        if (n == 1)
485
            return ch;
486

    
487
        return n;
488
    }
489
#elif HAVE_CONIO_H
490
    if(kbhit())
491
        return(getch());
492
#endif
493
    return -1;
494
}
495

    
496
static int decode_interrupt_cb(void)
497
{
498
    return q_pressed || (q_pressed = read_key() == 'q');
499
}
500

    
501
static int ffmpeg_exit(int ret)
502
{
503
    int i;
504

    
505
    /* close files */
506
    for(i=0;i<nb_output_files;i++) {
507
        /* maybe av_close_output_file ??? */
508
        AVFormatContext *s = output_files[i];
509
        int j;
510
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
511
            url_fclose(s->pb);
512
        for(j=0;j<s->nb_streams;j++) {
513
            av_metadata_free(&s->streams[j]->metadata);
514
            av_free(s->streams[j]->codec);
515
            av_free(s->streams[j]->info);
516
            av_free(s->streams[j]);
517
        }
518
        for(j=0;j<s->nb_programs;j++) {
519
            av_metadata_free(&s->programs[j]->metadata);
520
        }
521
        for(j=0;j<s->nb_chapters;j++) {
522
            av_metadata_free(&s->chapters[j]->metadata);
523
        }
524
        av_metadata_free(&s->metadata);
525
        av_free(s);
526
        av_free(output_streams_for_file[i]);
527
    }
528
    for(i=0;i<nb_input_files;i++) {
529
        av_close_input_file(input_files[i]);
530
        av_free(input_files_ts_scale[i]);
531
    }
532

    
533
    av_free(intra_matrix);
534
    av_free(inter_matrix);
535

    
536
    if (vstats_file)
537
        fclose(vstats_file);
538
    av_free(vstats_filename);
539

    
540
    av_free(opt_names);
541
    av_free(streamid_map);
542
    av_free(input_codecs);
543
    av_free(output_codecs);
544
    av_free(stream_maps);
545
    av_free(meta_data_maps);
546

    
547
    av_free(video_codec_name);
548
    av_free(audio_codec_name);
549
    av_free(subtitle_codec_name);
550

    
551
    av_free(video_standard);
552

    
553
    uninit_opts();
554
    av_free(audio_buf);
555
    av_free(audio_out);
556
    allocated_audio_buf_size= allocated_audio_out_size= 0;
557
    av_free(samples);
558

    
559
#if CONFIG_AVFILTER
560
    avfilter_uninit();
561
#endif
562

    
563
    if (received_sigterm) {
564
        fprintf(stderr,
565
            "Received signal %d: terminating.\n",
566
            (int) received_sigterm);
567
        exit (255);
568
    }
569

    
570
    exit(ret); /* not all OS-es handle main() return value */
571
    return ret;
572
}
573

    
574
/* similar to ff_dynarray_add() and av_fast_realloc() */
575
static void *grow_array(void *array, int elem_size, int *size, int new_size)
576
{
577
    if (new_size >= INT_MAX / elem_size) {
578
        fprintf(stderr, "Array too big.\n");
579
        ffmpeg_exit(1);
580
    }
581
    if (*size < new_size) {
582
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
583
        if (!tmp) {
584
            fprintf(stderr, "Could not alloc buffer.\n");
585
            ffmpeg_exit(1);
586
        }
587
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
588
        *size = new_size;
589
        return tmp;
590
    }
591
    return array;
592
}
593

    
594
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
595
{
596
    if(codec && codec->sample_fmts){
597
        const enum AVSampleFormat *p= codec->sample_fmts;
598
        for(; *p!=-1; p++){
599
            if(*p == st->codec->sample_fmt)
600
                break;
601
        }
602
        if(*p == -1)
603
            st->codec->sample_fmt = codec->sample_fmts[0];
604
    }
605
}
606

    
607
static void choose_sample_rate(AVStream *st, AVCodec *codec)
608
{
609
    if(codec && codec->supported_samplerates){
610
        const int *p= codec->supported_samplerates;
611
        int best=0;
612
        int best_dist=INT_MAX;
613
        for(; *p; p++){
614
            int dist= abs(st->codec->sample_rate - *p);
615
            if(dist < best_dist){
616
                best_dist= dist;
617
                best= *p;
618
            }
619
        }
620
        if(best_dist){
621
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
622
        }
623
        st->codec->sample_rate= best;
624
    }
625
}
626

    
627
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
628
{
629
    if(codec && codec->pix_fmts){
630
        const enum PixelFormat *p= codec->pix_fmts;
631
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
632
            if(st->codec->codec_id==CODEC_ID_MJPEG){
633
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
634
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
635
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
636
            }
637
        }
638
        for(; *p!=-1; p++){
639
            if(*p == st->codec->pix_fmt)
640
                break;
641
        }
642
        if(*p == -1)
643
            st->codec->pix_fmt = codec->pix_fmts[0];
644
    }
645
}
646

    
647
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
648
{
649
    int idx = oc->nb_streams - 1;
650
    AVOutputStream *ost;
651

    
652
    output_streams_for_file[file_idx] =
653
        grow_array(output_streams_for_file[file_idx],
654
                   sizeof(*output_streams_for_file[file_idx]),
655
                   &nb_output_streams_for_file[file_idx],
656
                   oc->nb_streams);
657
    ost = output_streams_for_file[file_idx][idx] =
658
        av_mallocz(sizeof(AVOutputStream));
659
    if (!ost) {
660
        fprintf(stderr, "Could not alloc output stream\n");
661
        ffmpeg_exit(1);
662
    }
663
    ost->file_index = file_idx;
664
    ost->index = idx;
665
    return ost;
666
}
667

    
668
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
669
{
670
    int i, err;
671
    AVFormatContext *ic;
672
    int nopts = 0;
673

    
674
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
675
    if (err < 0)
676
        return err;
677
    /* copy stream format */
678
    s->nb_streams = 0;
679
    for(i=0;i<ic->nb_streams;i++) {
680
        AVStream *st;
681
        AVCodec *codec;
682

    
683
        s->nb_streams++;
684

    
685
        // FIXME: a more elegant solution is needed
686
        st = av_mallocz(sizeof(AVStream));
687
        memcpy(st, ic->streams[i], sizeof(AVStream));
688
        st->codec = avcodec_alloc_context();
689
        if (!st->codec) {
690
            print_error(filename, AVERROR(ENOMEM));
691
            ffmpeg_exit(1);
692
        }
693
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
694
        s->streams[i] = st;
695

    
696
        codec = avcodec_find_encoder(st->codec->codec_id);
697
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
698
            if (audio_stream_copy) {
699
                st->stream_copy = 1;
700
            } else
701
                choose_sample_fmt(st, codec);
702
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
703
            if (video_stream_copy) {
704
                st->stream_copy = 1;
705
            } else
706
                choose_pixel_fmt(st, codec);
707
        }
708

    
709
        if(!st->codec->thread_count)
710
            st->codec->thread_count = 1;
711
        if(st->codec->thread_count>1)
712
            avcodec_thread_init(st->codec, st->codec->thread_count);
713

    
714
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
715
            nopts = 1;
716

    
717
        new_output_stream(s, nb_output_files);
718
    }
719

    
720
    if (!nopts)
721
        s->timestamp = av_gettime();
722

    
723
    av_close_input_file(ic);
724
    return 0;
725
}
726

    
727
static double
728
get_sync_ipts(const AVOutputStream *ost)
729
{
730
    const AVInputStream *ist = ost->sync_ist;
731
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
732
}
733

    
734
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
735
    int ret;
736

    
737
    while(bsfc){
738
        AVPacket new_pkt= *pkt;
739
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
740
                                          &new_pkt.data, &new_pkt.size,
741
                                          pkt->data, pkt->size,
742
                                          pkt->flags & AV_PKT_FLAG_KEY);
743
        if(a>0){
744
            av_free_packet(pkt);
745
            new_pkt.destruct= av_destruct_packet;
746
        } else if(a<0){
747
            fprintf(stderr, "%s failed for stream %d, codec %s",
748
                    bsfc->filter->name, pkt->stream_index,
749
                    avctx->codec ? avctx->codec->name : "copy");
750
            print_error("", a);
751
            if (exit_on_error)
752
                ffmpeg_exit(1);
753
        }
754
        *pkt= new_pkt;
755

    
756
        bsfc= bsfc->next;
757
    }
758

    
759
    ret= av_interleaved_write_frame(s, pkt);
760
    if(ret < 0){
761
        print_error("av_interleaved_write_frame()", ret);
762
        ffmpeg_exit(1);
763
    }
764
}
765

    
766
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
767

    
768
static void do_audio_out(AVFormatContext *s,
769
                         AVOutputStream *ost,
770
                         AVInputStream *ist,
771
                         unsigned char *buf, int size)
772
{
773
    uint8_t *buftmp;
774
    int64_t audio_out_size, audio_buf_size;
775
    int64_t allocated_for_size= size;
776

    
777
    int size_out, frame_bytes, ret, resample_changed;
778
    AVCodecContext *enc= ost->st->codec;
779
    AVCodecContext *dec= ist->st->codec;
780
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
781
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
782
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
783

    
784
need_realloc:
785
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
786
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
787
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
788
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
789
    audio_buf_size*= osize*enc->channels;
790

    
791
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
792
    if(coded_bps > 8*osize)
793
        audio_out_size= audio_out_size * coded_bps / (8*osize);
794
    audio_out_size += FF_MIN_BUFFER_SIZE;
795

    
796
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
797
        fprintf(stderr, "Buffer sizes too large\n");
798
        ffmpeg_exit(1);
799
    }
800

    
801
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
802
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
803
    if (!audio_buf || !audio_out){
804
        fprintf(stderr, "Out of memory in do_audio_out\n");
805
        ffmpeg_exit(1);
806
    }
807

    
808
    if (enc->channels != dec->channels)
809
        ost->audio_resample = 1;
810

    
811
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
812
                       ost->resample_channels    != dec->channels   ||
813
                       ost->resample_sample_rate != dec->sample_rate;
814

    
815
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
816
        if (resample_changed) {
817
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
818
                   ist->file_index, ist->index,
819
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
820
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
821
            ost->resample_sample_fmt  = dec->sample_fmt;
822
            ost->resample_channels    = dec->channels;
823
            ost->resample_sample_rate = dec->sample_rate;
824
            if (ost->resample)
825
                audio_resample_close(ost->resample);
826
        }
827
        if (ost->resample_sample_fmt  == enc->sample_fmt &&
828
            ost->resample_channels    == enc->channels   &&
829
            ost->resample_sample_rate == enc->sample_rate) {
830
            ost->resample = NULL;
831
            ost->audio_resample = 0;
832
        } else {
833
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
834
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
835
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
836
                                                   enc->sample_rate, dec->sample_rate,
837
                                                   enc->sample_fmt,  dec->sample_fmt,
838
                                                   16, 10, 0, 0.8);
839
            if (!ost->resample) {
840
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
841
                        dec->channels, dec->sample_rate,
842
                        enc->channels, enc->sample_rate);
843
                ffmpeg_exit(1);
844
            }
845
        }
846
    }
847

    
848
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
849
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
850
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
851
        if (ost->reformat_ctx)
852
            av_audio_convert_free(ost->reformat_ctx);
853
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
854
                                                   dec->sample_fmt, 1, NULL, 0);
855
        if (!ost->reformat_ctx) {
856
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
857
                av_get_sample_fmt_name(dec->sample_fmt),
858
                av_get_sample_fmt_name(enc->sample_fmt));
859
            ffmpeg_exit(1);
860
        }
861
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
862
    }
863

    
864
    if(audio_sync_method){
865
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
866
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
867
        double idelta= delta*dec->sample_rate / enc->sample_rate;
868
        int byte_delta= ((int)idelta)*2*dec->channels;
869

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

    
886
                    if(byte_delta > allocated_for_size - size){
887
                        allocated_for_size= byte_delta + (int64_t)size;
888
                        goto need_realloc;
889
                    }
890
                    ist->is_start=0;
891

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

    
912
    if (ost->audio_resample) {
913
        buftmp = audio_buf;
914
        size_out = audio_resample(ost->resample,
915
                                  (short *)buftmp, (short *)buf,
916
                                  size / (dec->channels * isize));
917
        size_out = size_out * enc->channels * osize;
918
    } else {
919
        buftmp = buf;
920
        size_out = size;
921
    }
922

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

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

    
948
        frame_bytes = enc->frame_size * osize * enc->channels;
949

    
950
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
951
            AVPacket pkt;
952
            av_init_packet(&pkt);
953

    
954
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
955

    
956
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
957

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

    
973
            ost->sync_opts += enc->frame_size;
974
        }
975
    } else {
976
        AVPacket pkt;
977
        av_init_packet(&pkt);
978

    
979
        ost->sync_opts += size_out / (osize * enc->channels);
980

    
981
        /* output a pcm frame */
982
        /* determine the size of the coded buffer */
983
        size_out /= osize;
984
        if (coded_bps)
985
            size_out = size_out*coded_bps/8;
986

    
987
        if(size_out > audio_out_size){
988
            fprintf(stderr, "Internal error, buffer size too small\n");
989
            ffmpeg_exit(1);
990
        }
991

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

    
1010
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1011
{
1012
    AVCodecContext *dec;
1013
    AVPicture *picture2;
1014
    AVPicture picture_tmp;
1015
    uint8_t *buf = 0;
1016

    
1017
    dec = ist->st->codec;
1018

    
1019
    /* deinterlace : must be done before any resize */
1020
    if (do_deinterlace) {
1021
        int size;
1022

    
1023
        /* create temporary picture */
1024
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1025
        buf = av_malloc(size);
1026
        if (!buf)
1027
            return;
1028

    
1029
        picture2 = &picture_tmp;
1030
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1031

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

    
1044
    if (picture != picture2)
1045
        *picture = *picture2;
1046
    *bufp = buf;
1047
}
1048

    
1049
/* we begin to correct av delay at this threshold */
1050
#define AV_DELAY_MAX 0.100
1051

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

    
1064
    if (pts == AV_NOPTS_VALUE) {
1065
        fprintf(stderr, "Subtitle packets must have a pts\n");
1066
        if (exit_on_error)
1067
            ffmpeg_exit(1);
1068
        return;
1069
    }
1070

    
1071
    enc = ost->st->codec;
1072

    
1073
    if (!subtitle_out) {
1074
        subtitle_out = av_malloc(subtitle_out_max_size);
1075
    }
1076

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

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

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

    
1115
static int bit_buffer_size= 1024*256;
1116
static uint8_t *bit_buffer= NULL;
1117

    
1118
static void do_video_out(AVFormatContext *s,
1119
                         AVOutputStream *ost,
1120
                         AVInputStream *ist,
1121
                         AVFrame *in_picture,
1122
                         int *frame_size)
1123
{
1124
    int nb_frames, i, ret;
1125
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1126
    AVCodecContext *enc, *dec;
1127
    double sync_ipts;
1128

    
1129
    enc = ost->st->codec;
1130
    dec = ist->st->codec;
1131

    
1132
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1133

    
1134
    /* by default, we output a single frame */
1135
    nb_frames = 1;
1136

    
1137
    *frame_size = 0;
1138

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

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

    
1168
    formatted_picture = in_picture;
1169
    final_picture = formatted_picture;
1170
    padding_src = formatted_picture;
1171
    resampling_dst = &ost->pict_tmp;
1172

    
1173
    if (   ost->resample_height != ist->st->codec->height
1174
        || ost->resample_width  != ist->st->codec->width
1175
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1176

    
1177
        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));
1178
        if(!ost->video_resample)
1179
            ffmpeg_exit(1);
1180
    }
1181

    
1182
#if !CONFIG_AVFILTER
1183
    if (ost->video_resample) {
1184
        padding_src = NULL;
1185
        final_picture = &ost->pict_tmp;
1186
        if(  ost->resample_height != ist->st->codec->height
1187
          || ost->resample_width  != ist->st->codec->width
1188
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1189

    
1190
            /* initialize a new scaler context */
1191
            sws_freeContext(ost->img_resample_ctx);
1192
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1193
            ost->img_resample_ctx = sws_getContext(
1194
                ist->st->codec->width,
1195
                ist->st->codec->height,
1196
                ist->st->codec->pix_fmt,
1197
                ost->st->codec->width,
1198
                ost->st->codec->height,
1199
                ost->st->codec->pix_fmt,
1200
                sws_flags, NULL, NULL, NULL);
1201
            if (ost->img_resample_ctx == NULL) {
1202
                fprintf(stderr, "Cannot get resampling context\n");
1203
                ffmpeg_exit(1);
1204
            }
1205
        }
1206
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1207
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1208
    }
1209
#endif
1210

    
1211
    /* duplicates frame if needed */
1212
    for(i=0;i<nb_frames;i++) {
1213
        AVPacket pkt;
1214
        av_init_packet(&pkt);
1215
        pkt.stream_index= ost->index;
1216

    
1217
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1218
            /* raw pictures are written as AVPicture structure to
1219
               avoid any copies. We support temorarily the older
1220
               method. */
1221
            AVFrame* old_frame = enc->coded_frame;
1222
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1223
            pkt.data= (uint8_t *)final_picture;
1224
            pkt.size=  sizeof(AVPicture);
1225
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1226
            pkt.flags |= AV_PKT_FLAG_KEY;
1227

    
1228
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1229
            enc->coded_frame = old_frame;
1230
        } else {
1231
            AVFrame big_picture;
1232

    
1233
            big_picture= *final_picture;
1234
            /* better than nothing: use input picture interlaced
1235
               settings */
1236
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1237
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1238
                if(top_field_first == -1)
1239
                    big_picture.top_field_first = in_picture->top_field_first;
1240
                else
1241
                    big_picture.top_field_first = top_field_first;
1242
            }
1243

    
1244
            /* handles sameq here. This is not correct because it may
1245
               not be a global option */
1246
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1247
            if(!me_threshold)
1248
                big_picture.pict_type = 0;
1249
//            big_picture.pts = AV_NOPTS_VALUE;
1250
            big_picture.pts= ost->sync_opts;
1251
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1252
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1253
            if (ost->forced_kf_index < ost->forced_kf_count &&
1254
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1255
                big_picture.pict_type = FF_I_TYPE;
1256
                ost->forced_kf_index++;
1257
            }
1258
            ret = avcodec_encode_video(enc,
1259
                                       bit_buffer, bit_buffer_size,
1260
                                       &big_picture);
1261
            if (ret < 0) {
1262
                fprintf(stderr, "Video encoding failed\n");
1263
                ffmpeg_exit(1);
1264
            }
1265

    
1266
            if(ret>0){
1267
                pkt.data= bit_buffer;
1268
                pkt.size= ret;
1269
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1270
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1271
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1272
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1273
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1274

    
1275
                if(enc->coded_frame->key_frame)
1276
                    pkt.flags |= AV_PKT_FLAG_KEY;
1277
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1278
                *frame_size = ret;
1279
                video_size += ret;
1280
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1281
                //        enc->frame_number-1, ret, enc->pict_type);
1282
                /* if two pass, output log */
1283
                if (ost->logfile && enc->stats_out) {
1284
                    fprintf(ost->logfile, "%s", enc->stats_out);
1285
                }
1286
            }
1287
        }
1288
        ost->sync_opts++;
1289
        ost->frame_number++;
1290
    }
1291
}
1292

    
1293
static double psnr(double d){
1294
    return -10.0*log(d)/log(10.0);
1295
}
1296

    
1297
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1298
                           int frame_size)
1299
{
1300
    AVCodecContext *enc;
1301
    int frame_number;
1302
    double ti1, bitrate, avg_bitrate;
1303

    
1304
    /* this is executed just the first time do_video_stats is called */
1305
    if (!vstats_file) {
1306
        vstats_file = fopen(vstats_filename, "w");
1307
        if (!vstats_file) {
1308
            perror("fopen");
1309
            ffmpeg_exit(1);
1310
        }
1311
    }
1312

    
1313
    enc = ost->st->codec;
1314
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1315
        frame_number = ost->frame_number;
1316
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1317
        if (enc->flags&CODEC_FLAG_PSNR)
1318
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1319

    
1320
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1321
        /* compute pts value */
1322
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1323
        if (ti1 < 0.01)
1324
            ti1 = 0.01;
1325

    
1326
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1327
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1328
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1329
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1330
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1331
    }
1332
}
1333

    
1334
static void print_report(AVFormatContext **output_files,
1335
                         AVOutputStream **ost_table, int nb_ostreams,
1336
                         int is_last_report)
1337
{
1338
    char buf[1024];
1339
    AVOutputStream *ost;
1340
    AVFormatContext *oc;
1341
    int64_t total_size;
1342
    AVCodecContext *enc;
1343
    int frame_number, vid, i;
1344
    double bitrate, ti1, pts;
1345
    static int64_t last_time = -1;
1346
    static int qp_histogram[52];
1347

    
1348
    if (!is_last_report) {
1349
        int64_t cur_time;
1350
        /* display the report every 0.5 seconds */
1351
        cur_time = av_gettime();
1352
        if (last_time == -1) {
1353
            last_time = cur_time;
1354
            return;
1355
        }
1356
        if ((cur_time - last_time) < 500000)
1357
            return;
1358
        last_time = cur_time;
1359
    }
1360

    
1361

    
1362
    oc = output_files[0];
1363

    
1364
    total_size = url_fsize(oc->pb);
1365
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1366
        total_size= url_ftell(oc->pb);
1367

    
1368
    buf[0] = '\0';
1369
    ti1 = 1e10;
1370
    vid = 0;
1371
    for(i=0;i<nb_ostreams;i++) {
1372
        ost = ost_table[i];
1373
        enc = ost->st->codec;
1374
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1375
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1376
                     !ost->st->stream_copy ?
1377
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1378
        }
1379
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1380
            float t = (av_gettime()-timer_start) / 1000000.0;
1381

    
1382
            frame_number = ost->frame_number;
1383
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1384
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1385
                     !ost->st->stream_copy ?
1386
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1387
            if(is_last_report)
1388
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1389
            if(qp_hist){
1390
                int j;
1391
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1392
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1393
                    qp_histogram[qp]++;
1394
                for(j=0; j<32; j++)
1395
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1396
            }
1397
            if (enc->flags&CODEC_FLAG_PSNR){
1398
                int j;
1399
                double error, error_sum=0;
1400
                double scale, scale_sum=0;
1401
                char type[3]= {'Y','U','V'};
1402
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1403
                for(j=0; j<3; j++){
1404
                    if(is_last_report){
1405
                        error= enc->error[j];
1406
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1407
                    }else{
1408
                        error= enc->coded_frame->error[j];
1409
                        scale= enc->width*enc->height*255.0*255.0;
1410
                    }
1411
                    if(j) scale/=4;
1412
                    error_sum += error;
1413
                    scale_sum += scale;
1414
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1415
                }
1416
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1417
            }
1418
            vid = 1;
1419
        }
1420
        /* compute min output value */
1421
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1422
        if ((pts < ti1) && (pts > 0))
1423
            ti1 = pts;
1424
    }
1425
    if (ti1 < 0.01)
1426
        ti1 = 0.01;
1427

    
1428
    if (verbose || is_last_report) {
1429
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1430

    
1431
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1432
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1433
            (double)total_size / 1024, ti1, bitrate);
1434

    
1435
        if (nb_frames_dup || nb_frames_drop)
1436
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1437
                  nb_frames_dup, nb_frames_drop);
1438

    
1439
        if (verbose >= 0)
1440
            fprintf(stderr, "%s    \r", buf);
1441

    
1442
        fflush(stderr);
1443
    }
1444

    
1445
    if (is_last_report && verbose >= 0){
1446
        int64_t raw= audio_size + video_size + extra_size;
1447
        fprintf(stderr, "\n");
1448
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1449
                video_size/1024.0,
1450
                audio_size/1024.0,
1451
                extra_size/1024.0,
1452
                100.0*(total_size - raw)/raw
1453
        );
1454
    }
1455
}
1456

    
1457
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1458
static int output_packet(AVInputStream *ist, int ist_index,
1459
                         AVOutputStream **ost_table, int nb_ostreams,
1460
                         const AVPacket *pkt)
1461
{
1462
    AVFormatContext *os;
1463
    AVOutputStream *ost;
1464
    int ret, i;
1465
    int got_picture;
1466
    AVFrame picture;
1467
    void *buffer_to_free;
1468
    static unsigned int samples_size= 0;
1469
    AVSubtitle subtitle, *subtitle_to_free;
1470
    int64_t pkt_pts = AV_NOPTS_VALUE;
1471
#if CONFIG_AVFILTER
1472
    int frame_available;
1473
#endif
1474

    
1475
    AVPacket avpkt;
1476
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1477

    
1478
    if(ist->next_pts == AV_NOPTS_VALUE)
1479
        ist->next_pts= ist->pts;
1480

    
1481
    if (pkt == NULL) {
1482
        /* EOF handling */
1483
        av_init_packet(&avpkt);
1484
        avpkt.data = NULL;
1485
        avpkt.size = 0;
1486
        goto handle_eof;
1487
    } else {
1488
        avpkt = *pkt;
1489
    }
1490

    
1491
    if(pkt->dts != AV_NOPTS_VALUE)
1492
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1493
    if(pkt->pts != AV_NOPTS_VALUE)
1494
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1495

    
1496
    //while we have more to decode or while the decoder did output something on EOF
1497
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1498
        uint8_t *data_buf, *decoded_data_buf;
1499
        int data_size, decoded_data_size;
1500
    handle_eof:
1501
        ist->pts= ist->next_pts;
1502

    
1503
        if(avpkt.size && avpkt.size != pkt->size &&
1504
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1505
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1506
            ist->showed_multi_packet_warning=1;
1507
        }
1508

    
1509
        /* decode the packet if needed */
1510
        decoded_data_buf = NULL; /* fail safe */
1511
        decoded_data_size= 0;
1512
        data_buf  = avpkt.data;
1513
        data_size = avpkt.size;
1514
        subtitle_to_free = NULL;
1515
        if (ist->decoding_needed) {
1516
            switch(ist->st->codec->codec_type) {
1517
            case AVMEDIA_TYPE_AUDIO:{
1518
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1519
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1520
                    av_free(samples);
1521
                    samples= av_malloc(samples_size);
1522
                }
1523
                decoded_data_size= samples_size;
1524
                    /* XXX: could avoid copy if PCM 16 bits with same
1525
                       endianness as CPU */
1526
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1527
                                            &avpkt);
1528
                if (ret < 0)
1529
                    goto fail_decode;
1530
                avpkt.data += ret;
1531
                avpkt.size -= ret;
1532
                data_size   = ret;
1533
                /* Some bug in mpeg audio decoder gives */
1534
                /* decoded_data_size < 0, it seems they are overflows */
1535
                if (decoded_data_size <= 0) {
1536
                    /* no audio frame */
1537
                    continue;
1538
                }
1539
                decoded_data_buf = (uint8_t *)samples;
1540
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1541
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1542
                break;}
1543
            case AVMEDIA_TYPE_VIDEO:
1544
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1545
                    /* XXX: allocate picture correctly */
1546
                    avcodec_get_frame_defaults(&picture);
1547
                    ist->st->codec->reordered_opaque = pkt_pts;
1548
                    pkt_pts = AV_NOPTS_VALUE;
1549

    
1550
                    ret = avcodec_decode_video2(ist->st->codec,
1551
                                                &picture, &got_picture, &avpkt);
1552
                    ist->st->quality= picture.quality;
1553
                    if (ret < 0)
1554
                        goto fail_decode;
1555
                    if (!got_picture) {
1556
                        /* no picture yet */
1557
                        goto discard_packet;
1558
                    }
1559
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1560
                    if (ist->st->codec->time_base.num != 0) {
1561
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1562
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1563
                                          ist->st->codec->time_base.num * ticks) /
1564
                            ist->st->codec->time_base.den;
1565
                    }
1566
                    avpkt.size = 0;
1567
                    break;
1568
            case AVMEDIA_TYPE_SUBTITLE:
1569
                ret = avcodec_decode_subtitle2(ist->st->codec,
1570
                                               &subtitle, &got_picture, &avpkt);
1571
                if (ret < 0)
1572
                    goto fail_decode;
1573
                if (!got_picture) {
1574
                    goto discard_packet;
1575
                }
1576
                subtitle_to_free = &subtitle;
1577
                avpkt.size = 0;
1578
                break;
1579
            default:
1580
                goto fail_decode;
1581
            }
1582
        } else {
1583
            switch(ist->st->codec->codec_type) {
1584
            case AVMEDIA_TYPE_AUDIO:
1585
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1586
                    ist->st->codec->sample_rate;
1587
                break;
1588
            case AVMEDIA_TYPE_VIDEO:
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
                break;
1596
            }
1597
            ret = avpkt.size;
1598
            avpkt.size = 0;
1599
        }
1600

    
1601
        buffer_to_free = NULL;
1602
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1603
            pre_process_video_frame(ist, (AVPicture *)&picture,
1604
                                    &buffer_to_free);
1605
        }
1606

    
1607
#if CONFIG_AVFILTER
1608
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1609
            // add it to be filtered
1610
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1611
                                     ist->pts,
1612
                                     ist->st->codec->sample_aspect_ratio);
1613
        }
1614
#endif
1615

    
1616
        // preprocess audio (volume)
1617
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1618
            if (audio_volume != 256) {
1619
                short *volp;
1620
                volp = samples;
1621
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1622
                    int v = ((*volp) * audio_volume + 128) >> 8;
1623
                    if (v < -32768) v = -32768;
1624
                    if (v >  32767) v = 32767;
1625
                    *volp++ = v;
1626
                }
1627
            }
1628
        }
1629

    
1630
        /* frame rate emulation */
1631
        if (rate_emu) {
1632
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1633
            int64_t now = av_gettime() - ist->start;
1634
            if (pts > now)
1635
                usleep(pts - now);
1636
        }
1637
#if CONFIG_AVFILTER
1638
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1639
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1640
#endif
1641
        /* if output time reached then transcode raw format,
1642
           encode packets and output them */
1643
        if (start_time == 0 || ist->pts >= start_time)
1644
#if CONFIG_AVFILTER
1645
        while (frame_available) {
1646
            AVRational ist_pts_tb;
1647
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1648
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1649
            if (ist->picref)
1650
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1651
#endif
1652
            for(i=0;i<nb_ostreams;i++) {
1653
                int frame_size;
1654

    
1655
                ost = ost_table[i];
1656
                if (ost->source_index == ist_index) {
1657
                    os = output_files[ost->file_index];
1658

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

    
1662
                    if (ost->encoding_needed) {
1663
                        av_assert0(ist->decoding_needed);
1664
                        switch(ost->st->codec->codec_type) {
1665
                        case AVMEDIA_TYPE_AUDIO:
1666
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1667
                            break;
1668
                        case AVMEDIA_TYPE_VIDEO:
1669
#if CONFIG_AVFILTER
1670
                            if (ist->picref->video)
1671
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1672
#endif
1673
                            do_video_out(os, ost, ist, &picture, &frame_size);
1674
                            if (vstats_filename && frame_size)
1675
                                do_video_stats(os, ost, frame_size);
1676
                            break;
1677
                        case AVMEDIA_TYPE_SUBTITLE:
1678
                            do_subtitle_out(os, ost, ist, &subtitle,
1679
                                            pkt->pts);
1680
                            break;
1681
                        default:
1682
                            abort();
1683
                        }
1684
                    } else {
1685
                        AVFrame avframe; //FIXME/XXX remove this
1686
                        AVPacket opkt;
1687
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1688

    
1689
                        av_init_packet(&opkt);
1690

    
1691
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1692
                            continue;
1693

    
1694
                        /* no reencoding needed : output the packet directly */
1695
                        /* force the input stream PTS */
1696

    
1697
                        avcodec_get_frame_defaults(&avframe);
1698
                        ost->st->codec->coded_frame= &avframe;
1699
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1700

    
1701
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1702
                            audio_size += data_size;
1703
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1704
                            video_size += data_size;
1705
                            ost->sync_opts++;
1706
                        }
1707

    
1708
                        opkt.stream_index= ost->index;
1709
                        if(pkt->pts != AV_NOPTS_VALUE)
1710
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1711
                        else
1712
                            opkt.pts= AV_NOPTS_VALUE;
1713

    
1714
                        if (pkt->dts == AV_NOPTS_VALUE)
1715
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1716
                        else
1717
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1718
                        opkt.dts -= ost_tb_start_time;
1719

    
1720
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1721
                        opkt.flags= pkt->flags;
1722

    
1723
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1724
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1725
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1726
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1727
                           ) {
1728
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1729
                                opkt.destruct= av_destruct_packet;
1730
                        } else {
1731
                            opkt.data = data_buf;
1732
                            opkt.size = data_size;
1733
                        }
1734

    
1735
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1736
                        ost->st->codec->frame_number++;
1737
                        ost->frame_number++;
1738
                        av_free_packet(&opkt);
1739
                    }
1740
                }
1741
            }
1742

    
1743
#if CONFIG_AVFILTER
1744
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1745
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1746
            if(ist->picref)
1747
                avfilter_unref_buffer(ist->picref);
1748
        }
1749
#endif
1750
        av_free(buffer_to_free);
1751
        /* XXX: allocate the subtitles in the codec ? */
1752
        if (subtitle_to_free) {
1753
            avsubtitle_free(subtitle_to_free);
1754
            subtitle_to_free = NULL;
1755
        }
1756
    }
1757
 discard_packet:
1758
    if (pkt == NULL) {
1759
        /* EOF handling */
1760

    
1761
        for(i=0;i<nb_ostreams;i++) {
1762
            ost = ost_table[i];
1763
            if (ost->source_index == ist_index) {
1764
                AVCodecContext *enc= ost->st->codec;
1765
                os = output_files[ost->file_index];
1766

    
1767
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1768
                    continue;
1769
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1770
                    continue;
1771

    
1772
                if (ost->encoding_needed) {
1773
                    for(;;) {
1774
                        AVPacket pkt;
1775
                        int fifo_bytes;
1776
                        av_init_packet(&pkt);
1777
                        pkt.stream_index= ost->index;
1778

    
1779
                        switch(ost->st->codec->codec_type) {
1780
                        case AVMEDIA_TYPE_AUDIO:
1781
                            fifo_bytes = av_fifo_size(ost->fifo);
1782
                            ret = 0;
1783
                            /* encode any samples remaining in fifo */
1784
                            if (fifo_bytes > 0) {
1785
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1786
                                int fs_tmp = enc->frame_size;
1787

    
1788
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1789
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1790
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1791
                                } else { /* pad */
1792
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1793
                                    if (allocated_audio_buf_size < frame_bytes)
1794
                                        ffmpeg_exit(1);
1795
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1796
                                }
1797

    
1798
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1799
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1800
                                                          ost->st->time_base.num, enc->sample_rate);
1801
                                enc->frame_size = fs_tmp;
1802
                            }
1803
                            if(ret <= 0) {
1804
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1805
                            }
1806
                            if (ret < 0) {
1807
                                fprintf(stderr, "Audio encoding failed\n");
1808
                                ffmpeg_exit(1);
1809
                            }
1810
                            audio_size += ret;
1811
                            pkt.flags |= AV_PKT_FLAG_KEY;
1812
                            break;
1813
                        case AVMEDIA_TYPE_VIDEO:
1814
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1815
                            if (ret < 0) {
1816
                                fprintf(stderr, "Video encoding failed\n");
1817
                                ffmpeg_exit(1);
1818
                            }
1819
                            video_size += ret;
1820
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1821
                                pkt.flags |= AV_PKT_FLAG_KEY;
1822
                            if (ost->logfile && enc->stats_out) {
1823
                                fprintf(ost->logfile, "%s", enc->stats_out);
1824
                            }
1825
                            break;
1826
                        default:
1827
                            ret=-1;
1828
                        }
1829

    
1830
                        if(ret<=0)
1831
                            break;
1832
                        pkt.data= bit_buffer;
1833
                        pkt.size= ret;
1834
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1835
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1836
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1837
                    }
1838
                }
1839
            }
1840
        }
1841
    }
1842

    
1843
    return 0;
1844
 fail_decode:
1845
    return -1;
1846
}
1847

    
1848
static void print_sdp(AVFormatContext **avc, int n)
1849
{
1850
    char sdp[2048];
1851

    
1852
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1853
    printf("SDP:\n%s\n", sdp);
1854
    fflush(stdout);
1855
}
1856

    
1857
static int copy_chapters(int infile, int outfile)
1858
{
1859
    AVFormatContext *is = input_files[infile];
1860
    AVFormatContext *os = output_files[outfile];
1861
    int i;
1862

    
1863
    for (i = 0; i < is->nb_chapters; i++) {
1864
        AVChapter *in_ch = is->chapters[i], *out_ch;
1865
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1866
                                      AV_TIME_BASE_Q, in_ch->time_base);
1867
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1868
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1869

    
1870

    
1871
        if (in_ch->end < ts_off)
1872
            continue;
1873
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1874
            break;
1875

    
1876
        out_ch = av_mallocz(sizeof(AVChapter));
1877
        if (!out_ch)
1878
            return AVERROR(ENOMEM);
1879

    
1880
        out_ch->id        = in_ch->id;
1881
        out_ch->time_base = in_ch->time_base;
1882
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1883
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1884

    
1885
        if (metadata_chapters_autocopy)
1886
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1887

    
1888
        os->nb_chapters++;
1889
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1890
        if (!os->chapters)
1891
            return AVERROR(ENOMEM);
1892
        os->chapters[os->nb_chapters - 1] = out_ch;
1893
    }
1894
    return 0;
1895
}
1896

    
1897
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1898
                                    AVCodecContext *avctx)
1899
{
1900
    char *p;
1901
    int n = 1, i;
1902
    int64_t t;
1903

    
1904
    for (p = kf; *p; p++)
1905
        if (*p == ',')
1906
            n++;
1907
    ost->forced_kf_count = n;
1908
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1909
    if (!ost->forced_kf_pts) {
1910
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1911
        ffmpeg_exit(1);
1912
    }
1913
    for (i = 0; i < n; i++) {
1914
        p = i ? strchr(p, ',') + 1 : kf;
1915
        t = parse_time_or_die("force_key_frames", p, 1);
1916
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1917
    }
1918
}
1919

    
1920
/*
1921
 * The following code is the main loop of the file converter
1922
 */
1923
static int transcode(AVFormatContext **output_files,
1924
                     int nb_output_files,
1925
                     AVFormatContext **input_files,
1926
                     int nb_input_files,
1927
                     AVStreamMap *stream_maps, int nb_stream_maps)
1928
{
1929
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1930
    AVFormatContext *is, *os;
1931
    AVCodecContext *codec, *icodec;
1932
    AVOutputStream *ost, **ost_table = NULL;
1933
    AVInputStream *ist, **ist_table = NULL;
1934
    AVInputFile *file_table;
1935
    char error[1024];
1936
    int key;
1937
    int want_sdp = 1;
1938
    uint8_t no_packet[MAX_FILES]={0};
1939
    int no_packet_count=0;
1940

    
1941
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1942
    if (!file_table)
1943
        goto fail;
1944

    
1945
    /* input stream init */
1946
    j = 0;
1947
    for(i=0;i<nb_input_files;i++) {
1948
        is = input_files[i];
1949
        file_table[i].ist_index = j;
1950
        file_table[i].nb_streams = is->nb_streams;
1951
        j += is->nb_streams;
1952
    }
1953
    nb_istreams = j;
1954

    
1955
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1956
    if (!ist_table)
1957
        goto fail;
1958

    
1959
    for(i=0;i<nb_istreams;i++) {
1960
        ist = av_mallocz(sizeof(AVInputStream));
1961
        if (!ist)
1962
            goto fail;
1963
        ist_table[i] = ist;
1964
    }
1965
    j = 0;
1966
    for(i=0;i<nb_input_files;i++) {
1967
        is = input_files[i];
1968
        for(k=0;k<is->nb_streams;k++) {
1969
            ist = ist_table[j++];
1970
            ist->st = is->streams[k];
1971
            ist->file_index = i;
1972
            ist->index = k;
1973
            ist->discard = 1; /* the stream is discarded by default
1974
                                 (changed later) */
1975

    
1976
            if (rate_emu) {
1977
                ist->start = av_gettime();
1978
            }
1979
        }
1980
    }
1981

    
1982
    /* output stream init */
1983
    nb_ostreams = 0;
1984
    for(i=0;i<nb_output_files;i++) {
1985
        os = output_files[i];
1986
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1987
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1988
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1989
            ret = AVERROR(EINVAL);
1990
            goto fail;
1991
        }
1992
        nb_ostreams += os->nb_streams;
1993
    }
1994
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1995
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1996
        ret = AVERROR(EINVAL);
1997
        goto fail;
1998
    }
1999

    
2000
    /* Sanity check the mapping args -- do the input files & streams exist? */
2001
    for(i=0;i<nb_stream_maps;i++) {
2002
        int fi = stream_maps[i].file_index;
2003
        int si = stream_maps[i].stream_index;
2004

    
2005
        if (fi < 0 || fi > nb_input_files - 1 ||
2006
            si < 0 || si > file_table[fi].nb_streams - 1) {
2007
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2008
            ret = AVERROR(EINVAL);
2009
            goto fail;
2010
        }
2011
        fi = stream_maps[i].sync_file_index;
2012
        si = stream_maps[i].sync_stream_index;
2013
        if (fi < 0 || fi > nb_input_files - 1 ||
2014
            si < 0 || si > file_table[fi].nb_streams - 1) {
2015
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2016
            ret = AVERROR(EINVAL);
2017
            goto fail;
2018
        }
2019
    }
2020

    
2021
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2022
    if (!ost_table)
2023
        goto fail;
2024
    n = 0;
2025
    for(k=0;k<nb_output_files;k++) {
2026
        os = output_files[k];
2027
        for(i=0;i<os->nb_streams;i++,n++) {
2028
            int found;
2029
            ost = ost_table[n] = output_streams_for_file[k][i];
2030
            ost->st = os->streams[i];
2031
            if (nb_stream_maps > 0) {
2032
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2033
                    stream_maps[n].stream_index;
2034

    
2035
                /* Sanity check that the stream types match */
2036
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2037
                    int i= ost->file_index;
2038
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2039
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2040
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2041
                        ost->file_index, ost->index);
2042
                    ffmpeg_exit(1);
2043
                }
2044

    
2045
            } else {
2046
                int best_nb_frames=-1;
2047
                /* get corresponding input stream index : we select the first one with the right type */
2048
                found = 0;
2049
                for(j=0;j<nb_istreams;j++) {
2050
                    int skip=0;
2051
                    ist = ist_table[j];
2052
                    if(opt_programid){
2053
                        int pi,si;
2054
                        AVFormatContext *f= input_files[ ist->file_index ];
2055
                        skip=1;
2056
                        for(pi=0; pi<f->nb_programs; pi++){
2057
                            AVProgram *p= f->programs[pi];
2058
                            if(p->id == opt_programid)
2059
                                for(si=0; si<p->nb_stream_indexes; si++){
2060
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2061
                                        skip=0;
2062
                                }
2063
                        }
2064
                    }
2065
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2066
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2067
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2068
                            best_nb_frames= ist->st->codec_info_nb_frames;
2069
                            ost->source_index = j;
2070
                            found = 1;
2071
                        }
2072
                    }
2073
                }
2074

    
2075
                if (!found) {
2076
                    if(! opt_programid) {
2077
                        /* try again and reuse existing stream */
2078
                        for(j=0;j<nb_istreams;j++) {
2079
                            ist = ist_table[j];
2080
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2081
                                && ist->st->discard != AVDISCARD_ALL) {
2082
                                ost->source_index = j;
2083
                                found = 1;
2084
                            }
2085
                        }
2086
                    }
2087
                    if (!found) {
2088
                        int i= ost->file_index;
2089
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2090
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2091
                                ost->file_index, ost->index);
2092
                        ffmpeg_exit(1);
2093
                    }
2094
                }
2095
            }
2096
            ist = ist_table[ost->source_index];
2097
            ist->discard = 0;
2098
            ost->sync_ist = (nb_stream_maps > 0) ?
2099
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2100
                         stream_maps[n].sync_stream_index] : ist;
2101
        }
2102
    }
2103

    
2104
    /* for each output stream, we compute the right encoding parameters */
2105
    for(i=0;i<nb_ostreams;i++) {
2106
        ost = ost_table[i];
2107
        os = output_files[ost->file_index];
2108
        ist = ist_table[ost->source_index];
2109

    
2110
        codec = ost->st->codec;
2111
        icodec = ist->st->codec;
2112

    
2113
        if (metadata_streams_autocopy)
2114
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2115
                             AV_METADATA_DONT_OVERWRITE);
2116

    
2117
        ost->st->disposition = ist->st->disposition;
2118
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2119
        codec->chroma_sample_location = icodec->chroma_sample_location;
2120

    
2121
        if (ost->st->stream_copy) {
2122
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2123

    
2124
            if (extra_size > INT_MAX)
2125
                goto fail;
2126

    
2127
            /* if stream_copy is selected, no need to decode or encode */
2128
            codec->codec_id = icodec->codec_id;
2129
            codec->codec_type = icodec->codec_type;
2130

    
2131
            if(!codec->codec_tag){
2132
                if(   !os->oformat->codec_tag
2133
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2134
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2135
                    codec->codec_tag = icodec->codec_tag;
2136
            }
2137

    
2138
            codec->bit_rate = icodec->bit_rate;
2139
            codec->rc_max_rate    = icodec->rc_max_rate;
2140
            codec->rc_buffer_size = icodec->rc_buffer_size;
2141
            codec->extradata= av_mallocz(extra_size);
2142
            if (!codec->extradata)
2143
                goto fail;
2144
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2145
            codec->extradata_size= icodec->extradata_size;
2146
            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){
2147
                codec->time_base = icodec->time_base;
2148
                codec->time_base.num *= icodec->ticks_per_frame;
2149
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2150
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2151
            }else
2152
                codec->time_base = ist->st->time_base;
2153
            switch(codec->codec_type) {
2154
            case AVMEDIA_TYPE_AUDIO:
2155
                if(audio_volume != 256) {
2156
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2157
                    ffmpeg_exit(1);
2158
                }
2159
                codec->channel_layout = icodec->channel_layout;
2160
                codec->sample_rate = icodec->sample_rate;
2161
                codec->channels = icodec->channels;
2162
                codec->frame_size = icodec->frame_size;
2163
                codec->block_align= icodec->block_align;
2164
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2165
                    codec->block_align= 0;
2166
                if(codec->codec_id == CODEC_ID_AC3)
2167
                    codec->block_align= 0;
2168
                break;
2169
            case AVMEDIA_TYPE_VIDEO:
2170
                codec->pix_fmt = icodec->pix_fmt;
2171
                codec->width = icodec->width;
2172
                codec->height = icodec->height;
2173
                codec->has_b_frames = icodec->has_b_frames;
2174
                break;
2175
            case AVMEDIA_TYPE_SUBTITLE:
2176
                codec->width = icodec->width;
2177
                codec->height = icodec->height;
2178
                break;
2179
            default:
2180
                abort();
2181
            }
2182
        } else {
2183
            switch(codec->codec_type) {
2184
            case AVMEDIA_TYPE_AUDIO:
2185
                ost->fifo= av_fifo_alloc(1024);
2186
                if(!ost->fifo)
2187
                    goto fail;
2188
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2189
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2190
                icodec->request_channels = codec->channels;
2191
                ist->decoding_needed = 1;
2192
                ost->encoding_needed = 1;
2193
                ost->resample_sample_fmt  = icodec->sample_fmt;
2194
                ost->resample_sample_rate = icodec->sample_rate;
2195
                ost->resample_channels    = icodec->channels;
2196
                break;
2197
            case AVMEDIA_TYPE_VIDEO:
2198
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2199
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2200
                    ffmpeg_exit(1);
2201
                }
2202
                ost->video_resample = (codec->width != icodec->width   ||
2203
                                       codec->height != icodec->height ||
2204
                        (codec->pix_fmt != icodec->pix_fmt));
2205
                if (ost->video_resample) {
2206
#if !CONFIG_AVFILTER
2207
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2208
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2209
                                         codec->width, codec->height)) {
2210
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2211
                        ffmpeg_exit(1);
2212
                    }
2213
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2214
                    ost->img_resample_ctx = sws_getContext(
2215
                        icodec->width,
2216
                        icodec->height,
2217
                            icodec->pix_fmt,
2218
                            codec->width,
2219
                            codec->height,
2220
                            codec->pix_fmt,
2221
                            sws_flags, NULL, NULL, NULL);
2222
                    if (ost->img_resample_ctx == NULL) {
2223
                        fprintf(stderr, "Cannot get resampling context\n");
2224
                        ffmpeg_exit(1);
2225
                    }
2226

    
2227
                    ost->original_height = icodec->height;
2228
                    ost->original_width  = icodec->width;
2229
#endif
2230
                    codec->bits_per_raw_sample= 0;
2231
                }
2232
                ost->resample_height = icodec->height;
2233
                ost->resample_width  = icodec->width;
2234
                ost->resample_pix_fmt= icodec->pix_fmt;
2235
                ost->encoding_needed = 1;
2236
                ist->decoding_needed = 1;
2237

    
2238
#if CONFIG_AVFILTER
2239
                if (configure_filters(ist, ost)) {
2240
                    fprintf(stderr, "Error opening filters!\n");
2241
                    exit(1);
2242
                }
2243
#endif
2244
                break;
2245
            case AVMEDIA_TYPE_SUBTITLE:
2246
                ost->encoding_needed = 1;
2247
                ist->decoding_needed = 1;
2248
                break;
2249
            default:
2250
                abort();
2251
                break;
2252
            }
2253
            /* two pass mode */
2254
            if (ost->encoding_needed &&
2255
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2256
                char logfilename[1024];
2257
                FILE *f;
2258

    
2259
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2260
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2261
                         i);
2262
                if (codec->flags & CODEC_FLAG_PASS1) {
2263
                    f = fopen(logfilename, "wb");
2264
                    if (!f) {
2265
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2266
                        ffmpeg_exit(1);
2267
                    }
2268
                    ost->logfile = f;
2269
                } else {
2270
                    char  *logbuffer;
2271
                    size_t logbuffer_size;
2272
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2273
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2274
                        ffmpeg_exit(1);
2275
                    }
2276
                    codec->stats_in = logbuffer;
2277
                }
2278
            }
2279
        }
2280
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2281
            int size= codec->width * codec->height;
2282
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2283
        }
2284
    }
2285

    
2286
    if (!bit_buffer)
2287
        bit_buffer = av_malloc(bit_buffer_size);
2288
    if (!bit_buffer) {
2289
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2290
                bit_buffer_size);
2291
        ret = AVERROR(ENOMEM);
2292
        goto fail;
2293
    }
2294

    
2295
    /* open each encoder */
2296
    for(i=0;i<nb_ostreams;i++) {
2297
        ost = ost_table[i];
2298
        if (ost->encoding_needed) {
2299
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2300
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2301
            if (!codec)
2302
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2303
            if (!codec) {
2304
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2305
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2306
                ret = AVERROR(EINVAL);
2307
                goto dump_format;
2308
            }
2309
            if (dec->subtitle_header) {
2310
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2311
                if (!ost->st->codec->subtitle_header) {
2312
                    ret = AVERROR(ENOMEM);
2313
                    goto dump_format;
2314
                }
2315
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2316
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2317
            }
2318
            if (avcodec_open(ost->st->codec, codec) < 0) {
2319
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2320
                        ost->file_index, ost->index);
2321
                ret = AVERROR(EINVAL);
2322
                goto dump_format;
2323
            }
2324
            extra_size += ost->st->codec->extradata_size;
2325
        }
2326
    }
2327

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

    
2352
    /* init pts */
2353
    for(i=0;i<nb_istreams;i++) {
2354
        AVStream *st;
2355
        ist = ist_table[i];
2356
        st= ist->st;
2357
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2358
        ist->next_pts = AV_NOPTS_VALUE;
2359
        init_pts_correction(&ist->pts_ctx);
2360
        ist->is_start = 1;
2361
    }
2362

    
2363
    /* set meta data information from input file if required */
2364
    for (i=0;i<nb_meta_data_maps;i++) {
2365
        AVFormatContext *files[2];
2366
        AVMetadata      **meta[2];
2367
        int j;
2368

    
2369
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2370
        if ((index) < 0 || (index) >= (nb_elems)) {\
2371
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2372
                     (desc), (index));\
2373
            ret = AVERROR(EINVAL);\
2374
            goto dump_format;\
2375
        }
2376

    
2377
        int out_file_index = meta_data_maps[i][0].file;
2378
        int in_file_index = meta_data_maps[i][1].file;
2379
        if (in_file_index < 0 || out_file_index < 0)
2380
            continue;
2381
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2382
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2383

    
2384
        files[0] = output_files[out_file_index];
2385
        files[1] = input_files[in_file_index];
2386

    
2387
        for (j = 0; j < 2; j++) {
2388
            AVMetaDataMap *map = &meta_data_maps[i][j];
2389

    
2390
            switch (map->type) {
2391
            case 'g':
2392
                meta[j] = &files[j]->metadata;
2393
                break;
2394
            case 's':
2395
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2396
                meta[j] = &files[j]->streams[map->index]->metadata;
2397
                break;
2398
            case 'c':
2399
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2400
                meta[j] = &files[j]->chapters[map->index]->metadata;
2401
                break;
2402
            case 'p':
2403
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2404
                meta[j] = &files[j]->programs[map->index]->metadata;
2405
                break;
2406
            }
2407
        }
2408

    
2409
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2410
    }
2411

    
2412
    /* copy global metadata by default */
2413
    if (metadata_global_autocopy) {
2414

    
2415
        for (i = 0; i < nb_output_files; i++)
2416
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2417
                             AV_METADATA_DONT_OVERWRITE);
2418
    }
2419

    
2420
    /* copy chapters according to chapter maps */
2421
    for (i = 0; i < nb_chapter_maps; i++) {
2422
        int infile  = chapter_maps[i].in_file;
2423
        int outfile = chapter_maps[i].out_file;
2424

    
2425
        if (infile < 0 || outfile < 0)
2426
            continue;
2427
        if (infile >= nb_input_files) {
2428
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2429
            ret = AVERROR(EINVAL);
2430
            goto dump_format;
2431
        }
2432
        if (outfile >= nb_output_files) {
2433
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2434
            ret = AVERROR(EINVAL);
2435
            goto dump_format;
2436
        }
2437
        copy_chapters(infile, outfile);
2438
    }
2439

    
2440
    /* copy chapters from the first input file that has them*/
2441
    if (!nb_chapter_maps)
2442
        for (i = 0; i < nb_input_files; i++) {
2443
            if (!input_files[i]->nb_chapters)
2444
                continue;
2445

    
2446
            for (j = 0; j < nb_output_files; j++)
2447
                if ((ret = copy_chapters(i, j)) < 0)
2448
                    goto dump_format;
2449
            break;
2450
        }
2451

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

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

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

    
2490
    if (ret) {
2491
        fprintf(stderr, "%s\n", error);
2492
        goto fail;
2493
    }
2494

    
2495
    if (want_sdp) {
2496
        print_sdp(output_files, nb_output_files);
2497
    }
2498

    
2499
    if (!using_stdin && verbose >= 0) {
2500
        fprintf(stderr, "Press [q] to stop encoding\n");
2501
        url_set_interrupt_cb(decode_interrupt_cb);
2502
    }
2503
    term_init();
2504

    
2505
    timer_start = av_gettime();
2506

    
2507
    for(; received_sigterm == 0;) {
2508
        int file_index, ist_index;
2509
        AVPacket pkt;
2510
        double ipts_min;
2511
        double opts_min;
2512

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

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

    
2564
        /* finish if limit size exhausted */
2565
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2566
            break;
2567

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

    
2584
        no_packet_count=0;
2585
        memset(no_packet, 0, sizeof(no_packet));
2586

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

    
2599
        if (pkt.dts != AV_NOPTS_VALUE)
2600
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2601
        if (pkt.pts != AV_NOPTS_VALUE)
2602
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2603

    
2604
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2605
            && input_files_ts_scale[file_index][pkt.stream_index]){
2606
            if(pkt.pts != AV_NOPTS_VALUE)
2607
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2608
            if(pkt.dts != AV_NOPTS_VALUE)
2609
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2610
        }
2611

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

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

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

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

    
2646
    discard_packet:
2647
        av_free_packet(&pkt);
2648

    
2649
        /* dump report by using the output first video and audio streams */
2650
        print_report(output_files, ost_table, nb_ostreams, 0);
2651
    }
2652

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

    
2661
    term_exit();
2662

    
2663
    /* write the trailer if needed and close file */
2664
    for(i=0;i<nb_output_files;i++) {
2665
        os = output_files[i];
2666
        av_write_trailer(os);
2667
    }
2668

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

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

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

    
2695
    /* finished ! */
2696
    ret = 0;
2697

    
2698
 fail:
2699
    av_freep(&bit_buffer);
2700
    av_free(file_table);
2701

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

    
2738
static void opt_format(const char *arg)
2739
{
2740
    last_asked_format = arg;
2741
}
2742

    
2743
static void opt_video_rc_override_string(const char *arg)
2744
{
2745
    video_rc_override_string = arg;
2746
}
2747

    
2748
static int opt_me_threshold(const char *opt, const char *arg)
2749
{
2750
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2751
    return 0;
2752
}
2753

    
2754
static int opt_verbose(const char *opt, const char *arg)
2755
{
2756
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2757
    return 0;
2758
}
2759

    
2760
static int opt_frame_rate(const char *opt, const char *arg)
2761
{
2762
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2763
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2764
        ffmpeg_exit(1);
2765
    }
2766
    return 0;
2767
}
2768

    
2769
static int opt_bitrate(const char *opt, const char *arg)
2770
{
2771
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2772

    
2773
    opt_default(opt, arg);
2774

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

    
2778
    return 0;
2779
}
2780

    
2781
static int opt_frame_crop(const char *opt, const char *arg)
2782
{
2783
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2784
    return AVERROR(EINVAL);
2785
}
2786

    
2787
static void opt_frame_size(const char *arg)
2788
{
2789
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2790
        fprintf(stderr, "Incorrect frame size\n");
2791
        ffmpeg_exit(1);
2792
    }
2793
}
2794

    
2795
static int opt_pad(const char *opt, const char *arg) {
2796
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2797
    return -1;
2798
}
2799

    
2800
static void opt_frame_pix_fmt(const char *arg)
2801
{
2802
    if (strcmp(arg, "list")) {
2803
        frame_pix_fmt = av_get_pix_fmt(arg);
2804
        if (frame_pix_fmt == PIX_FMT_NONE) {
2805
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2806
            ffmpeg_exit(1);
2807
        }
2808
    } else {
2809
        show_pix_fmts();
2810
        ffmpeg_exit(0);
2811
    }
2812
}
2813

    
2814
static void opt_frame_aspect_ratio(const char *arg)
2815
{
2816
    int x = 0, y = 0;
2817
    double ar = 0;
2818
    const char *p;
2819
    char *end;
2820

    
2821
    p = strchr(arg, ':');
2822
    if (p) {
2823
        x = strtol(arg, &end, 10);
2824
        if (end == p)
2825
            y = strtol(end+1, &end, 10);
2826
        if (x > 0 && y > 0)
2827
            ar = (double)x / (double)y;
2828
    } else
2829
        ar = strtod(arg, NULL);
2830

    
2831
    if (!ar) {
2832
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2833
        ffmpeg_exit(1);
2834
    }
2835
    frame_aspect_ratio = ar;
2836
}
2837

    
2838
static int opt_metadata(const char *opt, const char *arg)
2839
{
2840
    char *mid= strchr(arg, '=');
2841

    
2842
    if(!mid){
2843
        fprintf(stderr, "Missing =\n");
2844
        ffmpeg_exit(1);
2845
    }
2846
    *mid++= 0;
2847

    
2848
    av_metadata_set2(&metadata, arg, mid, 0);
2849

    
2850
    return 0;
2851
}
2852

    
2853
static void opt_qscale(const char *arg)
2854
{
2855
    video_qscale = atof(arg);
2856
    if (video_qscale <= 0 ||
2857
        video_qscale > 255) {
2858
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2859
        ffmpeg_exit(1);
2860
    }
2861
}
2862

    
2863
static void opt_top_field_first(const char *arg)
2864
{
2865
    top_field_first= atoi(arg);
2866
}
2867

    
2868
static int opt_thread_count(const char *opt, const char *arg)
2869
{
2870
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2871
#if !HAVE_THREADS
2872
    if (verbose >= 0)
2873
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2874
#endif
2875
    return 0;
2876
}
2877

    
2878
static void opt_audio_sample_fmt(const char *arg)
2879
{
2880
    if (strcmp(arg, "list")) {
2881
        audio_sample_fmt = av_get_sample_fmt(arg);
2882
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2883
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2884
            ffmpeg_exit(1);
2885
        }
2886
    } else {
2887
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2888
        ffmpeg_exit(0);
2889
    }
2890
}
2891

    
2892
static int opt_audio_rate(const char *opt, const char *arg)
2893
{
2894
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2895
    return 0;
2896
}
2897

    
2898
static int opt_audio_channels(const char *opt, const char *arg)
2899
{
2900
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2901
    return 0;
2902
}
2903

    
2904
static void opt_video_channel(const char *arg)
2905
{
2906
    video_channel = strtol(arg, NULL, 0);
2907
}
2908

    
2909
static void opt_video_standard(const char *arg)
2910
{
2911
    video_standard = av_strdup(arg);
2912
}
2913

    
2914
static void opt_codec(int *pstream_copy, char **pcodec_name,
2915
                      int codec_type, const char *arg)
2916
{
2917
    av_freep(pcodec_name);
2918
    if (!strcmp(arg, "copy")) {
2919
        *pstream_copy = 1;
2920
    } else {
2921
        *pcodec_name = av_strdup(arg);
2922
    }
2923
}
2924

    
2925
static void opt_audio_codec(const char *arg)
2926
{
2927
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2928
}
2929

    
2930
static void opt_video_codec(const char *arg)
2931
{
2932
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2933
}
2934

    
2935
static void opt_subtitle_codec(const char *arg)
2936
{
2937
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2938
}
2939

    
2940
static int opt_codec_tag(const char *opt, const char *arg)
2941
{
2942
    char *tail;
2943
    uint32_t *codec_tag;
2944

    
2945
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2946
                !strcmp(opt, "vtag") ? &video_codec_tag :
2947
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2948
    if (!codec_tag)
2949
        return -1;
2950

    
2951
    *codec_tag = strtol(arg, &tail, 0);
2952
    if (!tail || *tail)
2953
        *codec_tag = AV_RL32(arg);
2954

    
2955
    return 0;
2956
}
2957

    
2958
static void opt_map(const char *arg)
2959
{
2960
    AVStreamMap *m;
2961
    char *p;
2962

    
2963
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2964
    m = &stream_maps[nb_stream_maps-1];
2965

    
2966
    m->file_index = strtol(arg, &p, 0);
2967
    if (*p)
2968
        p++;
2969

    
2970
    m->stream_index = strtol(p, &p, 0);
2971
    if (*p) {
2972
        p++;
2973
        m->sync_file_index = strtol(p, &p, 0);
2974
        if (*p)
2975
            p++;
2976
        m->sync_stream_index = strtol(p, &p, 0);
2977
    } else {
2978
        m->sync_file_index = m->file_index;
2979
        m->sync_stream_index = m->stream_index;
2980
    }
2981
}
2982

    
2983
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2984
{
2985
    *endptr = arg;
2986
    if (*arg == ',') {
2987
        *type = *(++arg);
2988
        switch (*arg) {
2989
        case 'g':
2990
            break;
2991
        case 's':
2992
        case 'c':
2993
        case 'p':
2994
            *index = strtol(++arg, endptr, 0);
2995
            break;
2996
        default:
2997
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2998
            ffmpeg_exit(1);
2999
        }
3000
    } else
3001
        *type = 'g';
3002
}
3003

    
3004
static void opt_map_meta_data(const char *arg)
3005
{
3006
    AVMetaDataMap *m, *m1;
3007
    char *p;
3008

    
3009
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3010
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3011

    
3012
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3013
    m->file = strtol(arg, &p, 0);
3014
    parse_meta_type(p, &m->type, &m->index, &p);
3015
    if (*p)
3016
        p++;
3017

    
3018
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3019
    m1->file = strtol(p, &p, 0);
3020
    parse_meta_type(p, &m1->type, &m1->index, &p);
3021

    
3022
    if (m->type == 'g' || m1->type == 'g')
3023
        metadata_global_autocopy = 0;
3024
    if (m->type == 's' || m1->type == 's')
3025
        metadata_streams_autocopy = 0;
3026
    if (m->type == 'c' || m1->type == 'c')
3027
        metadata_chapters_autocopy = 0;
3028
}
3029

    
3030
static void opt_map_chapters(const char *arg)
3031
{
3032
    AVChapterMap *c;
3033
    char *p;
3034

    
3035
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3036
                              nb_chapter_maps + 1);
3037
    c = &chapter_maps[nb_chapter_maps - 1];
3038
    c->out_file = strtol(arg, &p, 0);
3039
    if (*p)
3040
        p++;
3041

    
3042
    c->in_file = strtol(p, &p, 0);
3043
}
3044

    
3045
static void opt_input_ts_scale(const char *arg)
3046
{
3047
    unsigned int stream;
3048
    double scale;
3049
    char *p;
3050

    
3051
    stream = strtol(arg, &p, 0);
3052
    if (*p)
3053
        p++;
3054
    scale= strtod(p, &p);
3055

    
3056
    if(stream >= MAX_STREAMS)
3057
        ffmpeg_exit(1);
3058

    
3059
    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);
3060
    input_files_ts_scale[nb_input_files][stream]= scale;
3061
}
3062

    
3063
static int opt_recording_time(const char *opt, const char *arg)
3064
{
3065
    recording_time = parse_time_or_die(opt, arg, 1);
3066
    return 0;
3067
}
3068

    
3069
static int opt_start_time(const char *opt, const char *arg)
3070
{
3071
    start_time = parse_time_or_die(opt, arg, 1);
3072
    return 0;
3073
}
3074

    
3075
static int opt_recording_timestamp(const char *opt, const char *arg)
3076
{
3077
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3078
    return 0;
3079
}
3080

    
3081
static int opt_input_ts_offset(const char *opt, const char *arg)
3082
{
3083
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3084
    return 0;
3085
}
3086

    
3087
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3088
{
3089
    const char *codec_string = encoder ? "encoder" : "decoder";
3090
    AVCodec *codec;
3091

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

    
3121
static void opt_input_file(const char *filename)
3122
{
3123
    AVFormatContext *ic;
3124
    AVFormatParameters params, *ap = &params;
3125
    AVInputFormat *file_iformat = NULL;
3126
    int err, i, ret, rfps, rfps_base;
3127
    int64_t timestamp;
3128

    
3129
    if (last_asked_format) {
3130
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3131
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3132
            ffmpeg_exit(1);
3133
        }
3134
        last_asked_format = NULL;
3135
    }
3136

    
3137
    if (!strcmp(filename, "-"))
3138
        filename = "pipe:";
3139

    
3140
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3141
                    !strcmp(filename, "/dev/stdin");
3142

    
3143
    /* get default parameters from command line */
3144
    ic = avformat_alloc_context();
3145
    if (!ic) {
3146
        print_error(filename, AVERROR(ENOMEM));
3147
        ffmpeg_exit(1);
3148
    }
3149

    
3150
    memset(ap, 0, sizeof(*ap));
3151
    ap->prealloced_context = 1;
3152
    ap->sample_rate = audio_sample_rate;
3153
    ap->channels = audio_channels;
3154
    ap->time_base.den = frame_rate.num;
3155
    ap->time_base.num = frame_rate.den;
3156
    ap->width = frame_width;
3157
    ap->height = frame_height;
3158
    ap->pix_fmt = frame_pix_fmt;
3159
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3160
    ap->channel = video_channel;
3161
    ap->standard = video_standard;
3162

    
3163
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3164

    
3165
    ic->video_codec_id   =
3166
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3167
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3168
    ic->audio_codec_id   =
3169
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3170
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3171
    ic->subtitle_codec_id=
3172
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3173
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3174
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3175

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

    
3206
    ic->loop_input = loop_input;
3207

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

    
3217
    timestamp = start_time;
3218
    /* add the stream start time */
3219
    if (ic->start_time != AV_NOPTS_VALUE)
3220
        timestamp += ic->start_time;
3221

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

    
3233
    /* update the current parameters so that they match the one of the input stream */
3234
    for(i=0;i<ic->nb_streams;i++) {
3235
        AVStream *st = ic->streams[i];
3236
        AVCodecContext *dec = st->codec;
3237
        avcodec_thread_init(dec, thread_count);
3238
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3239
        switch (dec->codec_type) {
3240
        case AVMEDIA_TYPE_AUDIO:
3241
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3242
            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]);
3243
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3244
            channel_layout    = dec->channel_layout;
3245
            audio_channels    = dec->channels;
3246
            audio_sample_rate = dec->sample_rate;
3247
            audio_sample_fmt  = dec->sample_fmt;
3248
            if(audio_disable)
3249
                st->discard= AVDISCARD_ALL;
3250
            /* Note that av_find_stream_info can add more streams, and we
3251
             * currently have no chance of setting up lowres decoding
3252
             * early enough for them. */
3253
            if (dec->lowres)
3254
                audio_sample_rate >>= dec->lowres;
3255
            break;
3256
        case AVMEDIA_TYPE_VIDEO:
3257
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3258
            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]);
3259
            frame_height = dec->height;
3260
            frame_width  = dec->width;
3261
            if(ic->streams[i]->sample_aspect_ratio.num)
3262
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3263
            else
3264
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3265
            frame_aspect_ratio *= (float) dec->width / dec->height;
3266
            frame_pix_fmt = dec->pix_fmt;
3267
            rfps      = ic->streams[i]->r_frame_rate.num;
3268
            rfps_base = ic->streams[i]->r_frame_rate.den;
3269
            if (dec->lowres) {
3270
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3271
                frame_height >>= dec->lowres;
3272
                frame_width  >>= dec->lowres;
3273
                dec->height = frame_height;
3274
                dec->width  = frame_width;
3275
            }
3276
            if(me_threshold)
3277
                dec->debug |= FF_DEBUG_MV;
3278

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

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

    
3285
                    (float)rfps / rfps_base, rfps, rfps_base);
3286
            }
3287
            /* update the current frame rate to match the stream frame rate */
3288
            frame_rate.num = rfps;
3289
            frame_rate.den = rfps_base;
3290

    
3291
            if(video_disable)
3292
                st->discard= AVDISCARD_ALL;
3293
            else if(video_discard)
3294
                st->discard= video_discard;
3295
            break;
3296
        case AVMEDIA_TYPE_DATA:
3297
            break;
3298
        case AVMEDIA_TYPE_SUBTITLE:
3299
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3300
            if(subtitle_disable)
3301
                st->discard = AVDISCARD_ALL;
3302
            break;
3303
        case AVMEDIA_TYPE_ATTACHMENT:
3304
        case AVMEDIA_TYPE_UNKNOWN:
3305
            break;
3306
        default:
3307
            abort();
3308
        }
3309
    }
3310

    
3311
    input_files[nb_input_files] = ic;
3312
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3313
    /* dump the file content */
3314
    if (verbose >= 0)
3315
        dump_format(ic, nb_input_files, filename, 0);
3316

    
3317
    nb_input_files++;
3318

    
3319
    video_channel = 0;
3320

    
3321
    av_freep(&video_codec_name);
3322
    av_freep(&audio_codec_name);
3323
    av_freep(&subtitle_codec_name);
3324
}
3325

    
3326
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3327
                                         int *has_subtitle_ptr)
3328
{
3329
    int has_video, has_audio, has_subtitle, i, j;
3330
    AVFormatContext *ic;
3331

    
3332
    has_video = 0;
3333
    has_audio = 0;
3334
    has_subtitle = 0;
3335
    for(j=0;j<nb_input_files;j++) {
3336
        ic = input_files[j];
3337
        for(i=0;i<ic->nb_streams;i++) {
3338
            AVCodecContext *enc = ic->streams[i]->codec;
3339
            switch(enc->codec_type) {
3340
            case AVMEDIA_TYPE_AUDIO:
3341
                has_audio = 1;
3342
                break;
3343
            case AVMEDIA_TYPE_VIDEO:
3344
                has_video = 1;
3345
                break;
3346
            case AVMEDIA_TYPE_SUBTITLE:
3347
                has_subtitle = 1;
3348
                break;
3349
            case AVMEDIA_TYPE_DATA:
3350
            case AVMEDIA_TYPE_ATTACHMENT:
3351
            case AVMEDIA_TYPE_UNKNOWN:
3352
                break;
3353
            default:
3354
                abort();
3355
            }
3356
        }
3357
    }
3358
    *has_video_ptr = has_video;
3359
    *has_audio_ptr = has_audio;
3360
    *has_subtitle_ptr = has_subtitle;
3361
}
3362

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

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

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

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

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

    
3397
    video_enc = st->codec;
3398

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

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

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

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

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

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

    
3436
        choose_pixel_fmt(st, codec);
3437

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

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

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

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

    
3484
        /* two pass mode */
3485
        if (do_pass) {
3486
            if (do_pass == 1) {
3487
                video_enc->flags |= CODEC_FLAG_PASS1;
3488
            } else {
3489
                video_enc->flags |= CODEC_FLAG_PASS2;
3490
            }
3491
        }
3492

    
3493
        if (forced_key_frames)
3494
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3495
    }
3496
    if (video_language) {
3497
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3498
        av_freep(&video_language);
3499
    }
3500

    
3501
    /* reset some key parameters */
3502
    video_disable = 0;
3503
    av_freep(&video_codec_name);
3504
    av_freep(&forced_key_frames);
3505
    video_stream_copy = 0;
3506
    frame_pix_fmt = PIX_FMT_NONE;
3507
}
3508

    
3509
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3510
{
3511
    AVStream *st;
3512
    AVOutputStream *ost;
3513
    AVCodec *codec= NULL;
3514
    AVCodecContext *audio_enc;
3515
    enum CodecID codec_id = CODEC_ID_NONE;
3516

    
3517
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3518
    if (!st) {
3519
        fprintf(stderr, "Could not alloc stream\n");
3520
        ffmpeg_exit(1);
3521
    }
3522
    ost = new_output_stream(oc, file_idx);
3523

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

    
3537
    avcodec_get_context_defaults3(st->codec, codec);
3538

    
3539
    ost->bitstream_filters = audio_bitstream_filters;
3540
    audio_bitstream_filters= NULL;
3541

    
3542
    avcodec_thread_init(st->codec, thread_count);
3543

    
3544
    audio_enc = st->codec;
3545
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3546

    
3547
    if(audio_codec_tag)
3548
        audio_enc->codec_tag= audio_codec_tag;
3549

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

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

    
3581
    /* reset some key parameters */
3582
    audio_disable = 0;
3583
    av_freep(&audio_codec_name);
3584
    audio_stream_copy = 0;
3585
}
3586

    
3587
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3588
{
3589
    AVStream *st;
3590
    AVOutputStream *ost;
3591
    AVCodec *codec=NULL;
3592
    AVCodecContext *subtitle_enc;
3593
    enum CodecID codec_id = CODEC_ID_NONE;
3594

    
3595
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3596
    if (!st) {
3597
        fprintf(stderr, "Could not alloc stream\n");
3598
        ffmpeg_exit(1);
3599
    }
3600
    ost = new_output_stream(oc, file_idx);
3601
    subtitle_enc = st->codec;
3602
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3603
    if(!subtitle_stream_copy){
3604
        if (subtitle_codec_name) {
3605
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3606
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3607
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3608
        } else {
3609
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3610
            codec = avcodec_find_encoder(codec_id);
3611
        }
3612
    }
3613
    avcodec_get_context_defaults3(st->codec, codec);
3614

    
3615
    ost->bitstream_filters = subtitle_bitstream_filters;
3616
    subtitle_bitstream_filters= NULL;
3617

    
3618
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3619

    
3620
    if(subtitle_codec_tag)
3621
        subtitle_enc->codec_tag= subtitle_codec_tag;
3622

    
3623
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3624
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3625
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3626
    }
3627
    if (subtitle_stream_copy) {
3628
        st->stream_copy = 1;
3629
    } else {
3630
        subtitle_enc->codec_id = codec_id;
3631
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3632
    }
3633

    
3634
    if (subtitle_language) {
3635
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3636
        av_freep(&subtitle_language);
3637
    }
3638

    
3639
    subtitle_disable = 0;
3640
    av_freep(&subtitle_codec_name);
3641
    subtitle_stream_copy = 0;
3642
}
3643

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

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

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

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

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

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

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

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

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

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

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

    
3747
        /* manual disable */
3748
        if (audio_disable)    use_audio    = 0;
3749
        if (video_disable)    use_video    = 0;
3750
        if (subtitle_disable) use_subtitle = 0;
3751

    
3752
        if (use_video)    new_video_stream(oc, nb_output_files);
3753
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3754
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3755

    
3756
        oc->timestamp = recording_timestamp;
3757

    
3758
        av_metadata_copy(&oc->metadata, metadata, 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
    av_freep(&forced_key_frames);
3817
}
3818

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

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

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

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

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

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

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

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

    
3903
static void show_help(void)
3904
{
3905
    AVCodec *c;
3906
    AVOutputFormat *oformat = NULL;
3907

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

    
3937
    /* individual codec options */
3938
    c = NULL;
3939
    while ((c = av_codec_next(c))) {
3940
        if (c->priv_class) {
3941
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3942
            printf("\n");
3943
        }
3944
    }
3945

    
3946
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3947
    printf("\n");
3948

    
3949
    /* individual muxer options */
3950
    while ((oformat = av_oformat_next(oformat))) {
3951
        if (oformat->priv_class) {
3952
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3953
            printf("\n");
3954
        }
3955
    }
3956

    
3957
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3958
}
3959

    
3960
static void opt_target(const char *arg)
3961
{
3962
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3963
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3964

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

    
4009
    if(norm == UNKNOWN) {
4010
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4011
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4012
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4013
        ffmpeg_exit(1);
4014
    }
4015

    
4016
    if(!strcmp(arg, "vcd")) {
4017

    
4018
        opt_video_codec("mpeg1video");
4019
        opt_audio_codec("mp2");
4020
        opt_format("vcd");
4021

    
4022
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4023
        opt_frame_rate(NULL, frame_rates[norm]);
4024
        opt_default("g", norm == PAL ? "15" : "18");
4025

    
4026
        opt_default("b", "1150000");
4027
        opt_default("maxrate", "1150000");
4028
        opt_default("minrate", "1150000");
4029
        opt_default("bufsize", "327680"); // 40*1024*8;
4030

    
4031
        opt_default("ab", "224000");
4032
        audio_sample_rate = 44100;
4033
        audio_channels = 2;
4034

    
4035
        opt_default("packetsize", "2324");
4036
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4037

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

    
4046
        opt_video_codec("mpeg2video");
4047
        opt_audio_codec("mp2");
4048
        opt_format("svcd");
4049

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

    
4054
        opt_default("b", "2040000");
4055
        opt_default("maxrate", "2516000");
4056
        opt_default("minrate", "0"); //1145000;
4057
        opt_default("bufsize", "1835008"); //224*1024*8;
4058
        opt_default("flags", "+scan_offset");
4059

    
4060

    
4061
        opt_default("ab", "224000");
4062
        audio_sample_rate = 44100;
4063

    
4064
        opt_default("packetsize", "2324");
4065

    
4066
    } else if(!strcmp(arg, "dvd")) {
4067

    
4068
        opt_video_codec("mpeg2video");
4069
        opt_audio_codec("ac3");
4070
        opt_format("dvd");
4071

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

    
4076
        opt_default("b", "6000000");
4077
        opt_default("maxrate", "9000000");
4078
        opt_default("minrate", "0"); //1500000;
4079
        opt_default("bufsize", "1835008"); //224*1024*8;
4080

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

    
4084
        opt_default("ab", "448000");
4085
        audio_sample_rate = 48000;
4086

    
4087
    } else if(!strncmp(arg, "dv", 2)) {
4088

    
4089
        opt_format("dv");
4090

    
4091
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4092
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4093
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4094
        opt_frame_rate(NULL, frame_rates[norm]);
4095

    
4096
        audio_sample_rate = 48000;
4097
        audio_channels = 2;
4098

    
4099
    } else {
4100
        fprintf(stderr, "Unknown target: %s\n", arg);
4101
        ffmpeg_exit(1);
4102
    }
4103
}
4104

    
4105
static void opt_vstats_file (const char *arg)
4106
{
4107
    av_free (vstats_filename);
4108
    vstats_filename=av_strdup (arg);
4109
}
4110

    
4111
static void opt_vstats (void)
4112
{
4113
    char filename[40];
4114
    time_t today2 = time(NULL);
4115
    struct tm *today = localtime(&today2);
4116

    
4117
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4118
             today->tm_sec);
4119
    opt_vstats_file(filename);
4120
}
4121

    
4122
static int opt_bsf(const char *opt, const char *arg)
4123
{
4124
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4125
    AVBitStreamFilterContext **bsfp;
4126

    
4127
    if(!bsfc){
4128
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4129
        ffmpeg_exit(1);
4130
    }
4131

    
4132
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4133
          *opt == 'a' ? &audio_bitstream_filters :
4134
                        &subtitle_bitstream_filters;
4135
    while(*bsfp)
4136
        bsfp= &(*bsfp)->next;
4137

    
4138
    *bsfp= bsfc;
4139

    
4140
    return 0;
4141
}
4142

    
4143
static int opt_preset(const char *opt, const char *arg)
4144
{
4145
    FILE *f=NULL;
4146
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4147
    char *codec_name = *opt == 'v' ? video_codec_name :
4148
                       *opt == 'a' ? audio_codec_name :
4149
                                     subtitle_codec_name;
4150

    
4151
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4152
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4153
        ffmpeg_exit(1);
4154
    }
4155

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

    
4177
    fclose(f);
4178

    
4179
    return 0;
4180
}
4181

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

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

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

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

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

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

    
4301
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4302
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4303
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4304

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

    
4310
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4311
    { NULL, },
4312
};
4313

    
4314
int main(int argc, char **argv)
4315
{
4316
    int64_t ti;
4317

    
4318
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4319

    
4320
    avcodec_register_all();
4321
#if CONFIG_AVDEVICE
4322
    avdevice_register_all();
4323
#endif
4324
#if CONFIG_AVFILTER
4325
    avfilter_register_all();
4326
#endif
4327
    av_register_all();
4328

    
4329
#if HAVE_ISATTY
4330
    if(isatty(STDIN_FILENO))
4331
        url_set_interrupt_cb(decode_interrupt_cb);
4332
#endif
4333

    
4334
    init_opts();
4335

    
4336
    show_banner();
4337

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

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

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

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

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

    
4368
    return ffmpeg_exit(0);
4369
}