Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 5c20c81b

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

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

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

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

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

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

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

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

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

    
111
static const OptionDef options[];
112

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

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

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

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

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

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

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

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

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

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

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

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

    
223
static int rate_emu = 0;
224

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

    
228
static int audio_volume = 256;
229

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

    
245
static float dts_delta_threshold = 10;
246

    
247
static unsigned int sws_flags = SWS_BICUBIC;
248

    
249
static int64_t timer_start;
250

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

    
255
static short *samples;
256

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

    
261
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
262

    
263
struct AVInputStream;
264

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

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

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

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

    
306
#if CONFIG_AVFILTER
307
    AVFilterContext *output_video_filter;
308
    AVFilterContext *input_video_filter;
309
    AVFilterBufferRef *picref;
310
    char *avfilter;
311
    AVFilterGraph *graph;
312
#endif
313
} AVOutputStream;
314

    
315
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
316
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
317

    
318
typedef struct AVInputStream {
319
    int file_index;
320
    int index;
321
    AVStream *st;
322
    int discard;             /* true if stream data should be discarded */
323
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
324
    int64_t sample_index;      /* current sample */
325

    
326
    int64_t       start;     /* time when read started */
327
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
328
                                is not defined */
329
    int64_t       pts;       /* current pts */
330
    int is_start;            /* is 1 at the start and after a discontinuity */
331
    int showed_multi_packet_warning;
332
    int is_past_recording_time;
333
#if CONFIG_AVFILTER
334
    AVFrame *filter_frame;
335
    int has_filter_frame;
336
#endif
337
} AVInputStream;
338

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

    
346
#if HAVE_TERMIOS_H
347

    
348
/* init terminal so that we can grab keys */
349
static struct termios oldtty;
350
#endif
351

    
352
#if CONFIG_AVFILTER
353

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

    
365
    ost->graph = avfilter_graph_alloc();
366

    
367
    if (ist->st->sample_aspect_ratio.num){
368
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
369
    }else
370
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
371

    
372
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
373
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
374
             sample_aspect_ratio.num, sample_aspect_ratio.den);
375

    
376
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
377
                                       "src", args, NULL, ost->graph);
378
    if (ret < 0)
379
        return ret;
380
    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
381
                                       "out", NULL, &ffsink_ctx, ost->graph);
382
    if (ret < 0)
383
        return ret;
384
    last_filter = ost->input_video_filter;
385

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

    
399
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
400
    ost->graph->scale_sws_opts = av_strdup(args);
401

    
402
    if (ost->avfilter) {
403
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
404
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
405

    
406
        outputs->name    = av_strdup("in");
407
        outputs->filter_ctx = last_filter;
408
        outputs->pad_idx = 0;
409
        outputs->next    = NULL;
410

    
411
        inputs->name    = av_strdup("out");
412
        inputs->filter_ctx = ost->output_video_filter;
413
        inputs->pad_idx = 0;
414
        inputs->next    = NULL;
415

    
416
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
417
            return ret;
418
        av_freep(&ost->avfilter);
419
    } else {
420
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
421
            return ret;
422
    }
423

    
424
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
425
        return ret;
426

    
427
    codec->width  = ost->output_video_filter->inputs[0]->w;
428
    codec->height = ost->output_video_filter->inputs[0]->h;
429
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
430
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
431

    
432
    return 0;
433
}
434
#endif /* CONFIG_AVFILTER */
435

    
436
static void term_exit(void)
437
{
438
    av_log(NULL, AV_LOG_QUIET, "");
439
#if HAVE_TERMIOS_H
440
    tcsetattr (0, TCSANOW, &oldtty);
441
#endif
442
}
443

    
444
static volatile int received_sigterm = 0;
445

    
446
static void
447
sigterm_handler(int sig)
448
{
449
    received_sigterm = sig;
450
    term_exit();
451
}
452

    
453
static void term_init(void)
454
{
455
#if HAVE_TERMIOS_H
456
    struct termios tty;
457

    
458
    tcgetattr (0, &tty);
459
    oldtty = tty;
460
    atexit(term_exit);
461

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

    
471
    tcsetattr (0, TCSANOW, &tty);
472
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
473
#endif
474

    
475
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
476
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
477
#ifdef SIGXCPU
478
    signal(SIGXCPU, sigterm_handler);
479
#endif
480
}
481

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

    
491
    FD_ZERO(&rfds);
492
    FD_SET(0, &rfds);
493
    tv.tv_sec = 0;
494
    tv.tv_usec = 0;
495
    n = select(1, &rfds, NULL, NULL, &tv);
496
    if (n > 0) {
497
        n = read(0, &ch, 1);
498
        if (n == 1)
499
            return ch;
500

    
501
        return n;
502
    }
503
#elif HAVE_CONIO_H
504
    if(kbhit())
505
        return(getch());
506
#endif
507
    return -1;
508
}
509

    
510
static int decode_interrupt_cb(void)
511
{
512
    return q_pressed || (q_pressed = read_key() == 'q');
513
}
514

    
515
static int ffmpeg_exit(int ret)
516
{
517
    int i;
518

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

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

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

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

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

    
550
    av_free(video_standard);
551

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

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

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

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

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

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

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

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

    
652
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
653
{
654
    int idx = oc->nb_streams - 1;
655
    AVOutputStream *ost;
656

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

    
673
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
674
{
675
    int i, err;
676
    AVFormatContext *ic;
677
    int nopts = 0;
678

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

    
688
        s->nb_streams++;
689

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

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

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

    
717
        new_output_stream(s, nb_output_files);
718
    }
719

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

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

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

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

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

    
756
        bsfc= bsfc->next;
757
    }
758

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

    
766
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
767

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1139
    *frame_size = 0;
1140

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1363

    
1364
    oc = output_files[0];
1365

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

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

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

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

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

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

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

    
1444
        fflush(stderr);
1445
    }
1446

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

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

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

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

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

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

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

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

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

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

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

    
1610
#if CONFIG_AVFILTER
1611
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1612
            for(i=0;i<nb_ostreams;i++) {
1613
                ost = ost_table[i];
1614
                if (ost->input_video_filter && ost->source_index == ist_index) {
1615
                    AVRational sar;
1616
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1617
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1618
                    // add it to be filtered
1619
                    av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1620
                                             ist->pts,
1621
                                             sar);
1622
                }
1623
            }
1624
        }
1625
#endif
1626

    
1627
        // preprocess audio (volume)
1628
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1629
            if (audio_volume != 256) {
1630
                short *volp;
1631
                volp = samples;
1632
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1633
                    int v = ((*volp) * audio_volume + 128) >> 8;
1634
                    if (v < -32768) v = -32768;
1635
                    if (v >  32767) v = 32767;
1636
                    *volp++ = v;
1637
                }
1638
            }
1639
        }
1640

    
1641
        /* frame rate emulation */
1642
        if (rate_emu) {
1643
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1644
            int64_t now = av_gettime() - ist->start;
1645
            if (pts > now)
1646
                usleep(pts - now);
1647
        }
1648
        /* if output time reached then transcode raw format,
1649
           encode packets and output them */
1650
        if (start_time == 0 || ist->pts >= start_time)
1651
            for(i=0;i<nb_ostreams;i++) {
1652
                int frame_size;
1653

    
1654
                ost = ost_table[i];
1655
                if (ost->source_index == ist_index) {
1656
#if CONFIG_AVFILTER
1657
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1658
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1659
                while (frame_available) {
1660
                    AVRational ist_pts_tb;
1661
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1662
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1663
                    if (ost->picref)
1664
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1665
#endif
1666
                    os = output_files[ost->file_index];
1667

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

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

    
1698
                        av_init_packet(&opkt);
1699

    
1700
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1701
                            goto cont;
1702

    
1703
                        /* no reencoding needed : output the packet directly */
1704
                        /* force the input stream PTS */
1705

    
1706
                        avcodec_get_frame_defaults(&avframe);
1707
                        ost->st->codec->coded_frame= &avframe;
1708
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1709

    
1710
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1711
                            audio_size += data_size;
1712
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1713
                            video_size += data_size;
1714
                            ost->sync_opts++;
1715
                        }
1716

    
1717
                        opkt.stream_index= ost->index;
1718
                        if(pkt->pts != AV_NOPTS_VALUE)
1719
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1720
                        else
1721
                            opkt.pts= AV_NOPTS_VALUE;
1722

    
1723
                        if (pkt->dts == AV_NOPTS_VALUE)
1724
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1725
                        else
1726
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1727
                        opkt.dts -= ost_tb_start_time;
1728

    
1729
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1730
                        opkt.flags= pkt->flags;
1731

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

    
1744
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1745
                        ost->st->codec->frame_number++;
1746
                        ost->frame_number++;
1747
                        av_free_packet(&opkt);
1748
                    }
1749
                    cont:
1750
#if CONFIG_AVFILTER
1751
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1752
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1753
                    if(ost->picref)
1754
                        avfilter_unref_buffer(ost->picref);
1755
                }
1756
#endif
1757
                }
1758
            }
1759

    
1760
        av_free(buffer_to_free);
1761
        /* XXX: allocate the subtitles in the codec ? */
1762
        if (subtitle_to_free) {
1763
            avsubtitle_free(subtitle_to_free);
1764
            subtitle_to_free = NULL;
1765
        }
1766
    }
1767
 discard_packet:
1768
    if (pkt == NULL) {
1769
        /* EOF handling */
1770

    
1771
        for(i=0;i<nb_ostreams;i++) {
1772
            ost = ost_table[i];
1773
            if (ost->source_index == ist_index) {
1774
                AVCodecContext *enc= ost->st->codec;
1775
                os = output_files[ost->file_index];
1776

    
1777
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1778
                    continue;
1779
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1780
                    continue;
1781

    
1782
                if (ost->encoding_needed) {
1783
                    for(;;) {
1784
                        AVPacket pkt;
1785
                        int fifo_bytes;
1786
                        av_init_packet(&pkt);
1787
                        pkt.stream_index= ost->index;
1788

    
1789
                        switch(ost->st->codec->codec_type) {
1790
                        case AVMEDIA_TYPE_AUDIO:
1791
                            fifo_bytes = av_fifo_size(ost->fifo);
1792
                            ret = 0;
1793
                            /* encode any samples remaining in fifo */
1794
                            if (fifo_bytes > 0) {
1795
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1796
                                int fs_tmp = enc->frame_size;
1797

    
1798
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1799
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1800
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1801
                                } else { /* pad */
1802
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1803
                                    if (allocated_audio_buf_size < frame_bytes)
1804
                                        ffmpeg_exit(1);
1805
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1806
                                }
1807

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

    
1840
                        if(ret<=0)
1841
                            break;
1842
                        pkt.data= bit_buffer;
1843
                        pkt.size= ret;
1844
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1845
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1846
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1847
                    }
1848
                }
1849
            }
1850
        }
1851
    }
1852

    
1853
    return 0;
1854
 fail_decode:
1855
    return -1;
1856
}
1857

    
1858
static void print_sdp(AVFormatContext **avc, int n)
1859
{
1860
    char sdp[2048];
1861

    
1862
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1863
    printf("SDP:\n%s\n", sdp);
1864
    fflush(stdout);
1865
}
1866

    
1867
static int copy_chapters(int infile, int outfile)
1868
{
1869
    AVFormatContext *is = input_files[infile];
1870
    AVFormatContext *os = output_files[outfile];
1871
    int i;
1872

    
1873
    for (i = 0; i < is->nb_chapters; i++) {
1874
        AVChapter *in_ch = is->chapters[i], *out_ch;
1875
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1876
                                      AV_TIME_BASE_Q, in_ch->time_base);
1877
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1878
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1879

    
1880

    
1881
        if (in_ch->end < ts_off)
1882
            continue;
1883
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1884
            break;
1885

    
1886
        out_ch = av_mallocz(sizeof(AVChapter));
1887
        if (!out_ch)
1888
            return AVERROR(ENOMEM);
1889

    
1890
        out_ch->id        = in_ch->id;
1891
        out_ch->time_base = in_ch->time_base;
1892
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1893
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1894

    
1895
        if (metadata_chapters_autocopy)
1896
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1897

    
1898
        os->nb_chapters++;
1899
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1900
        if (!os->chapters)
1901
            return AVERROR(ENOMEM);
1902
        os->chapters[os->nb_chapters - 1] = out_ch;
1903
    }
1904
    return 0;
1905
}
1906

    
1907
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1908
                                    AVCodecContext *avctx)
1909
{
1910
    char *p;
1911
    int n = 1, i;
1912
    int64_t t;
1913

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2120
        codec = ost->st->codec;
2121
        icodec = ist->st->codec;
2122

    
2123
        if (metadata_streams_autocopy)
2124
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2125
                             AV_METADATA_DONT_OVERWRITE);
2126

    
2127
        ost->st->disposition = ist->st->disposition;
2128
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2129
        codec->chroma_sample_location = icodec->chroma_sample_location;
2130

    
2131
        if (ost->st->stream_copy) {
2132
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2133

    
2134
            if (extra_size > INT_MAX)
2135
                goto fail;
2136

    
2137
            /* if stream_copy is selected, no need to decode or encode */
2138
            codec->codec_id = icodec->codec_id;
2139
            codec->codec_type = icodec->codec_type;
2140

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

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

    
2237
                    ost->original_height = icodec->height;
2238
                    ost->original_width  = icodec->width;
2239
#endif
2240
                    codec->bits_per_raw_sample= 0;
2241
                }
2242
                ost->resample_height = icodec->height;
2243
                ost->resample_width  = icodec->width;
2244
                ost->resample_pix_fmt= icodec->pix_fmt;
2245
                ost->encoding_needed = 1;
2246
                ist->decoding_needed = 1;
2247

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

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

    
2296
    if (!bit_buffer)
2297
        bit_buffer = av_malloc(bit_buffer_size);
2298
    if (!bit_buffer) {
2299
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2300
                bit_buffer_size);
2301
        ret = AVERROR(ENOMEM);
2302
        goto fail;
2303
    }
2304

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

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

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

    
2372
    /* set meta data information from input file if required */
2373
    for (i=0;i<nb_meta_data_maps;i++) {
2374
        AVFormatContext *files[2];
2375
        AVMetadata      **meta[2];
2376
        int j;
2377

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

    
2386
        int out_file_index = meta_data_maps[i][0].file;
2387
        int in_file_index = meta_data_maps[i][1].file;
2388
        if (in_file_index < 0 || out_file_index < 0)
2389
            continue;
2390
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2391
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2392

    
2393
        files[0] = output_files[out_file_index];
2394
        files[1] = input_files[in_file_index];
2395

    
2396
        for (j = 0; j < 2; j++) {
2397
            AVMetaDataMap *map = &meta_data_maps[i][j];
2398

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

    
2418
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2419
    }
2420

    
2421
    /* copy global metadata by default */
2422
    if (metadata_global_autocopy) {
2423

    
2424
        for (i = 0; i < nb_output_files; i++)
2425
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2426
                             AV_METADATA_DONT_OVERWRITE);
2427
    }
2428

    
2429
    /* copy chapters according to chapter maps */
2430
    for (i = 0; i < nb_chapter_maps; i++) {
2431
        int infile  = chapter_maps[i].in_file;
2432
        int outfile = chapter_maps[i].out_file;
2433

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

    
2449
    /* copy chapters from the first input file that has them*/
2450
    if (!nb_chapter_maps)
2451
        for (i = 0; i < nb_input_files; i++) {
2452
            if (!input_files[i]->nb_chapters)
2453
                continue;
2454

    
2455
            for (j = 0; j < nb_output_files; j++)
2456
                if ((ret = copy_chapters(i, j)) < 0)
2457
                    goto dump_format;
2458
            break;
2459
        }
2460

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

    
2474
 dump_format:
2475
    /* dump the file output parameters - cannot be done before in case
2476
       of stream copy */
2477
    for(i=0;i<nb_output_files;i++) {
2478
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2479
    }
2480

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

    
2499
    if (ret) {
2500
        fprintf(stderr, "%s\n", error);
2501
        goto fail;
2502
    }
2503

    
2504
    if (want_sdp) {
2505
        print_sdp(output_files, nb_output_files);
2506
    }
2507

    
2508
    if (!using_stdin && verbose >= 0) {
2509
        fprintf(stderr, "Press [q] to stop encoding\n");
2510
        url_set_interrupt_cb(decode_interrupt_cb);
2511
    }
2512
    term_init();
2513

    
2514
    timer_start = av_gettime();
2515

    
2516
    for(; received_sigterm == 0;) {
2517
        int file_index, ist_index;
2518
        AVPacket pkt;
2519
        double ipts_min;
2520
        double opts_min;
2521

    
2522
    redo:
2523
        ipts_min= 1e100;
2524
        opts_min= 1e100;
2525
        /* if 'q' pressed, exits */
2526
        if (!using_stdin) {
2527
            if (q_pressed)
2528
                break;
2529
            /* read_key() returns 0 on EOF */
2530
            key = read_key();
2531
            if (key == 'q')
2532
                break;
2533
        }
2534

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

    
2573
        /* finish if limit size exhausted */
2574
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2575
            break;
2576

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

    
2593
        no_packet_count=0;
2594
        memset(no_packet, 0, sizeof(no_packet));
2595

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

    
2608
        if (pkt.dts != AV_NOPTS_VALUE)
2609
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2610
        if (pkt.pts != AV_NOPTS_VALUE)
2611
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2612

    
2613
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2614
            && input_files_ts_scale[file_index][pkt.stream_index]){
2615
            if(pkt.pts != AV_NOPTS_VALUE)
2616
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2617
            if(pkt.dts != AV_NOPTS_VALUE)
2618
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2619
        }
2620

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

    
2636
        /* finish if recording time exhausted */
2637
        if (recording_time != INT64_MAX &&
2638
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2639
            ist->is_past_recording_time = 1;
2640
            goto discard_packet;
2641
        }
2642

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

    
2646
            if (verbose >= 0)
2647
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2648
                        ist->file_index, ist->index);
2649
            if (exit_on_error)
2650
                ffmpeg_exit(1);
2651
            av_free_packet(&pkt);
2652
            goto redo;
2653
        }
2654

    
2655
    discard_packet:
2656
        av_free_packet(&pkt);
2657

    
2658
        /* dump report by using the output first video and audio streams */
2659
        print_report(output_files, ost_table, nb_ostreams, 0);
2660
    }
2661

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

    
2670
    term_exit();
2671

    
2672
    /* write the trailer if needed and close file */
2673
    for(i=0;i<nb_output_files;i++) {
2674
        os = output_files[i];
2675
        av_write_trailer(os);
2676
    }
2677

    
2678
    /* dump report by using the first video and audio streams */
2679
    print_report(output_files, ost_table, nb_ostreams, 1);
2680

    
2681
    /* close each encoder */
2682
    for(i=0;i<nb_ostreams;i++) {
2683
        ost = ost_table[i];
2684
        if (ost->encoding_needed) {
2685
            av_freep(&ost->st->codec->stats_in);
2686
            avcodec_close(ost->st->codec);
2687
        }
2688
#if CONFIG_AVFILTER
2689
        avfilter_graph_free(&ost->graph);
2690
#endif
2691
    }
2692

    
2693
    /* close each decoder */
2694
    for(i=0;i<nb_istreams;i++) {
2695
        ist = ist_table[i];
2696
        if (ist->decoding_needed) {
2697
            avcodec_close(ist->st->codec);
2698
        }
2699
    }
2700

    
2701
    /* finished ! */
2702
    ret = 0;
2703

    
2704
 fail:
2705
    av_freep(&bit_buffer);
2706
    av_free(file_table);
2707

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

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

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

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

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

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

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

    
2779
    opt_default(opt, arg);
2780

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

    
2784
    return 0;
2785
}
2786

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

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

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

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

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

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

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

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

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

    
2854
    av_metadata_set2(&metadata, arg, mid, 0);
2855

    
2856
    return 0;
2857
}
2858

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2961
    return 0;
2962
}
2963

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

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

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

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

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

    
3010
static void opt_map_metadata(const char *arg)
3011
{
3012
    AVMetaDataMap *m, *m1;
3013
    char *p;
3014

    
3015
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3016
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3017

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

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

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

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

    
3043
static void opt_map_chapters(const char *arg)
3044
{
3045
    AVChapterMap *c;
3046
    char *p;
3047

    
3048
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3049
                              nb_chapter_maps + 1);
3050
    c = &chapter_maps[nb_chapter_maps - 1];
3051
    c->out_file = strtol(arg, &p, 0);
3052
    if (*p)
3053
        p++;
3054

    
3055
    c->in_file = strtol(p, &p, 0);
3056
}
3057

    
3058
static void opt_input_ts_scale(const char *arg)
3059
{
3060
    unsigned int stream;
3061
    double scale;
3062
    char *p;
3063

    
3064
    stream = strtol(arg, &p, 0);
3065
    if (*p)
3066
        p++;
3067
    scale= strtod(p, &p);
3068

    
3069
    if(stream >= MAX_STREAMS)
3070
        ffmpeg_exit(1);
3071

    
3072
    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);
3073
    input_files_ts_scale[nb_input_files][stream]= scale;
3074
}
3075

    
3076
static int opt_recording_time(const char *opt, const char *arg)
3077
{
3078
    recording_time = parse_time_or_die(opt, arg, 1);
3079
    return 0;
3080
}
3081

    
3082
static int opt_start_time(const char *opt, const char *arg)
3083
{
3084
    start_time = parse_time_or_die(opt, arg, 1);
3085
    return 0;
3086
}
3087

    
3088
static int opt_recording_timestamp(const char *opt, const char *arg)
3089
{
3090
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3091
    return 0;
3092
}
3093

    
3094
static int opt_input_ts_offset(const char *opt, const char *arg)
3095
{
3096
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3097
    return 0;
3098
}
3099

    
3100
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3101
{
3102
    const char *codec_string = encoder ? "encoder" : "decoder";
3103
    AVCodec *codec;
3104

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

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

    
3142
    if (last_asked_format) {
3143
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3144
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3145
            ffmpeg_exit(1);
3146
        }
3147
        last_asked_format = NULL;
3148
    }
3149

    
3150
    if (!strcmp(filename, "-"))
3151
        filename = "pipe:";
3152

    
3153
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3154
                    !strcmp(filename, "/dev/stdin");
3155

    
3156
    /* get default parameters from command line */
3157
    ic = avformat_alloc_context();
3158
    if (!ic) {
3159
        print_error(filename, AVERROR(ENOMEM));
3160
        ffmpeg_exit(1);
3161
    }
3162

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

    
3176
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3177

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

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

    
3219
    ic->loop_input = loop_input;
3220

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

    
3230
    timestamp = start_time;
3231
    /* add the stream start time */
3232
    if (ic->start_time != AV_NOPTS_VALUE)
3233
        timestamp += ic->start_time;
3234

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

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

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

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

    
3298
                    (float)rfps / rfps_base, rfps, rfps_base);
3299
            }
3300
            /* update the current frame rate to match the stream frame rate */
3301
            frame_rate.num = rfps;
3302
            frame_rate.den = rfps_base;
3303

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

    
3324
    input_files[nb_input_files] = ic;
3325
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3326
    /* dump the file content */
3327
    if (verbose >= 0)
3328
        av_dump_format(ic, nb_input_files, filename, 0);
3329

    
3330
    nb_input_files++;
3331

    
3332
    video_channel = 0;
3333

    
3334
    av_freep(&video_codec_name);
3335
    av_freep(&audio_codec_name);
3336
    av_freep(&subtitle_codec_name);
3337
}
3338

    
3339
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3340
                                         int *has_subtitle_ptr)
3341
{
3342
    int has_video, has_audio, has_subtitle, i, j;
3343
    AVFormatContext *ic;
3344

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

    
3376
static void new_video_stream(AVFormatContext *oc, int file_idx)
3377
{
3378
    AVStream *st;
3379
    AVOutputStream *ost;
3380
    AVCodecContext *video_enc;
3381
    enum CodecID codec_id = CODEC_ID_NONE;
3382
    AVCodec *codec= NULL;
3383
    int i;
3384

    
3385
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3386
    if (!st) {
3387
        fprintf(stderr, "Could not alloc stream\n");
3388
        ffmpeg_exit(1);
3389
    }
3390
    ost = new_output_stream(oc, file_idx);
3391

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

    
3404
        if(frame_aspect_ratio > 0){
3405
            i = vfilters ? strlen(vfilters) : 0;
3406
            vfilters = av_realloc(vfilters, i+100);
3407
            snprintf(vfilters+i, i+100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3408
            frame_aspect_ratio=0;
3409
        }
3410

    
3411
        ost->avfilter= vfilters;
3412
        vfilters= NULL;
3413
    }
3414

    
3415
    avcodec_get_context_defaults3(st->codec, codec);
3416
    ost->bitstream_filters = video_bitstream_filters;
3417
    video_bitstream_filters= NULL;
3418

    
3419
    st->codec->thread_count= thread_count;
3420

    
3421
    video_enc = st->codec;
3422

    
3423
    if(video_codec_tag)
3424
        video_enc->codec_tag= video_codec_tag;
3425

    
3426
    if(   (video_global_header&1)
3427
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3428
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3429
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3430
    }
3431
    if(video_global_header&2){
3432
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3433
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3434
    }
3435

    
3436
    if (video_stream_copy) {
3437
        st->stream_copy = 1;
3438
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3439
        video_enc->sample_aspect_ratio =
3440
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3441
    } else {
3442
        const char *p;
3443
        int i;
3444
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3445

    
3446
        video_enc->codec_id = codec_id;
3447
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3448

    
3449
        if (codec && codec->supported_framerates && !force_fps)
3450
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3451
        video_enc->time_base.den = fps.num;
3452
        video_enc->time_base.num = fps.den;
3453

    
3454
        video_enc->width = frame_width;
3455
        video_enc->height = frame_height;
3456
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3457
        video_enc->pix_fmt = frame_pix_fmt;
3458
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3459

    
3460
        choose_pixel_fmt(st, codec);
3461

    
3462
        if (intra_only)
3463
            video_enc->gop_size = 0;
3464
        if (video_qscale || same_quality) {
3465
            video_enc->flags |= CODEC_FLAG_QSCALE;
3466
            video_enc->global_quality=
3467
                st->quality = FF_QP2LAMBDA * video_qscale;
3468
        }
3469

    
3470
        if(intra_matrix)
3471
            video_enc->intra_matrix = intra_matrix;
3472
        if(inter_matrix)
3473
            video_enc->inter_matrix = inter_matrix;
3474

    
3475
        p= video_rc_override_string;
3476
        for(i=0; p; i++){
3477
            int start, end, q;
3478
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3479
            if(e!=3){
3480
                fprintf(stderr, "error parsing rc_override\n");
3481
                ffmpeg_exit(1);
3482
            }
3483
            video_enc->rc_override=
3484
                av_realloc(video_enc->rc_override,
3485
                           sizeof(RcOverride)*(i+1));
3486
            video_enc->rc_override[i].start_frame= start;
3487
            video_enc->rc_override[i].end_frame  = end;
3488
            if(q>0){
3489
                video_enc->rc_override[i].qscale= q;
3490
                video_enc->rc_override[i].quality_factor= 1.0;
3491
            }
3492
            else{
3493
                video_enc->rc_override[i].qscale= 0;
3494
                video_enc->rc_override[i].quality_factor= -q/100.0;
3495
            }
3496
            p= strchr(p, '/');
3497
            if(p) p++;
3498
        }
3499
        video_enc->rc_override_count=i;
3500
        if (!video_enc->rc_initial_buffer_occupancy)
3501
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3502
        video_enc->me_threshold= me_threshold;
3503
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3504

    
3505
        if (do_psnr)
3506
            video_enc->flags|= CODEC_FLAG_PSNR;
3507

    
3508
        /* two pass mode */
3509
        if (do_pass) {
3510
            if (do_pass == 1) {
3511
                video_enc->flags |= CODEC_FLAG_PASS1;
3512
            } else {
3513
                video_enc->flags |= CODEC_FLAG_PASS2;
3514
            }
3515
        }
3516

    
3517
        if (forced_key_frames)
3518
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3519
    }
3520
    if (video_language) {
3521
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3522
        av_freep(&video_language);
3523
    }
3524

    
3525
    /* reset some key parameters */
3526
    video_disable = 0;
3527
    av_freep(&video_codec_name);
3528
    av_freep(&forced_key_frames);
3529
    video_stream_copy = 0;
3530
    frame_pix_fmt = PIX_FMT_NONE;
3531
}
3532

    
3533
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3534
{
3535
    AVStream *st;
3536
    AVOutputStream *ost;
3537
    AVCodec *codec= NULL;
3538
    AVCodecContext *audio_enc;
3539
    enum CodecID codec_id = CODEC_ID_NONE;
3540

    
3541
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3542
    if (!st) {
3543
        fprintf(stderr, "Could not alloc stream\n");
3544
        ffmpeg_exit(1);
3545
    }
3546
    ost = new_output_stream(oc, file_idx);
3547

    
3548
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3549
    if(!audio_stream_copy){
3550
        if (audio_codec_name) {
3551
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3552
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3553
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3554
            output_codecs[nb_output_codecs-1] = codec;
3555
        } else {
3556
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3557
            codec = avcodec_find_encoder(codec_id);
3558
        }
3559
    }
3560

    
3561
    avcodec_get_context_defaults3(st->codec, codec);
3562

    
3563
    ost->bitstream_filters = audio_bitstream_filters;
3564
    audio_bitstream_filters= NULL;
3565

    
3566
    st->codec->thread_count= thread_count;
3567

    
3568
    audio_enc = st->codec;
3569
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3570

    
3571
    if(audio_codec_tag)
3572
        audio_enc->codec_tag= audio_codec_tag;
3573

    
3574
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3575
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3576
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3577
    }
3578
    if (audio_stream_copy) {
3579
        st->stream_copy = 1;
3580
        audio_enc->channels = audio_channels;
3581
        audio_enc->sample_rate = audio_sample_rate;
3582
    } else {
3583
        audio_enc->codec_id = codec_id;
3584
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3585

    
3586
        if (audio_qscale > QSCALE_NONE) {
3587
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3588
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3589
        }
3590
        audio_enc->channels = audio_channels;
3591
        audio_enc->sample_fmt = audio_sample_fmt;
3592
        audio_enc->sample_rate = audio_sample_rate;
3593
        audio_enc->channel_layout = channel_layout;
3594
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3595
            audio_enc->channel_layout = 0;
3596
        choose_sample_fmt(st, codec);
3597
        choose_sample_rate(st, codec);
3598
    }
3599
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3600
    if (audio_language) {
3601
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3602
        av_freep(&audio_language);
3603
    }
3604

    
3605
    /* reset some key parameters */
3606
    audio_disable = 0;
3607
    av_freep(&audio_codec_name);
3608
    audio_stream_copy = 0;
3609
}
3610

    
3611
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3612
{
3613
    AVStream *st;
3614
    AVOutputStream *ost;
3615
    AVCodec *codec=NULL;
3616
    AVCodecContext *subtitle_enc;
3617
    enum CodecID codec_id = CODEC_ID_NONE;
3618

    
3619
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3620
    if (!st) {
3621
        fprintf(stderr, "Could not alloc stream\n");
3622
        ffmpeg_exit(1);
3623
    }
3624
    ost = new_output_stream(oc, file_idx);
3625
    subtitle_enc = st->codec;
3626
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3627
    if(!subtitle_stream_copy){
3628
        if (subtitle_codec_name) {
3629
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3630
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3631
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3632
        } else {
3633
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3634
            codec = avcodec_find_encoder(codec_id);
3635
        }
3636
    }
3637
    avcodec_get_context_defaults3(st->codec, codec);
3638

    
3639
    ost->bitstream_filters = subtitle_bitstream_filters;
3640
    subtitle_bitstream_filters= NULL;
3641

    
3642
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3643

    
3644
    if(subtitle_codec_tag)
3645
        subtitle_enc->codec_tag= subtitle_codec_tag;
3646

    
3647
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3648
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3649
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3650
    }
3651
    if (subtitle_stream_copy) {
3652
        st->stream_copy = 1;
3653
    } else {
3654
        subtitle_enc->codec_id = codec_id;
3655
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3656
    }
3657

    
3658
    if (subtitle_language) {
3659
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3660
        av_freep(&subtitle_language);
3661
    }
3662

    
3663
    subtitle_disable = 0;
3664
    av_freep(&subtitle_codec_name);
3665
    subtitle_stream_copy = 0;
3666
}
3667

    
3668
static int opt_new_stream(const char *opt, const char *arg)
3669
{
3670
    AVFormatContext *oc;
3671
    int file_idx = nb_output_files - 1;
3672
    if (nb_output_files <= 0) {
3673
        fprintf(stderr, "At least one output file must be specified\n");
3674
        ffmpeg_exit(1);
3675
    }
3676
    oc = output_files[file_idx];
3677

    
3678
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3679
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3680
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3681
    else av_assert0(0);
3682
    return 0;
3683
}
3684

    
3685
/* arg format is "output-stream-index:streamid-value". */
3686
static int opt_streamid(const char *opt, const char *arg)
3687
{
3688
    int idx;
3689
    char *p;
3690
    char idx_str[16];
3691

    
3692
    strncpy(idx_str, arg, sizeof(idx_str));
3693
    idx_str[sizeof(idx_str)-1] = '\0';
3694
    p = strchr(idx_str, ':');
3695
    if (!p) {
3696
        fprintf(stderr,
3697
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3698
                arg, opt);
3699
        ffmpeg_exit(1);
3700
    }
3701
    *p++ = '\0';
3702
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3703
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3704
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3705
    return 0;
3706
}
3707

    
3708
static void opt_output_file(const char *filename)
3709
{
3710
    AVFormatContext *oc;
3711
    int err, use_video, use_audio, use_subtitle;
3712
    int input_has_video, input_has_audio, input_has_subtitle;
3713
    AVFormatParameters params, *ap = &params;
3714
    AVOutputFormat *file_oformat;
3715

    
3716
    if (!strcmp(filename, "-"))
3717
        filename = "pipe:";
3718

    
3719
    oc = avformat_alloc_context();
3720
    if (!oc) {
3721
        print_error(filename, AVERROR(ENOMEM));
3722
        ffmpeg_exit(1);
3723
    }
3724

    
3725
    if (last_asked_format) {
3726
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3727
        if (!file_oformat) {
3728
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3729
            ffmpeg_exit(1);
3730
        }
3731
        last_asked_format = NULL;
3732
    } else {
3733
        file_oformat = av_guess_format(NULL, filename, NULL);
3734
        if (!file_oformat) {
3735
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3736
                    filename);
3737
            ffmpeg_exit(1);
3738
        }
3739
    }
3740

    
3741
    oc->oformat = file_oformat;
3742
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3743

    
3744
    if (!strcmp(file_oformat->name, "ffm") &&
3745
        av_strstart(filename, "http:", NULL)) {
3746
        /* special case for files sent to ffserver: we get the stream
3747
           parameters from ffserver */
3748
        int err = read_ffserver_streams(oc, filename);
3749
        if (err < 0) {
3750
            print_error(filename, err);
3751
            ffmpeg_exit(1);
3752
        }
3753
    } else {
3754
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3755
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3756
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3757

    
3758
        /* disable if no corresponding type found and at least one
3759
           input file */
3760
        if (nb_input_files > 0) {
3761
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3762
                                         &input_has_subtitle);
3763
            if (!input_has_video)
3764
                use_video = 0;
3765
            if (!input_has_audio)
3766
                use_audio = 0;
3767
            if (!input_has_subtitle)
3768
                use_subtitle = 0;
3769
        }
3770

    
3771
        /* manual disable */
3772
        if (audio_disable)    use_audio    = 0;
3773
        if (video_disable)    use_video    = 0;
3774
        if (subtitle_disable) use_subtitle = 0;
3775

    
3776
        if (use_video)    new_video_stream(oc, nb_output_files);
3777
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3778
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3779

    
3780
        oc->timestamp = recording_timestamp;
3781

    
3782
        av_metadata_copy(&oc->metadata, metadata, 0);
3783
        av_metadata_free(&metadata);
3784
    }
3785

    
3786
    output_files[nb_output_files++] = oc;
3787

    
3788
    /* check filename in case of an image number is expected */
3789
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3790
        if (!av_filename_number_test(oc->filename)) {
3791
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3792
            ffmpeg_exit(1);
3793
        }
3794
    }
3795

    
3796
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3797
        /* test if it already exists to avoid loosing precious files */
3798
        if (!file_overwrite &&
3799
            (strchr(filename, ':') == NULL ||
3800
             filename[1] == ':' ||
3801
             av_strstart(filename, "file:", NULL))) {
3802
            if (url_exist(filename)) {
3803
                if (!using_stdin) {
3804
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3805
                    fflush(stderr);
3806
                    if (!read_yesno()) {
3807
                        fprintf(stderr, "Not overwriting - exiting\n");
3808
                        ffmpeg_exit(1);
3809
                    }
3810
                }
3811
                else {
3812
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3813
                    ffmpeg_exit(1);
3814
                }
3815
            }
3816
        }
3817

    
3818
        /* open the file */
3819
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3820
            print_error(filename, err);
3821
            ffmpeg_exit(1);
3822
        }
3823
    }
3824

    
3825
    memset(ap, 0, sizeof(*ap));
3826
    if (av_set_parameters(oc, ap) < 0) {
3827
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3828
                oc->filename);
3829
        ffmpeg_exit(1);
3830
    }
3831

    
3832
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3833
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3834
    oc->loop_output = loop_output;
3835
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3836

    
3837
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3838

    
3839
    av_freep(&forced_key_frames);
3840
}
3841

    
3842
/* same option as mencoder */
3843
static void opt_pass(const char *pass_str)
3844
{
3845
    int pass;
3846
    pass = atoi(pass_str);
3847
    if (pass != 1 && pass != 2) {
3848
        fprintf(stderr, "pass number can be only 1 or 2\n");
3849
        ffmpeg_exit(1);
3850
    }
3851
    do_pass = pass;
3852
}
3853

    
3854
static int64_t getutime(void)
3855
{
3856
#if HAVE_GETRUSAGE
3857
    struct rusage rusage;
3858

    
3859
    getrusage(RUSAGE_SELF, &rusage);
3860
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3861
#elif HAVE_GETPROCESSTIMES
3862
    HANDLE proc;
3863
    FILETIME c, e, k, u;
3864
    proc = GetCurrentProcess();
3865
    GetProcessTimes(proc, &c, &e, &k, &u);
3866
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3867
#else
3868
    return av_gettime();
3869
#endif
3870
}
3871

    
3872
static int64_t getmaxrss(void)
3873
{
3874
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3875
    struct rusage rusage;
3876
    getrusage(RUSAGE_SELF, &rusage);
3877
    return (int64_t)rusage.ru_maxrss * 1024;
3878
#elif HAVE_GETPROCESSMEMORYINFO
3879
    HANDLE proc;
3880
    PROCESS_MEMORY_COUNTERS memcounters;
3881
    proc = GetCurrentProcess();
3882
    memcounters.cb = sizeof(memcounters);
3883
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3884
    return memcounters.PeakPagefileUsage;
3885
#else
3886
    return 0;
3887
#endif
3888
}
3889

    
3890
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3891
{
3892
    int i;
3893
    const char *p = str;
3894
    for(i = 0;; i++) {
3895
        dest[i] = atoi(p);
3896
        if(i == 63)
3897
            break;
3898
        p = strchr(p, ',');
3899
        if(!p) {
3900
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3901
            ffmpeg_exit(1);
3902
        }
3903
        p++;
3904
    }
3905
}
3906

    
3907
static void opt_inter_matrix(const char *arg)
3908
{
3909
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3910
    parse_matrix_coeffs(inter_matrix, arg);
3911
}
3912

    
3913
static void opt_intra_matrix(const char *arg)
3914
{
3915
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3916
    parse_matrix_coeffs(intra_matrix, arg);
3917
}
3918

    
3919
static void show_usage(void)
3920
{
3921
    printf("Hyper fast Audio and Video encoder\n");
3922
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3923
    printf("\n");
3924
}
3925

    
3926
static void show_help(void)
3927
{
3928
    AVCodec *c;
3929
    AVOutputFormat *oformat = NULL;
3930

    
3931
    av_log_set_callback(log_callback_help);
3932
    show_usage();
3933
    show_help_options(options, "Main options:\n",
3934
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3935
    show_help_options(options, "\nAdvanced options:\n",
3936
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3937
                      OPT_EXPERT);
3938
    show_help_options(options, "\nVideo options:\n",
3939
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3940
                      OPT_VIDEO);
3941
    show_help_options(options, "\nAdvanced Video options:\n",
3942
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3943
                      OPT_VIDEO | OPT_EXPERT);
3944
    show_help_options(options, "\nAudio options:\n",
3945
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3946
                      OPT_AUDIO);
3947
    show_help_options(options, "\nAdvanced Audio options:\n",
3948
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3949
                      OPT_AUDIO | OPT_EXPERT);
3950
    show_help_options(options, "\nSubtitle options:\n",
3951
                      OPT_SUBTITLE | OPT_GRAB,
3952
                      OPT_SUBTITLE);
3953
    show_help_options(options, "\nAudio/Video grab options:\n",
3954
                      OPT_GRAB,
3955
                      OPT_GRAB);
3956
    printf("\n");
3957
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3958
    printf("\n");
3959

    
3960
    /* individual codec options */
3961
    c = NULL;
3962
    while ((c = av_codec_next(c))) {
3963
        if (c->priv_class) {
3964
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3965
            printf("\n");
3966
        }
3967
    }
3968

    
3969
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3970
    printf("\n");
3971

    
3972
    /* individual muxer options */
3973
    while ((oformat = av_oformat_next(oformat))) {
3974
        if (oformat->priv_class) {
3975
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3976
            printf("\n");
3977
        }
3978
    }
3979

    
3980
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3981
}
3982

    
3983
static void opt_target(const char *arg)
3984
{
3985
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3986
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3987

    
3988
    if(!strncmp(arg, "pal-", 4)) {
3989
        norm = PAL;
3990
        arg += 4;
3991
    } else if(!strncmp(arg, "ntsc-", 5)) {
3992
        norm = NTSC;
3993
        arg += 5;
3994
    } else if(!strncmp(arg, "film-", 5)) {
3995
        norm = FILM;
3996
        arg += 5;
3997
    } else {
3998
        int fr;
3999
        /* Calculate FR via float to avoid int overflow */
4000
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4001
        if(fr == 25000) {
4002
            norm = PAL;
4003
        } else if((fr == 29970) || (fr == 23976)) {
4004
            norm = NTSC;
4005
        } else {
4006
            /* Try to determine PAL/NTSC by peeking in the input files */
4007
            if(nb_input_files) {
4008
                int i, j;
4009
                for(j = 0; j < nb_input_files; j++) {
4010
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4011
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4012
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4013
                            continue;
4014
                        fr = c->time_base.den * 1000 / c->time_base.num;
4015
                        if(fr == 25000) {
4016
                            norm = PAL;
4017
                            break;
4018
                        } else if((fr == 29970) || (fr == 23976)) {
4019
                            norm = NTSC;
4020
                            break;
4021
                        }
4022
                    }
4023
                    if(norm != UNKNOWN)
4024
                        break;
4025
                }
4026
            }
4027
        }
4028
        if(verbose && norm != UNKNOWN)
4029
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4030
    }
4031

    
4032
    if(norm == UNKNOWN) {
4033
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4034
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4035
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4036
        ffmpeg_exit(1);
4037
    }
4038

    
4039
    if(!strcmp(arg, "vcd")) {
4040

    
4041
        opt_video_codec("mpeg1video");
4042
        opt_audio_codec("mp2");
4043
        opt_format("vcd");
4044

    
4045
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4046
        opt_frame_rate(NULL, frame_rates[norm]);
4047
        opt_default("g", norm == PAL ? "15" : "18");
4048

    
4049
        opt_default("b", "1150000");
4050
        opt_default("maxrate", "1150000");
4051
        opt_default("minrate", "1150000");
4052
        opt_default("bufsize", "327680"); // 40*1024*8;
4053

    
4054
        opt_default("ab", "224000");
4055
        audio_sample_rate = 44100;
4056
        audio_channels = 2;
4057

    
4058
        opt_default("packetsize", "2324");
4059
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4060

    
4061
        /* We have to offset the PTS, so that it is consistent with the SCR.
4062
           SCR starts at 36000, but the first two packs contain only padding
4063
           and the first pack from the other stream, respectively, may also have
4064
           been written before.
4065
           So the real data starts at SCR 36000+3*1200. */
4066
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4067
    } else if(!strcmp(arg, "svcd")) {
4068

    
4069
        opt_video_codec("mpeg2video");
4070
        opt_audio_codec("mp2");
4071
        opt_format("svcd");
4072

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

    
4077
        opt_default("b", "2040000");
4078
        opt_default("maxrate", "2516000");
4079
        opt_default("minrate", "0"); //1145000;
4080
        opt_default("bufsize", "1835008"); //224*1024*8;
4081
        opt_default("flags", "+scan_offset");
4082

    
4083

    
4084
        opt_default("ab", "224000");
4085
        audio_sample_rate = 44100;
4086

    
4087
        opt_default("packetsize", "2324");
4088

    
4089
    } else if(!strcmp(arg, "dvd")) {
4090

    
4091
        opt_video_codec("mpeg2video");
4092
        opt_audio_codec("ac3");
4093
        opt_format("dvd");
4094

    
4095
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4096
        opt_frame_rate(NULL, frame_rates[norm]);
4097
        opt_default("g", norm == PAL ? "15" : "18");
4098

    
4099
        opt_default("b", "6000000");
4100
        opt_default("maxrate", "9000000");
4101
        opt_default("minrate", "0"); //1500000;
4102
        opt_default("bufsize", "1835008"); //224*1024*8;
4103

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

    
4107
        opt_default("ab", "448000");
4108
        audio_sample_rate = 48000;
4109

    
4110
    } else if(!strncmp(arg, "dv", 2)) {
4111

    
4112
        opt_format("dv");
4113

    
4114
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4115
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4116
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4117
        opt_frame_rate(NULL, frame_rates[norm]);
4118

    
4119
        audio_sample_rate = 48000;
4120
        audio_channels = 2;
4121

    
4122
    } else {
4123
        fprintf(stderr, "Unknown target: %s\n", arg);
4124
        ffmpeg_exit(1);
4125
    }
4126
}
4127

    
4128
static void opt_vstats_file (const char *arg)
4129
{
4130
    av_free (vstats_filename);
4131
    vstats_filename=av_strdup (arg);
4132
}
4133

    
4134
static void opt_vstats (void)
4135
{
4136
    char filename[40];
4137
    time_t today2 = time(NULL);
4138
    struct tm *today = localtime(&today2);
4139

    
4140
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4141
             today->tm_sec);
4142
    opt_vstats_file(filename);
4143
}
4144

    
4145
static int opt_bsf(const char *opt, const char *arg)
4146
{
4147
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4148
    AVBitStreamFilterContext **bsfp;
4149

    
4150
    if(!bsfc){
4151
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4152
        ffmpeg_exit(1);
4153
    }
4154

    
4155
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4156
          *opt == 'a' ? &audio_bitstream_filters :
4157
                        &subtitle_bitstream_filters;
4158
    while(*bsfp)
4159
        bsfp= &(*bsfp)->next;
4160

    
4161
    *bsfp= bsfc;
4162

    
4163
    return 0;
4164
}
4165

    
4166
static int opt_preset(const char *opt, const char *arg)
4167
{
4168
    FILE *f=NULL;
4169
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4170
    char *codec_name = *opt == 'v' ? video_codec_name :
4171
                       *opt == 'a' ? audio_codec_name :
4172
                                     subtitle_codec_name;
4173

    
4174
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4175
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4176
        ffmpeg_exit(1);
4177
    }
4178

    
4179
    while(!feof(f)){
4180
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4181
        if(line[0] == '#' && !e)
4182
            continue;
4183
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4184
        if(e){
4185
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4186
            ffmpeg_exit(1);
4187
        }
4188
        if(!strcmp(tmp, "acodec")){
4189
            opt_audio_codec(tmp2);
4190
        }else if(!strcmp(tmp, "vcodec")){
4191
            opt_video_codec(tmp2);
4192
        }else if(!strcmp(tmp, "scodec")){
4193
            opt_subtitle_codec(tmp2);
4194
        }else if(opt_default(tmp, tmp2) < 0){
4195
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4196
            ffmpeg_exit(1);
4197
        }
4198
    }
4199

    
4200
    fclose(f);
4201

    
4202
    return 0;
4203
}
4204

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

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

    
4298
    /* audio options */
4299
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4300
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4301
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4302
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4303
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4304
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4305
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4306
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4307
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4308
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4309
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4310
    { "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" },
4311

    
4312
    /* subtitle options */
4313
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4314
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4315
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4316
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4317
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4318

    
4319
    /* grab options */
4320
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4321
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4322
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4323

    
4324
    /* muxer options */
4325
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4326
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4327

    
4328
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4329
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4330
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4331

    
4332
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4333
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4334
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4335
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4336

    
4337
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4338
    { NULL, },
4339
};
4340

    
4341
int main(int argc, char **argv)
4342
{
4343
    int64_t ti;
4344

    
4345
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4346

    
4347
    avcodec_register_all();
4348
#if CONFIG_AVDEVICE
4349
    avdevice_register_all();
4350
#endif
4351
#if CONFIG_AVFILTER
4352
    avfilter_register_all();
4353
#endif
4354
    av_register_all();
4355

    
4356
#if HAVE_ISATTY
4357
    if(isatty(STDIN_FILENO))
4358
        url_set_interrupt_cb(decode_interrupt_cb);
4359
#endif
4360

    
4361
    init_opts();
4362

    
4363
    show_banner();
4364

    
4365
    /* parse options */
4366
    parse_options(argc, argv, options, opt_output_file);
4367

    
4368
    if(nb_output_files <= 0 && nb_input_files == 0) {
4369
        show_usage();
4370
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4371
        ffmpeg_exit(1);
4372
    }
4373

    
4374
    /* file converter / grab */
4375
    if (nb_output_files <= 0) {
4376
        fprintf(stderr, "At least one output file must be specified\n");
4377
        ffmpeg_exit(1);
4378
    }
4379

    
4380
    if (nb_input_files == 0) {
4381
        fprintf(stderr, "At least one input file must be specified\n");
4382
        ffmpeg_exit(1);
4383
    }
4384

    
4385
    ti = getutime();
4386
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4387
                  stream_maps, nb_stream_maps) < 0)
4388
        ffmpeg_exit(1);
4389
    ti = getutime() - ti;
4390
    if (do_benchmark) {
4391
        int maxrss = getmaxrss() / 1024;
4392
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4393
    }
4394

    
4395
    return ffmpeg_exit(0);
4396
}