Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 20ac9de3

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 copy_tb;
217
static int opt_shortest = 0;
218
static int video_global_header = 0;
219
static char *vstats_filename;
220
static FILE *vstats_file;
221
static int opt_programid = 0;
222
static int copy_initial_nonkeyframes = 0;
223

    
224
static int rate_emu = 0;
225

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

    
229
static int audio_volume = 256;
230

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

    
246
static float dts_delta_threshold = 10;
247

    
248
static unsigned int sws_flags = SWS_BICUBIC;
249

    
250
static int64_t timer_start;
251

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

    
256
static short *samples;
257

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

    
262
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263

    
264
struct AVInputStream;
265

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

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

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

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

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

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

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

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

    
343
#if HAVE_TERMIOS_H
344

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

    
349
#if CONFIG_AVFILTER
350

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

    
361
    graph = avfilter_graph_alloc();
362

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

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

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

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

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

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

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

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

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

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

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

    
431
static volatile int received_sigterm = 0;
432

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
552
    av_free(video_standard);
553

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

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

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

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

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

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

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

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

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

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

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

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

    
684
        s->nb_streams++;
685

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

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

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

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

    
718
        new_output_stream(s, nb_output_files);
719
    }
720

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

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

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

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

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

    
757
        bsfc= bsfc->next;
758
    }
759

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

    
767
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
768

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1138
    *frame_size = 0;
1139

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1362

    
1363
    oc = output_files[0];
1364

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

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

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

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

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

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

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

    
1443
        fflush(stderr);
1444
    }
1445

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

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

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

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

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

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

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

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

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

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

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

    
1608
#if CONFIG_AVFILTER
1609
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1610
            AVRational sar;
1611
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1612
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1613
            // add it to be filtered
1614
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1615
                                     ist->pts,
1616
                                     sar);
1617
        }
1618
#endif
1619

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

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

    
1659
                ost = ost_table[i];
1660
                if (ost->source_index == ist_index) {
1661
                    os = output_files[ost->file_index];
1662

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

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

    
1693
                        av_init_packet(&opkt);
1694

    
1695
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1696
                            continue;
1697

    
1698
                        /* no reencoding needed : output the packet directly */
1699
                        /* force the input stream PTS */
1700

    
1701
                        avcodec_get_frame_defaults(&avframe);
1702
                        ost->st->codec->coded_frame= &avframe;
1703
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1704

    
1705
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1706
                            audio_size += data_size;
1707
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1708
                            video_size += data_size;
1709
                            ost->sync_opts++;
1710
                        }
1711

    
1712
                        opkt.stream_index= ost->index;
1713
                        if(pkt->pts != AV_NOPTS_VALUE)
1714
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1715
                        else
1716
                            opkt.pts= AV_NOPTS_VALUE;
1717

    
1718
                        if (pkt->dts == AV_NOPTS_VALUE)
1719
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1720
                        else
1721
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1722
                        opkt.dts -= ost_tb_start_time;
1723

    
1724
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1725
                        opkt.flags= pkt->flags;
1726

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

    
1739
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1740
                        ost->st->codec->frame_number++;
1741
                        ost->frame_number++;
1742
                        av_free_packet(&opkt);
1743
                    }
1744
                }
1745
            }
1746

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

    
1765
        for(i=0;i<nb_ostreams;i++) {
1766
            ost = ost_table[i];
1767
            if (ost->source_index == ist_index) {
1768
                AVCodecContext *enc= ost->st->codec;
1769
                os = output_files[ost->file_index];
1770

    
1771
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1772
                    continue;
1773
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1774
                    continue;
1775

    
1776
                if (ost->encoding_needed) {
1777
                    for(;;) {
1778
                        AVPacket pkt;
1779
                        int fifo_bytes;
1780
                        av_init_packet(&pkt);
1781
                        pkt.stream_index= ost->index;
1782

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

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

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

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

    
1847
    return 0;
1848
 fail_decode:
1849
    return -1;
1850
}
1851

    
1852
static void print_sdp(AVFormatContext **avc, int n)
1853
{
1854
    char sdp[2048];
1855

    
1856
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1857
    printf("SDP:\n%s\n", sdp);
1858
    fflush(stdout);
1859
}
1860

    
1861
static int copy_chapters(int infile, int outfile)
1862
{
1863
    AVFormatContext *is = input_files[infile];
1864
    AVFormatContext *os = output_files[outfile];
1865
    int i;
1866

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

    
1874

    
1875
        if (in_ch->end < ts_off)
1876
            continue;
1877
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1878
            break;
1879

    
1880
        out_ch = av_mallocz(sizeof(AVChapter));
1881
        if (!out_ch)
1882
            return AVERROR(ENOMEM);
1883

    
1884
        out_ch->id        = in_ch->id;
1885
        out_ch->time_base = in_ch->time_base;
1886
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1887
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1888

    
1889
        if (metadata_chapters_autocopy)
1890
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1891

    
1892
        os->nb_chapters++;
1893
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1894
        if (!os->chapters)
1895
            return AVERROR(ENOMEM);
1896
        os->chapters[os->nb_chapters - 1] = out_ch;
1897
    }
1898
    return 0;
1899
}
1900

    
1901
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1902
                                    AVCodecContext *avctx)
1903
{
1904
    char *p;
1905
    int n = 1, i;
1906
    int64_t t;
1907

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

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

    
1945
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1946
    if (!file_table)
1947
        goto fail;
1948

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

    
1959
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1960
    if (!ist_table)
1961
        goto fail;
1962

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

    
1980
            if (rate_emu) {
1981
                ist->start = av_gettime();
1982
            }
1983
        }
1984
    }
1985

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

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

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

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

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

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

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

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

    
2114
        codec = ost->st->codec;
2115
        icodec = ist->st->codec;
2116

    
2117
        if (metadata_streams_autocopy)
2118
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2119
                             AV_METADATA_DONT_OVERWRITE);
2120

    
2121
        ost->st->disposition = ist->st->disposition;
2122
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2123
        codec->chroma_sample_location = icodec->chroma_sample_location;
2124

    
2125
        if (ost->st->stream_copy) {
2126
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2127

    
2128
            if (extra_size > INT_MAX)
2129
                goto fail;
2130

    
2131
            /* if stream_copy is selected, no need to decode or encode */
2132
            codec->codec_id = icodec->codec_id;
2133
            codec->codec_type = icodec->codec_type;
2134

    
2135
            if(!codec->codec_tag){
2136
                if(   !os->oformat->codec_tag
2137
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2138
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2139
                    codec->codec_tag = icodec->codec_tag;
2140
            }
2141

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

    
2231
                    ost->original_height = icodec->height;
2232
                    ost->original_width  = icodec->width;
2233
#endif
2234
                    codec->bits_per_raw_sample= 0;
2235
                }
2236
                ost->resample_height = icodec->height;
2237
                ost->resample_width  = icodec->width;
2238
                ost->resample_pix_fmt= icodec->pix_fmt;
2239
                ost->encoding_needed = 1;
2240
                ist->decoding_needed = 1;
2241

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

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

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

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

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

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

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

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

    
2381
        int out_file_index = meta_data_maps[i][0].file;
2382
        int in_file_index = meta_data_maps[i][1].file;
2383
        if (in_file_index < 0 || out_file_index < 0)
2384
            continue;
2385
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2386
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2387

    
2388
        files[0] = output_files[out_file_index];
2389
        files[1] = input_files[in_file_index];
2390

    
2391
        for (j = 0; j < 2; j++) {
2392
            AVMetaDataMap *map = &meta_data_maps[i][j];
2393

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

    
2413
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2414
    }
2415

    
2416
    /* copy global metadata by default */
2417
    if (metadata_global_autocopy) {
2418

    
2419
        for (i = 0; i < nb_output_files; i++)
2420
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2421
                             AV_METADATA_DONT_OVERWRITE);
2422
    }
2423

    
2424
    /* copy chapters according to chapter maps */
2425
    for (i = 0; i < nb_chapter_maps; i++) {
2426
        int infile  = chapter_maps[i].in_file;
2427
        int outfile = chapter_maps[i].out_file;
2428

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

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

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

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

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

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

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

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

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

    
2509
    timer_start = av_gettime();
2510

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2650
    discard_packet:
2651
        av_free_packet(&pkt);
2652

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

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

    
2665
    term_exit();
2666

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

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

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

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

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

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

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

    
2742
static void opt_format(const char *arg)
2743
{
2744
    last_asked_format = arg;
2745
}
2746

    
2747
static void opt_video_rc_override_string(const char *arg)
2748
{
2749
    video_rc_override_string = arg;
2750
}
2751

    
2752
static int opt_me_threshold(const char *opt, const char *arg)
2753
{
2754
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2755
    return 0;
2756
}
2757

    
2758
static int opt_verbose(const char *opt, const char *arg)
2759
{
2760
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2761
    return 0;
2762
}
2763

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

    
2773
static int opt_bitrate(const char *opt, const char *arg)
2774
{
2775
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2776

    
2777
    opt_default(opt, arg);
2778

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

    
2782
    return 0;
2783
}
2784

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

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

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

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

    
2818
static void opt_frame_aspect_ratio(const char *arg)
2819
{
2820
    int x = 0, y = 0;
2821
    double ar = 0;
2822
    const char *p;
2823
    char *end;
2824

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

    
2835
    if (!ar) {
2836
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2837
        ffmpeg_exit(1);
2838
    }
2839
    frame_aspect_ratio = ar;
2840
}
2841

    
2842
static int opt_metadata(const char *opt, const char *arg)
2843
{
2844
    char *mid= strchr(arg, '=');
2845

    
2846
    if(!mid){
2847
        fprintf(stderr, "Missing =\n");
2848
        ffmpeg_exit(1);
2849
    }
2850
    *mid++= 0;
2851

    
2852
    av_metadata_set2(&metadata, arg, mid, 0);
2853

    
2854
    return 0;
2855
}
2856

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

    
2867
static void opt_top_field_first(const char *arg)
2868
{
2869
    top_field_first= atoi(arg);
2870
}
2871

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

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

    
2896
static int opt_audio_rate(const char *opt, const char *arg)
2897
{
2898
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2899
    return 0;
2900
}
2901

    
2902
static int opt_audio_channels(const char *opt, const char *arg)
2903
{
2904
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2905
    return 0;
2906
}
2907

    
2908
static void opt_video_channel(const char *arg)
2909
{
2910
    video_channel = strtol(arg, NULL, 0);
2911
}
2912

    
2913
static void opt_video_standard(const char *arg)
2914
{
2915
    video_standard = av_strdup(arg);
2916
}
2917

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

    
2929
static void opt_audio_codec(const char *arg)
2930
{
2931
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2932
}
2933

    
2934
static void opt_video_codec(const char *arg)
2935
{
2936
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2937
}
2938

    
2939
static void opt_subtitle_codec(const char *arg)
2940
{
2941
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2942
}
2943

    
2944
static int opt_codec_tag(const char *opt, const char *arg)
2945
{
2946
    char *tail;
2947
    uint32_t *codec_tag;
2948

    
2949
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2950
                !strcmp(opt, "vtag") ? &video_codec_tag :
2951
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2952
    if (!codec_tag)
2953
        return -1;
2954

    
2955
    *codec_tag = strtol(arg, &tail, 0);
2956
    if (!tail || *tail)
2957
        *codec_tag = AV_RL32(arg);
2958

    
2959
    return 0;
2960
}
2961

    
2962
static void opt_map(const char *arg)
2963
{
2964
    AVStreamMap *m;
2965
    char *p;
2966

    
2967
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2968
    m = &stream_maps[nb_stream_maps-1];
2969

    
2970
    m->file_index = strtol(arg, &p, 0);
2971
    if (*p)
2972
        p++;
2973

    
2974
    m->stream_index = strtol(p, &p, 0);
2975
    if (*p) {
2976
        p++;
2977
        m->sync_file_index = strtol(p, &p, 0);
2978
        if (*p)
2979
            p++;
2980
        m->sync_stream_index = strtol(p, &p, 0);
2981
    } else {
2982
        m->sync_file_index = m->file_index;
2983
        m->sync_stream_index = m->stream_index;
2984
    }
2985
}
2986

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

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

    
3013
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3014
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3015

    
3016
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3017
    m->file = strtol(arg, &p, 0);
3018
    parse_meta_type(p, &m->type, &m->index, &p);
3019
    if (*p)
3020
        p++;
3021

    
3022
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3023
    m1->file = strtol(p, &p, 0);
3024
    parse_meta_type(p, &m1->type, &m1->index, &p);
3025

    
3026
    if (m->type == 'g' || m1->type == 'g')
3027
        metadata_global_autocopy = 0;
3028
    if (m->type == 's' || m1->type == 's')
3029
        metadata_streams_autocopy = 0;
3030
    if (m->type == 'c' || m1->type == 'c')
3031
        metadata_chapters_autocopy = 0;
3032
}
3033

    
3034
static void opt_map_chapters(const char *arg)
3035
{
3036
    AVChapterMap *c;
3037
    char *p;
3038

    
3039
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3040
                              nb_chapter_maps + 1);
3041
    c = &chapter_maps[nb_chapter_maps - 1];
3042
    c->out_file = strtol(arg, &p, 0);
3043
    if (*p)
3044
        p++;
3045

    
3046
    c->in_file = strtol(p, &p, 0);
3047
}
3048

    
3049
static void opt_input_ts_scale(const char *arg)
3050
{
3051
    unsigned int stream;
3052
    double scale;
3053
    char *p;
3054

    
3055
    stream = strtol(arg, &p, 0);
3056
    if (*p)
3057
        p++;
3058
    scale= strtod(p, &p);
3059

    
3060
    if(stream >= MAX_STREAMS)
3061
        ffmpeg_exit(1);
3062

    
3063
    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);
3064
    input_files_ts_scale[nb_input_files][stream]= scale;
3065
}
3066

    
3067
static int opt_recording_time(const char *opt, const char *arg)
3068
{
3069
    recording_time = parse_time_or_die(opt, arg, 1);
3070
    return 0;
3071
}
3072

    
3073
static int opt_start_time(const char *opt, const char *arg)
3074
{
3075
    start_time = parse_time_or_die(opt, arg, 1);
3076
    return 0;
3077
}
3078

    
3079
static int opt_recording_timestamp(const char *opt, const char *arg)
3080
{
3081
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3082
    return 0;
3083
}
3084

    
3085
static int opt_input_ts_offset(const char *opt, const char *arg)
3086
{
3087
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3088
    return 0;
3089
}
3090

    
3091
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3092
{
3093
    const char *codec_string = encoder ? "encoder" : "decoder";
3094
    AVCodec *codec;
3095

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

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

    
3133
    if (last_asked_format) {
3134
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3135
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3136
            ffmpeg_exit(1);
3137
        }
3138
        last_asked_format = NULL;
3139
    }
3140

    
3141
    if (!strcmp(filename, "-"))
3142
        filename = "pipe:";
3143

    
3144
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3145
                    !strcmp(filename, "/dev/stdin");
3146

    
3147
    /* get default parameters from command line */
3148
    ic = avformat_alloc_context();
3149
    if (!ic) {
3150
        print_error(filename, AVERROR(ENOMEM));
3151
        ffmpeg_exit(1);
3152
    }
3153

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

    
3167
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3168

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

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

    
3210
    ic->loop_input = loop_input;
3211

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

    
3221
    timestamp = start_time;
3222
    /* add the stream start time */
3223
    if (ic->start_time != AV_NOPTS_VALUE)
3224
        timestamp += ic->start_time;
3225

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

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

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

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

    
3289
                    (float)rfps / rfps_base, rfps, rfps_base);
3290
            }
3291
            /* update the current frame rate to match the stream frame rate */
3292
            frame_rate.num = rfps;
3293
            frame_rate.den = rfps_base;
3294

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

    
3315
    input_files[nb_input_files] = ic;
3316
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3317
    /* dump the file content */
3318
    if (verbose >= 0)
3319
        dump_format(ic, nb_input_files, filename, 0);
3320

    
3321
    nb_input_files++;
3322

    
3323
    video_channel = 0;
3324

    
3325
    av_freep(&video_codec_name);
3326
    av_freep(&audio_codec_name);
3327
    av_freep(&subtitle_codec_name);
3328
}
3329

    
3330
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3331
                                         int *has_subtitle_ptr)
3332
{
3333
    int has_video, has_audio, has_subtitle, i, j;
3334
    AVFormatContext *ic;
3335

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

    
3367
static void new_video_stream(AVFormatContext *oc, int file_idx)
3368
{
3369
    AVStream *st;
3370
    AVOutputStream *ost;
3371
    AVCodecContext *video_enc;
3372
    enum CodecID codec_id = CODEC_ID_NONE;
3373
    AVCodec *codec= NULL;
3374

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

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

    
3395
    avcodec_get_context_defaults3(st->codec, codec);
3396
    ost->bitstream_filters = video_bitstream_filters;
3397
    video_bitstream_filters= NULL;
3398

    
3399
    avcodec_thread_init(st->codec, thread_count);
3400

    
3401
    video_enc = st->codec;
3402

    
3403
    if(video_codec_tag)
3404
        video_enc->codec_tag= video_codec_tag;
3405

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

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

    
3426
        video_enc->codec_id = codec_id;
3427
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3428

    
3429
        if (codec && codec->supported_framerates && !force_fps)
3430
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3431
        video_enc->time_base.den = fps.num;
3432
        video_enc->time_base.num = fps.den;
3433

    
3434
        video_enc->width = frame_width;
3435
        video_enc->height = frame_height;
3436
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3437
        video_enc->pix_fmt = frame_pix_fmt;
3438
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3439

    
3440
        choose_pixel_fmt(st, codec);
3441

    
3442
        if (intra_only)
3443
            video_enc->gop_size = 0;
3444
        if (video_qscale || same_quality) {
3445
            video_enc->flags |= CODEC_FLAG_QSCALE;
3446
            video_enc->global_quality=
3447
                st->quality = FF_QP2LAMBDA * video_qscale;
3448
        }
3449

    
3450
        if(intra_matrix)
3451
            video_enc->intra_matrix = intra_matrix;
3452
        if(inter_matrix)
3453
            video_enc->inter_matrix = inter_matrix;
3454

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

    
3485
        if (do_psnr)
3486
            video_enc->flags|= CODEC_FLAG_PSNR;
3487

    
3488
        /* two pass mode */
3489
        if (do_pass) {
3490
            if (do_pass == 1) {
3491
                video_enc->flags |= CODEC_FLAG_PASS1;
3492
            } else {
3493
                video_enc->flags |= CODEC_FLAG_PASS2;
3494
            }
3495
        }
3496

    
3497
        if (forced_key_frames)
3498
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3499
    }
3500
    if (video_language) {
3501
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3502
        av_freep(&video_language);
3503
    }
3504

    
3505
    /* reset some key parameters */
3506
    video_disable = 0;
3507
    av_freep(&video_codec_name);
3508
    av_freep(&forced_key_frames);
3509
    video_stream_copy = 0;
3510
    frame_pix_fmt = PIX_FMT_NONE;
3511
}
3512

    
3513
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3514
{
3515
    AVStream *st;
3516
    AVOutputStream *ost;
3517
    AVCodec *codec= NULL;
3518
    AVCodecContext *audio_enc;
3519
    enum CodecID codec_id = CODEC_ID_NONE;
3520

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

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

    
3541
    avcodec_get_context_defaults3(st->codec, codec);
3542

    
3543
    ost->bitstream_filters = audio_bitstream_filters;
3544
    audio_bitstream_filters= NULL;
3545

    
3546
    avcodec_thread_init(st->codec, thread_count);
3547

    
3548
    audio_enc = st->codec;
3549
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3550

    
3551
    if(audio_codec_tag)
3552
        audio_enc->codec_tag= audio_codec_tag;
3553

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

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

    
3585
    /* reset some key parameters */
3586
    audio_disable = 0;
3587
    av_freep(&audio_codec_name);
3588
    audio_stream_copy = 0;
3589
}
3590

    
3591
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3592
{
3593
    AVStream *st;
3594
    AVOutputStream *ost;
3595
    AVCodec *codec=NULL;
3596
    AVCodecContext *subtitle_enc;
3597
    enum CodecID codec_id = CODEC_ID_NONE;
3598

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

    
3619
    ost->bitstream_filters = subtitle_bitstream_filters;
3620
    subtitle_bitstream_filters= NULL;
3621

    
3622
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3623

    
3624
    if(subtitle_codec_tag)
3625
        subtitle_enc->codec_tag= subtitle_codec_tag;
3626

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

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

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

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

    
3658
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3659
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3660
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3661
    else av_assert0(0);
3662
    return 0;
3663
}
3664

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

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

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

    
3696
    if (!strcmp(filename, "-"))
3697
        filename = "pipe:";
3698

    
3699
    oc = avformat_alloc_context();
3700
    if (!oc) {
3701
        print_error(filename, AVERROR(ENOMEM));
3702
        ffmpeg_exit(1);
3703
    }
3704

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

    
3721
    oc->oformat = file_oformat;
3722
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3723

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

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

    
3751
        /* manual disable */
3752
        if (audio_disable)    use_audio    = 0;
3753
        if (video_disable)    use_video    = 0;
3754
        if (subtitle_disable) use_subtitle = 0;
3755

    
3756
        if (use_video)    new_video_stream(oc, nb_output_files);
3757
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3758
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3759

    
3760
        oc->timestamp = recording_timestamp;
3761

    
3762
        av_metadata_copy(&oc->metadata, metadata, 0);
3763
        av_metadata_free(&metadata);
3764
    }
3765

    
3766
    output_files[nb_output_files++] = oc;
3767

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

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

    
3798
        /* open the file */
3799
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3800
            print_error(filename, err);
3801
            ffmpeg_exit(1);
3802
        }
3803
    }
3804

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

    
3812
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3813
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3814
    oc->loop_output = loop_output;
3815
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3816

    
3817
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3818

    
3819
    av_freep(&forced_key_frames);
3820
}
3821

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

    
3834
static int64_t getutime(void)
3835
{
3836
#if HAVE_GETRUSAGE
3837
    struct rusage rusage;
3838

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

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

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

    
3887
static void opt_inter_matrix(const char *arg)
3888
{
3889
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3890
    parse_matrix_coeffs(inter_matrix, arg);
3891
}
3892

    
3893
static void opt_intra_matrix(const char *arg)
3894
{
3895
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3896
    parse_matrix_coeffs(intra_matrix, arg);
3897
}
3898

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

    
3906
static void show_help(void)
3907
{
3908
    AVCodec *c;
3909
    AVOutputFormat *oformat = NULL;
3910

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

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

    
3949
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3950
    printf("\n");
3951

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

    
3960
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3961
}
3962

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

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

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

    
4019
    if(!strcmp(arg, "vcd")) {
4020

    
4021
        opt_video_codec("mpeg1video");
4022
        opt_audio_codec("mp2");
4023
        opt_format("vcd");
4024

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

    
4029
        opt_default("b", "1150000");
4030
        opt_default("maxrate", "1150000");
4031
        opt_default("minrate", "1150000");
4032
        opt_default("bufsize", "327680"); // 40*1024*8;
4033

    
4034
        opt_default("ab", "224000");
4035
        audio_sample_rate = 44100;
4036
        audio_channels = 2;
4037

    
4038
        opt_default("packetsize", "2324");
4039
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4040

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

    
4049
        opt_video_codec("mpeg2video");
4050
        opt_audio_codec("mp2");
4051
        opt_format("svcd");
4052

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

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

    
4063

    
4064
        opt_default("ab", "224000");
4065
        audio_sample_rate = 44100;
4066

    
4067
        opt_default("packetsize", "2324");
4068

    
4069
    } else if(!strcmp(arg, "dvd")) {
4070

    
4071
        opt_video_codec("mpeg2video");
4072
        opt_audio_codec("ac3");
4073
        opt_format("dvd");
4074

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

    
4079
        opt_default("b", "6000000");
4080
        opt_default("maxrate", "9000000");
4081
        opt_default("minrate", "0"); //1500000;
4082
        opt_default("bufsize", "1835008"); //224*1024*8;
4083

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

    
4087
        opt_default("ab", "448000");
4088
        audio_sample_rate = 48000;
4089

    
4090
    } else if(!strncmp(arg, "dv", 2)) {
4091

    
4092
        opt_format("dv");
4093

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

    
4099
        audio_sample_rate = 48000;
4100
        audio_channels = 2;
4101

    
4102
    } else {
4103
        fprintf(stderr, "Unknown target: %s\n", arg);
4104
        ffmpeg_exit(1);
4105
    }
4106
}
4107

    
4108
static void opt_vstats_file (const char *arg)
4109
{
4110
    av_free (vstats_filename);
4111
    vstats_filename=av_strdup (arg);
4112
}
4113

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

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

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

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

    
4135
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4136
          *opt == 'a' ? &audio_bitstream_filters :
4137
                        &subtitle_bitstream_filters;
4138
    while(*bsfp)
4139
        bsfp= &(*bsfp)->next;
4140

    
4141
    *bsfp= bsfc;
4142

    
4143
    return 0;
4144
}
4145

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

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

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

    
4180
    fclose(f);
4181

    
4182
    return 0;
4183
}
4184

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

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

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

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

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

    
4301
    /* muxer options */
4302
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4303
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4304

    
4305
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4306
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4307
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4308

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

    
4314
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4315
    { NULL, },
4316
};
4317

    
4318
int main(int argc, char **argv)
4319
{
4320
    int64_t ti;
4321

    
4322
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4323

    
4324
    avcodec_register_all();
4325
#if CONFIG_AVDEVICE
4326
    avdevice_register_all();
4327
#endif
4328
#if CONFIG_AVFILTER
4329
    avfilter_register_all();
4330
#endif
4331
    av_register_all();
4332

    
4333
#if HAVE_ISATTY
4334
    if(isatty(STDIN_FILENO))
4335
        url_set_interrupt_cb(decode_interrupt_cb);
4336
#endif
4337

    
4338
    init_opts();
4339

    
4340
    show_banner();
4341

    
4342
    /* parse options */
4343
    parse_options(argc, argv, options, opt_output_file);
4344

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

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

    
4357
    if (nb_input_files == 0) {
4358
        fprintf(stderr, "At least one input file must be specified\n");
4359
        ffmpeg_exit(1);
4360
    }
4361

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

    
4372
    return ffmpeg_exit(0);
4373
}