Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 043d2ff2

History | View | Annotate | Download (160 KB)

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

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

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

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

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

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

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

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

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

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

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

    
111
static const OptionDef options[];
112

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

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

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

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

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

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

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

    
149
static int frame_width  = 0;
150
static int frame_height = 0;
151
static float frame_aspect_ratio = 0;
152
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153
static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155
static AVRational frame_rate;
156
static float video_qscale = 0;
157
static uint16_t *intra_matrix = NULL;
158
static uint16_t *inter_matrix = NULL;
159
static const char *video_rc_override_string=NULL;
160
static int video_disable = 0;
161
static int video_discard = 0;
162
static char *video_codec_name = NULL;
163
static unsigned int video_codec_tag = 0;
164
static char *video_language = NULL;
165
static int same_quality = 0;
166
static int do_deinterlace = 0;
167
static int top_field_first = -1;
168
static int me_threshold = 0;
169
static int intra_dc_precision = 8;
170
static int loop_input = 0;
171
static int loop_output = AVFMT_NOOUTPUTLOOP;
172
static int qp_hist = 0;
173
#if CONFIG_AVFILTER
174
static char *vfilters = NULL;
175
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
    int is_start;            /* is 1 at the start and after a discontinuity */
324
    int showed_multi_packet_warning;
325
    int is_past_recording_time;
326
#if CONFIG_AVFILTER
327
    AVFilterContext *output_video_filter;
328
    AVFilterContext *input_video_filter;
329
    AVFrame *filter_frame;
330
    int has_filter_frame;
331
    AVFilterBufferRef *picref;
332
#endif
333
} AVInputStream;
334

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

    
342
#if HAVE_TERMIOS_H
343

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

    
348
#if CONFIG_AVFILTER
349

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

    
361
    graph = avfilter_graph_alloc();
362

    
363
    if (ist->st->sample_aspect_ratio.num){
364
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
365
    }else
366
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
367

    
368
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
369
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
370
             sample_aspect_ratio.num, sample_aspect_ratio.den);
371

    
372
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
373
                                       "src", args, NULL, graph);
374
    if (ret < 0)
375
        return ret;
376
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
377
                                       "out", NULL, &ffsink_ctx, graph);
378
    if (ret < 0)
379
        return ret;
380
    last_filter = ist->input_video_filter;
381

    
382
    if (codec->width  != icodec->width || codec->height != icodec->height) {
383
        snprintf(args, 255, "%d:%d:flags=0x%X",
384
                 codec->width,
385
                 codec->height,
386
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
387
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
388
                                                NULL, args, NULL, graph)) < 0)
389
            return ret;
390
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
391
            return ret;
392
        last_filter = filter;
393
    }
394

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

    
398
    if (vfilters) {
399
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
400
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
401

    
402
        outputs->name    = av_strdup("in");
403
        outputs->filter_ctx = last_filter;
404
        outputs->pad_idx = 0;
405
        outputs->next    = NULL;
406

    
407
        inputs->name    = av_strdup("out");
408
        inputs->filter_ctx = ist->output_video_filter;
409
        inputs->pad_idx = 0;
410
        inputs->next    = NULL;
411

    
412
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
413
            return ret;
414
        av_freep(&vfilters);
415
    } else {
416
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
417
            return ret;
418
    }
419

    
420
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
421
        return ret;
422

    
423
    codec->width  = ist->output_video_filter->inputs[0]->w;
424
    codec->height = ist->output_video_filter->inputs[0]->h;
425
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
426
        ist->output_video_filter->inputs[0]->sample_aspect_ratio;
427

    
428
    return 0;
429
}
430
#endif /* CONFIG_AVFILTER */
431

    
432
static void term_exit(void)
433
{
434
    av_log(NULL, AV_LOG_QUIET, "");
435
#if HAVE_TERMIOS_H
436
    tcsetattr (0, TCSANOW, &oldtty);
437
#endif
438
}
439

    
440
static volatile int received_sigterm = 0;
441

    
442
static void
443
sigterm_handler(int sig)
444
{
445
    received_sigterm = sig;
446
    term_exit();
447
}
448

    
449
static void term_init(void)
450
{
451
#if HAVE_TERMIOS_H
452
    struct termios tty;
453

    
454
    tcgetattr (0, &tty);
455
    oldtty = tty;
456
    atexit(term_exit);
457

    
458
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
459
                          |INLCR|IGNCR|ICRNL|IXON);
460
    tty.c_oflag |= OPOST;
461
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
462
    tty.c_cflag &= ~(CSIZE|PARENB);
463
    tty.c_cflag |= CS8;
464
    tty.c_cc[VMIN] = 1;
465
    tty.c_cc[VTIME] = 0;
466

    
467
    tcsetattr (0, TCSANOW, &tty);
468
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
469
#endif
470

    
471
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
472
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
473
#ifdef SIGXCPU
474
    signal(SIGXCPU, sigterm_handler);
475
#endif
476
}
477

    
478
/* read a key without blocking */
479
static int read_key(void)
480
{
481
#if HAVE_TERMIOS_H
482
    int n = 1;
483
    unsigned char ch;
484
    struct timeval tv;
485
    fd_set rfds;
486

    
487
    FD_ZERO(&rfds);
488
    FD_SET(0, &rfds);
489
    tv.tv_sec = 0;
490
    tv.tv_usec = 0;
491
    n = select(1, &rfds, NULL, NULL, &tv);
492
    if (n > 0) {
493
        n = read(0, &ch, 1);
494
        if (n == 1)
495
            return ch;
496

    
497
        return n;
498
    }
499
#elif HAVE_CONIO_H
500
    if(kbhit())
501
        return(getch());
502
#endif
503
    return -1;
504
}
505

    
506
static int decode_interrupt_cb(void)
507
{
508
    return q_pressed || (q_pressed = read_key() == 'q');
509
}
510

    
511
static int ffmpeg_exit(int ret)
512
{
513
    int i;
514

    
515
    /* close files */
516
    for(i=0;i<nb_output_files;i++) {
517
        AVFormatContext *s = output_files[i];
518
        int j;
519
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
520
            url_fclose(s->pb);
521
        avformat_free_context(s);
522
        av_free(output_streams_for_file[i]);
523
    }
524
    for(i=0;i<nb_input_files;i++) {
525
        av_close_input_file(input_files[i]);
526
        av_free(input_files_ts_scale[i]);
527
    }
528

    
529
    av_free(intra_matrix);
530
    av_free(inter_matrix);
531

    
532
    if (vstats_file)
533
        fclose(vstats_file);
534
    av_free(vstats_filename);
535

    
536
    av_free(streamid_map);
537
    av_free(input_codecs);
538
    av_free(output_codecs);
539
    av_free(stream_maps);
540
    av_free(meta_data_maps);
541

    
542
    av_free(video_codec_name);
543
    av_free(audio_codec_name);
544
    av_free(subtitle_codec_name);
545

    
546
    av_free(video_standard);
547

    
548
    uninit_opts();
549
    av_free(audio_buf);
550
    av_free(audio_out);
551
    allocated_audio_buf_size= allocated_audio_out_size= 0;
552
    av_free(samples);
553

    
554
#if CONFIG_AVFILTER
555
    avfilter_uninit();
556
#endif
557

    
558
    if (received_sigterm) {
559
        fprintf(stderr,
560
            "Received signal %d: terminating.\n",
561
            (int) received_sigterm);
562
        exit (255);
563
    }
564

    
565
    exit(ret); /* not all OS-es handle main() return value */
566
    return ret;
567
}
568

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

    
589
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
590
{
591
    if(codec && codec->sample_fmts){
592
        const enum AVSampleFormat *p= codec->sample_fmts;
593
        for(; *p!=-1; p++){
594
            if(*p == st->codec->sample_fmt)
595
                break;
596
        }
597
        if (*p == -1) {
598
            av_log(NULL, AV_LOG_WARNING,
599
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
600
                   av_get_sample_fmt_name(st->codec->sample_fmt),
601
                   codec->name,
602
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
603
            st->codec->sample_fmt = codec->sample_fmts[0];
604
        }
605
    }
606
}
607

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

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

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

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

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

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

    
684
        s->nb_streams++;
685

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

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

    
710
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
711
            nopts = 1;
712

    
713
        new_output_stream(s, nb_output_files);
714
    }
715

    
716
    if (!nopts)
717
        s->timestamp = av_gettime();
718

    
719
    av_close_input_file(ic);
720
    return 0;
721
}
722

    
723
static double
724
get_sync_ipts(const AVOutputStream *ost)
725
{
726
    const AVInputStream *ist = ost->sync_ist;
727
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
728
}
729

    
730
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
731
    int ret;
732

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

    
752
        bsfc= bsfc->next;
753
    }
754

    
755
    ret= av_interleaved_write_frame(s, pkt);
756
    if(ret < 0){
757
        print_error("av_interleaved_write_frame()", ret);
758
        ffmpeg_exit(1);
759
    }
760
}
761

    
762
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
763

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

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

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

    
787
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
788
    if(coded_bps > 8*osize)
789
        audio_out_size= audio_out_size * coded_bps / (8*osize);
790
    audio_out_size += FF_MIN_BUFFER_SIZE;
791

    
792
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
793
        fprintf(stderr, "Buffer sizes too large\n");
794
        ffmpeg_exit(1);
795
    }
796

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

    
804
    if (enc->channels != dec->channels)
805
        ost->audio_resample = 1;
806

    
807
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
808
                       ost->resample_channels    != dec->channels   ||
809
                       ost->resample_sample_rate != dec->sample_rate;
810

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

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

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

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

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

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

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

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

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

    
946
        frame_bytes = enc->frame_size * osize * enc->channels;
947

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

    
952
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
953

    
954
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
955

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

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

    
977
        ost->sync_opts += size_out / (osize * enc->channels);
978

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

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

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

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

    
1015
    dec = ist->st->codec;
1016

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

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

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

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

    
1042
    if (picture != picture2)
1043
        *picture = *picture2;
1044
    *bufp = buf;
1045
}
1046

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

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

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

    
1069
    enc = ost->st->codec;
1070

    
1071
    if (!subtitle_out) {
1072
        subtitle_out = av_malloc(subtitle_out_max_size);
1073
    }
1074

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

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

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

    
1113
static int bit_buffer_size= 1024*256;
1114
static uint8_t *bit_buffer= NULL;
1115

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

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

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

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

    
1135
    *frame_size = 0;
1136

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

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

    
1166
    formatted_picture = in_picture;
1167
    final_picture = formatted_picture;
1168
    padding_src = formatted_picture;
1169
    resampling_dst = &ost->pict_tmp;
1170

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1359

    
1360
    oc = output_files[0];
1361

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

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

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

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

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

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

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

    
1440
        fflush(stderr);
1441
    }
1442

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

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

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

    
1476
    if(ist->next_pts == AV_NOPTS_VALUE)
1477
        ist->next_pts= ist->pts;
1478

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1691
                        av_init_packet(&opkt);
1692

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

    
1696
                        /* no reencoding needed : output the packet directly */
1697
                        /* force the input stream PTS */
1698

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1845
    return 0;
1846
 fail_decode:
1847
    return -1;
1848
}
1849

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

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

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

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

    
1872

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

    
1878
        out_ch = av_mallocz(sizeof(AVChapter));
1879
        if (!out_ch)
1880
            return AVERROR(ENOMEM);
1881

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

    
1887
        if (metadata_chapters_autocopy)
1888
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1889

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2112
        codec = ost->st->codec;
2113
        icodec = ist->st->codec;
2114

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

    
2119
        ost->st->disposition = ist->st->disposition;
2120
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2121
        codec->chroma_sample_location = icodec->chroma_sample_location;
2122

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

    
2126
            if (extra_size > INT_MAX)
2127
                goto fail;
2128

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2506
    timer_start = av_gettime();
2507

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2647
    discard_packet:
2648
        av_free_packet(&pkt);
2649

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

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

    
2662
    term_exit();
2663

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

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

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

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

    
2693
    /* finished ! */
2694
    ret = 0;
2695

    
2696
 fail:
2697
    av_freep(&bit_buffer);
2698
    av_free(file_table);
2699

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

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

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

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

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

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

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

    
2771
    opt_default(opt, arg);
2772

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

    
2776
    return 0;
2777
}
2778

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

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

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

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

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

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

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

    
2835
    x = vfilters ? strlen(vfilters) : 0;
2836
    vfilters = av_realloc(vfilters, x+100);
2837
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2838
}
2839

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

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

    
2850
    av_metadata_set2(&metadata, arg, mid, 0);
2851

    
2852
    return 0;
2853
}
2854

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2957
    return 0;
2958
}
2959

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

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

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

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

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

    
3006
static void opt_map_metadata(const char *arg)
3007
{
3008
    AVMetaDataMap *m, *m1;
3009
    char *p;
3010

    
3011
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3012
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3013

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

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

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

    
3032
static void opt_map_meta_data(const char *arg)
3033
{
3034
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3035
                    "Use -map_metadata instead.\n");
3036
    opt_map_metadata(arg);
3037
}
3038

    
3039
static void opt_map_chapters(const char *arg)
3040
{
3041
    AVChapterMap *c;
3042
    char *p;
3043

    
3044
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3045
                              nb_chapter_maps + 1);
3046
    c = &chapter_maps[nb_chapter_maps - 1];
3047
    c->out_file = strtol(arg, &p, 0);
3048
    if (*p)
3049
        p++;
3050

    
3051
    c->in_file = strtol(p, &p, 0);
3052
}
3053

    
3054
static void opt_input_ts_scale(const char *arg)
3055
{
3056
    unsigned int stream;
3057
    double scale;
3058
    char *p;
3059

    
3060
    stream = strtol(arg, &p, 0);
3061
    if (*p)
3062
        p++;
3063
    scale= strtod(p, &p);
3064

    
3065
    if(stream >= MAX_STREAMS)
3066
        ffmpeg_exit(1);
3067

    
3068
    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);
3069
    input_files_ts_scale[nb_input_files][stream]= scale;
3070
}
3071

    
3072
static int opt_recording_time(const char *opt, const char *arg)
3073
{
3074
    recording_time = parse_time_or_die(opt, arg, 1);
3075
    return 0;
3076
}
3077

    
3078
static int opt_start_time(const char *opt, const char *arg)
3079
{
3080
    start_time = parse_time_or_die(opt, arg, 1);
3081
    return 0;
3082
}
3083

    
3084
static int opt_recording_timestamp(const char *opt, const char *arg)
3085
{
3086
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3087
    return 0;
3088
}
3089

    
3090
static int opt_input_ts_offset(const char *opt, const char *arg)
3091
{
3092
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3093
    return 0;
3094
}
3095

    
3096
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3097
{
3098
    const char *codec_string = encoder ? "encoder" : "decoder";
3099
    AVCodec *codec;
3100

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

    
3130
static void opt_input_file(const char *filename)
3131
{
3132
    AVFormatContext *ic;
3133
    AVFormatParameters params, *ap = &params;
3134
    AVInputFormat *file_iformat = NULL;
3135
    int err, i, ret, rfps, rfps_base;
3136
    int64_t timestamp;
3137

    
3138
    if (last_asked_format) {
3139
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3140
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3141
            ffmpeg_exit(1);
3142
        }
3143
        last_asked_format = NULL;
3144
    }
3145

    
3146
    if (!strcmp(filename, "-"))
3147
        filename = "pipe:";
3148

    
3149
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3150
                    !strcmp(filename, "/dev/stdin");
3151

    
3152
    /* get default parameters from command line */
3153
    ic = avformat_alloc_context();
3154
    if (!ic) {
3155
        print_error(filename, AVERROR(ENOMEM));
3156
        ffmpeg_exit(1);
3157
    }
3158

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

    
3172
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3173

    
3174
    ic->video_codec_id   =
3175
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3176
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3177
    ic->audio_codec_id   =
3178
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3179
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3180
    ic->subtitle_codec_id=
3181
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3182
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3183
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3184

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

    
3215
    ic->loop_input = loop_input;
3216

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

    
3226
    timestamp = start_time;
3227
    /* add the stream start time */
3228
    if (ic->start_time != AV_NOPTS_VALUE)
3229
        timestamp += ic->start_time;
3230

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

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

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

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

    
3294
                    (float)rfps / rfps_base, rfps, rfps_base);
3295
            }
3296
            /* update the current frame rate to match the stream frame rate */
3297
            frame_rate.num = rfps;
3298
            frame_rate.den = rfps_base;
3299

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

    
3320
    input_files[nb_input_files] = ic;
3321
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3322
    /* dump the file content */
3323
    if (verbose >= 0)
3324
        dump_format(ic, nb_input_files, filename, 0);
3325

    
3326
    nb_input_files++;
3327

    
3328
    video_channel = 0;
3329

    
3330
    av_freep(&video_codec_name);
3331
    av_freep(&audio_codec_name);
3332
    av_freep(&subtitle_codec_name);
3333
}
3334

    
3335
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3336
                                         int *has_subtitle_ptr)
3337
{
3338
    int has_video, has_audio, has_subtitle, i, j;
3339
    AVFormatContext *ic;
3340

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

    
3372
static void new_video_stream(AVFormatContext *oc, int file_idx)
3373
{
3374
    AVStream *st;
3375
    AVOutputStream *ost;
3376
    AVCodecContext *video_enc;
3377
    enum CodecID codec_id = CODEC_ID_NONE;
3378
    AVCodec *codec= NULL;
3379

    
3380
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3381
    if (!st) {
3382
        fprintf(stderr, "Could not alloc stream\n");
3383
        ffmpeg_exit(1);
3384
    }
3385
    ost = new_output_stream(oc, file_idx);
3386

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

    
3400
    avcodec_get_context_defaults3(st->codec, codec);
3401
    ost->bitstream_filters = video_bitstream_filters;
3402
    video_bitstream_filters= NULL;
3403

    
3404
    st->codec->thread_count= thread_count;
3405

    
3406
    video_enc = st->codec;
3407

    
3408
    if(video_codec_tag)
3409
        video_enc->codec_tag= video_codec_tag;
3410

    
3411
    if(   (video_global_header&1)
3412
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3413
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3414
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3415
    }
3416
    if(video_global_header&2){
3417
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3418
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3419
    }
3420

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

    
3431
        video_enc->codec_id = codec_id;
3432
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3433

    
3434
        if (codec && codec->supported_framerates && !force_fps)
3435
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3436
        video_enc->time_base.den = fps.num;
3437
        video_enc->time_base.num = fps.den;
3438

    
3439
        video_enc->width = frame_width;
3440
        video_enc->height = frame_height;
3441
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3442
        video_enc->pix_fmt = frame_pix_fmt;
3443
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3444

    
3445
        choose_pixel_fmt(st, codec);
3446

    
3447
        if (intra_only)
3448
            video_enc->gop_size = 0;
3449
        if (video_qscale || same_quality) {
3450
            video_enc->flags |= CODEC_FLAG_QSCALE;
3451
            video_enc->global_quality=
3452
                st->quality = FF_QP2LAMBDA * video_qscale;
3453
        }
3454

    
3455
        if(intra_matrix)
3456
            video_enc->intra_matrix = intra_matrix;
3457
        if(inter_matrix)
3458
            video_enc->inter_matrix = inter_matrix;
3459

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

    
3490
        if (do_psnr)
3491
            video_enc->flags|= CODEC_FLAG_PSNR;
3492

    
3493
        /* two pass mode */
3494
        if (do_pass) {
3495
            if (do_pass == 1) {
3496
                video_enc->flags |= CODEC_FLAG_PASS1;
3497
            } else {
3498
                video_enc->flags |= CODEC_FLAG_PASS2;
3499
            }
3500
        }
3501

    
3502
        if (forced_key_frames)
3503
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3504
    }
3505
    if (video_language) {
3506
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3507
        av_freep(&video_language);
3508
    }
3509

    
3510
    /* reset some key parameters */
3511
    video_disable = 0;
3512
    av_freep(&video_codec_name);
3513
    av_freep(&forced_key_frames);
3514
    video_stream_copy = 0;
3515
    frame_pix_fmt = PIX_FMT_NONE;
3516
}
3517

    
3518
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3519
{
3520
    AVStream *st;
3521
    AVOutputStream *ost;
3522
    AVCodec *codec= NULL;
3523
    AVCodecContext *audio_enc;
3524
    enum CodecID codec_id = CODEC_ID_NONE;
3525

    
3526
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3527
    if (!st) {
3528
        fprintf(stderr, "Could not alloc stream\n");
3529
        ffmpeg_exit(1);
3530
    }
3531
    ost = new_output_stream(oc, file_idx);
3532

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

    
3546
    avcodec_get_context_defaults3(st->codec, codec);
3547

    
3548
    ost->bitstream_filters = audio_bitstream_filters;
3549
    audio_bitstream_filters= NULL;
3550

    
3551
    st->codec->thread_count= thread_count;
3552

    
3553
    audio_enc = st->codec;
3554
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3555

    
3556
    if(audio_codec_tag)
3557
        audio_enc->codec_tag= audio_codec_tag;
3558

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

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

    
3590
    /* reset some key parameters */
3591
    audio_disable = 0;
3592
    av_freep(&audio_codec_name);
3593
    audio_stream_copy = 0;
3594
}
3595

    
3596
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3597
{
3598
    AVStream *st;
3599
    AVOutputStream *ost;
3600
    AVCodec *codec=NULL;
3601
    AVCodecContext *subtitle_enc;
3602
    enum CodecID codec_id = CODEC_ID_NONE;
3603

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

    
3624
    ost->bitstream_filters = subtitle_bitstream_filters;
3625
    subtitle_bitstream_filters= NULL;
3626

    
3627
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3628

    
3629
    if(subtitle_codec_tag)
3630
        subtitle_enc->codec_tag= subtitle_codec_tag;
3631

    
3632
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3633
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3634
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3635
    }
3636
    if (subtitle_stream_copy) {
3637
        st->stream_copy = 1;
3638
    } else {
3639
        subtitle_enc->codec_id = codec_id;
3640
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3641
    }
3642

    
3643
    if (subtitle_language) {
3644
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3645
        av_freep(&subtitle_language);
3646
    }
3647

    
3648
    subtitle_disable = 0;
3649
    av_freep(&subtitle_codec_name);
3650
    subtitle_stream_copy = 0;
3651
}
3652

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

    
3663
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3664
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3665
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3666
    else av_assert0(0);
3667
    return 0;
3668
}
3669

    
3670
/* arg format is "output-stream-index:streamid-value". */
3671
static int opt_streamid(const char *opt, const char *arg)
3672
{
3673
    int idx;
3674
    char *p;
3675
    char idx_str[16];
3676

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

    
3693
static void opt_output_file(const char *filename)
3694
{
3695
    AVFormatContext *oc;
3696
    int err, use_video, use_audio, use_subtitle;
3697
    int input_has_video, input_has_audio, input_has_subtitle;
3698
    AVFormatParameters params, *ap = &params;
3699
    AVOutputFormat *file_oformat;
3700

    
3701
    if (!strcmp(filename, "-"))
3702
        filename = "pipe:";
3703

    
3704
    oc = avformat_alloc_context();
3705
    if (!oc) {
3706
        print_error(filename, AVERROR(ENOMEM));
3707
        ffmpeg_exit(1);
3708
    }
3709

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

    
3726
    oc->oformat = file_oformat;
3727
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3728

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

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

    
3756
        /* manual disable */
3757
        if (audio_disable)    use_audio    = 0;
3758
        if (video_disable)    use_video    = 0;
3759
        if (subtitle_disable) use_subtitle = 0;
3760

    
3761
        if (use_video)    new_video_stream(oc, nb_output_files);
3762
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3763
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3764

    
3765
        oc->timestamp = recording_timestamp;
3766

    
3767
        av_metadata_copy(&oc->metadata, metadata, 0);
3768
        av_metadata_free(&metadata);
3769
    }
3770

    
3771
    output_files[nb_output_files++] = oc;
3772

    
3773
    /* check filename in case of an image number is expected */
3774
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3775
        if (!av_filename_number_test(oc->filename)) {
3776
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3777
            ffmpeg_exit(1);
3778
        }
3779
    }
3780

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

    
3803
        /* open the file */
3804
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3805
            print_error(filename, err);
3806
            ffmpeg_exit(1);
3807
        }
3808
    }
3809

    
3810
    memset(ap, 0, sizeof(*ap));
3811
    if (av_set_parameters(oc, ap) < 0) {
3812
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3813
                oc->filename);
3814
        ffmpeg_exit(1);
3815
    }
3816

    
3817
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3818
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3819
    oc->loop_output = loop_output;
3820
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3821

    
3822
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3823

    
3824
    av_freep(&forced_key_frames);
3825
}
3826

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

    
3839
static int64_t getutime(void)
3840
{
3841
#if HAVE_GETRUSAGE
3842
    struct rusage rusage;
3843

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

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

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

    
3892
static void opt_inter_matrix(const char *arg)
3893
{
3894
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3895
    parse_matrix_coeffs(inter_matrix, arg);
3896
}
3897

    
3898
static void opt_intra_matrix(const char *arg)
3899
{
3900
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3901
    parse_matrix_coeffs(intra_matrix, arg);
3902
}
3903

    
3904
static void show_usage(void)
3905
{
3906
    printf("Hyper fast Audio and Video encoder\n");
3907
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3908
    printf("\n");
3909
}
3910

    
3911
static void show_help(void)
3912
{
3913
    AVCodec *c;
3914
    AVOutputFormat *oformat = NULL;
3915

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

    
3945
    /* individual codec options */
3946
    c = NULL;
3947
    while ((c = av_codec_next(c))) {
3948
        if (c->priv_class) {
3949
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3950
            printf("\n");
3951
        }
3952
    }
3953

    
3954
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3955
    printf("\n");
3956

    
3957
    /* individual muxer options */
3958
    while ((oformat = av_oformat_next(oformat))) {
3959
        if (oformat->priv_class) {
3960
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3961
            printf("\n");
3962
        }
3963
    }
3964

    
3965
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3966
}
3967

    
3968
static void opt_target(const char *arg)
3969
{
3970
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3971
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3972

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

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

    
4024
    if(!strcmp(arg, "vcd")) {
4025

    
4026
        opt_video_codec("mpeg1video");
4027
        opt_audio_codec("mp2");
4028
        opt_format("vcd");
4029

    
4030
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4031
        opt_frame_rate(NULL, frame_rates[norm]);
4032
        opt_default("g", norm == PAL ? "15" : "18");
4033

    
4034
        opt_default("b", "1150000");
4035
        opt_default("maxrate", "1150000");
4036
        opt_default("minrate", "1150000");
4037
        opt_default("bufsize", "327680"); // 40*1024*8;
4038

    
4039
        opt_default("ab", "224000");
4040
        audio_sample_rate = 44100;
4041
        audio_channels = 2;
4042

    
4043
        opt_default("packetsize", "2324");
4044
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4045

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

    
4054
        opt_video_codec("mpeg2video");
4055
        opt_audio_codec("mp2");
4056
        opt_format("svcd");
4057

    
4058
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4059
        opt_frame_rate(NULL, frame_rates[norm]);
4060
        opt_default("g", norm == PAL ? "15" : "18");
4061

    
4062
        opt_default("b", "2040000");
4063
        opt_default("maxrate", "2516000");
4064
        opt_default("minrate", "0"); //1145000;
4065
        opt_default("bufsize", "1835008"); //224*1024*8;
4066
        opt_default("flags", "+scan_offset");
4067

    
4068

    
4069
        opt_default("ab", "224000");
4070
        audio_sample_rate = 44100;
4071

    
4072
        opt_default("packetsize", "2324");
4073

    
4074
    } else if(!strcmp(arg, "dvd")) {
4075

    
4076
        opt_video_codec("mpeg2video");
4077
        opt_audio_codec("ac3");
4078
        opt_format("dvd");
4079

    
4080
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4081
        opt_frame_rate(NULL, frame_rates[norm]);
4082
        opt_default("g", norm == PAL ? "15" : "18");
4083

    
4084
        opt_default("b", "6000000");
4085
        opt_default("maxrate", "9000000");
4086
        opt_default("minrate", "0"); //1500000;
4087
        opt_default("bufsize", "1835008"); //224*1024*8;
4088

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

    
4092
        opt_default("ab", "448000");
4093
        audio_sample_rate = 48000;
4094

    
4095
    } else if(!strncmp(arg, "dv", 2)) {
4096

    
4097
        opt_format("dv");
4098

    
4099
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4100
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4101
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4102
        opt_frame_rate(NULL, frame_rates[norm]);
4103

    
4104
        audio_sample_rate = 48000;
4105
        audio_channels = 2;
4106

    
4107
    } else {
4108
        fprintf(stderr, "Unknown target: %s\n", arg);
4109
        ffmpeg_exit(1);
4110
    }
4111
}
4112

    
4113
static void opt_vstats_file (const char *arg)
4114
{
4115
    av_free (vstats_filename);
4116
    vstats_filename=av_strdup (arg);
4117
}
4118

    
4119
static void opt_vstats (void)
4120
{
4121
    char filename[40];
4122
    time_t today2 = time(NULL);
4123
    struct tm *today = localtime(&today2);
4124

    
4125
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4126
             today->tm_sec);
4127
    opt_vstats_file(filename);
4128
}
4129

    
4130
static int opt_bsf(const char *opt, const char *arg)
4131
{
4132
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4133
    AVBitStreamFilterContext **bsfp;
4134

    
4135
    if(!bsfc){
4136
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4137
        ffmpeg_exit(1);
4138
    }
4139

    
4140
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4141
          *opt == 'a' ? &audio_bitstream_filters :
4142
                        &subtitle_bitstream_filters;
4143
    while(*bsfp)
4144
        bsfp= &(*bsfp)->next;
4145

    
4146
    *bsfp= bsfc;
4147

    
4148
    return 0;
4149
}
4150

    
4151
static int opt_preset(const char *opt, const char *arg)
4152
{
4153
    FILE *f=NULL;
4154
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4155
    char *codec_name = *opt == 'v' ? video_codec_name :
4156
                       *opt == 'a' ? audio_codec_name :
4157
                                     subtitle_codec_name;
4158

    
4159
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4160
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4161
        ffmpeg_exit(1);
4162
    }
4163

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

    
4185
    fclose(f);
4186

    
4187
    return 0;
4188
}
4189

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

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

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

    
4297
    /* subtitle options */
4298
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4299
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4300
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4301
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4302
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4303

    
4304
    /* grab options */
4305
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4306
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4307
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4308

    
4309
    /* muxer options */
4310
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4311
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4312

    
4313
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4314
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4315
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4316

    
4317
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4318
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4319
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4320
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4321

    
4322
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4323
    { NULL, },
4324
};
4325

    
4326
int main(int argc, char **argv)
4327
{
4328
    int64_t ti;
4329

    
4330
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4331

    
4332
    avcodec_register_all();
4333
#if CONFIG_AVDEVICE
4334
    avdevice_register_all();
4335
#endif
4336
#if CONFIG_AVFILTER
4337
    avfilter_register_all();
4338
#endif
4339
    av_register_all();
4340

    
4341
#if HAVE_ISATTY
4342
    if(isatty(STDIN_FILENO))
4343
        url_set_interrupt_cb(decode_interrupt_cb);
4344
#endif
4345

    
4346
    init_opts();
4347

    
4348
    show_banner();
4349

    
4350
    /* parse options */
4351
    parse_options(argc, argv, options, opt_output_file);
4352

    
4353
    if(nb_output_files <= 0 && nb_input_files == 0) {
4354
        show_usage();
4355
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4356
        ffmpeg_exit(1);
4357
    }
4358

    
4359
    /* file converter / grab */
4360
    if (nb_output_files <= 0) {
4361
        fprintf(stderr, "At least one output file must be specified\n");
4362
        ffmpeg_exit(1);
4363
    }
4364

    
4365
    if (nb_input_files == 0) {
4366
        fprintf(stderr, "At least one input file must be specified\n");
4367
        ffmpeg_exit(1);
4368
    }
4369

    
4370
    ti = getutime();
4371
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4372
                  stream_maps, nb_stream_maps) < 0)
4373
        ffmpeg_exit(1);
4374
    ti = getutime() - ti;
4375
    if (do_benchmark) {
4376
        int maxrss = getmaxrss() / 1024;
4377
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4378
    }
4379

    
4380
    return ffmpeg_exit(0);
4381
}