Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ cb2c971d

History | View | Annotate | Download (157 KB)

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

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

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

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

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

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

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

    
81
#include "cmdutils.h"
82

    
83
#include "libavutil/avassert.h"
84

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

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

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

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

    
110
static const OptionDef options[];
111

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

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

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

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

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

    
140
static AVChapterMap *chapter_maps = NULL;
141
static int nb_chapter_maps;
142

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

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

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

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

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

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

    
221
static int rate_emu = 0;
222

    
223
static int  video_channel = 0;
224
static char *video_standard;
225

    
226
static int audio_volume = 256;
227

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

    
243
static float dts_delta_threshold = 10;
244

    
245
static unsigned int sws_flags = SWS_BICUBIC;
246

    
247
static int64_t timer_start;
248

    
249
static uint8_t *audio_buf;
250
static uint8_t *audio_out;
251
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
252

    
253
static short *samples;
254

    
255
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
256
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
257
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
258

    
259
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
260

    
261
struct AVInputStream;
262

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

    
284
    /* full frame size of first frame */
285
    int original_height;
286
    int original_width;
287

    
288
    /* forced key frames */
289
    int64_t *forced_kf_pts;
290
    int forced_kf_count;
291
    int forced_kf_index;
292

    
293
    /* audio only */
294
    int audio_resample;
295
    ReSampleContext *resample; /* for audio resampling */
296
    int reformat_pair;
297
    AVAudioConvert *reformat_ctx;
298
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
299
    FILE *logfile;
300
} AVOutputStream;
301

    
302
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
303
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
304

    
305
typedef struct AVInputStream {
306
    int file_index;
307
    int index;
308
    AVStream *st;
309
    int discard;             /* true if stream data should be discarded */
310
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
311
    int64_t sample_index;      /* current sample */
312

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

    
330
typedef struct AVInputFile {
331
    int eof_reached;      /* true if eof reached */
332
    int ist_index;        /* index of first stream in ist_table */
333
    int buffer_size;      /* current total buffer size */
334
    int nb_streams;       /* nb streams we are aware of */
335
} AVInputFile;
336

    
337
#if HAVE_TERMIOS_H
338

    
339
/* init terminal so that we can grab keys */
340
static struct termios oldtty;
341
#endif
342

    
343
#if CONFIG_AVFILTER
344

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

    
355
    graph = avfilter_graph_alloc();
356

    
357
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
358
        return ret;
359
    if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
360
        return ret;
361

    
362
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
363
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
364
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
365
        return ret;
366
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
367
        return ret;
368

    
369
    /* add input and output filters to the overall graph */
370
    avfilter_graph_add_filter(graph, ist->input_video_filter);
371
    avfilter_graph_add_filter(graph, ist->output_video_filter);
372

    
373
    last_filter = ist->input_video_filter;
374

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

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

    
393
    if (vfilters) {
394
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
395
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
396

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

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

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

    
415
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
416
        return ret;
417

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

    
421
    return 0;
422
}
423
#endif /* CONFIG_AVFILTER */
424

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

    
433
static volatile int received_sigterm = 0;
434

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

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

    
447
    tcgetattr (0, &tty);
448
    oldtty = tty;
449
    atexit(term_exit);
450

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

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

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

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

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

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

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

    
504
static int ffmpeg_exit(int ret)
505
{
506
    int i;
507

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

    
536
    av_free(intra_matrix);
537
    av_free(inter_matrix);
538

    
539
    if (vstats_file)
540
        fclose(vstats_file);
541
    av_free(vstats_filename);
542

    
543
    av_free(opt_names);
544
    av_free(streamid_map);
545
    av_free(input_codecs);
546
    av_free(output_codecs);
547
    av_free(stream_maps);
548
    av_free(meta_data_maps);
549

    
550
    av_free(video_codec_name);
551
    av_free(audio_codec_name);
552
    av_free(subtitle_codec_name);
553

    
554
    av_free(video_standard);
555

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

    
562
#if CONFIG_AVFILTER
563
    avfilter_uninit();
564
#endif
565

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

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

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

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

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

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

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

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

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

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

    
683
        s->nb_streams++;
684

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

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

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

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

    
717
        new_output_stream(s, nb_output_files);
718
    }
719

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

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

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

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

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

    
756
        bsfc= bsfc->next;
757
    }
758

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

    
766
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
767

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

    
777
    int size_out, frame_bytes, ret;
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
    if (ost->audio_resample && !ost->resample) {
812
        if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
813
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
814
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
815
                                               enc->sample_rate, dec->sample_rate,
816
                                               enc->sample_fmt,  dec->sample_fmt,
817
                                               16, 10, 0, 0.8);
818
        if (!ost->resample) {
819
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
820
                    dec->channels, dec->sample_rate,
821
                    enc->channels, enc->sample_rate);
822
            ffmpeg_exit(1);
823
        }
824
    }
825

    
826
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
827
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
828
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
829
        if (ost->reformat_ctx)
830
            av_audio_convert_free(ost->reformat_ctx);
831
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
832
                                                   dec->sample_fmt, 1, NULL, 0);
833
        if (!ost->reformat_ctx) {
834
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
835
                av_get_sample_fmt_name(dec->sample_fmt),
836
                av_get_sample_fmt_name(enc->sample_fmt));
837
            ffmpeg_exit(1);
838
        }
839
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
840
    }
841

    
842
    if(audio_sync_method){
843
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
844
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
845
        double idelta= delta*dec->sample_rate / enc->sample_rate;
846
        int byte_delta= ((int)idelta)*2*dec->channels;
847

    
848
        //FIXME resample delay
849
        if(fabs(delta) > 50){
850
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
851
                if(byte_delta < 0){
852
                    byte_delta= FFMAX(byte_delta, -size);
853
                    size += byte_delta;
854
                    buf  -= byte_delta;
855
                    if(verbose > 2)
856
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
857
                    if(!size)
858
                        return;
859
                    ist->is_start=0;
860
                }else{
861
                    static uint8_t *input_tmp= NULL;
862
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
863

    
864
                    if(byte_delta > allocated_for_size - size){
865
                        allocated_for_size= byte_delta + (int64_t)size;
866
                        goto need_realloc;
867
                    }
868
                    ist->is_start=0;
869

    
870
                    memset(input_tmp, 0, byte_delta);
871
                    memcpy(input_tmp + byte_delta, buf, size);
872
                    buf= input_tmp;
873
                    size += byte_delta;
874
                    if(verbose > 2)
875
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
876
                }
877
            }else if(audio_sync_method>1){
878
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
879
                av_assert0(ost->audio_resample);
880
                if(verbose > 2)
881
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
882
//                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));
883
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
884
            }
885
        }
886
    }else
887
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
888
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
889

    
890
    if (ost->audio_resample) {
891
        buftmp = audio_buf;
892
        size_out = audio_resample(ost->resample,
893
                                  (short *)buftmp, (short *)buf,
894
                                  size / (dec->channels * isize));
895
        size_out = size_out * enc->channels * osize;
896
    } else {
897
        buftmp = buf;
898
        size_out = size;
899
    }
900

    
901
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
902
        const void *ibuf[6]= {buftmp};
903
        void *obuf[6]= {audio_buf};
904
        int istride[6]= {isize};
905
        int ostride[6]= {osize};
906
        int len= size_out/istride[0];
907
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
908
            printf("av_audio_convert() failed\n");
909
            if (exit_on_error)
910
                ffmpeg_exit(1);
911
            return;
912
        }
913
        buftmp = audio_buf;
914
        size_out = len*osize;
915
    }
916

    
917
    /* now encode as many frames as possible */
918
    if (enc->frame_size > 1) {
919
        /* output resampled raw samples */
920
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
921
            fprintf(stderr, "av_fifo_realloc2() failed\n");
922
            ffmpeg_exit(1);
923
        }
924
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
925

    
926
        frame_bytes = enc->frame_size * osize * enc->channels;
927

    
928
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
929
            AVPacket pkt;
930
            av_init_packet(&pkt);
931

    
932
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
933

    
934
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
935

    
936
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
937
                                       (short *)audio_buf);
938
            if (ret < 0) {
939
                fprintf(stderr, "Audio encoding failed\n");
940
                ffmpeg_exit(1);
941
            }
942
            audio_size += ret;
943
            pkt.stream_index= ost->index;
944
            pkt.data= audio_out;
945
            pkt.size= ret;
946
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
947
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
948
            pkt.flags |= AV_PKT_FLAG_KEY;
949
            write_frame(s, &pkt, enc, ost->bitstream_filters);
950

    
951
            ost->sync_opts += enc->frame_size;
952
        }
953
    } else {
954
        AVPacket pkt;
955
        av_init_packet(&pkt);
956

    
957
        ost->sync_opts += size_out / (osize * enc->channels);
958

    
959
        /* output a pcm frame */
960
        /* determine the size of the coded buffer */
961
        size_out /= osize;
962
        if (coded_bps)
963
            size_out = size_out*coded_bps/8;
964

    
965
        if(size_out > audio_out_size){
966
            fprintf(stderr, "Internal error, buffer size too small\n");
967
            ffmpeg_exit(1);
968
        }
969

    
970
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
971
        ret = avcodec_encode_audio(enc, audio_out, size_out,
972
                                   (short *)buftmp);
973
        if (ret < 0) {
974
            fprintf(stderr, "Audio encoding failed\n");
975
            ffmpeg_exit(1);
976
        }
977
        audio_size += ret;
978
        pkt.stream_index= ost->index;
979
        pkt.data= audio_out;
980
        pkt.size= ret;
981
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
982
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
983
        pkt.flags |= AV_PKT_FLAG_KEY;
984
        write_frame(s, &pkt, enc, ost->bitstream_filters);
985
    }
986
}
987

    
988
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
989
{
990
    AVCodecContext *dec;
991
    AVPicture *picture2;
992
    AVPicture picture_tmp;
993
    uint8_t *buf = 0;
994

    
995
    dec = ist->st->codec;
996

    
997
    /* deinterlace : must be done before any resize */
998
    if (do_deinterlace) {
999
        int size;
1000

    
1001
        /* create temporary picture */
1002
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1003
        buf = av_malloc(size);
1004
        if (!buf)
1005
            return;
1006

    
1007
        picture2 = &picture_tmp;
1008
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1009

    
1010
        if(avpicture_deinterlace(picture2, picture,
1011
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1012
            /* if error, do not deinterlace */
1013
            fprintf(stderr, "Deinterlacing failed\n");
1014
            av_free(buf);
1015
            buf = NULL;
1016
            picture2 = picture;
1017
        }
1018
    } else {
1019
        picture2 = picture;
1020
    }
1021

    
1022
    if (picture != picture2)
1023
        *picture = *picture2;
1024
    *bufp = buf;
1025
}
1026

    
1027
/* we begin to correct av delay at this threshold */
1028
#define AV_DELAY_MAX 0.100
1029

    
1030
static void do_subtitle_out(AVFormatContext *s,
1031
                            AVOutputStream *ost,
1032
                            AVInputStream *ist,
1033
                            AVSubtitle *sub,
1034
                            int64_t pts)
1035
{
1036
    static uint8_t *subtitle_out = NULL;
1037
    int subtitle_out_max_size = 1024 * 1024;
1038
    int subtitle_out_size, nb, i;
1039
    AVCodecContext *enc;
1040
    AVPacket pkt;
1041

    
1042
    if (pts == AV_NOPTS_VALUE) {
1043
        fprintf(stderr, "Subtitle packets must have a pts\n");
1044
        if (exit_on_error)
1045
            ffmpeg_exit(1);
1046
        return;
1047
    }
1048

    
1049
    enc = ost->st->codec;
1050

    
1051
    if (!subtitle_out) {
1052
        subtitle_out = av_malloc(subtitle_out_max_size);
1053
    }
1054

    
1055
    /* Note: DVB subtitle need one packet to draw them and one other
1056
       packet to clear them */
1057
    /* XXX: signal it in the codec context ? */
1058
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1059
        nb = 2;
1060
    else
1061
        nb = 1;
1062

    
1063
    for(i = 0; i < nb; i++) {
1064
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1065
        // start_display_time is required to be 0
1066
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1067
        sub->end_display_time -= sub->start_display_time;
1068
        sub->start_display_time = 0;
1069
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1070
                                                    subtitle_out_max_size, sub);
1071
        if (subtitle_out_size < 0) {
1072
            fprintf(stderr, "Subtitle encoding failed\n");
1073
            ffmpeg_exit(1);
1074
        }
1075

    
1076
        av_init_packet(&pkt);
1077
        pkt.stream_index = ost->index;
1078
        pkt.data = subtitle_out;
1079
        pkt.size = subtitle_out_size;
1080
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1081
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1082
            /* XXX: the pts correction is handled here. Maybe handling
1083
               it in the codec would be better */
1084
            if (i == 0)
1085
                pkt.pts += 90 * sub->start_display_time;
1086
            else
1087
                pkt.pts += 90 * sub->end_display_time;
1088
        }
1089
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1090
    }
1091
}
1092

    
1093
static int bit_buffer_size= 1024*256;
1094
static uint8_t *bit_buffer= NULL;
1095

    
1096
static void do_video_out(AVFormatContext *s,
1097
                         AVOutputStream *ost,
1098
                         AVInputStream *ist,
1099
                         AVFrame *in_picture,
1100
                         int *frame_size)
1101
{
1102
    int nb_frames, i, ret;
1103
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1104
    AVCodecContext *enc, *dec;
1105
    double sync_ipts;
1106

    
1107
    enc = ost->st->codec;
1108
    dec = ist->st->codec;
1109

    
1110
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1111

    
1112
    /* by default, we output a single frame */
1113
    nb_frames = 1;
1114

    
1115
    *frame_size = 0;
1116

    
1117
    if(video_sync_method){
1118
        double vdelta = sync_ipts - ost->sync_opts;
1119
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1120
        if (vdelta < -1.1)
1121
            nb_frames = 0;
1122
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1123
            if(vdelta<=-0.6){
1124
                nb_frames=0;
1125
            }else if(vdelta>0.6)
1126
            ost->sync_opts= lrintf(sync_ipts);
1127
        }else if (vdelta > 1.1)
1128
            nb_frames = lrintf(vdelta);
1129
//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);
1130
        if (nb_frames == 0){
1131
            ++nb_frames_drop;
1132
            if (verbose>2)
1133
                fprintf(stderr, "*** drop!\n");
1134
        }else if (nb_frames > 1) {
1135
            nb_frames_dup += nb_frames - 1;
1136
            if (verbose>2)
1137
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1138
        }
1139
    }else
1140
        ost->sync_opts= lrintf(sync_ipts);
1141

    
1142
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1143
    if (nb_frames <= 0)
1144
        return;
1145

    
1146
    formatted_picture = in_picture;
1147
    final_picture = formatted_picture;
1148
    padding_src = formatted_picture;
1149
    resampling_dst = &ost->pict_tmp;
1150

    
1151
    if (   ost->resample_height != ist->st->codec->height
1152
        || ost->resample_width  != ist->st->codec->width
1153
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1154

    
1155
        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));
1156
        if(!ost->video_resample)
1157
            ffmpeg_exit(1);
1158
    }
1159

    
1160
#if !CONFIG_AVFILTER
1161
    if (ost->video_resample) {
1162
        padding_src = NULL;
1163
        final_picture = &ost->pict_tmp;
1164
        if(  ost->resample_height != ist->st->codec->height
1165
          || ost->resample_width  != ist->st->codec->width
1166
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1167

    
1168
            /* initialize a new scaler context */
1169
            sws_freeContext(ost->img_resample_ctx);
1170
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1171
            ost->img_resample_ctx = sws_getContext(
1172
                ist->st->codec->width,
1173
                ist->st->codec->height,
1174
                ist->st->codec->pix_fmt,
1175
                ost->st->codec->width,
1176
                ost->st->codec->height,
1177
                ost->st->codec->pix_fmt,
1178
                sws_flags, NULL, NULL, NULL);
1179
            if (ost->img_resample_ctx == NULL) {
1180
                fprintf(stderr, "Cannot get resampling context\n");
1181
                ffmpeg_exit(1);
1182
            }
1183
        }
1184
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1185
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1186
    }
1187
#endif
1188

    
1189
    /* duplicates frame if needed */
1190
    for(i=0;i<nb_frames;i++) {
1191
        AVPacket pkt;
1192
        av_init_packet(&pkt);
1193
        pkt.stream_index= ost->index;
1194

    
1195
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1196
            /* raw pictures are written as AVPicture structure to
1197
               avoid any copies. We support temorarily the older
1198
               method. */
1199
            AVFrame* old_frame = enc->coded_frame;
1200
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1201
            pkt.data= (uint8_t *)final_picture;
1202
            pkt.size=  sizeof(AVPicture);
1203
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1204
            pkt.flags |= AV_PKT_FLAG_KEY;
1205

    
1206
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1207
            enc->coded_frame = old_frame;
1208
        } else {
1209
            AVFrame big_picture;
1210

    
1211
            big_picture= *final_picture;
1212
            /* better than nothing: use input picture interlaced
1213
               settings */
1214
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1215
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1216
                if(top_field_first == -1)
1217
                    big_picture.top_field_first = in_picture->top_field_first;
1218
                else
1219
                    big_picture.top_field_first = top_field_first;
1220
            }
1221

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

    
1244
            if(ret>0){
1245
                pkt.data= bit_buffer;
1246
                pkt.size= ret;
1247
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1248
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1249
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1250
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1251
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1252

    
1253
                if(enc->coded_frame->key_frame)
1254
                    pkt.flags |= AV_PKT_FLAG_KEY;
1255
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1256
                *frame_size = ret;
1257
                video_size += ret;
1258
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1259
                //        enc->frame_number-1, ret, enc->pict_type);
1260
                /* if two pass, output log */
1261
                if (ost->logfile && enc->stats_out) {
1262
                    fprintf(ost->logfile, "%s", enc->stats_out);
1263
                }
1264
            }
1265
        }
1266
        ost->sync_opts++;
1267
        ost->frame_number++;
1268
    }
1269
}
1270

    
1271
static double psnr(double d){
1272
    return -10.0*log(d)/log(10.0);
1273
}
1274

    
1275
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1276
                           int frame_size)
1277
{
1278
    AVCodecContext *enc;
1279
    int frame_number;
1280
    double ti1, bitrate, avg_bitrate;
1281

    
1282
    /* this is executed just the first time do_video_stats is called */
1283
    if (!vstats_file) {
1284
        vstats_file = fopen(vstats_filename, "w");
1285
        if (!vstats_file) {
1286
            perror("fopen");
1287
            ffmpeg_exit(1);
1288
        }
1289
    }
1290

    
1291
    enc = ost->st->codec;
1292
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1293
        frame_number = ost->frame_number;
1294
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1295
        if (enc->flags&CODEC_FLAG_PSNR)
1296
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1297

    
1298
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1299
        /* compute pts value */
1300
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1301
        if (ti1 < 0.01)
1302
            ti1 = 0.01;
1303

    
1304
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1305
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1306
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1307
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1308
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1309
    }
1310
}
1311

    
1312
static void print_report(AVFormatContext **output_files,
1313
                         AVOutputStream **ost_table, int nb_ostreams,
1314
                         int is_last_report)
1315
{
1316
    char buf[1024];
1317
    AVOutputStream *ost;
1318
    AVFormatContext *oc;
1319
    int64_t total_size;
1320
    AVCodecContext *enc;
1321
    int frame_number, vid, i;
1322
    double bitrate, ti1, pts;
1323
    static int64_t last_time = -1;
1324
    static int qp_histogram[52];
1325

    
1326
    if (!is_last_report) {
1327
        int64_t cur_time;
1328
        /* display the report every 0.5 seconds */
1329
        cur_time = av_gettime();
1330
        if (last_time == -1) {
1331
            last_time = cur_time;
1332
            return;
1333
        }
1334
        if ((cur_time - last_time) < 500000)
1335
            return;
1336
        last_time = cur_time;
1337
    }
1338

    
1339

    
1340
    oc = output_files[0];
1341

    
1342
    total_size = url_fsize(oc->pb);
1343
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1344
        total_size= url_ftell(oc->pb);
1345

    
1346
    buf[0] = '\0';
1347
    ti1 = 1e10;
1348
    vid = 0;
1349
    for(i=0;i<nb_ostreams;i++) {
1350
        ost = ost_table[i];
1351
        enc = ost->st->codec;
1352
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1354
                     !ost->st->stream_copy ?
1355
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1356
        }
1357
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1358
            float t = (av_gettime()-timer_start) / 1000000.0;
1359

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

    
1406
    if (verbose || is_last_report) {
1407
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1408

    
1409
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1410
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1411
            (double)total_size / 1024, ti1, bitrate);
1412

    
1413
        if (nb_frames_dup || nb_frames_drop)
1414
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1415
                  nb_frames_dup, nb_frames_drop);
1416

    
1417
        if (verbose >= 0)
1418
            fprintf(stderr, "%s    \r", buf);
1419

    
1420
        fflush(stderr);
1421
    }
1422

    
1423
    if (is_last_report && verbose >= 0){
1424
        int64_t raw= audio_size + video_size + extra_size;
1425
        fprintf(stderr, "\n");
1426
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1427
                video_size/1024.0,
1428
                audio_size/1024.0,
1429
                extra_size/1024.0,
1430
                100.0*(total_size - raw)/raw
1431
        );
1432
    }
1433
}
1434

    
1435
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1436
static int output_packet(AVInputStream *ist, int ist_index,
1437
                         AVOutputStream **ost_table, int nb_ostreams,
1438
                         const AVPacket *pkt)
1439
{
1440
    AVFormatContext *os;
1441
    AVOutputStream *ost;
1442
    int ret, i;
1443
    int got_picture;
1444
    AVFrame picture;
1445
    void *buffer_to_free;
1446
    static unsigned int samples_size= 0;
1447
    AVSubtitle subtitle, *subtitle_to_free;
1448
    int64_t pkt_pts = AV_NOPTS_VALUE;
1449
#if CONFIG_AVFILTER
1450
    int frame_available;
1451
#endif
1452

    
1453
    AVPacket avpkt;
1454
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1455

    
1456
    if(ist->next_pts == AV_NOPTS_VALUE)
1457
        ist->next_pts= ist->pts;
1458

    
1459
    if (pkt == NULL) {
1460
        /* EOF handling */
1461
        av_init_packet(&avpkt);
1462
        avpkt.data = NULL;
1463
        avpkt.size = 0;
1464
        goto handle_eof;
1465
    } else {
1466
        avpkt = *pkt;
1467
    }
1468

    
1469
    if(pkt->dts != AV_NOPTS_VALUE)
1470
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1471
    if(pkt->pts != AV_NOPTS_VALUE)
1472
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1473

    
1474
    //while we have more to decode or while the decoder did output something on EOF
1475
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1476
        uint8_t *data_buf, *decoded_data_buf;
1477
        int data_size, decoded_data_size;
1478
    handle_eof:
1479
        ist->pts= ist->next_pts;
1480

    
1481
        if(avpkt.size && avpkt.size != pkt->size &&
1482
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1483
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1484
            ist->showed_multi_packet_warning=1;
1485
        }
1486

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

    
1528
                    ret = avcodec_decode_video2(ist->st->codec,
1529
                                                &picture, &got_picture, &avpkt);
1530
                    ist->st->quality= picture.quality;
1531
                    if (ret < 0)
1532
                        goto fail_decode;
1533
                    if (!got_picture) {
1534
                        /* no picture yet */
1535
                        goto discard_packet;
1536
                    }
1537
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1538
                    if (ist->st->codec->time_base.num != 0) {
1539
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1540
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1541
                                          ist->st->codec->time_base.num * ticks) /
1542
                            ist->st->codec->time_base.den;
1543
                    }
1544
                    avpkt.size = 0;
1545
                    break;
1546
            case AVMEDIA_TYPE_SUBTITLE:
1547
                ret = avcodec_decode_subtitle2(ist->st->codec,
1548
                                               &subtitle, &got_picture, &avpkt);
1549
                if (ret < 0)
1550
                    goto fail_decode;
1551
                if (!got_picture) {
1552
                    goto discard_packet;
1553
                }
1554
                subtitle_to_free = &subtitle;
1555
                avpkt.size = 0;
1556
                break;
1557
            default:
1558
                goto fail_decode;
1559
            }
1560
        } else {
1561
            switch(ist->st->codec->codec_type) {
1562
            case AVMEDIA_TYPE_AUDIO:
1563
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1564
                    ist->st->codec->sample_rate;
1565
                break;
1566
            case AVMEDIA_TYPE_VIDEO:
1567
                if (ist->st->codec->time_base.num != 0) {
1568
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1569
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1570
                                      ist->st->codec->time_base.num * ticks) /
1571
                        ist->st->codec->time_base.den;
1572
                }
1573
                break;
1574
            }
1575
            ret = avpkt.size;
1576
            avpkt.size = 0;
1577
        }
1578

    
1579
        buffer_to_free = NULL;
1580
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1581
            pre_process_video_frame(ist, (AVPicture *)&picture,
1582
                                    &buffer_to_free);
1583
        }
1584

    
1585
#if CONFIG_AVFILTER
1586
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1587
            // add it to be filtered
1588
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1589
                                     ist->pts,
1590
                                     ist->st->codec->sample_aspect_ratio);
1591
        }
1592
#endif
1593

    
1594
        // preprocess audio (volume)
1595
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1596
            if (audio_volume != 256) {
1597
                short *volp;
1598
                volp = samples;
1599
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1600
                    int v = ((*volp) * audio_volume + 128) >> 8;
1601
                    if (v < -32768) v = -32768;
1602
                    if (v >  32767) v = 32767;
1603
                    *volp++ = v;
1604
                }
1605
            }
1606
        }
1607

    
1608
        /* frame rate emulation */
1609
        if (rate_emu) {
1610
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1611
            int64_t now = av_gettime() - ist->start;
1612
            if (pts > now)
1613
                usleep(pts - now);
1614
        }
1615
#if CONFIG_AVFILTER
1616
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1617
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1618
#endif
1619
        /* if output time reached then transcode raw format,
1620
           encode packets and output them */
1621
        if (start_time == 0 || ist->pts >= start_time)
1622
#if CONFIG_AVFILTER
1623
        while (frame_available) {
1624
            AVRational ist_pts_tb;
1625
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1626
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1627
            if (ist->picref)
1628
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1629
#endif
1630
            for(i=0;i<nb_ostreams;i++) {
1631
                int frame_size;
1632

    
1633
                ost = ost_table[i];
1634
                if (ost->source_index == ist_index) {
1635
                    os = output_files[ost->file_index];
1636

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

    
1640
                    if (ost->encoding_needed) {
1641
                        av_assert0(ist->decoding_needed);
1642
                        switch(ost->st->codec->codec_type) {
1643
                        case AVMEDIA_TYPE_AUDIO:
1644
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1645
                            break;
1646
                        case AVMEDIA_TYPE_VIDEO:
1647
#if CONFIG_AVFILTER
1648
                            if (ist->picref->video)
1649
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1650
#endif
1651
                            do_video_out(os, ost, ist, &picture, &frame_size);
1652
                            if (vstats_filename && frame_size)
1653
                                do_video_stats(os, ost, frame_size);
1654
                            break;
1655
                        case AVMEDIA_TYPE_SUBTITLE:
1656
                            do_subtitle_out(os, ost, ist, &subtitle,
1657
                                            pkt->pts);
1658
                            break;
1659
                        default:
1660
                            abort();
1661
                        }
1662
                    } else {
1663
                        AVFrame avframe; //FIXME/XXX remove this
1664
                        AVPacket opkt;
1665
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1666

    
1667
                        av_init_packet(&opkt);
1668

    
1669
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1670
                            continue;
1671

    
1672
                        /* no reencoding needed : output the packet directly */
1673
                        /* force the input stream PTS */
1674

    
1675
                        avcodec_get_frame_defaults(&avframe);
1676
                        ost->st->codec->coded_frame= &avframe;
1677
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1678

    
1679
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1680
                            audio_size += data_size;
1681
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1682
                            video_size += data_size;
1683
                            ost->sync_opts++;
1684
                        }
1685

    
1686
                        opkt.stream_index= ost->index;
1687
                        if(pkt->pts != AV_NOPTS_VALUE)
1688
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1689
                        else
1690
                            opkt.pts= AV_NOPTS_VALUE;
1691

    
1692
                        if (pkt->dts == AV_NOPTS_VALUE)
1693
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1694
                        else
1695
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1696
                        opkt.dts -= ost_tb_start_time;
1697

    
1698
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1699
                        opkt.flags= pkt->flags;
1700

    
1701
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1702
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1703
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1704
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1705
                           ) {
1706
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1707
                                opkt.destruct= av_destruct_packet;
1708
                        } else {
1709
                            opkt.data = data_buf;
1710
                            opkt.size = data_size;
1711
                        }
1712

    
1713
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1714
                        ost->st->codec->frame_number++;
1715
                        ost->frame_number++;
1716
                        av_free_packet(&opkt);
1717
                    }
1718
                }
1719
            }
1720

    
1721
#if CONFIG_AVFILTER
1722
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1723
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1724
            if(ist->picref)
1725
                avfilter_unref_buffer(ist->picref);
1726
        }
1727
#endif
1728
        av_free(buffer_to_free);
1729
        /* XXX: allocate the subtitles in the codec ? */
1730
        if (subtitle_to_free) {
1731
            if (subtitle_to_free->rects != NULL) {
1732
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1733
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1734
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1735
                    av_freep(&subtitle_to_free->rects[i]);
1736
                }
1737
                av_freep(&subtitle_to_free->rects);
1738
            }
1739
            subtitle_to_free->num_rects = 0;
1740
            subtitle_to_free = NULL;
1741
        }
1742
    }
1743
 discard_packet:
1744
    if (pkt == NULL) {
1745
        /* EOF handling */
1746

    
1747
        for(i=0;i<nb_ostreams;i++) {
1748
            ost = ost_table[i];
1749
            if (ost->source_index == ist_index) {
1750
                AVCodecContext *enc= ost->st->codec;
1751
                os = output_files[ost->file_index];
1752

    
1753
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1754
                    continue;
1755
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1756
                    continue;
1757

    
1758
                if (ost->encoding_needed) {
1759
                    for(;;) {
1760
                        AVPacket pkt;
1761
                        int fifo_bytes;
1762
                        av_init_packet(&pkt);
1763
                        pkt.stream_index= ost->index;
1764

    
1765
                        switch(ost->st->codec->codec_type) {
1766
                        case AVMEDIA_TYPE_AUDIO:
1767
                            fifo_bytes = av_fifo_size(ost->fifo);
1768
                            ret = 0;
1769
                            /* encode any samples remaining in fifo */
1770
                            if (fifo_bytes > 0) {
1771
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1772
                                int fs_tmp = enc->frame_size;
1773

    
1774
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1775
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1776
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1777
                                } else { /* pad */
1778
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1779
                                    if (allocated_audio_buf_size < frame_bytes)
1780
                                        ffmpeg_exit(1);
1781
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1782
                                }
1783

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

    
1816
                        if(ret<=0)
1817
                            break;
1818
                        pkt.data= bit_buffer;
1819
                        pkt.size= ret;
1820
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1821
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1822
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1823
                    }
1824
                }
1825
            }
1826
        }
1827
    }
1828

    
1829
    return 0;
1830
 fail_decode:
1831
    return -1;
1832
}
1833

    
1834
static void print_sdp(AVFormatContext **avc, int n)
1835
{
1836
    char sdp[2048];
1837

    
1838
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1839
    printf("SDP:\n%s\n", sdp);
1840
    fflush(stdout);
1841
}
1842

    
1843
static int copy_chapters(int infile, int outfile)
1844
{
1845
    AVFormatContext *is = input_files[infile];
1846
    AVFormatContext *os = output_files[outfile];
1847
    int i;
1848

    
1849
    for (i = 0; i < is->nb_chapters; i++) {
1850
        AVChapter *in_ch = is->chapters[i], *out_ch;
1851
        AVMetadataTag *t = NULL;
1852
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1853
                                      AV_TIME_BASE_Q, in_ch->time_base);
1854
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1855
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1856

    
1857

    
1858
        if (in_ch->end < ts_off)
1859
            continue;
1860
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1861
            break;
1862

    
1863
        out_ch = av_mallocz(sizeof(AVChapter));
1864
        if (!out_ch)
1865
            return AVERROR(ENOMEM);
1866

    
1867
        out_ch->id        = in_ch->id;
1868
        out_ch->time_base = in_ch->time_base;
1869
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1870
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1871

    
1872
        if (metadata_chapters_autocopy)
1873
            while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1874
                av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1875

    
1876
        os->nb_chapters++;
1877
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1878
        if (!os->chapters)
1879
            return AVERROR(ENOMEM);
1880
        os->chapters[os->nb_chapters - 1] = out_ch;
1881
    }
1882
    return 0;
1883
}
1884

    
1885
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1886
                                    AVCodecContext *avctx)
1887
{
1888
    char *p;
1889
    int n = 1, i;
1890
    int64_t t;
1891

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

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

    
1929
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1930
    if (!file_table)
1931
        goto fail;
1932

    
1933
    /* input stream init */
1934
    j = 0;
1935
    for(i=0;i<nb_input_files;i++) {
1936
        is = input_files[i];
1937
        file_table[i].ist_index = j;
1938
        file_table[i].nb_streams = is->nb_streams;
1939
        j += is->nb_streams;
1940
    }
1941
    nb_istreams = j;
1942

    
1943
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1944
    if (!ist_table)
1945
        goto fail;
1946

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

    
1964
            if (rate_emu) {
1965
                ist->start = av_gettime();
1966
            }
1967
        }
1968
    }
1969

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

    
1988
    /* Sanity check the mapping args -- do the input files & streams exist? */
1989
    for(i=0;i<nb_stream_maps;i++) {
1990
        int fi = stream_maps[i].file_index;
1991
        int si = stream_maps[i].stream_index;
1992

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

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

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

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

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

    
2092
    /* for each output stream, we compute the right encoding parameters */
2093
    for(i=0;i<nb_ostreams;i++) {
2094
        AVMetadataTag *t = NULL;
2095
        ost = ost_table[i];
2096
        os = output_files[ost->file_index];
2097
        ist = ist_table[ost->source_index];
2098

    
2099
        codec = ost->st->codec;
2100
        icodec = ist->st->codec;
2101

    
2102
        if (metadata_streams_autocopy)
2103
            while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2104
                av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2105
            }
2106

    
2107
        ost->st->disposition = ist->st->disposition;
2108
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2109
        codec->chroma_sample_location = icodec->chroma_sample_location;
2110

    
2111
        if (ost->st->stream_copy) {
2112
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2113

    
2114
            if (extra_size > INT_MAX)
2115
                goto fail;
2116

    
2117
            /* if stream_copy is selected, no need to decode or encode */
2118
            codec->codec_id = icodec->codec_id;
2119
            codec->codec_type = icodec->codec_type;
2120

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

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

    
2213
#if !CONFIG_AVFILTER
2214
                    ost->original_height = icodec->height;
2215
                    ost->original_width  = icodec->width;
2216
#endif
2217
                    codec->bits_per_raw_sample= 0;
2218
                }
2219
                ost->resample_height = icodec->height;
2220
                ost->resample_width  = icodec->width;
2221
                ost->resample_pix_fmt= icodec->pix_fmt;
2222
                ost->encoding_needed = 1;
2223
                ist->decoding_needed = 1;
2224

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

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

    
2273
    if (!bit_buffer)
2274
        bit_buffer = av_malloc(bit_buffer_size);
2275
    if (!bit_buffer) {
2276
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2277
                bit_buffer_size);
2278
        ret = AVERROR(ENOMEM);
2279
        goto fail;
2280
    }
2281

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

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

    
2339
    /* init pts */
2340
    for(i=0;i<nb_istreams;i++) {
2341
        AVStream *st;
2342
        ist = ist_table[i];
2343
        st= ist->st;
2344
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2345
        ist->next_pts = AV_NOPTS_VALUE;
2346
        init_pts_correction(&ist->pts_ctx);
2347
        ist->is_start = 1;
2348
    }
2349

    
2350
    /* set meta data information from input file if required */
2351
    for (i=0;i<nb_meta_data_maps;i++) {
2352
        AVFormatContext *files[2];
2353
        AVMetadata      **meta[2];
2354
        AVMetadataTag *mtag;
2355
        int j;
2356

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

    
2365
        int out_file_index = meta_data_maps[i][0].file;
2366
        int in_file_index = meta_data_maps[i][1].file;
2367
        if (in_file_index < 0 || out_file_index < 0)
2368
            continue;
2369
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2370
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2371

    
2372
        files[0] = output_files[out_file_index];
2373
        files[1] = input_files[in_file_index];
2374

    
2375
        for (j = 0; j < 2; j++) {
2376
            AVMetaDataMap *map = &meta_data_maps[i][j];
2377

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

    
2397
        mtag=NULL;
2398
        while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2399
            av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2400
    }
2401

    
2402
    /* copy chapters according to chapter maps */
2403
    for (i = 0; i < nb_chapter_maps; i++) {
2404
        int infile  = chapter_maps[i].in_file;
2405
        int outfile = chapter_maps[i].out_file;
2406

    
2407
        if (infile < 0 || outfile < 0)
2408
            continue;
2409
        if (infile >= nb_input_files) {
2410
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2411
            ret = AVERROR(EINVAL);
2412
            goto dump_format;
2413
        }
2414
        if (outfile >= nb_output_files) {
2415
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2416
            ret = AVERROR(EINVAL);
2417
            goto dump_format;
2418
        }
2419
        copy_chapters(infile, outfile);
2420
    }
2421

    
2422
    /* copy chapters from the first input file that has them*/
2423
    if (!nb_chapter_maps)
2424
        for (i = 0; i < nb_input_files; i++) {
2425
            if (!input_files[i]->nb_chapters)
2426
                continue;
2427

    
2428
            for (j = 0; j < nb_output_files; j++)
2429
                if ((ret = copy_chapters(i, j)) < 0)
2430
                    goto dump_format;
2431
            break;
2432
        }
2433

    
2434
    /* open files and write file headers */
2435
    for(i=0;i<nb_output_files;i++) {
2436
        os = output_files[i];
2437
        if (av_write_header(os) < 0) {
2438
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2439
            ret = AVERROR(EINVAL);
2440
            goto dump_format;
2441
        }
2442
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2443
            want_sdp = 0;
2444
        }
2445
    }
2446

    
2447
 dump_format:
2448
    /* dump the file output parameters - cannot be done before in case
2449
       of stream copy */
2450
    for(i=0;i<nb_output_files;i++) {
2451
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2452
    }
2453

    
2454
    /* dump the stream mapping */
2455
    if (verbose >= 0) {
2456
        fprintf(stderr, "Stream mapping:\n");
2457
        for(i=0;i<nb_ostreams;i++) {
2458
            ost = ost_table[i];
2459
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2460
                    ist_table[ost->source_index]->file_index,
2461
                    ist_table[ost->source_index]->index,
2462
                    ost->file_index,
2463
                    ost->index);
2464
            if (ost->sync_ist != ist_table[ost->source_index])
2465
                fprintf(stderr, " [sync #%d.%d]",
2466
                        ost->sync_ist->file_index,
2467
                        ost->sync_ist->index);
2468
            fprintf(stderr, "\n");
2469
        }
2470
    }
2471

    
2472
    if (ret) {
2473
        fprintf(stderr, "%s\n", error);
2474
        goto fail;
2475
    }
2476

    
2477
    if (want_sdp) {
2478
        print_sdp(output_files, nb_output_files);
2479
    }
2480

    
2481
    if (!using_stdin && verbose >= 0) {
2482
        fprintf(stderr, "Press [q] to stop encoding\n");
2483
        url_set_interrupt_cb(decode_interrupt_cb);
2484
    }
2485
    term_init();
2486

    
2487
    timer_start = av_gettime();
2488

    
2489
    for(; received_sigterm == 0;) {
2490
        int file_index, ist_index;
2491
        AVPacket pkt;
2492
        double ipts_min;
2493
        double opts_min;
2494

    
2495
    redo:
2496
        ipts_min= 1e100;
2497
        opts_min= 1e100;
2498
        /* if 'q' pressed, exits */
2499
        if (!using_stdin) {
2500
            if (q_pressed)
2501
                break;
2502
            /* read_key() returns 0 on EOF */
2503
            key = read_key();
2504
            if (key == 'q')
2505
                break;
2506
        }
2507

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

    
2546
        /* finish if limit size exhausted */
2547
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2548
            break;
2549

    
2550
        /* read a frame from it and output it in the fifo */
2551
        is = input_files[file_index];
2552
        ret= av_read_frame(is, &pkt);
2553
        if(ret == AVERROR(EAGAIN)){
2554
            no_packet[file_index]=1;
2555
            no_packet_count++;
2556
            continue;
2557
        }
2558
        if (ret < 0) {
2559
            file_table[file_index].eof_reached = 1;
2560
            if (opt_shortest)
2561
                break;
2562
            else
2563
                continue;
2564
        }
2565

    
2566
        no_packet_count=0;
2567
        memset(no_packet, 0, sizeof(no_packet));
2568

    
2569
        if (do_pkt_dump) {
2570
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2571
        }
2572
        /* the following test is needed in case new streams appear
2573
           dynamically in stream : we ignore them */
2574
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2575
            goto discard_packet;
2576
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2577
        ist = ist_table[ist_index];
2578
        if (ist->discard)
2579
            goto discard_packet;
2580

    
2581
        if (pkt.dts != AV_NOPTS_VALUE)
2582
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2583
        if (pkt.pts != AV_NOPTS_VALUE)
2584
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2585

    
2586
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2587
            && input_files_ts_scale[file_index][pkt.stream_index]){
2588
            if(pkt.pts != AV_NOPTS_VALUE)
2589
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2590
            if(pkt.dts != AV_NOPTS_VALUE)
2591
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2592
        }
2593

    
2594
//        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);
2595
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2596
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2597
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2598
            int64_t delta= pkt_dts - ist->next_pts;
2599
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2600
                input_files_ts_offset[ist->file_index]-= delta;
2601
                if (verbose > 2)
2602
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2603
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2604
                if(pkt.pts != AV_NOPTS_VALUE)
2605
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2606
            }
2607
        }
2608

    
2609
        /* finish if recording time exhausted */
2610
        if (recording_time != INT64_MAX &&
2611
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2612
            ist->is_past_recording_time = 1;
2613
            goto discard_packet;
2614
        }
2615

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

    
2619
            if (verbose >= 0)
2620
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2621
                        ist->file_index, ist->index);
2622
            if (exit_on_error)
2623
                ffmpeg_exit(1);
2624
            av_free_packet(&pkt);
2625
            goto redo;
2626
        }
2627

    
2628
    discard_packet:
2629
        av_free_packet(&pkt);
2630

    
2631
        /* dump report by using the output first video and audio streams */
2632
        print_report(output_files, ost_table, nb_ostreams, 0);
2633
    }
2634

    
2635
    /* at the end of stream, we must flush the decoder buffers */
2636
    for(i=0;i<nb_istreams;i++) {
2637
        ist = ist_table[i];
2638
        if (ist->decoding_needed) {
2639
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2640
        }
2641
    }
2642

    
2643
    term_exit();
2644

    
2645
    /* write the trailer if needed and close file */
2646
    for(i=0;i<nb_output_files;i++) {
2647
        os = output_files[i];
2648
        av_write_trailer(os);
2649
    }
2650

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

    
2654
    /* close each encoder */
2655
    for(i=0;i<nb_ostreams;i++) {
2656
        ost = ost_table[i];
2657
        if (ost->encoding_needed) {
2658
            av_freep(&ost->st->codec->stats_in);
2659
            avcodec_close(ost->st->codec);
2660
        }
2661
    }
2662

    
2663
    /* close each decoder */
2664
    for(i=0;i<nb_istreams;i++) {
2665
        ist = ist_table[i];
2666
        if (ist->decoding_needed) {
2667
            avcodec_close(ist->st->codec);
2668
        }
2669
    }
2670
#if CONFIG_AVFILTER
2671
    if (graph) {
2672
        avfilter_graph_free(graph);
2673
        av_freep(&graph);
2674
    }
2675
#endif
2676

    
2677
    /* finished ! */
2678
    ret = 0;
2679

    
2680
 fail:
2681
    av_freep(&bit_buffer);
2682
    av_free(file_table);
2683

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

    
2720
static void opt_format(const char *arg)
2721
{
2722
    last_asked_format = arg;
2723
}
2724

    
2725
static void opt_video_rc_override_string(const char *arg)
2726
{
2727
    video_rc_override_string = arg;
2728
}
2729

    
2730
static int opt_me_threshold(const char *opt, const char *arg)
2731
{
2732
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2733
    return 0;
2734
}
2735

    
2736
static int opt_verbose(const char *opt, const char *arg)
2737
{
2738
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2739
    return 0;
2740
}
2741

    
2742
static int opt_frame_rate(const char *opt, const char *arg)
2743
{
2744
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2745
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2746
        ffmpeg_exit(1);
2747
    }
2748
    return 0;
2749
}
2750

    
2751
static int opt_bitrate(const char *opt, const char *arg)
2752
{
2753
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2754

    
2755
    opt_default(opt, arg);
2756

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

    
2760
    return 0;
2761
}
2762

    
2763
static int opt_frame_crop(const char *opt, const char *arg)
2764
{
2765
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2766
    return AVERROR(EINVAL);
2767
}
2768

    
2769
static void opt_frame_size(const char *arg)
2770
{
2771
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2772
        fprintf(stderr, "Incorrect frame size\n");
2773
        ffmpeg_exit(1);
2774
    }
2775
}
2776

    
2777
static int opt_pad(const char *opt, const char *arg) {
2778
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2779
    return -1;
2780
}
2781

    
2782
static void opt_frame_pix_fmt(const char *arg)
2783
{
2784
    if (strcmp(arg, "list")) {
2785
        frame_pix_fmt = av_get_pix_fmt(arg);
2786
        if (frame_pix_fmt == PIX_FMT_NONE) {
2787
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2788
            ffmpeg_exit(1);
2789
        }
2790
    } else {
2791
        show_pix_fmts();
2792
        ffmpeg_exit(0);
2793
    }
2794
}
2795

    
2796
static void opt_frame_aspect_ratio(const char *arg)
2797
{
2798
    int x = 0, y = 0;
2799
    double ar = 0;
2800
    const char *p;
2801
    char *end;
2802

    
2803
    p = strchr(arg, ':');
2804
    if (p) {
2805
        x = strtol(arg, &end, 10);
2806
        if (end == p)
2807
            y = strtol(end+1, &end, 10);
2808
        if (x > 0 && y > 0)
2809
            ar = (double)x / (double)y;
2810
    } else
2811
        ar = strtod(arg, NULL);
2812

    
2813
    if (!ar) {
2814
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2815
        ffmpeg_exit(1);
2816
    }
2817
    frame_aspect_ratio = ar;
2818
}
2819

    
2820
static int opt_metadata(const char *opt, const char *arg)
2821
{
2822
    char *mid= strchr(arg, '=');
2823

    
2824
    if(!mid){
2825
        fprintf(stderr, "Missing =\n");
2826
        ffmpeg_exit(1);
2827
    }
2828
    *mid++= 0;
2829

    
2830
    av_metadata_set2(&metadata, arg, mid, 0);
2831

    
2832
    return 0;
2833
}
2834

    
2835
static void opt_qscale(const char *arg)
2836
{
2837
    video_qscale = atof(arg);
2838
    if (video_qscale <= 0 ||
2839
        video_qscale > 255) {
2840
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2841
        ffmpeg_exit(1);
2842
    }
2843
}
2844

    
2845
static void opt_top_field_first(const char *arg)
2846
{
2847
    top_field_first= atoi(arg);
2848
}
2849

    
2850
static int opt_thread_count(const char *opt, const char *arg)
2851
{
2852
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2853
#if !HAVE_THREADS
2854
    if (verbose >= 0)
2855
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2856
#endif
2857
    return 0;
2858
}
2859

    
2860
static void opt_audio_sample_fmt(const char *arg)
2861
{
2862
    if (strcmp(arg, "list"))
2863
        audio_sample_fmt = av_get_sample_fmt(arg);
2864
    else {
2865
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2866
        ffmpeg_exit(0);
2867
    }
2868
}
2869

    
2870
static int opt_audio_rate(const char *opt, const char *arg)
2871
{
2872
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2873
    return 0;
2874
}
2875

    
2876
static int opt_audio_channels(const char *opt, const char *arg)
2877
{
2878
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2879
    return 0;
2880
}
2881

    
2882
static void opt_video_channel(const char *arg)
2883
{
2884
    video_channel = strtol(arg, NULL, 0);
2885
}
2886

    
2887
static void opt_video_standard(const char *arg)
2888
{
2889
    video_standard = av_strdup(arg);
2890
}
2891

    
2892
static void opt_codec(int *pstream_copy, char **pcodec_name,
2893
                      int codec_type, const char *arg)
2894
{
2895
    av_freep(pcodec_name);
2896
    if (!strcmp(arg, "copy")) {
2897
        *pstream_copy = 1;
2898
    } else {
2899
        *pcodec_name = av_strdup(arg);
2900
    }
2901
}
2902

    
2903
static void opt_audio_codec(const char *arg)
2904
{
2905
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2906
}
2907

    
2908
static void opt_video_codec(const char *arg)
2909
{
2910
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2911
}
2912

    
2913
static void opt_subtitle_codec(const char *arg)
2914
{
2915
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2916
}
2917

    
2918
static int opt_codec_tag(const char *opt, const char *arg)
2919
{
2920
    char *tail;
2921
    uint32_t *codec_tag;
2922

    
2923
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2924
                !strcmp(opt, "vtag") ? &video_codec_tag :
2925
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2926
    if (!codec_tag)
2927
        return -1;
2928

    
2929
    *codec_tag = strtol(arg, &tail, 0);
2930
    if (!tail || *tail)
2931
        *codec_tag = AV_RL32(arg);
2932

    
2933
    return 0;
2934
}
2935

    
2936
static void opt_map(const char *arg)
2937
{
2938
    AVStreamMap *m;
2939
    char *p;
2940

    
2941
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2942
    m = &stream_maps[nb_stream_maps-1];
2943

    
2944
    m->file_index = strtol(arg, &p, 0);
2945
    if (*p)
2946
        p++;
2947

    
2948
    m->stream_index = strtol(p, &p, 0);
2949
    if (*p) {
2950
        p++;
2951
        m->sync_file_index = strtol(p, &p, 0);
2952
        if (*p)
2953
            p++;
2954
        m->sync_stream_index = strtol(p, &p, 0);
2955
    } else {
2956
        m->sync_file_index = m->file_index;
2957
        m->sync_stream_index = m->stream_index;
2958
    }
2959
}
2960

    
2961
static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
2962
{
2963
    *endptr = arg;
2964
    if (*arg == ',') {
2965
        *type = *(++arg);
2966
        switch (*arg) {
2967
        case 'g':
2968
            break;
2969
        case 's':
2970
        case 'c':
2971
        case 'p':
2972
            *index = strtol(++arg, endptr, 0);
2973
            break;
2974
        default:
2975
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2976
            ffmpeg_exit(1);
2977
        }
2978
    } else
2979
        *type = 'g';
2980
}
2981

    
2982
static void opt_map_meta_data(const char *arg)
2983
{
2984
    AVMetaDataMap *m, *m1;
2985
    char *p;
2986

    
2987
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2988
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2989

    
2990
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2991
    m->file = strtol(arg, &p, 0);
2992
    parse_meta_type(p, &m->type, &m->index, &p);
2993
    if (*p)
2994
        p++;
2995

    
2996
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2997
    m1->file = strtol(p, &p, 0);
2998
    parse_meta_type(p, &m1->type, &m1->index, &p);
2999

    
3000
    if (m->type == 's' || m1->type == 's')
3001
        metadata_streams_autocopy = 0;
3002
    if (m->type == 'c' || m1->type == 'c')
3003
        metadata_chapters_autocopy = 0;
3004
}
3005

    
3006
static void opt_map_chapters(const char *arg)
3007
{
3008
    AVChapterMap *c;
3009
    char *p;
3010

    
3011
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3012
                              nb_chapter_maps + 1);
3013
    c = &chapter_maps[nb_chapter_maps - 1];
3014
    c->out_file = strtol(arg, &p, 0);
3015
    if (*p)
3016
        p++;
3017

    
3018
    c->in_file = strtol(p, &p, 0);
3019
}
3020

    
3021
static void opt_input_ts_scale(const char *arg)
3022
{
3023
    unsigned int stream;
3024
    double scale;
3025
    char *p;
3026

    
3027
    stream = strtol(arg, &p, 0);
3028
    if (*p)
3029
        p++;
3030
    scale= strtod(p, &p);
3031

    
3032
    if(stream >= MAX_STREAMS)
3033
        ffmpeg_exit(1);
3034

    
3035
    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);
3036
    input_files_ts_scale[nb_input_files][stream]= scale;
3037
}
3038

    
3039
static int opt_recording_time(const char *opt, const char *arg)
3040
{
3041
    recording_time = parse_time_or_die(opt, arg, 1);
3042
    return 0;
3043
}
3044

    
3045
static int opt_start_time(const char *opt, const char *arg)
3046
{
3047
    start_time = parse_time_or_die(opt, arg, 1);
3048
    return 0;
3049
}
3050

    
3051
static int opt_recording_timestamp(const char *opt, const char *arg)
3052
{
3053
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3054
    return 0;
3055
}
3056

    
3057
static int opt_input_ts_offset(const char *opt, const char *arg)
3058
{
3059
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3060
    return 0;
3061
}
3062

    
3063
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3064
{
3065
    const char *codec_string = encoder ? "encoder" : "decoder";
3066
    AVCodec *codec;
3067

    
3068
    if(!name)
3069
        return CODEC_ID_NONE;
3070
    codec = encoder ?
3071
        avcodec_find_encoder_by_name(name) :
3072
        avcodec_find_decoder_by_name(name);
3073
    if(!codec) {
3074
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3075
        ffmpeg_exit(1);
3076
    }
3077
    if(codec->type != type) {
3078
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3079
        ffmpeg_exit(1);
3080
    }
3081
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3082
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3083
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3084
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3085
                codec_string, codec->name);
3086
        codec = encoder ?
3087
            avcodec_find_encoder(codec->id) :
3088
            avcodec_find_decoder(codec->id);
3089
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3090
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3091
                    codec_string, codec->name);
3092
        ffmpeg_exit(1);
3093
    }
3094
    return codec->id;
3095
}
3096

    
3097
static void opt_input_file(const char *filename)
3098
{
3099
    AVFormatContext *ic;
3100
    AVFormatParameters params, *ap = &params;
3101
    AVInputFormat *file_iformat = NULL;
3102
    int err, i, ret, rfps, rfps_base;
3103
    int64_t timestamp;
3104

    
3105
    if (last_asked_format) {
3106
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3107
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3108
            ffmpeg_exit(1);
3109
        }
3110
        last_asked_format = NULL;
3111
    }
3112

    
3113
    if (!strcmp(filename, "-"))
3114
        filename = "pipe:";
3115

    
3116
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3117
                    !strcmp(filename, "/dev/stdin");
3118

    
3119
    /* get default parameters from command line */
3120
    ic = avformat_alloc_context();
3121
    if (!ic) {
3122
        print_error(filename, AVERROR(ENOMEM));
3123
        ffmpeg_exit(1);
3124
    }
3125

    
3126
    memset(ap, 0, sizeof(*ap));
3127
    ap->prealloced_context = 1;
3128
    ap->sample_rate = audio_sample_rate;
3129
    ap->channels = audio_channels;
3130
    ap->time_base.den = frame_rate.num;
3131
    ap->time_base.num = frame_rate.den;
3132
    ap->width = frame_width;
3133
    ap->height = frame_height;
3134
    ap->pix_fmt = frame_pix_fmt;
3135
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3136
    ap->channel = video_channel;
3137
    ap->standard = video_standard;
3138

    
3139
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3140

    
3141
    ic->video_codec_id   =
3142
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3143
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3144
    ic->audio_codec_id   =
3145
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3146
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3147
    ic->subtitle_codec_id=
3148
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3149
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3150
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3151

    
3152
    /* open the input file with generic libav function */
3153
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3154
    if (err < 0) {
3155
        print_error(filename, err);
3156
        ffmpeg_exit(1);
3157
    }
3158
    if(opt_programid) {
3159
        int i, j;
3160
        int found=0;
3161
        for(i=0; i<ic->nb_streams; i++){
3162
            ic->streams[i]->discard= AVDISCARD_ALL;
3163
        }
3164
        for(i=0; i<ic->nb_programs; i++){
3165
            AVProgram *p= ic->programs[i];
3166
            if(p->id != opt_programid){
3167
                p->discard = AVDISCARD_ALL;
3168
            }else{
3169
                found=1;
3170
                for(j=0; j<p->nb_stream_indexes; j++){
3171
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3172
                }
3173
            }
3174
        }
3175
        if(!found){
3176
            fprintf(stderr, "Specified program id not found\n");
3177
            ffmpeg_exit(1);
3178
        }
3179
        opt_programid=0;
3180
    }
3181

    
3182
    ic->loop_input = loop_input;
3183

    
3184
    /* If not enough info to get the stream parameters, we decode the
3185
       first frames to get it. (used in mpeg case for example) */
3186
    ret = av_find_stream_info(ic);
3187
    if (ret < 0 && verbose >= 0) {
3188
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3189
        av_close_input_file(ic);
3190
        ffmpeg_exit(1);
3191
    }
3192

    
3193
    timestamp = start_time;
3194
    /* add the stream start time */
3195
    if (ic->start_time != AV_NOPTS_VALUE)
3196
        timestamp += ic->start_time;
3197

    
3198
    /* if seeking requested, we execute it */
3199
    if (start_time != 0) {
3200
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3201
        if (ret < 0) {
3202
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3203
                    filename, (double)timestamp / AV_TIME_BASE);
3204
        }
3205
        /* reset seek info */
3206
        start_time = 0;
3207
    }
3208

    
3209
    /* update the current parameters so that they match the one of the input stream */
3210
    for(i=0;i<ic->nb_streams;i++) {
3211
        AVStream *st = ic->streams[i];
3212
        AVCodecContext *dec = st->codec;
3213
        avcodec_thread_init(dec, thread_count);
3214
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3215
        switch (dec->codec_type) {
3216
        case AVMEDIA_TYPE_AUDIO:
3217
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3218
            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]);
3219
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3220
            channel_layout    = dec->channel_layout;
3221
            audio_channels    = dec->channels;
3222
            audio_sample_rate = dec->sample_rate;
3223
            audio_sample_fmt  = dec->sample_fmt;
3224
            if(audio_disable)
3225
                st->discard= AVDISCARD_ALL;
3226
            /* Note that av_find_stream_info can add more streams, and we
3227
             * currently have no chance of setting up lowres decoding
3228
             * early enough for them. */
3229
            if (dec->lowres)
3230
                audio_sample_rate >>= dec->lowres;
3231
            break;
3232
        case AVMEDIA_TYPE_VIDEO:
3233
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3234
            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]);
3235
            frame_height = dec->height;
3236
            frame_width  = dec->width;
3237
            if(ic->streams[i]->sample_aspect_ratio.num)
3238
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3239
            else
3240
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3241
            frame_aspect_ratio *= (float) dec->width / dec->height;
3242
            frame_pix_fmt = dec->pix_fmt;
3243
            rfps      = ic->streams[i]->r_frame_rate.num;
3244
            rfps_base = ic->streams[i]->r_frame_rate.den;
3245
            if (dec->lowres) {
3246
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3247
                frame_height >>= dec->lowres;
3248
                frame_width  >>= dec->lowres;
3249
            }
3250
            if(me_threshold)
3251
                dec->debug |= FF_DEBUG_MV;
3252

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

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

    
3259
                    (float)rfps / rfps_base, rfps, rfps_base);
3260
            }
3261
            /* update the current frame rate to match the stream frame rate */
3262
            frame_rate.num = rfps;
3263
            frame_rate.den = rfps_base;
3264

    
3265
            if(video_disable)
3266
                st->discard= AVDISCARD_ALL;
3267
            else if(video_discard)
3268
                st->discard= video_discard;
3269
            break;
3270
        case AVMEDIA_TYPE_DATA:
3271
            break;
3272
        case AVMEDIA_TYPE_SUBTITLE:
3273
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3274
            if(subtitle_disable)
3275
                st->discard = AVDISCARD_ALL;
3276
            break;
3277
        case AVMEDIA_TYPE_ATTACHMENT:
3278
        case AVMEDIA_TYPE_UNKNOWN:
3279
            break;
3280
        default:
3281
            abort();
3282
        }
3283
    }
3284

    
3285
    input_files[nb_input_files] = ic;
3286
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3287
    /* dump the file content */
3288
    if (verbose >= 0)
3289
        dump_format(ic, nb_input_files, filename, 0);
3290

    
3291
    nb_input_files++;
3292

    
3293
    video_channel = 0;
3294

    
3295
    av_freep(&video_codec_name);
3296
    av_freep(&audio_codec_name);
3297
    av_freep(&subtitle_codec_name);
3298
}
3299

    
3300
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3301
                                         int *has_subtitle_ptr)
3302
{
3303
    int has_video, has_audio, has_subtitle, i, j;
3304
    AVFormatContext *ic;
3305

    
3306
    has_video = 0;
3307
    has_audio = 0;
3308
    has_subtitle = 0;
3309
    for(j=0;j<nb_input_files;j++) {
3310
        ic = input_files[j];
3311
        for(i=0;i<ic->nb_streams;i++) {
3312
            AVCodecContext *enc = ic->streams[i]->codec;
3313
            switch(enc->codec_type) {
3314
            case AVMEDIA_TYPE_AUDIO:
3315
                has_audio = 1;
3316
                break;
3317
            case AVMEDIA_TYPE_VIDEO:
3318
                has_video = 1;
3319
                break;
3320
            case AVMEDIA_TYPE_SUBTITLE:
3321
                has_subtitle = 1;
3322
                break;
3323
            case AVMEDIA_TYPE_DATA:
3324
            case AVMEDIA_TYPE_ATTACHMENT:
3325
            case AVMEDIA_TYPE_UNKNOWN:
3326
                break;
3327
            default:
3328
                abort();
3329
            }
3330
        }
3331
    }
3332
    *has_video_ptr = has_video;
3333
    *has_audio_ptr = has_audio;
3334
    *has_subtitle_ptr = has_subtitle;
3335
}
3336

    
3337
static void new_video_stream(AVFormatContext *oc, int file_idx)
3338
{
3339
    AVStream *st;
3340
    AVOutputStream *ost;
3341
    AVCodecContext *video_enc;
3342
    enum CodecID codec_id;
3343
    AVCodec *codec= NULL;
3344

    
3345
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3346
    if (!st) {
3347
        fprintf(stderr, "Could not alloc stream\n");
3348
        ffmpeg_exit(1);
3349
    }
3350
    ost = new_output_stream(oc, file_idx);
3351

    
3352
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3353
    if(!video_stream_copy){
3354
        if (video_codec_name) {
3355
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3356
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3357
            codec = avcodec_find_encoder_by_name(video_codec_name);
3358
            output_codecs[nb_output_codecs-1] = codec;
3359
        } else {
3360
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3361
            codec = avcodec_find_encoder(codec_id);
3362
        }
3363
    }
3364

    
3365
    avcodec_get_context_defaults3(st->codec, codec);
3366
    ost->bitstream_filters = video_bitstream_filters;
3367
    video_bitstream_filters= NULL;
3368

    
3369
    avcodec_thread_init(st->codec, thread_count);
3370

    
3371
    video_enc = st->codec;
3372

    
3373
    if(video_codec_tag)
3374
        video_enc->codec_tag= video_codec_tag;
3375

    
3376
    if(   (video_global_header&1)
3377
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3378
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3379
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3380
    }
3381
    if(video_global_header&2){
3382
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3383
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3384
    }
3385

    
3386
    if (video_stream_copy) {
3387
        st->stream_copy = 1;
3388
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3389
        video_enc->sample_aspect_ratio =
3390
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3391
    } else {
3392
        const char *p;
3393
        int i;
3394
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3395

    
3396
        video_enc->codec_id = codec_id;
3397
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3398

    
3399
        if (codec && codec->supported_framerates && !force_fps)
3400
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3401
        video_enc->time_base.den = fps.num;
3402
        video_enc->time_base.num = fps.den;
3403

    
3404
        video_enc->width = frame_width;
3405
        video_enc->height = frame_height;
3406
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3407
        video_enc->pix_fmt = frame_pix_fmt;
3408
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3409

    
3410
        choose_pixel_fmt(st, codec);
3411

    
3412
        if (intra_only)
3413
            video_enc->gop_size = 0;
3414
        if (video_qscale || same_quality) {
3415
            video_enc->flags |= CODEC_FLAG_QSCALE;
3416
            video_enc->global_quality=
3417
                st->quality = FF_QP2LAMBDA * video_qscale;
3418
        }
3419

    
3420
        if(intra_matrix)
3421
            video_enc->intra_matrix = intra_matrix;
3422
        if(inter_matrix)
3423
            video_enc->inter_matrix = inter_matrix;
3424

    
3425
        p= video_rc_override_string;
3426
        for(i=0; p; i++){
3427
            int start, end, q;
3428
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3429
            if(e!=3){
3430
                fprintf(stderr, "error parsing rc_override\n");
3431
                ffmpeg_exit(1);
3432
            }
3433
            video_enc->rc_override=
3434
                av_realloc(video_enc->rc_override,
3435
                           sizeof(RcOverride)*(i+1));
3436
            video_enc->rc_override[i].start_frame= start;
3437
            video_enc->rc_override[i].end_frame  = end;
3438
            if(q>0){
3439
                video_enc->rc_override[i].qscale= q;
3440
                video_enc->rc_override[i].quality_factor= 1.0;
3441
            }
3442
            else{
3443
                video_enc->rc_override[i].qscale= 0;
3444
                video_enc->rc_override[i].quality_factor= -q/100.0;
3445
            }
3446
            p= strchr(p, '/');
3447
            if(p) p++;
3448
        }
3449
        video_enc->rc_override_count=i;
3450
        if (!video_enc->rc_initial_buffer_occupancy)
3451
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3452
        video_enc->me_threshold= me_threshold;
3453
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3454

    
3455
        if (do_psnr)
3456
            video_enc->flags|= CODEC_FLAG_PSNR;
3457

    
3458
        /* two pass mode */
3459
        if (do_pass) {
3460
            if (do_pass == 1) {
3461
                video_enc->flags |= CODEC_FLAG_PASS1;
3462
            } else {
3463
                video_enc->flags |= CODEC_FLAG_PASS2;
3464
            }
3465
        }
3466

    
3467
        if (forced_key_frames)
3468
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3469
    }
3470
    if (video_language) {
3471
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3472
        av_freep(&video_language);
3473
    }
3474

    
3475
    /* reset some key parameters */
3476
    video_disable = 0;
3477
    av_freep(&video_codec_name);
3478
    av_freep(&forced_key_frames);
3479
    video_stream_copy = 0;
3480
    frame_pix_fmt = PIX_FMT_NONE;
3481
}
3482

    
3483
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3484
{
3485
    AVStream *st;
3486
    AVOutputStream *ost;
3487
    AVCodec *codec= NULL;
3488
    AVCodecContext *audio_enc;
3489
    enum CodecID codec_id;
3490

    
3491
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3492
    if (!st) {
3493
        fprintf(stderr, "Could not alloc stream\n");
3494
        ffmpeg_exit(1);
3495
    }
3496
    ost = new_output_stream(oc, file_idx);
3497

    
3498
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3499
    if(!audio_stream_copy){
3500
        if (audio_codec_name) {
3501
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3502
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3503
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3504
            output_codecs[nb_output_codecs-1] = codec;
3505
        } else {
3506
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3507
            codec = avcodec_find_encoder(codec_id);
3508
        }
3509
    }
3510

    
3511
    avcodec_get_context_defaults3(st->codec, codec);
3512

    
3513
    ost->bitstream_filters = audio_bitstream_filters;
3514
    audio_bitstream_filters= NULL;
3515

    
3516
    avcodec_thread_init(st->codec, thread_count);
3517

    
3518
    audio_enc = st->codec;
3519
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3520

    
3521
    if(audio_codec_tag)
3522
        audio_enc->codec_tag= audio_codec_tag;
3523

    
3524
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3525
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3526
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3527
    }
3528
    if (audio_stream_copy) {
3529
        st->stream_copy = 1;
3530
        audio_enc->channels = audio_channels;
3531
        audio_enc->sample_rate = audio_sample_rate;
3532
    } else {
3533
        audio_enc->codec_id = codec_id;
3534
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3535

    
3536
        if (audio_qscale > QSCALE_NONE) {
3537
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3538
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3539
        }
3540
        audio_enc->channels = audio_channels;
3541
        audio_enc->sample_fmt = audio_sample_fmt;
3542
        audio_enc->sample_rate = audio_sample_rate;
3543
        audio_enc->channel_layout = channel_layout;
3544
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3545
            audio_enc->channel_layout = 0;
3546
        choose_sample_fmt(st, codec);
3547
        choose_sample_rate(st, codec);
3548
    }
3549
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3550
    if (audio_language) {
3551
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3552
        av_freep(&audio_language);
3553
    }
3554

    
3555
    /* reset some key parameters */
3556
    audio_disable = 0;
3557
    av_freep(&audio_codec_name);
3558
    audio_stream_copy = 0;
3559
}
3560

    
3561
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3562
{
3563
    AVStream *st;
3564
    AVOutputStream *ost;
3565
    AVCodec *codec=NULL;
3566
    AVCodecContext *subtitle_enc;
3567

    
3568
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3569
    if (!st) {
3570
        fprintf(stderr, "Could not alloc stream\n");
3571
        ffmpeg_exit(1);
3572
    }
3573
    ost = new_output_stream(oc, file_idx);
3574
    subtitle_enc = st->codec;
3575
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3576
    if(!subtitle_stream_copy){
3577
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3578
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3579
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3580
    }
3581
    avcodec_get_context_defaults3(st->codec, codec);
3582

    
3583
    ost->bitstream_filters = subtitle_bitstream_filters;
3584
    subtitle_bitstream_filters= NULL;
3585

    
3586
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3587

    
3588
    if(subtitle_codec_tag)
3589
        subtitle_enc->codec_tag= subtitle_codec_tag;
3590

    
3591
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3592
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3593
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3594
    }
3595
    if (subtitle_stream_copy) {
3596
        st->stream_copy = 1;
3597
    } else {
3598
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3599
    }
3600

    
3601
    if (subtitle_language) {
3602
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3603
        av_freep(&subtitle_language);
3604
    }
3605

    
3606
    subtitle_disable = 0;
3607
    av_freep(&subtitle_codec_name);
3608
    subtitle_stream_copy = 0;
3609
}
3610

    
3611
static int opt_new_stream(const char *opt, const char *arg)
3612
{
3613
    AVFormatContext *oc;
3614
    int file_idx = nb_output_files - 1;
3615
    if (nb_output_files <= 0) {
3616
        fprintf(stderr, "At least one output file must be specified\n");
3617
        ffmpeg_exit(1);
3618
    }
3619
    oc = output_files[file_idx];
3620

    
3621
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3622
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3623
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3624
    else av_assert0(0);
3625
    return 0;
3626
}
3627

    
3628
/* arg format is "output-stream-index:streamid-value". */
3629
static int opt_streamid(const char *opt, const char *arg)
3630
{
3631
    int idx;
3632
    char *p;
3633
    char idx_str[16];
3634

    
3635
    strncpy(idx_str, arg, sizeof(idx_str));
3636
    idx_str[sizeof(idx_str)-1] = '\0';
3637
    p = strchr(idx_str, ':');
3638
    if (!p) {
3639
        fprintf(stderr,
3640
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3641
                arg, opt);
3642
        ffmpeg_exit(1);
3643
    }
3644
    *p++ = '\0';
3645
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3646
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3647
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3648
    return 0;
3649
}
3650

    
3651
static void opt_output_file(const char *filename)
3652
{
3653
    AVFormatContext *oc;
3654
    int err, use_video, use_audio, use_subtitle;
3655
    int input_has_video, input_has_audio, input_has_subtitle;
3656
    AVFormatParameters params, *ap = &params;
3657
    AVOutputFormat *file_oformat;
3658
    AVMetadataTag *tag = NULL;
3659

    
3660
    if (!strcmp(filename, "-"))
3661
        filename = "pipe:";
3662

    
3663
    oc = avformat_alloc_context();
3664
    if (!oc) {
3665
        print_error(filename, AVERROR(ENOMEM));
3666
        ffmpeg_exit(1);
3667
    }
3668

    
3669
    if (last_asked_format) {
3670
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3671
        if (!file_oformat) {
3672
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3673
            ffmpeg_exit(1);
3674
        }
3675
        last_asked_format = NULL;
3676
    } else {
3677
        file_oformat = av_guess_format(NULL, filename, NULL);
3678
        if (!file_oformat) {
3679
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3680
                    filename);
3681
            ffmpeg_exit(1);
3682
        }
3683
    }
3684

    
3685
    oc->oformat = file_oformat;
3686
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3687

    
3688
    if (!strcmp(file_oformat->name, "ffm") &&
3689
        av_strstart(filename, "http:", NULL)) {
3690
        /* special case for files sent to ffserver: we get the stream
3691
           parameters from ffserver */
3692
        int err = read_ffserver_streams(oc, filename);
3693
        if (err < 0) {
3694
            print_error(filename, err);
3695
            ffmpeg_exit(1);
3696
        }
3697
    } else {
3698
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3699
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3700
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3701

    
3702
        /* disable if no corresponding type found and at least one
3703
           input file */
3704
        if (nb_input_files > 0) {
3705
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3706
                                         &input_has_subtitle);
3707
            if (!input_has_video)
3708
                use_video = 0;
3709
            if (!input_has_audio)
3710
                use_audio = 0;
3711
            if (!input_has_subtitle)
3712
                use_subtitle = 0;
3713
        }
3714

    
3715
        /* manual disable */
3716
        if (audio_disable)    use_audio    = 0;
3717
        if (video_disable)    use_video    = 0;
3718
        if (subtitle_disable) use_subtitle = 0;
3719

    
3720
        if (use_video)    new_video_stream(oc, nb_output_files);
3721
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3722
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3723

    
3724
        oc->timestamp = recording_timestamp;
3725

    
3726
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3727
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3728
        av_metadata_free(&metadata);
3729
    }
3730

    
3731
    output_files[nb_output_files++] = oc;
3732

    
3733
    /* check filename in case of an image number is expected */
3734
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3735
        if (!av_filename_number_test(oc->filename)) {
3736
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3737
            ffmpeg_exit(1);
3738
        }
3739
    }
3740

    
3741
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3742
        /* test if it already exists to avoid loosing precious files */
3743
        if (!file_overwrite &&
3744
            (strchr(filename, ':') == NULL ||
3745
             filename[1] == ':' ||
3746
             av_strstart(filename, "file:", NULL))) {
3747
            if (url_exist(filename)) {
3748
                if (!using_stdin) {
3749
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3750
                    fflush(stderr);
3751
                    if (!read_yesno()) {
3752
                        fprintf(stderr, "Not overwriting - exiting\n");
3753
                        ffmpeg_exit(1);
3754
                    }
3755
                }
3756
                else {
3757
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3758
                    ffmpeg_exit(1);
3759
                }
3760
            }
3761
        }
3762

    
3763
        /* open the file */
3764
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3765
            print_error(filename, err);
3766
            ffmpeg_exit(1);
3767
        }
3768
    }
3769

    
3770
    memset(ap, 0, sizeof(*ap));
3771
    if (av_set_parameters(oc, ap) < 0) {
3772
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3773
                oc->filename);
3774
        ffmpeg_exit(1);
3775
    }
3776

    
3777
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3778
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3779
    oc->loop_output = loop_output;
3780
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3781

    
3782
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3783

    
3784
    nb_streamid_map = 0;
3785
    av_freep(&forced_key_frames);
3786
}
3787

    
3788
/* same option as mencoder */
3789
static void opt_pass(const char *pass_str)
3790
{
3791
    int pass;
3792
    pass = atoi(pass_str);
3793
    if (pass != 1 && pass != 2) {
3794
        fprintf(stderr, "pass number can be only 1 or 2\n");
3795
        ffmpeg_exit(1);
3796
    }
3797
    do_pass = pass;
3798
}
3799

    
3800
static int64_t getutime(void)
3801
{
3802
#if HAVE_GETRUSAGE
3803
    struct rusage rusage;
3804

    
3805
    getrusage(RUSAGE_SELF, &rusage);
3806
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3807
#elif HAVE_GETPROCESSTIMES
3808
    HANDLE proc;
3809
    FILETIME c, e, k, u;
3810
    proc = GetCurrentProcess();
3811
    GetProcessTimes(proc, &c, &e, &k, &u);
3812
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3813
#else
3814
    return av_gettime();
3815
#endif
3816
}
3817

    
3818
static int64_t getmaxrss(void)
3819
{
3820
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3821
    struct rusage rusage;
3822
    getrusage(RUSAGE_SELF, &rusage);
3823
    return (int64_t)rusage.ru_maxrss * 1024;
3824
#elif HAVE_GETPROCESSMEMORYINFO
3825
    HANDLE proc;
3826
    PROCESS_MEMORY_COUNTERS memcounters;
3827
    proc = GetCurrentProcess();
3828
    memcounters.cb = sizeof(memcounters);
3829
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3830
    return memcounters.PeakPagefileUsage;
3831
#else
3832
    return 0;
3833
#endif
3834
}
3835

    
3836
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3837
{
3838
    int i;
3839
    const char *p = str;
3840
    for(i = 0;; i++) {
3841
        dest[i] = atoi(p);
3842
        if(i == 63)
3843
            break;
3844
        p = strchr(p, ',');
3845
        if(!p) {
3846
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3847
            ffmpeg_exit(1);
3848
        }
3849
        p++;
3850
    }
3851
}
3852

    
3853
static void opt_inter_matrix(const char *arg)
3854
{
3855
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3856
    parse_matrix_coeffs(inter_matrix, arg);
3857
}
3858

    
3859
static void opt_intra_matrix(const char *arg)
3860
{
3861
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3862
    parse_matrix_coeffs(intra_matrix, arg);
3863
}
3864

    
3865
static void show_usage(void)
3866
{
3867
    printf("Hyper fast Audio and Video encoder\n");
3868
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3869
    printf("\n");
3870
}
3871

    
3872
static void show_help(void)
3873
{
3874
    av_log_set_callback(log_callback_help);
3875
    show_usage();
3876
    show_help_options(options, "Main options:\n",
3877
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3878
    show_help_options(options, "\nAdvanced options:\n",
3879
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3880
                      OPT_EXPERT);
3881
    show_help_options(options, "\nVideo options:\n",
3882
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3883
                      OPT_VIDEO);
3884
    show_help_options(options, "\nAdvanced Video options:\n",
3885
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3886
                      OPT_VIDEO | OPT_EXPERT);
3887
    show_help_options(options, "\nAudio options:\n",
3888
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3889
                      OPT_AUDIO);
3890
    show_help_options(options, "\nAdvanced Audio options:\n",
3891
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3892
                      OPT_AUDIO | OPT_EXPERT);
3893
    show_help_options(options, "\nSubtitle options:\n",
3894
                      OPT_SUBTITLE | OPT_GRAB,
3895
                      OPT_SUBTITLE);
3896
    show_help_options(options, "\nAudio/Video grab options:\n",
3897
                      OPT_GRAB,
3898
                      OPT_GRAB);
3899
    printf("\n");
3900
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3901
    printf("\n");
3902
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3903
    printf("\n");
3904
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3905
}
3906

    
3907
static void opt_target(const char *arg)
3908
{
3909
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3910
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3911

    
3912
    if(!strncmp(arg, "pal-", 4)) {
3913
        norm = PAL;
3914
        arg += 4;
3915
    } else if(!strncmp(arg, "ntsc-", 5)) {
3916
        norm = NTSC;
3917
        arg += 5;
3918
    } else if(!strncmp(arg, "film-", 5)) {
3919
        norm = FILM;
3920
        arg += 5;
3921
    } else {
3922
        int fr;
3923
        /* Calculate FR via float to avoid int overflow */
3924
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3925
        if(fr == 25000) {
3926
            norm = PAL;
3927
        } else if((fr == 29970) || (fr == 23976)) {
3928
            norm = NTSC;
3929
        } else {
3930
            /* Try to determine PAL/NTSC by peeking in the input files */
3931
            if(nb_input_files) {
3932
                int i, j;
3933
                for(j = 0; j < nb_input_files; j++) {
3934
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3935
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3936
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3937
                            continue;
3938
                        fr = c->time_base.den * 1000 / c->time_base.num;
3939
                        if(fr == 25000) {
3940
                            norm = PAL;
3941
                            break;
3942
                        } else if((fr == 29970) || (fr == 23976)) {
3943
                            norm = NTSC;
3944
                            break;
3945
                        }
3946
                    }
3947
                    if(norm != UNKNOWN)
3948
                        break;
3949
                }
3950
            }
3951
        }
3952
        if(verbose && norm != UNKNOWN)
3953
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3954
    }
3955

    
3956
    if(norm == UNKNOWN) {
3957
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3958
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3959
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3960
        ffmpeg_exit(1);
3961
    }
3962

    
3963
    if(!strcmp(arg, "vcd")) {
3964

    
3965
        opt_video_codec("mpeg1video");
3966
        opt_audio_codec("mp2");
3967
        opt_format("vcd");
3968

    
3969
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3970
        opt_frame_rate(NULL, frame_rates[norm]);
3971
        opt_default("g", norm == PAL ? "15" : "18");
3972

    
3973
        opt_default("b", "1150000");
3974
        opt_default("maxrate", "1150000");
3975
        opt_default("minrate", "1150000");
3976
        opt_default("bufsize", "327680"); // 40*1024*8;
3977

    
3978
        opt_default("ab", "224000");
3979
        audio_sample_rate = 44100;
3980
        audio_channels = 2;
3981

    
3982
        opt_default("packetsize", "2324");
3983
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3984

    
3985
        /* We have to offset the PTS, so that it is consistent with the SCR.
3986
           SCR starts at 36000, but the first two packs contain only padding
3987
           and the first pack from the other stream, respectively, may also have
3988
           been written before.
3989
           So the real data starts at SCR 36000+3*1200. */
3990
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3991
    } else if(!strcmp(arg, "svcd")) {
3992

    
3993
        opt_video_codec("mpeg2video");
3994
        opt_audio_codec("mp2");
3995
        opt_format("svcd");
3996

    
3997
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3998
        opt_frame_rate(NULL, frame_rates[norm]);
3999
        opt_default("g", norm == PAL ? "15" : "18");
4000

    
4001
        opt_default("b", "2040000");
4002
        opt_default("maxrate", "2516000");
4003
        opt_default("minrate", "0"); //1145000;
4004
        opt_default("bufsize", "1835008"); //224*1024*8;
4005
        opt_default("flags", "+scan_offset");
4006

    
4007

    
4008
        opt_default("ab", "224000");
4009
        audio_sample_rate = 44100;
4010

    
4011
        opt_default("packetsize", "2324");
4012

    
4013
    } else if(!strcmp(arg, "dvd")) {
4014

    
4015
        opt_video_codec("mpeg2video");
4016
        opt_audio_codec("ac3");
4017
        opt_format("dvd");
4018

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

    
4023
        opt_default("b", "6000000");
4024
        opt_default("maxrate", "9000000");
4025
        opt_default("minrate", "0"); //1500000;
4026
        opt_default("bufsize", "1835008"); //224*1024*8;
4027

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

    
4031
        opt_default("ab", "448000");
4032
        audio_sample_rate = 48000;
4033

    
4034
    } else if(!strncmp(arg, "dv", 2)) {
4035

    
4036
        opt_format("dv");
4037

    
4038
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4039
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4040
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4041
        opt_frame_rate(NULL, frame_rates[norm]);
4042

    
4043
        audio_sample_rate = 48000;
4044
        audio_channels = 2;
4045

    
4046
    } else {
4047
        fprintf(stderr, "Unknown target: %s\n", arg);
4048
        ffmpeg_exit(1);
4049
    }
4050
}
4051

    
4052
static void opt_vstats_file (const char *arg)
4053
{
4054
    av_free (vstats_filename);
4055
    vstats_filename=av_strdup (arg);
4056
}
4057

    
4058
static void opt_vstats (void)
4059
{
4060
    char filename[40];
4061
    time_t today2 = time(NULL);
4062
    struct tm *today = localtime(&today2);
4063

    
4064
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4065
             today->tm_sec);
4066
    opt_vstats_file(filename);
4067
}
4068

    
4069
static int opt_bsf(const char *opt, const char *arg)
4070
{
4071
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4072
    AVBitStreamFilterContext **bsfp;
4073

    
4074
    if(!bsfc){
4075
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4076
        ffmpeg_exit(1);
4077
    }
4078

    
4079
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4080
          *opt == 'a' ? &audio_bitstream_filters :
4081
                        &subtitle_bitstream_filters;
4082
    while(*bsfp)
4083
        bsfp= &(*bsfp)->next;
4084

    
4085
    *bsfp= bsfc;
4086

    
4087
    return 0;
4088
}
4089

    
4090
static int opt_preset(const char *opt, const char *arg)
4091
{
4092
    FILE *f=NULL;
4093
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4094
    char *codec_name = *opt == 'v' ? video_codec_name :
4095
                       *opt == 'a' ? audio_codec_name :
4096
                                     subtitle_codec_name;
4097

    
4098
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4099
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4100
        ffmpeg_exit(1);
4101
    }
4102

    
4103
    while(!feof(f)){
4104
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4105
        if(line[0] == '#' && !e)
4106
            continue;
4107
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4108
        if(e){
4109
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4110
            ffmpeg_exit(1);
4111
        }
4112
        if(!strcmp(tmp, "acodec")){
4113
            opt_audio_codec(tmp2);
4114
        }else if(!strcmp(tmp, "vcodec")){
4115
            opt_video_codec(tmp2);
4116
        }else if(!strcmp(tmp, "scodec")){
4117
            opt_subtitle_codec(tmp2);
4118
        }else if(opt_default(tmp, tmp2) < 0){
4119
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4120
            ffmpeg_exit(1);
4121
        }
4122
    }
4123

    
4124
    fclose(f);
4125

    
4126
    return 0;
4127
}
4128

    
4129
static const OptionDef options[] = {
4130
    /* main options */
4131
#include "cmdutils_common_opts.h"
4132
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4133
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4134
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4135
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4136
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4137
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4138
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4139
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4140
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4141
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4142
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4143
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4144
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4145
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4146
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4147
      "add timings for benchmarking" },
4148
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4149
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4150
      "dump each input packet" },
4151
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4152
      "when dumping packets, also dump the payload" },
4153
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4154
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4155
    { "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)", "" },
4156
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4157
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4158
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4159
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4160
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4161
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4162
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4163
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4164
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4165
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4166
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4167
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4168
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4169

    
4170
    /* video options */
4171
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4172
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4173
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4174
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4175
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4176
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4177
    { "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" },
4178
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4179
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4180
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4181
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4182
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4183
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4184
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4185
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4186
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4187
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4188
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4189
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4190
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4191
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4192
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4193
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4194
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4195
      "use same video quality as source (implies VBR)" },
4196
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4197
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4198
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4199
      "deinterlace pictures" },
4200
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4201
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4202
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4203
#if CONFIG_AVFILTER
4204
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4205
#endif
4206
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4207
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4208
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4209
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4210
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4211
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4212
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4213
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4214
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4215
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4216
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4217

    
4218
    /* audio options */
4219
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4220
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4221
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4222
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4223
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4224
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4225
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4226
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4227
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4228
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4229
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4230
    { "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" },
4231

    
4232
    /* subtitle options */
4233
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4234
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4235
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4236
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4237
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4238

    
4239
    /* grab options */
4240
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4241
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4242
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4243

    
4244
    /* muxer options */
4245
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4246
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4247

    
4248
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4249
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4250
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4251

    
4252
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4253
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4254
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4255
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4256

    
4257
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4258
    { NULL, },
4259
};
4260

    
4261
int main(int argc, char **argv)
4262
{
4263
    int64_t ti;
4264

    
4265
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4266

    
4267
    avcodec_register_all();
4268
#if CONFIG_AVDEVICE
4269
    avdevice_register_all();
4270
#endif
4271
#if CONFIG_AVFILTER
4272
    avfilter_register_all();
4273
#endif
4274
    av_register_all();
4275

    
4276
#if HAVE_ISATTY
4277
    if(isatty(STDIN_FILENO))
4278
        url_set_interrupt_cb(decode_interrupt_cb);
4279
#endif
4280

    
4281
    init_opts();
4282

    
4283
    show_banner();
4284

    
4285
    /* parse options */
4286
    parse_options(argc, argv, options, opt_output_file);
4287

    
4288
    if(nb_output_files <= 0 && nb_input_files == 0) {
4289
        show_usage();
4290
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4291
        ffmpeg_exit(1);
4292
    }
4293

    
4294
    /* file converter / grab */
4295
    if (nb_output_files <= 0) {
4296
        fprintf(stderr, "At least one output file must be specified\n");
4297
        ffmpeg_exit(1);
4298
    }
4299

    
4300
    if (nb_input_files == 0) {
4301
        fprintf(stderr, "At least one input file must be specified\n");
4302
        ffmpeg_exit(1);
4303
    }
4304

    
4305
    ti = getutime();
4306
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4307
                  stream_maps, nb_stream_maps) < 0)
4308
        ffmpeg_exit(1);
4309
    ti = getutime() - ti;
4310
    if (do_benchmark) {
4311
        int maxrss = getmaxrss() / 1024;
4312
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4313
    }
4314

    
4315
    return ffmpeg_exit(0);
4316
}