Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 5e33e7bd

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 "libavutil/audioconvert.h"
40
#include "libavutil/parseutils.h"
41
#include "libavutil/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
static 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
static 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
        AVFormatContext *s = output_files[i];
509
        int j;
510
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
511
            avio_close(s->pb);
512
        avformat_free_context(s);
513
        av_free(output_streams_for_file[i]);
514
    }
515
    for(i=0;i<nb_input_files;i++) {
516
        av_close_input_file(input_files[i]);
517
        av_free(input_files_ts_scale[i]);
518
    }
519

    
520
    av_free(intra_matrix);
521
    av_free(inter_matrix);
522

    
523
    if (vstats_file)
524
        fclose(vstats_file);
525
    av_free(vstats_filename);
526

    
527
    av_free(streamid_map);
528
    av_free(input_codecs);
529
    av_free(output_codecs);
530
    av_free(stream_maps);
531
    av_free(meta_data_maps);
532

    
533
    av_free(video_codec_name);
534
    av_free(audio_codec_name);
535
    av_free(subtitle_codec_name);
536

    
537
    av_free(video_standard);
538

    
539
    uninit_opts();
540
    av_free(audio_buf);
541
    av_free(audio_out);
542
    allocated_audio_buf_size= allocated_audio_out_size= 0;
543
    av_free(samples);
544

    
545
#if CONFIG_AVFILTER
546
    avfilter_uninit();
547
#endif
548

    
549
    if (received_sigterm) {
550
        fprintf(stderr,
551
            "Received signal %d: terminating.\n",
552
            (int) received_sigterm);
553
        exit (255);
554
    }
555

    
556
    exit(ret); /* not all OS-es handle main() return value */
557
    return ret;
558
}
559

    
560
/* similar to ff_dynarray_add() and av_fast_realloc() */
561
static void *grow_array(void *array, int elem_size, int *size, int new_size)
562
{
563
    if (new_size >= INT_MAX / elem_size) {
564
        fprintf(stderr, "Array too big.\n");
565
        ffmpeg_exit(1);
566
    }
567
    if (*size < new_size) {
568
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
569
        if (!tmp) {
570
            fprintf(stderr, "Could not alloc buffer.\n");
571
            ffmpeg_exit(1);
572
        }
573
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
574
        *size = new_size;
575
        return tmp;
576
    }
577
    return array;
578
}
579

    
580
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
581
{
582
    if(codec && codec->sample_fmts){
583
        const enum AVSampleFormat *p= codec->sample_fmts;
584
        for(; *p!=-1; p++){
585
            if(*p == st->codec->sample_fmt)
586
                break;
587
        }
588
        if (*p == -1) {
589
            av_log(NULL, AV_LOG_WARNING,
590
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
591
                   av_get_sample_fmt_name(st->codec->sample_fmt),
592
                   codec->name,
593
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
594
            st->codec->sample_fmt = codec->sample_fmts[0];
595
        }
596
    }
597
}
598

    
599
static void choose_sample_rate(AVStream *st, AVCodec *codec)
600
{
601
    if(codec && codec->supported_samplerates){
602
        const int *p= codec->supported_samplerates;
603
        int best=0;
604
        int best_dist=INT_MAX;
605
        for(; *p; p++){
606
            int dist= abs(st->codec->sample_rate - *p);
607
            if(dist < best_dist){
608
                best_dist= dist;
609
                best= *p;
610
            }
611
        }
612
        if(best_dist){
613
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
614
        }
615
        st->codec->sample_rate= best;
616
    }
617
}
618

    
619
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
620
{
621
    if(codec && codec->pix_fmts){
622
        const enum PixelFormat *p= codec->pix_fmts;
623
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
624
            if(st->codec->codec_id==CODEC_ID_MJPEG){
625
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
626
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
627
                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};
628
            }
629
        }
630
        for(; *p!=-1; p++){
631
            if(*p == st->codec->pix_fmt)
632
                break;
633
        }
634
        if(*p == -1)
635
            st->codec->pix_fmt = codec->pix_fmts[0];
636
    }
637
}
638

    
639
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
640
{
641
    int idx = oc->nb_streams - 1;
642
    AVOutputStream *ost;
643

    
644
    output_streams_for_file[file_idx] =
645
        grow_array(output_streams_for_file[file_idx],
646
                   sizeof(*output_streams_for_file[file_idx]),
647
                   &nb_output_streams_for_file[file_idx],
648
                   oc->nb_streams);
649
    ost = output_streams_for_file[file_idx][idx] =
650
        av_mallocz(sizeof(AVOutputStream));
651
    if (!ost) {
652
        fprintf(stderr, "Could not alloc output stream\n");
653
        ffmpeg_exit(1);
654
    }
655
    ost->file_index = file_idx;
656
    ost->index = idx;
657
    return ost;
658
}
659

    
660
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
661
{
662
    int i, err;
663
    AVFormatContext *ic;
664
    int nopts = 0;
665

    
666
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
667
    if (err < 0)
668
        return err;
669
    /* copy stream format */
670
    s->nb_streams = 0;
671
    for(i=0;i<ic->nb_streams;i++) {
672
        AVStream *st;
673
        AVCodec *codec;
674

    
675
        s->nb_streams++;
676

    
677
        // FIXME: a more elegant solution is needed
678
        st = av_mallocz(sizeof(AVStream));
679
        memcpy(st, ic->streams[i], sizeof(AVStream));
680
        st->codec = avcodec_alloc_context();
681
        if (!st->codec) {
682
            print_error(filename, AVERROR(ENOMEM));
683
            ffmpeg_exit(1);
684
        }
685
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
686
        s->streams[i] = st;
687

    
688
        codec = avcodec_find_encoder(st->codec->codec_id);
689
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
690
            if (audio_stream_copy) {
691
                st->stream_copy = 1;
692
            } else
693
                choose_sample_fmt(st, codec);
694
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
695
            if (video_stream_copy) {
696
                st->stream_copy = 1;
697
            } else
698
                choose_pixel_fmt(st, codec);
699
        }
700

    
701
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
702
            nopts = 1;
703

    
704
        new_output_stream(s, nb_output_files);
705
    }
706

    
707
    if (!nopts)
708
        s->timestamp = av_gettime();
709

    
710
    av_close_input_file(ic);
711
    return 0;
712
}
713

    
714
static double
715
get_sync_ipts(const AVOutputStream *ost)
716
{
717
    const AVInputStream *ist = ost->sync_ist;
718
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
719
}
720

    
721
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
722
    int ret;
723

    
724
    while(bsfc){
725
        AVPacket new_pkt= *pkt;
726
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
727
                                          &new_pkt.data, &new_pkt.size,
728
                                          pkt->data, pkt->size,
729
                                          pkt->flags & AV_PKT_FLAG_KEY);
730
        if(a>0){
731
            av_free_packet(pkt);
732
            new_pkt.destruct= av_destruct_packet;
733
        } else if(a<0){
734
            fprintf(stderr, "%s failed for stream %d, codec %s",
735
                    bsfc->filter->name, pkt->stream_index,
736
                    avctx->codec ? avctx->codec->name : "copy");
737
            print_error("", a);
738
            if (exit_on_error)
739
                ffmpeg_exit(1);
740
        }
741
        *pkt= new_pkt;
742

    
743
        bsfc= bsfc->next;
744
    }
745

    
746
    ret= av_interleaved_write_frame(s, pkt);
747
    if(ret < 0){
748
        print_error("av_interleaved_write_frame()", ret);
749
        ffmpeg_exit(1);
750
    }
751
}
752

    
753
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
754

    
755
static void do_audio_out(AVFormatContext *s,
756
                         AVOutputStream *ost,
757
                         AVInputStream *ist,
758
                         unsigned char *buf, int size)
759
{
760
    uint8_t *buftmp;
761
    int64_t audio_out_size, audio_buf_size;
762
    int64_t allocated_for_size= size;
763

    
764
    int size_out, frame_bytes, ret, resample_changed;
765
    AVCodecContext *enc= ost->st->codec;
766
    AVCodecContext *dec= ist->st->codec;
767
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
768
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
769
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
770

    
771
need_realloc:
772
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
773
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
774
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
775
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
776
    audio_buf_size*= osize*enc->channels;
777

    
778
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
779
    if(coded_bps > 8*osize)
780
        audio_out_size= audio_out_size * coded_bps / (8*osize);
781
    audio_out_size += FF_MIN_BUFFER_SIZE;
782

    
783
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
784
        fprintf(stderr, "Buffer sizes too large\n");
785
        ffmpeg_exit(1);
786
    }
787

    
788
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
789
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
790
    if (!audio_buf || !audio_out){
791
        fprintf(stderr, "Out of memory in do_audio_out\n");
792
        ffmpeg_exit(1);
793
    }
794

    
795
    if (enc->channels != dec->channels)
796
        ost->audio_resample = 1;
797

    
798
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
799
                       ost->resample_channels    != dec->channels   ||
800
                       ost->resample_sample_rate != dec->sample_rate;
801

    
802
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
803
        if (resample_changed) {
804
            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",
805
                   ist->file_index, ist->index,
806
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
807
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
808
            ost->resample_sample_fmt  = dec->sample_fmt;
809
            ost->resample_channels    = dec->channels;
810
            ost->resample_sample_rate = dec->sample_rate;
811
            if (ost->resample)
812
                audio_resample_close(ost->resample);
813
        }
814
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
815
        if (audio_sync_method <= 1 &&
816
            ost->resample_sample_fmt  == enc->sample_fmt &&
817
            ost->resample_channels    == enc->channels   &&
818
            ost->resample_sample_rate == enc->sample_rate) {
819
            ost->resample = NULL;
820
            ost->audio_resample = 0;
821
        } else {
822
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
823
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
824
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
825
                                                   enc->sample_rate, dec->sample_rate,
826
                                                   enc->sample_fmt,  dec->sample_fmt,
827
                                                   16, 10, 0, 0.8);
828
            if (!ost->resample) {
829
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
830
                        dec->channels, dec->sample_rate,
831
                        enc->channels, enc->sample_rate);
832
                ffmpeg_exit(1);
833
            }
834
        }
835
    }
836

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

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

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

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

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

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

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

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

    
937
        frame_bytes = enc->frame_size * osize * enc->channels;
938

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

    
943
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
944

    
945
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
946

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

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

    
968
        ost->sync_opts += size_out / (osize * enc->channels);
969

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

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

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

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

    
1006
    dec = ist->st->codec;
1007

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

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

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

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

    
1033
    if (picture != picture2)
1034
        *picture = *picture2;
1035
    *bufp = buf;
1036
}
1037

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

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

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

    
1060
    enc = ost->st->codec;
1061

    
1062
    if (!subtitle_out) {
1063
        subtitle_out = av_malloc(subtitle_out_max_size);
1064
    }
1065

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

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

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

    
1104
static int bit_buffer_size= 1024*256;
1105
static uint8_t *bit_buffer= NULL;
1106

    
1107
static void do_video_out(AVFormatContext *s,
1108
                         AVOutputStream *ost,
1109
                         AVInputStream *ist,
1110
                         AVFrame *in_picture,
1111
                         int *frame_size)
1112
{
1113
    int nb_frames, i, ret;
1114
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1115
    AVCodecContext *enc, *dec;
1116
    double sync_ipts;
1117

    
1118
    enc = ost->st->codec;
1119
    dec = ist->st->codec;
1120

    
1121
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1122

    
1123
    /* by default, we output a single frame */
1124
    nb_frames = 1;
1125

    
1126
    *frame_size = 0;
1127

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

    
1153
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1154
    if (nb_frames <= 0)
1155
        return;
1156

    
1157
    formatted_picture = in_picture;
1158
    final_picture = formatted_picture;
1159
    padding_src = formatted_picture;
1160
    resampling_dst = &ost->pict_tmp;
1161

    
1162
    if (   ost->resample_height != ist->st->codec->height
1163
        || ost->resample_width  != ist->st->codec->width
1164
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1165

    
1166
        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));
1167
        if(!ost->video_resample)
1168
            ffmpeg_exit(1);
1169
    }
1170

    
1171
#if !CONFIG_AVFILTER
1172
    if (ost->video_resample) {
1173
        padding_src = NULL;
1174
        final_picture = &ost->pict_tmp;
1175
        if(  ost->resample_height != ist->st->codec->height
1176
          || ost->resample_width  != ist->st->codec->width
1177
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1178

    
1179
            /* initialize a new scaler context */
1180
            sws_freeContext(ost->img_resample_ctx);
1181
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1182
            ost->img_resample_ctx = sws_getContext(
1183
                ist->st->codec->width,
1184
                ist->st->codec->height,
1185
                ist->st->codec->pix_fmt,
1186
                ost->st->codec->width,
1187
                ost->st->codec->height,
1188
                ost->st->codec->pix_fmt,
1189
                sws_flags, NULL, NULL, NULL);
1190
            if (ost->img_resample_ctx == NULL) {
1191
                fprintf(stderr, "Cannot get resampling context\n");
1192
                ffmpeg_exit(1);
1193
            }
1194
        }
1195
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1196
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1197
    }
1198
#endif
1199

    
1200
    /* duplicates frame if needed */
1201
    for(i=0;i<nb_frames;i++) {
1202
        AVPacket pkt;
1203
        av_init_packet(&pkt);
1204
        pkt.stream_index= ost->index;
1205

    
1206
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1207
            /* raw pictures are written as AVPicture structure to
1208
               avoid any copies. We support temorarily the older
1209
               method. */
1210
            AVFrame* old_frame = enc->coded_frame;
1211
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1212
            pkt.data= (uint8_t *)final_picture;
1213
            pkt.size=  sizeof(AVPicture);
1214
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1215
            pkt.flags |= AV_PKT_FLAG_KEY;
1216

    
1217
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1218
            enc->coded_frame = old_frame;
1219
        } else {
1220
            AVFrame big_picture;
1221

    
1222
            big_picture= *final_picture;
1223
            /* better than nothing: use input picture interlaced
1224
               settings */
1225
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1226
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1227
                if(top_field_first == -1)
1228
                    big_picture.top_field_first = in_picture->top_field_first;
1229
                else
1230
                    big_picture.top_field_first = top_field_first;
1231
            }
1232

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

    
1255
            if(ret>0){
1256
                pkt.data= bit_buffer;
1257
                pkt.size= ret;
1258
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1259
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1260
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1261
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1262
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1263

    
1264
                if(enc->coded_frame->key_frame)
1265
                    pkt.flags |= AV_PKT_FLAG_KEY;
1266
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1267
                *frame_size = ret;
1268
                video_size += ret;
1269
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1270
                //        enc->frame_number-1, ret, enc->pict_type);
1271
                /* if two pass, output log */
1272
                if (ost->logfile && enc->stats_out) {
1273
                    fprintf(ost->logfile, "%s", enc->stats_out);
1274
                }
1275
            }
1276
        }
1277
        ost->sync_opts++;
1278
        ost->frame_number++;
1279
    }
1280
}
1281

    
1282
static double psnr(double d){
1283
    return -10.0*log(d)/log(10.0);
1284
}
1285

    
1286
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1287
                           int frame_size)
1288
{
1289
    AVCodecContext *enc;
1290
    int frame_number;
1291
    double ti1, bitrate, avg_bitrate;
1292

    
1293
    /* this is executed just the first time do_video_stats is called */
1294
    if (!vstats_file) {
1295
        vstats_file = fopen(vstats_filename, "w");
1296
        if (!vstats_file) {
1297
            perror("fopen");
1298
            ffmpeg_exit(1);
1299
        }
1300
    }
1301

    
1302
    enc = ost->st->codec;
1303
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1304
        frame_number = ost->frame_number;
1305
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1306
        if (enc->flags&CODEC_FLAG_PSNR)
1307
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1308

    
1309
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1310
        /* compute pts value */
1311
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1312
        if (ti1 < 0.01)
1313
            ti1 = 0.01;
1314

    
1315
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1316
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1317
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1318
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1319
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1320
    }
1321
}
1322

    
1323
static void print_report(AVFormatContext **output_files,
1324
                         AVOutputStream **ost_table, int nb_ostreams,
1325
                         int is_last_report)
1326
{
1327
    char buf[1024];
1328
    AVOutputStream *ost;
1329
    AVFormatContext *oc;
1330
    int64_t total_size;
1331
    AVCodecContext *enc;
1332
    int frame_number, vid, i;
1333
    double bitrate, ti1, pts;
1334
    static int64_t last_time = -1;
1335
    static int qp_histogram[52];
1336

    
1337
    if (!is_last_report) {
1338
        int64_t cur_time;
1339
        /* display the report every 0.5 seconds */
1340
        cur_time = av_gettime();
1341
        if (last_time == -1) {
1342
            last_time = cur_time;
1343
            return;
1344
        }
1345
        if ((cur_time - last_time) < 500000)
1346
            return;
1347
        last_time = cur_time;
1348
    }
1349

    
1350

    
1351
    oc = output_files[0];
1352

    
1353
    total_size = url_fsize(oc->pb);
1354
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1355
        total_size= url_ftell(oc->pb);
1356

    
1357
    buf[0] = '\0';
1358
    ti1 = 1e10;
1359
    vid = 0;
1360
    for(i=0;i<nb_ostreams;i++) {
1361
        ost = ost_table[i];
1362
        enc = ost->st->codec;
1363
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1364
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1365
                     !ost->st->stream_copy ?
1366
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1367
        }
1368
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1369
            float t = (av_gettime()-timer_start) / 1000000.0;
1370

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

    
1417
    if (verbose || is_last_report) {
1418
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1419

    
1420
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1421
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1422
            (double)total_size / 1024, ti1, bitrate);
1423

    
1424
        if (nb_frames_dup || nb_frames_drop)
1425
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1426
                  nb_frames_dup, nb_frames_drop);
1427

    
1428
        if (verbose >= 0)
1429
            fprintf(stderr, "%s    \r", buf);
1430

    
1431
        fflush(stderr);
1432
    }
1433

    
1434
    if (is_last_report && verbose >= 0){
1435
        int64_t raw= audio_size + video_size + extra_size;
1436
        fprintf(stderr, "\n");
1437
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1438
                video_size/1024.0,
1439
                audio_size/1024.0,
1440
                extra_size/1024.0,
1441
                100.0*(total_size - raw)/raw
1442
        );
1443
    }
1444
}
1445

    
1446
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1447
static int output_packet(AVInputStream *ist, int ist_index,
1448
                         AVOutputStream **ost_table, int nb_ostreams,
1449
                         const AVPacket *pkt)
1450
{
1451
    AVFormatContext *os;
1452
    AVOutputStream *ost;
1453
    int ret, i;
1454
    int got_picture;
1455
    AVFrame picture;
1456
    void *buffer_to_free;
1457
    static unsigned int samples_size= 0;
1458
    AVSubtitle subtitle, *subtitle_to_free;
1459
    int64_t pkt_pts = AV_NOPTS_VALUE;
1460
#if CONFIG_AVFILTER
1461
    int frame_available;
1462
#endif
1463

    
1464
    AVPacket avpkt;
1465
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1466

    
1467
    if(ist->next_pts == AV_NOPTS_VALUE)
1468
        ist->next_pts= ist->pts;
1469

    
1470
    if (pkt == NULL) {
1471
        /* EOF handling */
1472
        av_init_packet(&avpkt);
1473
        avpkt.data = NULL;
1474
        avpkt.size = 0;
1475
        goto handle_eof;
1476
    } else {
1477
        avpkt = *pkt;
1478
    }
1479

    
1480
    if(pkt->dts != AV_NOPTS_VALUE)
1481
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1482
    if(pkt->pts != AV_NOPTS_VALUE)
1483
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1484

    
1485
    //while we have more to decode or while the decoder did output something on EOF
1486
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1487
        uint8_t *data_buf, *decoded_data_buf;
1488
        int data_size, decoded_data_size;
1489
    handle_eof:
1490
        ist->pts= ist->next_pts;
1491

    
1492
        if(avpkt.size && avpkt.size != pkt->size &&
1493
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1494
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1495
            ist->showed_multi_packet_warning=1;
1496
        }
1497

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

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

    
1591
        buffer_to_free = NULL;
1592
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1593
            pre_process_video_frame(ist, (AVPicture *)&picture,
1594
                                    &buffer_to_free);
1595
        }
1596

    
1597
#if CONFIG_AVFILTER
1598
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1599
            AVRational sar;
1600
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1601
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1602
            // add it to be filtered
1603
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1604
                                     ist->pts,
1605
                                     sar);
1606
        }
1607
#endif
1608

    
1609
        // preprocess audio (volume)
1610
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1611
            if (audio_volume != 256) {
1612
                short *volp;
1613
                volp = samples;
1614
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1615
                    int v = ((*volp) * audio_volume + 128) >> 8;
1616
                    if (v < -32768) v = -32768;
1617
                    if (v >  32767) v = 32767;
1618
                    *volp++ = v;
1619
                }
1620
            }
1621
        }
1622

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

    
1648
                ost = ost_table[i];
1649
                if (ost->source_index == ist_index) {
1650
                    os = output_files[ost->file_index];
1651

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

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

    
1682
                        av_init_packet(&opkt);
1683

    
1684
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1685
                            continue;
1686

    
1687
                        /* no reencoding needed : output the packet directly */
1688
                        /* force the input stream PTS */
1689

    
1690
                        avcodec_get_frame_defaults(&avframe);
1691
                        ost->st->codec->coded_frame= &avframe;
1692
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1693

    
1694
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1695
                            audio_size += data_size;
1696
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1697
                            video_size += data_size;
1698
                            ost->sync_opts++;
1699
                        }
1700

    
1701
                        opkt.stream_index= ost->index;
1702
                        if(pkt->pts != AV_NOPTS_VALUE)
1703
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1704
                        else
1705
                            opkt.pts= AV_NOPTS_VALUE;
1706

    
1707
                        if (pkt->dts == AV_NOPTS_VALUE)
1708
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1709
                        else
1710
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1711
                        opkt.dts -= ost_tb_start_time;
1712

    
1713
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1714
                        opkt.flags= pkt->flags;
1715

    
1716
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1717
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1718
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1719
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1720
                           ) {
1721
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1722
                                opkt.destruct= av_destruct_packet;
1723
                        } else {
1724
                            opkt.data = data_buf;
1725
                            opkt.size = data_size;
1726
                        }
1727

    
1728
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1729
                        ost->st->codec->frame_number++;
1730
                        ost->frame_number++;
1731
                        av_free_packet(&opkt);
1732
                    }
1733
                }
1734
            }
1735

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

    
1754
        for(i=0;i<nb_ostreams;i++) {
1755
            ost = ost_table[i];
1756
            if (ost->source_index == ist_index) {
1757
                AVCodecContext *enc= ost->st->codec;
1758
                os = output_files[ost->file_index];
1759

    
1760
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1761
                    continue;
1762
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1763
                    continue;
1764

    
1765
                if (ost->encoding_needed) {
1766
                    for(;;) {
1767
                        AVPacket pkt;
1768
                        int fifo_bytes;
1769
                        av_init_packet(&pkt);
1770
                        pkt.stream_index= ost->index;
1771

    
1772
                        switch(ost->st->codec->codec_type) {
1773
                        case AVMEDIA_TYPE_AUDIO:
1774
                            fifo_bytes = av_fifo_size(ost->fifo);
1775
                            ret = 0;
1776
                            /* encode any samples remaining in fifo */
1777
                            if (fifo_bytes > 0) {
1778
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1779
                                int fs_tmp = enc->frame_size;
1780

    
1781
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1782
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1783
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1784
                                } else { /* pad */
1785
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1786
                                    if (allocated_audio_buf_size < frame_bytes)
1787
                                        ffmpeg_exit(1);
1788
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1789
                                }
1790

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

    
1823
                        if(ret<=0)
1824
                            break;
1825
                        pkt.data= bit_buffer;
1826
                        pkt.size= ret;
1827
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1828
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1829
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1830
                    }
1831
                }
1832
            }
1833
        }
1834
    }
1835

    
1836
    return 0;
1837
 fail_decode:
1838
    return -1;
1839
}
1840

    
1841
static void print_sdp(AVFormatContext **avc, int n)
1842
{
1843
    char sdp[2048];
1844

    
1845
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1846
    printf("SDP:\n%s\n", sdp);
1847
    fflush(stdout);
1848
}
1849

    
1850
static int copy_chapters(int infile, int outfile)
1851
{
1852
    AVFormatContext *is = input_files[infile];
1853
    AVFormatContext *os = output_files[outfile];
1854
    int i;
1855

    
1856
    for (i = 0; i < is->nb_chapters; i++) {
1857
        AVChapter *in_ch = is->chapters[i], *out_ch;
1858
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1859
                                      AV_TIME_BASE_Q, in_ch->time_base);
1860
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1861
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1862

    
1863

    
1864
        if (in_ch->end < ts_off)
1865
            continue;
1866
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1867
            break;
1868

    
1869
        out_ch = av_mallocz(sizeof(AVChapter));
1870
        if (!out_ch)
1871
            return AVERROR(ENOMEM);
1872

    
1873
        out_ch->id        = in_ch->id;
1874
        out_ch->time_base = in_ch->time_base;
1875
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1876
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1877

    
1878
        if (metadata_chapters_autocopy)
1879
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1880

    
1881
        os->nb_chapters++;
1882
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1883
        if (!os->chapters)
1884
            return AVERROR(ENOMEM);
1885
        os->chapters[os->nb_chapters - 1] = out_ch;
1886
    }
1887
    return 0;
1888
}
1889

    
1890
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1891
                                    AVCodecContext *avctx)
1892
{
1893
    char *p;
1894
    int n = 1, i;
1895
    int64_t t;
1896

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

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

    
1934
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1935
    if (!file_table)
1936
        goto fail;
1937

    
1938
    /* input stream init */
1939
    j = 0;
1940
    for(i=0;i<nb_input_files;i++) {
1941
        is = input_files[i];
1942
        file_table[i].ist_index = j;
1943
        file_table[i].nb_streams = is->nb_streams;
1944
        j += is->nb_streams;
1945
    }
1946
    nb_istreams = j;
1947

    
1948
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1949
    if (!ist_table)
1950
        goto fail;
1951

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

    
1969
            if (rate_emu) {
1970
                ist->start = av_gettime();
1971
            }
1972
        }
1973
    }
1974

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

    
1993
    /* Sanity check the mapping args -- do the input files & streams exist? */
1994
    for(i=0;i<nb_stream_maps;i++) {
1995
        int fi = stream_maps[i].file_index;
1996
        int si = stream_maps[i].stream_index;
1997

    
1998
        if (fi < 0 || fi > nb_input_files - 1 ||
1999
            si < 0 || si > file_table[fi].nb_streams - 1) {
2000
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2001
            ret = AVERROR(EINVAL);
2002
            goto fail;
2003
        }
2004
        fi = stream_maps[i].sync_file_index;
2005
        si = stream_maps[i].sync_stream_index;
2006
        if (fi < 0 || fi > nb_input_files - 1 ||
2007
            si < 0 || si > file_table[fi].nb_streams - 1) {
2008
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2009
            ret = AVERROR(EINVAL);
2010
            goto fail;
2011
        }
2012
    }
2013

    
2014
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2015
    if (!ost_table)
2016
        goto fail;
2017
    n = 0;
2018
    for(k=0;k<nb_output_files;k++) {
2019
        os = output_files[k];
2020
        for(i=0;i<os->nb_streams;i++,n++) {
2021
            int found;
2022
            ost = ost_table[n] = output_streams_for_file[k][i];
2023
            ost->st = os->streams[i];
2024
            if (nb_stream_maps > 0) {
2025
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2026
                    stream_maps[n].stream_index;
2027

    
2028
                /* Sanity check that the stream types match */
2029
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2030
                    int i= ost->file_index;
2031
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2032
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2033
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2034
                        ost->file_index, ost->index);
2035
                    ffmpeg_exit(1);
2036
                }
2037

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

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

    
2097
    /* for each output stream, we compute the right encoding parameters */
2098
    for(i=0;i<nb_ostreams;i++) {
2099
        ost = ost_table[i];
2100
        os = output_files[ost->file_index];
2101
        ist = ist_table[ost->source_index];
2102

    
2103
        codec = ost->st->codec;
2104
        icodec = ist->st->codec;
2105

    
2106
        if (metadata_streams_autocopy)
2107
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2108
                             AV_METADATA_DONT_OVERWRITE);
2109

    
2110
        ost->st->disposition = ist->st->disposition;
2111
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2112
        codec->chroma_sample_location = icodec->chroma_sample_location;
2113

    
2114
        if (ost->st->stream_copy) {
2115
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2116

    
2117
            if (extra_size > INT_MAX)
2118
                goto fail;
2119

    
2120
            /* if stream_copy is selected, no need to decode or encode */
2121
            codec->codec_id = icodec->codec_id;
2122
            codec->codec_type = icodec->codec_type;
2123

    
2124
            if(!codec->codec_tag){
2125
                if(   !os->oformat->codec_tag
2126
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2127
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2128
                    codec->codec_tag = icodec->codec_tag;
2129
            }
2130

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

    
2220
                    ost->original_height = icodec->height;
2221
                    ost->original_width  = icodec->width;
2222
#endif
2223
                    codec->bits_per_raw_sample= 0;
2224
                }
2225
                ost->resample_height = icodec->height;
2226
                ost->resample_width  = icodec->width;
2227
                ost->resample_pix_fmt= icodec->pix_fmt;
2228
                ost->encoding_needed = 1;
2229
                ist->decoding_needed = 1;
2230

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

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

    
2279
    if (!bit_buffer)
2280
        bit_buffer = av_malloc(bit_buffer_size);
2281
    if (!bit_buffer) {
2282
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2283
                bit_buffer_size);
2284
        ret = AVERROR(ENOMEM);
2285
        goto fail;
2286
    }
2287

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

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

    
2345
    /* init pts */
2346
    for(i=0;i<nb_istreams;i++) {
2347
        AVStream *st;
2348
        ist = ist_table[i];
2349
        st= ist->st;
2350
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2351
        ist->next_pts = AV_NOPTS_VALUE;
2352
        init_pts_correction(&ist->pts_ctx);
2353
        ist->is_start = 1;
2354
    }
2355

    
2356
    /* set meta data information from input file if required */
2357
    for (i=0;i<nb_meta_data_maps;i++) {
2358
        AVFormatContext *files[2];
2359
        AVMetadata      **meta[2];
2360
        int j;
2361

    
2362
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2363
        if ((index) < 0 || (index) >= (nb_elems)) {\
2364
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2365
                     (desc), (index));\
2366
            ret = AVERROR(EINVAL);\
2367
            goto dump_format;\
2368
        }
2369

    
2370
        int out_file_index = meta_data_maps[i][0].file;
2371
        int in_file_index = meta_data_maps[i][1].file;
2372
        if (in_file_index < 0 || out_file_index < 0)
2373
            continue;
2374
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2375
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2376

    
2377
        files[0] = output_files[out_file_index];
2378
        files[1] = input_files[in_file_index];
2379

    
2380
        for (j = 0; j < 2; j++) {
2381
            AVMetaDataMap *map = &meta_data_maps[i][j];
2382

    
2383
            switch (map->type) {
2384
            case 'g':
2385
                meta[j] = &files[j]->metadata;
2386
                break;
2387
            case 's':
2388
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2389
                meta[j] = &files[j]->streams[map->index]->metadata;
2390
                break;
2391
            case 'c':
2392
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2393
                meta[j] = &files[j]->chapters[map->index]->metadata;
2394
                break;
2395
            case 'p':
2396
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2397
                meta[j] = &files[j]->programs[map->index]->metadata;
2398
                break;
2399
            }
2400
        }
2401

    
2402
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2403
    }
2404

    
2405
    /* copy global metadata by default */
2406
    if (metadata_global_autocopy) {
2407

    
2408
        for (i = 0; i < nb_output_files; i++)
2409
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2410
                             AV_METADATA_DONT_OVERWRITE);
2411
    }
2412

    
2413
    /* copy chapters according to chapter maps */
2414
    for (i = 0; i < nb_chapter_maps; i++) {
2415
        int infile  = chapter_maps[i].in_file;
2416
        int outfile = chapter_maps[i].out_file;
2417

    
2418
        if (infile < 0 || outfile < 0)
2419
            continue;
2420
        if (infile >= nb_input_files) {
2421
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2422
            ret = AVERROR(EINVAL);
2423
            goto dump_format;
2424
        }
2425
        if (outfile >= nb_output_files) {
2426
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2427
            ret = AVERROR(EINVAL);
2428
            goto dump_format;
2429
        }
2430
        copy_chapters(infile, outfile);
2431
    }
2432

    
2433
    /* copy chapters from the first input file that has them*/
2434
    if (!nb_chapter_maps)
2435
        for (i = 0; i < nb_input_files; i++) {
2436
            if (!input_files[i]->nb_chapters)
2437
                continue;
2438

    
2439
            for (j = 0; j < nb_output_files; j++)
2440
                if ((ret = copy_chapters(i, j)) < 0)
2441
                    goto dump_format;
2442
            break;
2443
        }
2444

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

    
2458
 dump_format:
2459
    /* dump the file output parameters - cannot be done before in case
2460
       of stream copy */
2461
    for(i=0;i<nb_output_files;i++) {
2462
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2463
    }
2464

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

    
2483
    if (ret) {
2484
        fprintf(stderr, "%s\n", error);
2485
        goto fail;
2486
    }
2487

    
2488
    if (want_sdp) {
2489
        print_sdp(output_files, nb_output_files);
2490
    }
2491

    
2492
    if (!using_stdin && verbose >= 0) {
2493
        fprintf(stderr, "Press [q] to stop encoding\n");
2494
        url_set_interrupt_cb(decode_interrupt_cb);
2495
    }
2496
    term_init();
2497

    
2498
    timer_start = av_gettime();
2499

    
2500
    for(; received_sigterm == 0;) {
2501
        int file_index, ist_index;
2502
        AVPacket pkt;
2503
        double ipts_min;
2504
        double opts_min;
2505

    
2506
    redo:
2507
        ipts_min= 1e100;
2508
        opts_min= 1e100;
2509
        /* if 'q' pressed, exits */
2510
        if (!using_stdin) {
2511
            if (q_pressed)
2512
                break;
2513
            /* read_key() returns 0 on EOF */
2514
            key = read_key();
2515
            if (key == 'q')
2516
                break;
2517
        }
2518

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

    
2557
        /* finish if limit size exhausted */
2558
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2559
            break;
2560

    
2561
        /* read a frame from it and output it in the fifo */
2562
        is = input_files[file_index];
2563
        ret= av_read_frame(is, &pkt);
2564
        if(ret == AVERROR(EAGAIN)){
2565
            no_packet[file_index]=1;
2566
            no_packet_count++;
2567
            continue;
2568
        }
2569
        if (ret < 0) {
2570
            file_table[file_index].eof_reached = 1;
2571
            if (opt_shortest)
2572
                break;
2573
            else
2574
                continue;
2575
        }
2576

    
2577
        no_packet_count=0;
2578
        memset(no_packet, 0, sizeof(no_packet));
2579

    
2580
        if (do_pkt_dump) {
2581
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2582
                             is->streams[pkt.stream_index]);
2583
        }
2584
        /* the following test is needed in case new streams appear
2585
           dynamically in stream : we ignore them */
2586
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2587
            goto discard_packet;
2588
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2589
        ist = ist_table[ist_index];
2590
        if (ist->discard)
2591
            goto discard_packet;
2592

    
2593
        if (pkt.dts != AV_NOPTS_VALUE)
2594
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2595
        if (pkt.pts != AV_NOPTS_VALUE)
2596
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2597

    
2598
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2599
            && input_files_ts_scale[file_index][pkt.stream_index]){
2600
            if(pkt.pts != AV_NOPTS_VALUE)
2601
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2602
            if(pkt.dts != AV_NOPTS_VALUE)
2603
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2604
        }
2605

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

    
2621
        /* finish if recording time exhausted */
2622
        if (recording_time != INT64_MAX &&
2623
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2624
            ist->is_past_recording_time = 1;
2625
            goto discard_packet;
2626
        }
2627

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

    
2631
            if (verbose >= 0)
2632
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2633
                        ist->file_index, ist->index);
2634
            if (exit_on_error)
2635
                ffmpeg_exit(1);
2636
            av_free_packet(&pkt);
2637
            goto redo;
2638
        }
2639

    
2640
    discard_packet:
2641
        av_free_packet(&pkt);
2642

    
2643
        /* dump report by using the output first video and audio streams */
2644
        print_report(output_files, ost_table, nb_ostreams, 0);
2645
    }
2646

    
2647
    /* at the end of stream, we must flush the decoder buffers */
2648
    for(i=0;i<nb_istreams;i++) {
2649
        ist = ist_table[i];
2650
        if (ist->decoding_needed) {
2651
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2652
        }
2653
    }
2654

    
2655
    term_exit();
2656

    
2657
    /* write the trailer if needed and close file */
2658
    for(i=0;i<nb_output_files;i++) {
2659
        os = output_files[i];
2660
        av_write_trailer(os);
2661
    }
2662

    
2663
    /* dump report by using the first video and audio streams */
2664
    print_report(output_files, ost_table, nb_ostreams, 1);
2665

    
2666
    /* close each encoder */
2667
    for(i=0;i<nb_ostreams;i++) {
2668
        ost = ost_table[i];
2669
        if (ost->encoding_needed) {
2670
            av_freep(&ost->st->codec->stats_in);
2671
            avcodec_close(ost->st->codec);
2672
        }
2673
    }
2674

    
2675
    /* close each decoder */
2676
    for(i=0;i<nb_istreams;i++) {
2677
        ist = ist_table[i];
2678
        if (ist->decoding_needed) {
2679
            avcodec_close(ist->st->codec);
2680
        }
2681
    }
2682
#if CONFIG_AVFILTER
2683
    avfilter_graph_free(&graph);
2684
#endif
2685

    
2686
    /* finished ! */
2687
    ret = 0;
2688

    
2689
 fail:
2690
    av_freep(&bit_buffer);
2691
    av_free(file_table);
2692

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

    
2729
static void opt_format(const char *arg)
2730
{
2731
    last_asked_format = arg;
2732
}
2733

    
2734
static void opt_video_rc_override_string(const char *arg)
2735
{
2736
    video_rc_override_string = arg;
2737
}
2738

    
2739
static int opt_me_threshold(const char *opt, const char *arg)
2740
{
2741
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2742
    return 0;
2743
}
2744

    
2745
static int opt_verbose(const char *opt, const char *arg)
2746
{
2747
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2748
    return 0;
2749
}
2750

    
2751
static int opt_frame_rate(const char *opt, const char *arg)
2752
{
2753
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2754
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2755
        ffmpeg_exit(1);
2756
    }
2757
    return 0;
2758
}
2759

    
2760
static int opt_bitrate(const char *opt, const char *arg)
2761
{
2762
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2763

    
2764
    opt_default(opt, arg);
2765

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

    
2769
    return 0;
2770
}
2771

    
2772
static int opt_frame_crop(const char *opt, const char *arg)
2773
{
2774
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2775
    return AVERROR(EINVAL);
2776
}
2777

    
2778
static void opt_frame_size(const char *arg)
2779
{
2780
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2781
        fprintf(stderr, "Incorrect frame size\n");
2782
        ffmpeg_exit(1);
2783
    }
2784
}
2785

    
2786
static int opt_pad(const char *opt, const char *arg) {
2787
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2788
    return -1;
2789
}
2790

    
2791
static void opt_frame_pix_fmt(const char *arg)
2792
{
2793
    if (strcmp(arg, "list")) {
2794
        frame_pix_fmt = av_get_pix_fmt(arg);
2795
        if (frame_pix_fmt == PIX_FMT_NONE) {
2796
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2797
            ffmpeg_exit(1);
2798
        }
2799
    } else {
2800
        show_pix_fmts();
2801
        ffmpeg_exit(0);
2802
    }
2803
}
2804

    
2805
static void opt_frame_aspect_ratio(const char *arg)
2806
{
2807
    int x = 0, y = 0;
2808
    double ar = 0;
2809
    const char *p;
2810
    char *end;
2811

    
2812
    p = strchr(arg, ':');
2813
    if (p) {
2814
        x = strtol(arg, &end, 10);
2815
        if (end == p)
2816
            y = strtol(end+1, &end, 10);
2817
        if (x > 0 && y > 0)
2818
            ar = (double)x / (double)y;
2819
    } else
2820
        ar = strtod(arg, NULL);
2821

    
2822
    if (!ar) {
2823
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2824
        ffmpeg_exit(1);
2825
    }
2826
    frame_aspect_ratio = ar;
2827
}
2828

    
2829
static int opt_metadata(const char *opt, const char *arg)
2830
{
2831
    char *mid= strchr(arg, '=');
2832

    
2833
    if(!mid){
2834
        fprintf(stderr, "Missing =\n");
2835
        ffmpeg_exit(1);
2836
    }
2837
    *mid++= 0;
2838

    
2839
    av_metadata_set2(&metadata, arg, mid, 0);
2840

    
2841
    return 0;
2842
}
2843

    
2844
static void opt_qscale(const char *arg)
2845
{
2846
    video_qscale = atof(arg);
2847
    if (video_qscale <= 0 ||
2848
        video_qscale > 255) {
2849
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2850
        ffmpeg_exit(1);
2851
    }
2852
}
2853

    
2854
static void opt_top_field_first(const char *arg)
2855
{
2856
    top_field_first= atoi(arg);
2857
}
2858

    
2859
static int opt_thread_count(const char *opt, const char *arg)
2860
{
2861
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2862
#if !HAVE_THREADS
2863
    if (verbose >= 0)
2864
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2865
#endif
2866
    return 0;
2867
}
2868

    
2869
static void opt_audio_sample_fmt(const char *arg)
2870
{
2871
    if (strcmp(arg, "list")) {
2872
        audio_sample_fmt = av_get_sample_fmt(arg);
2873
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2874
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2875
            ffmpeg_exit(1);
2876
        }
2877
    } else {
2878
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2879
        ffmpeg_exit(0);
2880
    }
2881
}
2882

    
2883
static int opt_audio_rate(const char *opt, const char *arg)
2884
{
2885
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2886
    return 0;
2887
}
2888

    
2889
static int opt_audio_channels(const char *opt, const char *arg)
2890
{
2891
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2892
    return 0;
2893
}
2894

    
2895
static void opt_video_channel(const char *arg)
2896
{
2897
    video_channel = strtol(arg, NULL, 0);
2898
}
2899

    
2900
static void opt_video_standard(const char *arg)
2901
{
2902
    video_standard = av_strdup(arg);
2903
}
2904

    
2905
static void opt_codec(int *pstream_copy, char **pcodec_name,
2906
                      int codec_type, const char *arg)
2907
{
2908
    av_freep(pcodec_name);
2909
    if (!strcmp(arg, "copy")) {
2910
        *pstream_copy = 1;
2911
    } else {
2912
        *pcodec_name = av_strdup(arg);
2913
    }
2914
}
2915

    
2916
static void opt_audio_codec(const char *arg)
2917
{
2918
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2919
}
2920

    
2921
static void opt_video_codec(const char *arg)
2922
{
2923
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2924
}
2925

    
2926
static void opt_subtitle_codec(const char *arg)
2927
{
2928
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2929
}
2930

    
2931
static int opt_codec_tag(const char *opt, const char *arg)
2932
{
2933
    char *tail;
2934
    uint32_t *codec_tag;
2935

    
2936
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2937
                !strcmp(opt, "vtag") ? &video_codec_tag :
2938
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2939
    if (!codec_tag)
2940
        return -1;
2941

    
2942
    *codec_tag = strtol(arg, &tail, 0);
2943
    if (!tail || *tail)
2944
        *codec_tag = AV_RL32(arg);
2945

    
2946
    return 0;
2947
}
2948

    
2949
static void opt_map(const char *arg)
2950
{
2951
    AVStreamMap *m;
2952
    char *p;
2953

    
2954
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2955
    m = &stream_maps[nb_stream_maps-1];
2956

    
2957
    m->file_index = strtol(arg, &p, 0);
2958
    if (*p)
2959
        p++;
2960

    
2961
    m->stream_index = strtol(p, &p, 0);
2962
    if (*p) {
2963
        p++;
2964
        m->sync_file_index = strtol(p, &p, 0);
2965
        if (*p)
2966
            p++;
2967
        m->sync_stream_index = strtol(p, &p, 0);
2968
    } else {
2969
        m->sync_file_index = m->file_index;
2970
        m->sync_stream_index = m->stream_index;
2971
    }
2972
}
2973

    
2974
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2975
{
2976
    *endptr = arg;
2977
    if (*arg == ',') {
2978
        *type = *(++arg);
2979
        switch (*arg) {
2980
        case 'g':
2981
            break;
2982
        case 's':
2983
        case 'c':
2984
        case 'p':
2985
            *index = strtol(++arg, endptr, 0);
2986
            break;
2987
        default:
2988
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2989
            ffmpeg_exit(1);
2990
        }
2991
    } else
2992
        *type = 'g';
2993
}
2994

    
2995
static void opt_map_metadata(const char *arg)
2996
{
2997
    AVMetaDataMap *m, *m1;
2998
    char *p;
2999

    
3000
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3001
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3002

    
3003
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3004
    m->file = strtol(arg, &p, 0);
3005
    parse_meta_type(p, &m->type, &m->index, &p);
3006
    if (*p)
3007
        p++;
3008

    
3009
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3010
    m1->file = strtol(p, &p, 0);
3011
    parse_meta_type(p, &m1->type, &m1->index, &p);
3012

    
3013
    if (m->type == 'g' || m1->type == 'g')
3014
        metadata_global_autocopy = 0;
3015
    if (m->type == 's' || m1->type == 's')
3016
        metadata_streams_autocopy = 0;
3017
    if (m->type == 'c' || m1->type == 'c')
3018
        metadata_chapters_autocopy = 0;
3019
}
3020

    
3021
static void opt_map_meta_data(const char *arg)
3022
{
3023
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3024
                    "Use -map_metadata instead.\n");
3025
    opt_map_metadata(arg);
3026
}
3027

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

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

    
3040
    c->in_file = strtol(p, &p, 0);
3041
}
3042

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

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

    
3054
    if(stream >= MAX_STREAMS)
3055
        ffmpeg_exit(1);
3056

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

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

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

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

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

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

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

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

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

    
3135
    if (!strcmp(filename, "-"))
3136
        filename = "pipe:";
3137

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

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

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

    
3161
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3162

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

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

    
3204
    ic->loop_input = loop_input;
3205

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

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

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

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

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

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

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

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

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

    
3315
    nb_input_files++;
3316

    
3317
    video_channel = 0;
3318

    
3319
    av_freep(&video_codec_name);
3320
    av_freep(&audio_codec_name);
3321
    av_freep(&subtitle_codec_name);
3322
}
3323

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

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

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

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

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

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

    
3393
    st->codec->thread_count= thread_count;
3394

    
3395
    video_enc = st->codec;
3396

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

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

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

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

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

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

    
3434
        choose_pixel_fmt(st, codec);
3435

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

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

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

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

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

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

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

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

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

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

    
3535
    avcodec_get_context_defaults3(st->codec, codec);
3536

    
3537
    ost->bitstream_filters = audio_bitstream_filters;
3538
    audio_bitstream_filters= NULL;
3539

    
3540
    st->codec->thread_count= thread_count;
3541

    
3542
    audio_enc = st->codec;
3543
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3544

    
3545
    if(audio_codec_tag)
3546
        audio_enc->codec_tag= audio_codec_tag;
3547

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

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

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

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

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

    
3613
    ost->bitstream_filters = subtitle_bitstream_filters;
3614
    subtitle_bitstream_filters= NULL;
3615

    
3616
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3617

    
3618
    if(subtitle_codec_tag)
3619
        subtitle_enc->codec_tag= subtitle_codec_tag;
3620

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

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

    
3637
    subtitle_disable = 0;
3638
    av_freep(&subtitle_codec_name);
3639
    subtitle_stream_copy = 0;
3640
}
3641

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

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

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

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

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

    
3690
    if (!strcmp(filename, "-"))
3691
        filename = "pipe:";
3692

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

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

    
3715
    oc->oformat = file_oformat;
3716
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3717

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

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

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

    
3750
        if (use_video)    new_video_stream(oc, nb_output_files);
3751
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3752
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3753

    
3754
        oc->timestamp = recording_timestamp;
3755

    
3756
        av_metadata_copy(&oc->metadata, metadata, 0);
3757
        av_metadata_free(&metadata);
3758
    }
3759

    
3760
    output_files[nb_output_files++] = oc;
3761

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

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

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

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

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

    
3811
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3812

    
3813
    av_freep(&forced_key_frames);
3814
}
3815

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

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

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

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

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

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

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

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

    
3900
static void show_help(void)
3901
{
3902
    AVCodec *c;
3903
    AVOutputFormat *oformat = NULL;
3904

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

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

    
3943
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3944
    printf("\n");
3945

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

    
3954
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3955
}
3956

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

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

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

    
4013
    if(!strcmp(arg, "vcd")) {
4014

    
4015
        opt_video_codec("mpeg1video");
4016
        opt_audio_codec("mp2");
4017
        opt_format("vcd");
4018

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

    
4023
        opt_default("b", "1150000");
4024
        opt_default("maxrate", "1150000");
4025
        opt_default("minrate", "1150000");
4026
        opt_default("bufsize", "327680"); // 40*1024*8;
4027

    
4028
        opt_default("ab", "224000");
4029
        audio_sample_rate = 44100;
4030
        audio_channels = 2;
4031

    
4032
        opt_default("packetsize", "2324");
4033
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4034

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

    
4043
        opt_video_codec("mpeg2video");
4044
        opt_audio_codec("mp2");
4045
        opt_format("svcd");
4046

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

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

    
4057

    
4058
        opt_default("ab", "224000");
4059
        audio_sample_rate = 44100;
4060

    
4061
        opt_default("packetsize", "2324");
4062

    
4063
    } else if(!strcmp(arg, "dvd")) {
4064

    
4065
        opt_video_codec("mpeg2video");
4066
        opt_audio_codec("ac3");
4067
        opt_format("dvd");
4068

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

    
4073
        opt_default("b", "6000000");
4074
        opt_default("maxrate", "9000000");
4075
        opt_default("minrate", "0"); //1500000;
4076
        opt_default("bufsize", "1835008"); //224*1024*8;
4077

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

    
4081
        opt_default("ab", "448000");
4082
        audio_sample_rate = 48000;
4083

    
4084
    } else if(!strncmp(arg, "dv", 2)) {
4085

    
4086
        opt_format("dv");
4087

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

    
4093
        audio_sample_rate = 48000;
4094
        audio_channels = 2;
4095

    
4096
    } else {
4097
        fprintf(stderr, "Unknown target: %s\n", arg);
4098
        ffmpeg_exit(1);
4099
    }
4100
}
4101

    
4102
static void opt_vstats_file (const char *arg)
4103
{
4104
    av_free (vstats_filename);
4105
    vstats_filename=av_strdup (arg);
4106
}
4107

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

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

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

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

    
4129
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4130
          *opt == 'a' ? &audio_bitstream_filters :
4131
                        &subtitle_bitstream_filters;
4132
    while(*bsfp)
4133
        bsfp= &(*bsfp)->next;
4134

    
4135
    *bsfp= bsfc;
4136

    
4137
    return 0;
4138
}
4139

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

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

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

    
4174
    fclose(f);
4175

    
4176
    return 0;
4177
}
4178

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

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

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

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

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

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

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

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

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

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

    
4319
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4320

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

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

    
4335
    init_opts();
4336

    
4337
    show_banner();
4338

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

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

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

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

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

    
4369
    return ffmpeg_exit(0);
4370
}