Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 3fd62c6e

History | View | Annotate | Download (162 KB)

1
/*
2
 * ffmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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 "libavutil/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/audioconvert.h"
40
#include "libavutil/parseutils.h"
41
#include "libavutil/samplefmt.h"
42
#include "libavutil/colorspace.h"
43
#include "libavutil/fifo.h"
44
#include "libavutil/intreadwrite.h"
45
#include "libavutil/pixdesc.h"
46
#include "libavutil/avstring.h"
47
#include "libavutil/libm.h"
48
#include "libavformat/os_support.h"
49

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

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

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

    
72
#if HAVE_KBHIT
73
#include <conio.h>
74
#endif
75
#include <time.h>
76

    
77
#include "cmdutils.h"
78

    
79
#include "libavutil/avassert.h"
80

    
81
const char program_name[] = "ffmpeg";
82
const int program_birth_year = 2000;
83

    
84
/* select an input stream for an output stream */
85
typedef struct AVStreamMap {
86
    int file_index;
87
    int stream_index;
88
    int sync_file_index;
89
    int sync_stream_index;
90
} AVStreamMap;
91

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

    
101
typedef struct AVChapterMap {
102
    int in_file;
103
    int out_file;
104
} AVChapterMap;
105

    
106
static const OptionDef options[];
107

    
108
#define MAX_FILES 100
109
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
110

    
111
#define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
112

    
113
static const char *last_asked_format = NULL;
114
static AVFormatContext *input_files[MAX_FILES];
115
static int64_t input_files_ts_offset[MAX_FILES];
116
static double *input_files_ts_scale[MAX_FILES] = {NULL};
117
static AVCodec **input_codecs = NULL;
118
static int nb_input_files = 0;
119
static int nb_input_codecs = 0;
120
static int nb_input_files_ts_scale[MAX_FILES] = {0};
121

    
122
static AVFormatContext *output_files[MAX_FILES];
123
static AVCodec **output_codecs = NULL;
124
static int nb_output_files = 0;
125
static int nb_output_codecs = 0;
126

    
127
static AVStreamMap *stream_maps = NULL;
128
static int nb_stream_maps;
129

    
130
/* first item specifies output metadata, second is input */
131
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
132
static int nb_meta_data_maps;
133
static int metadata_global_autocopy   = 1;
134
static int metadata_streams_autocopy  = 1;
135
static int metadata_chapters_autocopy = 1;
136

    
137
static AVChapterMap *chapter_maps = NULL;
138
static int nb_chapter_maps;
139

    
140
/* indexed by output file stream index */
141
static int *streamid_map = NULL;
142
static int nb_streamid_map = 0;
143

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

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

    
184
static int subtitle_disable = 0;
185
static char *subtitle_codec_name = NULL;
186
static char *subtitle_language = NULL;
187
static unsigned int subtitle_codec_tag = 0;
188

    
189
static int data_disable = 0;
190
static char *data_codec_name = NULL;
191
static unsigned int data_codec_tag = 0;
192

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

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

    
224
static int rate_emu = 0;
225

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

    
229
static int audio_volume = 256;
230

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

    
246
static float dts_delta_threshold = 10;
247

    
248
static int64_t timer_start;
249

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

    
254
static short *samples;
255

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

    
260
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
261

    
262
struct AVInputStream;
263

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

    
285
    /* forced key frames */
286
    int64_t *forced_kf_pts;
287
    int forced_kf_count;
288
    int forced_kf_index;
289

    
290
    /* audio only */
291
    int audio_resample;
292
    ReSampleContext *resample; /* for audio resampling */
293
    int resample_sample_fmt;
294
    int resample_channels;
295
    int resample_sample_rate;
296
    int reformat_pair;
297
    AVAudioConvert *reformat_ctx;
298
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
299
    FILE *logfile;
300

    
301
   int sws_flags;
302
} AVOutputStream;
303

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

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

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

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

    
339
#if CONFIG_AVFILTER
340

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

    
352
    graph = avfilter_graph_alloc();
353

    
354
    if (ist->st->sample_aspect_ratio.num){
355
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
356
    }else
357
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
358

    
359
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
360
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
361
             sample_aspect_ratio.num, sample_aspect_ratio.den);
362

    
363
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
364
                                       "src", args, NULL, graph);
365
    if (ret < 0)
366
        return ret;
367
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
368
                                       "out", NULL, &ffsink_ctx, graph);
369
    if (ret < 0)
370
        return ret;
371
    last_filter = ist->input_video_filter;
372

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

    
386
    snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
387
    graph->scale_sws_opts = av_strdup(args);
388

    
389
    if (vfilters) {
390
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
391
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
392

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

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

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

    
411
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
412
        return ret;
413

    
414
    codec->width  = ist->output_video_filter->inputs[0]->w;
415
    codec->height = ist->output_video_filter->inputs[0]->h;
416
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
417
        ist->output_video_filter->inputs[0]->sample_aspect_ratio;
418

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

    
423
static void term_exit(void)
424
{
425
    av_log(NULL, AV_LOG_QUIET, "");
426
}
427

    
428
static volatile int received_sigterm = 0;
429

    
430
static void
431
sigterm_handler(int sig)
432
{
433
    received_sigterm = sig;
434
    term_exit();
435
}
436

    
437
static void term_init(void)
438
{
439
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
440
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
441
#ifdef SIGXCPU
442
    signal(SIGXCPU, sigterm_handler);
443
#endif
444
}
445

    
446
/* read a key without blocking */
447
static int read_key(void)
448
{
449
#if HAVE_KBHIT
450
    if(kbhit())
451
        return(getch());
452
#endif
453
    return -1;
454
}
455

    
456
static int decode_interrupt_cb(void)
457
{
458
    return q_pressed || (q_pressed = read_key() == 'q');
459
}
460

    
461
static int ffmpeg_exit(int ret)
462
{
463
    int i;
464

    
465
    /* close files */
466
    for(i=0;i<nb_output_files;i++) {
467
        AVFormatContext *s = output_files[i];
468
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
469
            avio_close(s->pb);
470
        avformat_free_context(s);
471
        av_free(output_streams_for_file[i]);
472
    }
473
    for(i=0;i<nb_input_files;i++) {
474
        av_close_input_file(input_files[i]);
475
        av_free(input_files_ts_scale[i]);
476
    }
477

    
478
    av_free(intra_matrix);
479
    av_free(inter_matrix);
480

    
481
    if (vstats_file)
482
        fclose(vstats_file);
483
    av_free(vstats_filename);
484

    
485
    av_free(streamid_map);
486
    av_free(input_codecs);
487
    av_free(output_codecs);
488
    av_free(stream_maps);
489
    av_free(meta_data_maps);
490

    
491
    av_free(video_codec_name);
492
    av_free(audio_codec_name);
493
    av_free(subtitle_codec_name);
494
    av_free(data_codec_name);
495

    
496
    av_free(video_standard);
497

    
498
    uninit_opts();
499
    av_free(audio_buf);
500
    av_free(audio_out);
501
    allocated_audio_buf_size= allocated_audio_out_size= 0;
502
    av_free(samples);
503

    
504
#if CONFIG_AVFILTER
505
    avfilter_uninit();
506
#endif
507

    
508
    if (received_sigterm) {
509
        fprintf(stderr,
510
            "Received signal %d: terminating.\n",
511
            (int) received_sigterm);
512
        exit (255);
513
    }
514

    
515
    exit(ret); /* not all OS-es handle main() return value */
516
    return ret;
517
}
518

    
519
/* similar to ff_dynarray_add() and av_fast_realloc() */
520
static void *grow_array(void *array, int elem_size, int *size, int new_size)
521
{
522
    if (new_size >= INT_MAX / elem_size) {
523
        fprintf(stderr, "Array too big.\n");
524
        ffmpeg_exit(1);
525
    }
526
    if (*size < new_size) {
527
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
528
        if (!tmp) {
529
            fprintf(stderr, "Could not alloc buffer.\n");
530
            ffmpeg_exit(1);
531
        }
532
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
533
        *size = new_size;
534
        return tmp;
535
    }
536
    return array;
537
}
538

    
539
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
540
{
541
    if(codec && codec->sample_fmts){
542
        const enum AVSampleFormat *p= codec->sample_fmts;
543
        for(; *p!=-1; p++){
544
            if(*p == st->codec->sample_fmt)
545
                break;
546
        }
547
        if (*p == -1) {
548
            av_log(NULL, AV_LOG_WARNING,
549
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
550
                   av_get_sample_fmt_name(st->codec->sample_fmt),
551
                   codec->name,
552
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
553
            st->codec->sample_fmt = codec->sample_fmts[0];
554
        }
555
    }
556
}
557

    
558
static void choose_sample_rate(AVStream *st, AVCodec *codec)
559
{
560
    if(codec && codec->supported_samplerates){
561
        const int *p= codec->supported_samplerates;
562
        int best=0;
563
        int best_dist=INT_MAX;
564
        for(; *p; p++){
565
            int dist= abs(st->codec->sample_rate - *p);
566
            if(dist < best_dist){
567
                best_dist= dist;
568
                best= *p;
569
            }
570
        }
571
        if(best_dist){
572
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
573
        }
574
        st->codec->sample_rate= best;
575
    }
576
}
577

    
578
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
579
{
580
    if(codec && codec->pix_fmts){
581
        const enum PixelFormat *p= codec->pix_fmts;
582
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
583
            if(st->codec->codec_id==CODEC_ID_MJPEG){
584
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
585
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
586
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
587
            }
588
        }
589
        for(; *p!=-1; p++){
590
            if(*p == st->codec->pix_fmt)
591
                break;
592
        }
593
        if (*p == -1) {
594
            if(st->codec->pix_fmt != PIX_FMT_NONE)
595
                av_log(NULL, AV_LOG_WARNING,
596
                        "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
597
                        av_pix_fmt_descriptors[st->codec->pix_fmt].name,
598
                        codec->name,
599
                        av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
600
            st->codec->pix_fmt = codec->pix_fmts[0];
601
        }
602
    }
603
}
604

    
605
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
606
{
607
    int idx = oc->nb_streams - 1;
608
    AVOutputStream *ost;
609

    
610
    output_streams_for_file[file_idx] =
611
        grow_array(output_streams_for_file[file_idx],
612
                   sizeof(*output_streams_for_file[file_idx]),
613
                   &nb_output_streams_for_file[file_idx],
614
                   oc->nb_streams);
615
    ost = output_streams_for_file[file_idx][idx] =
616
        av_mallocz(sizeof(AVOutputStream));
617
    if (!ost) {
618
        fprintf(stderr, "Could not alloc output stream\n");
619
        ffmpeg_exit(1);
620
    }
621
    ost->file_index = file_idx;
622
    ost->index = idx;
623

    
624
    ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
625
    return ost;
626
}
627

    
628
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
629
{
630
    int i, err;
631
    AVFormatContext *ic;
632
    int nopts = 0;
633

    
634
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
635
    if (err < 0)
636
        return err;
637
    /* copy stream format */
638
    s->nb_streams = 0;
639
    for(i=0;i<ic->nb_streams;i++) {
640
        AVStream *st;
641
        AVCodec *codec;
642

    
643
        s->nb_streams++;
644

    
645
        // FIXME: a more elegant solution is needed
646
        st = av_mallocz(sizeof(AVStream));
647
        memcpy(st, ic->streams[i], sizeof(AVStream));
648
        st->codec = avcodec_alloc_context();
649
        if (!st->codec) {
650
            print_error(filename, AVERROR(ENOMEM));
651
            ffmpeg_exit(1);
652
        }
653
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
654
        s->streams[i] = st;
655

    
656
        codec = avcodec_find_encoder(st->codec->codec_id);
657
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
658
            if (audio_stream_copy) {
659
                st->stream_copy = 1;
660
            } else
661
                choose_sample_fmt(st, codec);
662
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
663
            if (video_stream_copy) {
664
                st->stream_copy = 1;
665
            } else
666
                choose_pixel_fmt(st, codec);
667
        }
668

    
669
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
670
            nopts = 1;
671

    
672
        new_output_stream(s, nb_output_files);
673
    }
674

    
675
    if (!nopts)
676
        s->timestamp = av_gettime();
677

    
678
    av_close_input_file(ic);
679
    return 0;
680
}
681

    
682
static double
683
get_sync_ipts(const AVOutputStream *ost)
684
{
685
    const AVInputStream *ist = ost->sync_ist;
686
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
687
}
688

    
689
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
690
    int ret;
691

    
692
    while(bsfc){
693
        AVPacket new_pkt= *pkt;
694
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
695
                                          &new_pkt.data, &new_pkt.size,
696
                                          pkt->data, pkt->size,
697
                                          pkt->flags & AV_PKT_FLAG_KEY);
698
        if(a>0){
699
            av_free_packet(pkt);
700
            new_pkt.destruct= av_destruct_packet;
701
        } else if(a<0){
702
            fprintf(stderr, "%s failed for stream %d, codec %s",
703
                    bsfc->filter->name, pkt->stream_index,
704
                    avctx->codec ? avctx->codec->name : "copy");
705
            print_error("", a);
706
            if (exit_on_error)
707
                ffmpeg_exit(1);
708
        }
709
        *pkt= new_pkt;
710

    
711
        bsfc= bsfc->next;
712
    }
713

    
714
    ret= av_interleaved_write_frame(s, pkt);
715
    if(ret < 0){
716
        print_error("av_interleaved_write_frame()", ret);
717
        ffmpeg_exit(1);
718
    }
719
}
720

    
721
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
722

    
723
static void do_audio_out(AVFormatContext *s,
724
                         AVOutputStream *ost,
725
                         AVInputStream *ist,
726
                         unsigned char *buf, int size)
727
{
728
    uint8_t *buftmp;
729
    int64_t audio_out_size, audio_buf_size;
730
    int64_t allocated_for_size= size;
731

    
732
    int size_out, frame_bytes, ret, resample_changed;
733
    AVCodecContext *enc= ost->st->codec;
734
    AVCodecContext *dec= ist->st->codec;
735
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
736
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
737
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
738

    
739
need_realloc:
740
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
741
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
742
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
743
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
744
    audio_buf_size*= osize*enc->channels;
745

    
746
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
747
    if(coded_bps > 8*osize)
748
        audio_out_size= audio_out_size * coded_bps / (8*osize);
749
    audio_out_size += FF_MIN_BUFFER_SIZE;
750

    
751
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
752
        fprintf(stderr, "Buffer sizes too large\n");
753
        ffmpeg_exit(1);
754
    }
755

    
756
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
757
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
758
    if (!audio_buf || !audio_out){
759
        fprintf(stderr, "Out of memory in do_audio_out\n");
760
        ffmpeg_exit(1);
761
    }
762

    
763
    if (enc->channels != dec->channels)
764
        ost->audio_resample = 1;
765

    
766
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
767
                       ost->resample_channels    != dec->channels   ||
768
                       ost->resample_sample_rate != dec->sample_rate;
769

    
770
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
771
        if (resample_changed) {
772
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
773
                   ist->file_index, ist->index,
774
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
775
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
776
            ost->resample_sample_fmt  = dec->sample_fmt;
777
            ost->resample_channels    = dec->channels;
778
            ost->resample_sample_rate = dec->sample_rate;
779
            if (ost->resample)
780
                audio_resample_close(ost->resample);
781
        }
782
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
783
        if (audio_sync_method <= 1 &&
784
            ost->resample_sample_fmt  == enc->sample_fmt &&
785
            ost->resample_channels    == enc->channels   &&
786
            ost->resample_sample_rate == enc->sample_rate) {
787
            ost->resample = NULL;
788
            ost->audio_resample = 0;
789
        } else {
790
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
791
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
792
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
793
                                                   enc->sample_rate, dec->sample_rate,
794
                                                   enc->sample_fmt,  dec->sample_fmt,
795
                                                   16, 10, 0, 0.8);
796
            if (!ost->resample) {
797
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
798
                        dec->channels, dec->sample_rate,
799
                        enc->channels, enc->sample_rate);
800
                ffmpeg_exit(1);
801
            }
802
        }
803
    }
804

    
805
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
806
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
807
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
808
        if (ost->reformat_ctx)
809
            av_audio_convert_free(ost->reformat_ctx);
810
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
811
                                                   dec->sample_fmt, 1, NULL, 0);
812
        if (!ost->reformat_ctx) {
813
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
814
                av_get_sample_fmt_name(dec->sample_fmt),
815
                av_get_sample_fmt_name(enc->sample_fmt));
816
            ffmpeg_exit(1);
817
        }
818
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
819
    }
820

    
821
    if(audio_sync_method){
822
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
823
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
824
        double idelta= delta*dec->sample_rate / enc->sample_rate;
825
        int byte_delta= ((int)idelta)*2*dec->channels;
826

    
827
        //FIXME resample delay
828
        if(fabs(delta) > 50){
829
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
830
                if(byte_delta < 0){
831
                    byte_delta= FFMAX(byte_delta, -size);
832
                    size += byte_delta;
833
                    buf  -= byte_delta;
834
                    if(verbose > 2)
835
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
836
                    if(!size)
837
                        return;
838
                    ist->is_start=0;
839
                }else{
840
                    static uint8_t *input_tmp= NULL;
841
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
842

    
843
                    if(byte_delta > allocated_for_size - size){
844
                        allocated_for_size= byte_delta + (int64_t)size;
845
                        goto need_realloc;
846
                    }
847
                    ist->is_start=0;
848

    
849
                    memset(input_tmp, 0, byte_delta);
850
                    memcpy(input_tmp + byte_delta, buf, size);
851
                    buf= input_tmp;
852
                    size += byte_delta;
853
                    if(verbose > 2)
854
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
855
                }
856
            }else if(audio_sync_method>1){
857
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
858
                av_assert0(ost->audio_resample);
859
                if(verbose > 2)
860
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
861
//                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));
862
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
863
            }
864
        }
865
    }else
866
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
867
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
868

    
869
    if (ost->audio_resample) {
870
        buftmp = audio_buf;
871
        size_out = audio_resample(ost->resample,
872
                                  (short *)buftmp, (short *)buf,
873
                                  size / (dec->channels * isize));
874
        size_out = size_out * enc->channels * osize;
875
    } else {
876
        buftmp = buf;
877
        size_out = size;
878
    }
879

    
880
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
881
        const void *ibuf[6]= {buftmp};
882
        void *obuf[6]= {audio_buf};
883
        int istride[6]= {isize};
884
        int ostride[6]= {osize};
885
        int len= size_out/istride[0];
886
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
887
            printf("av_audio_convert() failed\n");
888
            if (exit_on_error)
889
                ffmpeg_exit(1);
890
            return;
891
        }
892
        buftmp = audio_buf;
893
        size_out = len*osize;
894
    }
895

    
896
    /* now encode as many frames as possible */
897
    if (enc->frame_size > 1) {
898
        /* output resampled raw samples */
899
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
900
            fprintf(stderr, "av_fifo_realloc2() failed\n");
901
            ffmpeg_exit(1);
902
        }
903
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
904

    
905
        frame_bytes = enc->frame_size * osize * enc->channels;
906

    
907
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
908
            AVPacket pkt;
909
            av_init_packet(&pkt);
910

    
911
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
912

    
913
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
914

    
915
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
916
                                       (short *)audio_buf);
917
            if (ret < 0) {
918
                fprintf(stderr, "Audio encoding failed\n");
919
                ffmpeg_exit(1);
920
            }
921
            audio_size += ret;
922
            pkt.stream_index= ost->index;
923
            pkt.data= audio_out;
924
            pkt.size= ret;
925
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
926
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
927
            pkt.flags |= AV_PKT_FLAG_KEY;
928
            write_frame(s, &pkt, enc, ost->bitstream_filters);
929

    
930
            ost->sync_opts += enc->frame_size;
931
        }
932
    } else {
933
        AVPacket pkt;
934
        av_init_packet(&pkt);
935

    
936
        ost->sync_opts += size_out / (osize * enc->channels);
937

    
938
        /* output a pcm frame */
939
        /* determine the size of the coded buffer */
940
        size_out /= osize;
941
        if (coded_bps)
942
            size_out = size_out*coded_bps/8;
943

    
944
        if(size_out > audio_out_size){
945
            fprintf(stderr, "Internal error, buffer size too small\n");
946
            ffmpeg_exit(1);
947
        }
948

    
949
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
950
        ret = avcodec_encode_audio(enc, audio_out, size_out,
951
                                   (short *)buftmp);
952
        if (ret < 0) {
953
            fprintf(stderr, "Audio encoding failed\n");
954
            ffmpeg_exit(1);
955
        }
956
        audio_size += ret;
957
        pkt.stream_index= ost->index;
958
        pkt.data= audio_out;
959
        pkt.size= ret;
960
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
961
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
962
        pkt.flags |= AV_PKT_FLAG_KEY;
963
        write_frame(s, &pkt, enc, ost->bitstream_filters);
964
    }
965
}
966

    
967
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
968
{
969
    AVCodecContext *dec;
970
    AVPicture *picture2;
971
    AVPicture picture_tmp;
972
    uint8_t *buf = 0;
973

    
974
    dec = ist->st->codec;
975

    
976
    /* deinterlace : must be done before any resize */
977
    if (do_deinterlace) {
978
        int size;
979

    
980
        /* create temporary picture */
981
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
982
        buf = av_malloc(size);
983
        if (!buf)
984
            return;
985

    
986
        picture2 = &picture_tmp;
987
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
988

    
989
        if(avpicture_deinterlace(picture2, picture,
990
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
991
            /* if error, do not deinterlace */
992
            fprintf(stderr, "Deinterlacing failed\n");
993
            av_free(buf);
994
            buf = NULL;
995
            picture2 = picture;
996
        }
997
    } else {
998
        picture2 = picture;
999
    }
1000

    
1001
    if (picture != picture2)
1002
        *picture = *picture2;
1003
    *bufp = buf;
1004
}
1005

    
1006
/* we begin to correct av delay at this threshold */
1007
#define AV_DELAY_MAX 0.100
1008

    
1009
static void do_subtitle_out(AVFormatContext *s,
1010
                            AVOutputStream *ost,
1011
                            AVInputStream *ist,
1012
                            AVSubtitle *sub,
1013
                            int64_t pts)
1014
{
1015
    static uint8_t *subtitle_out = NULL;
1016
    int subtitle_out_max_size = 1024 * 1024;
1017
    int subtitle_out_size, nb, i;
1018
    AVCodecContext *enc;
1019
    AVPacket pkt;
1020

    
1021
    if (pts == AV_NOPTS_VALUE) {
1022
        fprintf(stderr, "Subtitle packets must have a pts\n");
1023
        if (exit_on_error)
1024
            ffmpeg_exit(1);
1025
        return;
1026
    }
1027

    
1028
    enc = ost->st->codec;
1029

    
1030
    if (!subtitle_out) {
1031
        subtitle_out = av_malloc(subtitle_out_max_size);
1032
    }
1033

    
1034
    /* Note: DVB subtitle need one packet to draw them and one other
1035
       packet to clear them */
1036
    /* XXX: signal it in the codec context ? */
1037
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1038
        nb = 2;
1039
    else
1040
        nb = 1;
1041

    
1042
    for(i = 0; i < nb; i++) {
1043
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1044
        // start_display_time is required to be 0
1045
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1046
        sub->end_display_time -= sub->start_display_time;
1047
        sub->start_display_time = 0;
1048
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1049
                                                    subtitle_out_max_size, sub);
1050
        if (subtitle_out_size < 0) {
1051
            fprintf(stderr, "Subtitle encoding failed\n");
1052
            ffmpeg_exit(1);
1053
        }
1054

    
1055
        av_init_packet(&pkt);
1056
        pkt.stream_index = ost->index;
1057
        pkt.data = subtitle_out;
1058
        pkt.size = subtitle_out_size;
1059
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1060
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1061
            /* XXX: the pts correction is handled here. Maybe handling
1062
               it in the codec would be better */
1063
            if (i == 0)
1064
                pkt.pts += 90 * sub->start_display_time;
1065
            else
1066
                pkt.pts += 90 * sub->end_display_time;
1067
        }
1068
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1069
    }
1070
}
1071

    
1072
static int bit_buffer_size= 1024*256;
1073
static uint8_t *bit_buffer= NULL;
1074

    
1075
static void do_video_out(AVFormatContext *s,
1076
                         AVOutputStream *ost,
1077
                         AVInputStream *ist,
1078
                         AVFrame *in_picture,
1079
                         int *frame_size)
1080
{
1081
    int nb_frames, i, ret, resample_changed;
1082
    AVFrame *final_picture, *formatted_picture, *resampling_dst;
1083
    AVCodecContext *enc, *dec;
1084
    double sync_ipts;
1085

    
1086
    enc = ost->st->codec;
1087
    dec = ist->st->codec;
1088

    
1089
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1090

    
1091
    /* by default, we output a single frame */
1092
    nb_frames = 1;
1093

    
1094
    *frame_size = 0;
1095

    
1096
    if(video_sync_method){
1097
        double vdelta = sync_ipts - ost->sync_opts;
1098
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1099
        if (vdelta < -1.1)
1100
            nb_frames = 0;
1101
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1102
            if(vdelta<=-0.6){
1103
                nb_frames=0;
1104
            }else if(vdelta>0.6)
1105
                ost->sync_opts= lrintf(sync_ipts);
1106
        }else if (vdelta > 1.1)
1107
            nb_frames = lrintf(vdelta);
1108
//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);
1109
        if (nb_frames == 0){
1110
            ++nb_frames_drop;
1111
            if (verbose>2)
1112
                fprintf(stderr, "*** drop!\n");
1113
        }else if (nb_frames > 1) {
1114
            nb_frames_dup += nb_frames - 1;
1115
            if (verbose>2)
1116
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1117
        }
1118
    }else
1119
        ost->sync_opts= lrintf(sync_ipts);
1120

    
1121
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1122
    if (nb_frames <= 0)
1123
        return;
1124

    
1125
    formatted_picture = in_picture;
1126
    final_picture = formatted_picture;
1127
    resampling_dst = &ost->pict_tmp;
1128

    
1129
    resample_changed = ost->resample_width   != dec->width  ||
1130
                       ost->resample_height  != dec->height ||
1131
                       ost->resample_pix_fmt != dec->pix_fmt;
1132

    
1133
    if (resample_changed) {
1134
        av_log(NULL, AV_LOG_INFO,
1135
               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1136
               ist->file_index, ist->index,
1137
               ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1138
               dec->width         , dec->height         , avcodec_get_pix_fmt_name(dec->pix_fmt));
1139
        if(!ost->video_resample)
1140
            ffmpeg_exit(1);
1141
    }
1142

    
1143
#if !CONFIG_AVFILTER
1144
    if (ost->video_resample) {
1145
        final_picture = &ost->pict_tmp;
1146
        if (resample_changed) {
1147
            /* initialize a new scaler context */
1148
            sws_freeContext(ost->img_resample_ctx);
1149
            ost->img_resample_ctx = sws_getContext(
1150
                ist->st->codec->width,
1151
                ist->st->codec->height,
1152
                ist->st->codec->pix_fmt,
1153
                ost->st->codec->width,
1154
                ost->st->codec->height,
1155
                ost->st->codec->pix_fmt,
1156
                ost->sws_flags, NULL, NULL, NULL);
1157
            if (ost->img_resample_ctx == NULL) {
1158
                fprintf(stderr, "Cannot get resampling context\n");
1159
                ffmpeg_exit(1);
1160
            }
1161
        }
1162
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1163
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1164
    }
1165
#endif
1166

    
1167
    /* duplicates frame if needed */
1168
    for(i=0;i<nb_frames;i++) {
1169
        AVPacket pkt;
1170
        av_init_packet(&pkt);
1171
        pkt.stream_index= ost->index;
1172

    
1173
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1174
            /* raw pictures are written as AVPicture structure to
1175
               avoid any copies. We support temorarily the older
1176
               method. */
1177
            AVFrame* old_frame = enc->coded_frame;
1178
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1179
            pkt.data= (uint8_t *)final_picture;
1180
            pkt.size=  sizeof(AVPicture);
1181
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1182
            pkt.flags |= AV_PKT_FLAG_KEY;
1183

    
1184
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1185
            enc->coded_frame = old_frame;
1186
        } else {
1187
            AVFrame big_picture;
1188

    
1189
            big_picture= *final_picture;
1190
            /* better than nothing: use input picture interlaced
1191
               settings */
1192
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1193
            if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1194
                if(top_field_first == -1)
1195
                    big_picture.top_field_first = in_picture->top_field_first;
1196
                else
1197
                    big_picture.top_field_first = top_field_first;
1198
            }
1199

    
1200
            /* handles sameq here. This is not correct because it may
1201
               not be a global option */
1202
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1203
            if(!me_threshold)
1204
                big_picture.pict_type = 0;
1205
//            big_picture.pts = AV_NOPTS_VALUE;
1206
            big_picture.pts= ost->sync_opts;
1207
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1208
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1209
            if (ost->forced_kf_index < ost->forced_kf_count &&
1210
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1211
                big_picture.pict_type = AV_PICTURE_TYPE_I;
1212
                ost->forced_kf_index++;
1213
            }
1214
            ret = avcodec_encode_video(enc,
1215
                                       bit_buffer, bit_buffer_size,
1216
                                       &big_picture);
1217
            if (ret < 0) {
1218
                fprintf(stderr, "Video encoding failed\n");
1219
                ffmpeg_exit(1);
1220
            }
1221

    
1222
            if(ret>0){
1223
                pkt.data= bit_buffer;
1224
                pkt.size= ret;
1225
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1226
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1227
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1228
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1229
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1230

    
1231
                if(enc->coded_frame->key_frame)
1232
                    pkt.flags |= AV_PKT_FLAG_KEY;
1233
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1234
                *frame_size = ret;
1235
                video_size += ret;
1236
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1237
                //        enc->frame_number-1, ret, enc->pict_type);
1238
                /* if two pass, output log */
1239
                if (ost->logfile && enc->stats_out) {
1240
                    fprintf(ost->logfile, "%s", enc->stats_out);
1241
                }
1242
            }
1243
        }
1244
        ost->sync_opts++;
1245
        ost->frame_number++;
1246
    }
1247
}
1248

    
1249
static double psnr(double d){
1250
    return -10.0*log(d)/log(10.0);
1251
}
1252

    
1253
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1254
                           int frame_size)
1255
{
1256
    AVCodecContext *enc;
1257
    int frame_number;
1258
    double ti1, bitrate, avg_bitrate;
1259

    
1260
    /* this is executed just the first time do_video_stats is called */
1261
    if (!vstats_file) {
1262
        vstats_file = fopen(vstats_filename, "w");
1263
        if (!vstats_file) {
1264
            perror("fopen");
1265
            ffmpeg_exit(1);
1266
        }
1267
    }
1268

    
1269
    enc = ost->st->codec;
1270
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1271
        frame_number = ost->frame_number;
1272
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1273
        if (enc->flags&CODEC_FLAG_PSNR)
1274
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1275

    
1276
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1277
        /* compute pts value */
1278
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1279
        if (ti1 < 0.01)
1280
            ti1 = 0.01;
1281

    
1282
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1283
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1284
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1285
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1286
        fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1287
    }
1288
}
1289

    
1290
static void print_report(AVFormatContext **output_files,
1291
                         AVOutputStream **ost_table, int nb_ostreams,
1292
                         int is_last_report)
1293
{
1294
    char buf[1024];
1295
    AVOutputStream *ost;
1296
    AVFormatContext *oc;
1297
    int64_t total_size;
1298
    AVCodecContext *enc;
1299
    int frame_number, vid, i;
1300
    double bitrate, ti1, pts;
1301
    static int64_t last_time = -1;
1302
    static int qp_histogram[52];
1303

    
1304
    if (!is_last_report) {
1305
        int64_t cur_time;
1306
        /* display the report every 0.5 seconds */
1307
        cur_time = av_gettime();
1308
        if (last_time == -1) {
1309
            last_time = cur_time;
1310
            return;
1311
        }
1312
        if ((cur_time - last_time) < 500000)
1313
            return;
1314
        last_time = cur_time;
1315
    }
1316

    
1317

    
1318
    oc = output_files[0];
1319

    
1320
    total_size = avio_size(oc->pb);
1321
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1322
        total_size= avio_tell(oc->pb);
1323

    
1324
    buf[0] = '\0';
1325
    ti1 = 1e10;
1326
    vid = 0;
1327
    for(i=0;i<nb_ostreams;i++) {
1328
        ost = ost_table[i];
1329
        enc = ost->st->codec;
1330
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1331
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1332
                     !ost->st->stream_copy ?
1333
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1334
        }
1335
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1336
            float t = (av_gettime()-timer_start) / 1000000.0;
1337

    
1338
            frame_number = ost->frame_number;
1339
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1340
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1341
                     !ost->st->stream_copy ?
1342
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1343
            if(is_last_report)
1344
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1345
            if(qp_hist){
1346
                int j;
1347
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1348
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1349
                    qp_histogram[qp]++;
1350
                for(j=0; j<32; j++)
1351
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1352
            }
1353
            if (enc->flags&CODEC_FLAG_PSNR){
1354
                int j;
1355
                double error, error_sum=0;
1356
                double scale, scale_sum=0;
1357
                char type[3]= {'Y','U','V'};
1358
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1359
                for(j=0; j<3; j++){
1360
                    if(is_last_report){
1361
                        error= enc->error[j];
1362
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1363
                    }else{
1364
                        error= enc->coded_frame->error[j];
1365
                        scale= enc->width*enc->height*255.0*255.0;
1366
                    }
1367
                    if(j) scale/=4;
1368
                    error_sum += error;
1369
                    scale_sum += scale;
1370
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1371
                }
1372
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1373
            }
1374
            vid = 1;
1375
        }
1376
        /* compute min output value */
1377
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1378
        if ((pts < ti1) && (pts > 0))
1379
            ti1 = pts;
1380
    }
1381
    if (ti1 < 0.01)
1382
        ti1 = 0.01;
1383

    
1384
    if (verbose > 0 || is_last_report) {
1385
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1386

    
1387
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1388
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1389
            (double)total_size / 1024, ti1, bitrate);
1390

    
1391
        if (nb_frames_dup || nb_frames_drop)
1392
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1393
                  nb_frames_dup, nb_frames_drop);
1394

    
1395
        if (verbose >= 0)
1396
            fprintf(stderr, "%s    \r", buf);
1397

    
1398
        fflush(stderr);
1399
    }
1400

    
1401
    if (is_last_report && verbose >= 0){
1402
        int64_t raw= audio_size + video_size + extra_size;
1403
        fprintf(stderr, "\n");
1404
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1405
                video_size/1024.0,
1406
                audio_size/1024.0,
1407
                extra_size/1024.0,
1408
                100.0*(total_size - raw)/raw
1409
        );
1410
    }
1411
}
1412

    
1413
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1414
{
1415
    int fill_char = 0x00;
1416
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1417
        fill_char = 0x80;
1418
    memset(buf, fill_char, size);
1419
}
1420

    
1421
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1422
static int output_packet(AVInputStream *ist, int ist_index,
1423
                         AVOutputStream **ost_table, int nb_ostreams,
1424
                         const AVPacket *pkt)
1425
{
1426
    AVFormatContext *os;
1427
    AVOutputStream *ost;
1428
    int ret, i;
1429
    int got_output;
1430
    AVFrame picture;
1431
    void *buffer_to_free = NULL;
1432
    static unsigned int samples_size= 0;
1433
    AVSubtitle subtitle, *subtitle_to_free;
1434
    int64_t pkt_pts = AV_NOPTS_VALUE;
1435
#if CONFIG_AVFILTER
1436
    int frame_available;
1437
#endif
1438

    
1439
    AVPacket avpkt;
1440
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1441

    
1442
    if(ist->next_pts == AV_NOPTS_VALUE)
1443
        ist->next_pts= ist->pts;
1444

    
1445
    if (pkt == NULL) {
1446
        /* EOF handling */
1447
        av_init_packet(&avpkt);
1448
        avpkt.data = NULL;
1449
        avpkt.size = 0;
1450
        goto handle_eof;
1451
    } else {
1452
        avpkt = *pkt;
1453
    }
1454

    
1455
    if(pkt->dts != AV_NOPTS_VALUE)
1456
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1457
    if(pkt->pts != AV_NOPTS_VALUE)
1458
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1459

    
1460
    //while we have more to decode or while the decoder did output something on EOF
1461
    while (avpkt.size > 0 || (!pkt && got_output)) {
1462
        uint8_t *data_buf, *decoded_data_buf;
1463
        int data_size, decoded_data_size;
1464
    handle_eof:
1465
        ist->pts= ist->next_pts;
1466

    
1467
        if(avpkt.size && avpkt.size != pkt->size &&
1468
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1469
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1470
            ist->showed_multi_packet_warning=1;
1471
        }
1472

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

    
1516
                    ret = avcodec_decode_video2(ist->st->codec,
1517
                                                &picture, &got_output, &avpkt);
1518
                    ist->st->quality= picture.quality;
1519
                    if (ret < 0)
1520
                        goto fail_decode;
1521
                    if (!got_output) {
1522
                        /* no picture yet */
1523
                        goto discard_packet;
1524
                    }
1525
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1526
                    if (ist->st->codec->time_base.num != 0) {
1527
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1528
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1529
                                          ist->st->codec->time_base.num * ticks) /
1530
                            ist->st->codec->time_base.den;
1531
                    }
1532
                    avpkt.size = 0;
1533
                    buffer_to_free = NULL;
1534
                    pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1535
                    break;
1536
            case AVMEDIA_TYPE_SUBTITLE:
1537
                ret = avcodec_decode_subtitle2(ist->st->codec,
1538
                                               &subtitle, &got_output, &avpkt);
1539
                if (ret < 0)
1540
                    goto fail_decode;
1541
                if (!got_output) {
1542
                    goto discard_packet;
1543
                }
1544
                subtitle_to_free = &subtitle;
1545
                avpkt.size = 0;
1546
                break;
1547
            default:
1548
                goto fail_decode;
1549
            }
1550
        } else {
1551
            switch(ist->st->codec->codec_type) {
1552
            case AVMEDIA_TYPE_AUDIO:
1553
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1554
                    ist->st->codec->sample_rate;
1555
                break;
1556
            case AVMEDIA_TYPE_VIDEO:
1557
                if (ist->st->codec->time_base.num != 0) {
1558
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1559
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1560
                                      ist->st->codec->time_base.num * ticks) /
1561
                        ist->st->codec->time_base.den;
1562
                }
1563
                break;
1564
            }
1565
            ret = avpkt.size;
1566
            avpkt.size = 0;
1567
        }
1568

    
1569
#if CONFIG_AVFILTER
1570
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1571
            AVRational sar;
1572
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1573
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1574
            // add it to be filtered
1575
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1576
                                     ist->pts,
1577
                                     sar);
1578
        }
1579
#endif
1580

    
1581
        // preprocess audio (volume)
1582
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1583
            if (audio_volume != 256) {
1584
                short *volp;
1585
                volp = samples;
1586
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1587
                    int v = ((*volp) * audio_volume + 128) >> 8;
1588
                    if (v < -32768) v = -32768;
1589
                    if (v >  32767) v = 32767;
1590
                    *volp++ = v;
1591
                }
1592
            }
1593
        }
1594

    
1595
        /* frame rate emulation */
1596
        if (rate_emu) {
1597
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1598
            int64_t now = av_gettime() - ist->start;
1599
            if (pts > now)
1600
                usleep(pts - now);
1601
        }
1602
#if CONFIG_AVFILTER
1603
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1604
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1605
#endif
1606
        /* if output time reached then transcode raw format,
1607
           encode packets and output them */
1608
        if (start_time == 0 || ist->pts >= start_time)
1609
#if CONFIG_AVFILTER
1610
        while (frame_available) {
1611
            AVRational ist_pts_tb;
1612
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1613
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1614
            if (ist->picref)
1615
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1616
#endif
1617
            for(i=0;i<nb_ostreams;i++) {
1618
                int frame_size;
1619

    
1620
                ost = ost_table[i];
1621
                if (ost->source_index == ist_index) {
1622
                    os = output_files[ost->file_index];
1623

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

    
1627
                    if (ost->encoding_needed) {
1628
                        av_assert0(ist->decoding_needed);
1629
                        switch(ost->st->codec->codec_type) {
1630
                        case AVMEDIA_TYPE_AUDIO:
1631
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1632
                            break;
1633
                        case AVMEDIA_TYPE_VIDEO:
1634
#if CONFIG_AVFILTER
1635
                            if (ist->picref->video)
1636
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1637
#endif
1638
                            do_video_out(os, ost, ist, &picture, &frame_size);
1639
                            if (vstats_filename && frame_size)
1640
                                do_video_stats(os, ost, frame_size);
1641
                            break;
1642
                        case AVMEDIA_TYPE_SUBTITLE:
1643
                            do_subtitle_out(os, ost, ist, &subtitle,
1644
                                            pkt->pts);
1645
                            break;
1646
                        default:
1647
                            abort();
1648
                        }
1649
                    } else {
1650
                        AVFrame avframe; //FIXME/XXX remove this
1651
                        AVPacket opkt;
1652
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1653

    
1654
                        av_init_packet(&opkt);
1655

    
1656
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1657
                            continue;
1658

    
1659
                        /* no reencoding needed : output the packet directly */
1660
                        /* force the input stream PTS */
1661

    
1662
                        avcodec_get_frame_defaults(&avframe);
1663
                        ost->st->codec->coded_frame= &avframe;
1664
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1665

    
1666
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1667
                            audio_size += data_size;
1668
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1669
                            video_size += data_size;
1670
                            ost->sync_opts++;
1671
                        }
1672

    
1673
                        opkt.stream_index= ost->index;
1674
                        if(pkt->pts != AV_NOPTS_VALUE)
1675
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1676
                        else
1677
                            opkt.pts= AV_NOPTS_VALUE;
1678

    
1679
                        if (pkt->dts == AV_NOPTS_VALUE)
1680
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1681
                        else
1682
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1683
                        opkt.dts -= ost_tb_start_time;
1684

    
1685
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1686
                        opkt.flags= pkt->flags;
1687

    
1688
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1689
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1690
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1691
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1692
                           ) {
1693
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1694
                                opkt.destruct= av_destruct_packet;
1695
                        } else {
1696
                            opkt.data = data_buf;
1697
                            opkt.size = data_size;
1698
                        }
1699

    
1700
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1701
                        ost->st->codec->frame_number++;
1702
                        ost->frame_number++;
1703
                        av_free_packet(&opkt);
1704
                    }
1705
                }
1706
            }
1707

    
1708
#if CONFIG_AVFILTER
1709
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1710
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1711
            if(ist->picref)
1712
                avfilter_unref_buffer(ist->picref);
1713
        }
1714
#endif
1715
        av_free(buffer_to_free);
1716
        /* XXX: allocate the subtitles in the codec ? */
1717
        if (subtitle_to_free) {
1718
            avsubtitle_free(subtitle_to_free);
1719
            subtitle_to_free = NULL;
1720
        }
1721
    }
1722
 discard_packet:
1723
    if (pkt == NULL) {
1724
        /* EOF handling */
1725

    
1726
        for(i=0;i<nb_ostreams;i++) {
1727
            ost = ost_table[i];
1728
            if (ost->source_index == ist_index) {
1729
                AVCodecContext *enc= ost->st->codec;
1730
                os = output_files[ost->file_index];
1731

    
1732
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1733
                    continue;
1734
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1735
                    continue;
1736

    
1737
                if (ost->encoding_needed) {
1738
                    for(;;) {
1739
                        AVPacket pkt;
1740
                        int fifo_bytes;
1741
                        av_init_packet(&pkt);
1742
                        pkt.stream_index= ost->index;
1743

    
1744
                        switch(ost->st->codec->codec_type) {
1745
                        case AVMEDIA_TYPE_AUDIO:
1746
                            fifo_bytes = av_fifo_size(ost->fifo);
1747
                            ret = 0;
1748
                            /* encode any samples remaining in fifo */
1749
                            if (fifo_bytes > 0) {
1750
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1751
                                int fs_tmp = enc->frame_size;
1752

    
1753
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1754
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1755
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1756
                                } else { /* pad */
1757
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1758
                                    if (allocated_audio_buf_size < frame_bytes)
1759
                                        ffmpeg_exit(1);
1760
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1761
                                }
1762

    
1763
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1764
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1765
                                                          ost->st->time_base.num, enc->sample_rate);
1766
                                enc->frame_size = fs_tmp;
1767
                            }
1768
                            if(ret <= 0) {
1769
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1770
                            }
1771
                            if (ret < 0) {
1772
                                fprintf(stderr, "Audio encoding failed\n");
1773
                                ffmpeg_exit(1);
1774
                            }
1775
                            audio_size += ret;
1776
                            pkt.flags |= AV_PKT_FLAG_KEY;
1777
                            break;
1778
                        case AVMEDIA_TYPE_VIDEO:
1779
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1780
                            if (ret < 0) {
1781
                                fprintf(stderr, "Video encoding failed\n");
1782
                                ffmpeg_exit(1);
1783
                            }
1784
                            video_size += ret;
1785
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1786
                                pkt.flags |= AV_PKT_FLAG_KEY;
1787
                            if (ost->logfile && enc->stats_out) {
1788
                                fprintf(ost->logfile, "%s", enc->stats_out);
1789
                            }
1790
                            break;
1791
                        default:
1792
                            ret=-1;
1793
                        }
1794

    
1795
                        if(ret<=0)
1796
                            break;
1797
                        pkt.data= bit_buffer;
1798
                        pkt.size= ret;
1799
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1800
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1801
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1802
                    }
1803
                }
1804
            }
1805
        }
1806
    }
1807

    
1808
    return 0;
1809
 fail_decode:
1810
    return -1;
1811
}
1812

    
1813
static void print_sdp(AVFormatContext **avc, int n)
1814
{
1815
    char sdp[2048];
1816

    
1817
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1818
    printf("SDP:\n%s\n", sdp);
1819
    fflush(stdout);
1820
}
1821

    
1822
static int copy_chapters(int infile, int outfile)
1823
{
1824
    AVFormatContext *is = input_files[infile];
1825
    AVFormatContext *os = output_files[outfile];
1826
    int i;
1827

    
1828
    for (i = 0; i < is->nb_chapters; i++) {
1829
        AVChapter *in_ch = is->chapters[i], *out_ch;
1830
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1831
                                      AV_TIME_BASE_Q, in_ch->time_base);
1832
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1833
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1834

    
1835

    
1836
        if (in_ch->end < ts_off)
1837
            continue;
1838
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1839
            break;
1840

    
1841
        out_ch = av_mallocz(sizeof(AVChapter));
1842
        if (!out_ch)
1843
            return AVERROR(ENOMEM);
1844

    
1845
        out_ch->id        = in_ch->id;
1846
        out_ch->time_base = in_ch->time_base;
1847
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1848
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1849

    
1850
        if (metadata_chapters_autocopy)
1851
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1852

    
1853
        os->nb_chapters++;
1854
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1855
        if (!os->chapters)
1856
            return AVERROR(ENOMEM);
1857
        os->chapters[os->nb_chapters - 1] = out_ch;
1858
    }
1859
    return 0;
1860
}
1861

    
1862
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1863
                                    AVCodecContext *avctx)
1864
{
1865
    char *p;
1866
    int n = 1, i;
1867
    int64_t t;
1868

    
1869
    for (p = kf; *p; p++)
1870
        if (*p == ',')
1871
            n++;
1872
    ost->forced_kf_count = n;
1873
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1874
    if (!ost->forced_kf_pts) {
1875
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1876
        ffmpeg_exit(1);
1877
    }
1878
    for (i = 0; i < n; i++) {
1879
        p = i ? strchr(p, ',') + 1 : kf;
1880
        t = parse_time_or_die("force_key_frames", p, 1);
1881
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1882
    }
1883
}
1884

    
1885
/*
1886
 * The following code is the main loop of the file converter
1887
 */
1888
static int transcode(AVFormatContext **output_files,
1889
                     int nb_output_files,
1890
                     AVFormatContext **input_files,
1891
                     int nb_input_files,
1892
                     AVStreamMap *stream_maps, int nb_stream_maps)
1893
{
1894
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1895
    AVFormatContext *is, *os;
1896
    AVCodecContext *codec, *icodec;
1897
    AVOutputStream *ost, **ost_table = NULL;
1898
    AVInputStream *ist, **ist_table = NULL;
1899
    AVInputFile *file_table;
1900
    char error[1024];
1901
    int key;
1902
    int want_sdp = 1;
1903
    uint8_t no_packet[MAX_FILES]={0};
1904
    int no_packet_count=0;
1905

    
1906
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1907
    if (!file_table)
1908
        goto fail;
1909

    
1910
    /* input stream init */
1911
    j = 0;
1912
    for(i=0;i<nb_input_files;i++) {
1913
        is = input_files[i];
1914
        file_table[i].ist_index = j;
1915
        file_table[i].nb_streams = is->nb_streams;
1916
        j += is->nb_streams;
1917
    }
1918
    nb_istreams = j;
1919

    
1920
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1921
    if (!ist_table)
1922
        goto fail;
1923

    
1924
    for(i=0;i<nb_istreams;i++) {
1925
        ist = av_mallocz(sizeof(AVInputStream));
1926
        if (!ist)
1927
            goto fail;
1928
        ist_table[i] = ist;
1929
    }
1930
    j = 0;
1931
    for(i=0;i<nb_input_files;i++) {
1932
        is = input_files[i];
1933
        for(k=0;k<is->nb_streams;k++) {
1934
            ist = ist_table[j++];
1935
            ist->st = is->streams[k];
1936
            ist->file_index = i;
1937
            ist->index = k;
1938
            ist->discard = 1; /* the stream is discarded by default
1939
                                 (changed later) */
1940

    
1941
            if (rate_emu) {
1942
                ist->start = av_gettime();
1943
            }
1944
        }
1945
    }
1946

    
1947
    /* output stream init */
1948
    nb_ostreams = 0;
1949
    for(i=0;i<nb_output_files;i++) {
1950
        os = output_files[i];
1951
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1952
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1953
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1954
            ret = AVERROR(EINVAL);
1955
            goto fail;
1956
        }
1957
        nb_ostreams += os->nb_streams;
1958
    }
1959
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1960
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1961
        ret = AVERROR(EINVAL);
1962
        goto fail;
1963
    }
1964

    
1965
    /* Sanity check the mapping args -- do the input files & streams exist? */
1966
    for(i=0;i<nb_stream_maps;i++) {
1967
        int fi = stream_maps[i].file_index;
1968
        int si = stream_maps[i].stream_index;
1969

    
1970
        if (fi < 0 || fi > nb_input_files - 1 ||
1971
            si < 0 || si > file_table[fi].nb_streams - 1) {
1972
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1973
            ret = AVERROR(EINVAL);
1974
            goto fail;
1975
        }
1976
        fi = stream_maps[i].sync_file_index;
1977
        si = stream_maps[i].sync_stream_index;
1978
        if (fi < 0 || fi > nb_input_files - 1 ||
1979
            si < 0 || si > file_table[fi].nb_streams - 1) {
1980
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1981
            ret = AVERROR(EINVAL);
1982
            goto fail;
1983
        }
1984
    }
1985

    
1986
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1987
    if (!ost_table)
1988
        goto fail;
1989
    n = 0;
1990
    for(k=0;k<nb_output_files;k++) {
1991
        os = output_files[k];
1992
        for(i=0;i<os->nb_streams;i++,n++) {
1993
            int found;
1994
            ost = ost_table[n] = output_streams_for_file[k][i];
1995
            ost->st = os->streams[i];
1996
            if (nb_stream_maps > 0) {
1997
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1998
                    stream_maps[n].stream_index;
1999

    
2000
                /* Sanity check that the stream types match */
2001
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2002
                    int i= ost->file_index;
2003
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2004
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2005
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2006
                        ost->file_index, ost->index);
2007
                    ffmpeg_exit(1);
2008
                }
2009

    
2010
            } else {
2011
                int best_nb_frames=-1;
2012
                /* get corresponding input stream index : we select the first one with the right type */
2013
                found = 0;
2014
                for(j=0;j<nb_istreams;j++) {
2015
                    int skip=0;
2016
                    ist = ist_table[j];
2017
                    if(opt_programid){
2018
                        int pi,si;
2019
                        AVFormatContext *f= input_files[ ist->file_index ];
2020
                        skip=1;
2021
                        for(pi=0; pi<f->nb_programs; pi++){
2022
                            AVProgram *p= f->programs[pi];
2023
                            if(p->id == opt_programid)
2024
                                for(si=0; si<p->nb_stream_indexes; si++){
2025
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2026
                                        skip=0;
2027
                                }
2028
                        }
2029
                    }
2030
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2031
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2032
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2033
                            best_nb_frames= ist->st->codec_info_nb_frames;
2034
                            ost->source_index = j;
2035
                            found = 1;
2036
                        }
2037
                    }
2038
                }
2039

    
2040
                if (!found) {
2041
                    if(! opt_programid) {
2042
                        /* try again and reuse existing stream */
2043
                        for(j=0;j<nb_istreams;j++) {
2044
                            ist = ist_table[j];
2045
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2046
                                && ist->st->discard != AVDISCARD_ALL) {
2047
                                ost->source_index = j;
2048
                                found = 1;
2049
                            }
2050
                        }
2051
                    }
2052
                    if (!found) {
2053
                        int i= ost->file_index;
2054
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2055
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2056
                                ost->file_index, ost->index);
2057
                        ffmpeg_exit(1);
2058
                    }
2059
                }
2060
            }
2061
            ist = ist_table[ost->source_index];
2062
            ist->discard = 0;
2063
            ost->sync_ist = (nb_stream_maps > 0) ?
2064
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2065
                         stream_maps[n].sync_stream_index] : ist;
2066
        }
2067
    }
2068

    
2069
    /* for each output stream, we compute the right encoding parameters */
2070
    for(i=0;i<nb_ostreams;i++) {
2071
        ost = ost_table[i];
2072
        os = output_files[ost->file_index];
2073
        ist = ist_table[ost->source_index];
2074

    
2075
        codec = ost->st->codec;
2076
        icodec = ist->st->codec;
2077

    
2078
        if (metadata_streams_autocopy)
2079
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2080
                             AV_METADATA_DONT_OVERWRITE);
2081

    
2082
        ost->st->disposition = ist->st->disposition;
2083
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2084
        codec->chroma_sample_location = icodec->chroma_sample_location;
2085

    
2086
        if (ost->st->stream_copy) {
2087
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2088

    
2089
            if (extra_size > INT_MAX)
2090
                goto fail;
2091

    
2092
            /* if stream_copy is selected, no need to decode or encode */
2093
            codec->codec_id = icodec->codec_id;
2094
            codec->codec_type = icodec->codec_type;
2095

    
2096
            if(!codec->codec_tag){
2097
                if(   !os->oformat->codec_tag
2098
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2099
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2100
                    codec->codec_tag = icodec->codec_tag;
2101
            }
2102

    
2103
            codec->bit_rate = icodec->bit_rate;
2104
            codec->rc_max_rate    = icodec->rc_max_rate;
2105
            codec->rc_buffer_size = icodec->rc_buffer_size;
2106
            codec->extradata= av_mallocz(extra_size);
2107
            if (!codec->extradata)
2108
                goto fail;
2109
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2110
            codec->extradata_size= icodec->extradata_size;
2111
            if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2112
                codec->time_base = icodec->time_base;
2113
                codec->time_base.num *= icodec->ticks_per_frame;
2114
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2115
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2116
            }else
2117
                codec->time_base = ist->st->time_base;
2118
            switch(codec->codec_type) {
2119
            case AVMEDIA_TYPE_AUDIO:
2120
                if(audio_volume != 256) {
2121
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2122
                    ffmpeg_exit(1);
2123
                }
2124
                codec->channel_layout = icodec->channel_layout;
2125
                codec->sample_rate = icodec->sample_rate;
2126
                codec->channels = icodec->channels;
2127
                codec->frame_size = icodec->frame_size;
2128
                codec->audio_service_type = icodec->audio_service_type;
2129
                codec->block_align= icodec->block_align;
2130
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2131
                    codec->block_align= 0;
2132
                if(codec->codec_id == CODEC_ID_AC3)
2133
                    codec->block_align= 0;
2134
                break;
2135
            case AVMEDIA_TYPE_VIDEO:
2136
                codec->pix_fmt = icodec->pix_fmt;
2137
                codec->width = icodec->width;
2138
                codec->height = icodec->height;
2139
                codec->has_b_frames = icodec->has_b_frames;
2140
                break;
2141
            case AVMEDIA_TYPE_SUBTITLE:
2142
                codec->width = icodec->width;
2143
                codec->height = icodec->height;
2144
                break;
2145
            case AVMEDIA_TYPE_DATA:
2146
                break;
2147
            default:
2148
                abort();
2149
            }
2150
        } else {
2151
            switch(codec->codec_type) {
2152
            case AVMEDIA_TYPE_AUDIO:
2153
                ost->fifo= av_fifo_alloc(1024);
2154
                if(!ost->fifo)
2155
                    goto fail;
2156
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2157
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2158
                icodec->request_channels = codec->channels;
2159
                ist->decoding_needed = 1;
2160
                ost->encoding_needed = 1;
2161
                ost->resample_sample_fmt  = icodec->sample_fmt;
2162
                ost->resample_sample_rate = icodec->sample_rate;
2163
                ost->resample_channels    = icodec->channels;
2164
                break;
2165
            case AVMEDIA_TYPE_VIDEO:
2166
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2167
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2168
                    ffmpeg_exit(1);
2169
                }
2170
                ost->video_resample = codec->width   != icodec->width  ||
2171
                                      codec->height  != icodec->height ||
2172
                                      codec->pix_fmt != icodec->pix_fmt;
2173
                if (ost->video_resample) {
2174
#if !CONFIG_AVFILTER
2175
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2176
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2177
                                         codec->width, codec->height)) {
2178
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2179
                        ffmpeg_exit(1);
2180
                    }
2181
                    ost->img_resample_ctx = sws_getContext(
2182
                        icodec->width,
2183
                        icodec->height,
2184
                            icodec->pix_fmt,
2185
                            codec->width,
2186
                            codec->height,
2187
                            codec->pix_fmt,
2188
                            ost->sws_flags, NULL, NULL, NULL);
2189
                    if (ost->img_resample_ctx == NULL) {
2190
                        fprintf(stderr, "Cannot get resampling context\n");
2191
                        ffmpeg_exit(1);
2192
                    }
2193
#endif
2194
                    codec->bits_per_raw_sample= 0;
2195
                }
2196
                ost->resample_height = icodec->height;
2197
                ost->resample_width  = icodec->width;
2198
                ost->resample_pix_fmt= icodec->pix_fmt;
2199
                ost->encoding_needed = 1;
2200
                ist->decoding_needed = 1;
2201

    
2202
#if CONFIG_AVFILTER
2203
                if (configure_video_filters(ist, ost)) {
2204
                    fprintf(stderr, "Error opening filters!\n");
2205
                    exit(1);
2206
                }
2207
#endif
2208
                break;
2209
            case AVMEDIA_TYPE_SUBTITLE:
2210
                ost->encoding_needed = 1;
2211
                ist->decoding_needed = 1;
2212
                break;
2213
            default:
2214
                abort();
2215
                break;
2216
            }
2217
            /* two pass mode */
2218
            if (ost->encoding_needed &&
2219
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2220
                char logfilename[1024];
2221
                FILE *f;
2222

    
2223
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2224
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2225
                         i);
2226
                if (codec->flags & CODEC_FLAG_PASS1) {
2227
                    f = fopen(logfilename, "wb");
2228
                    if (!f) {
2229
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2230
                        ffmpeg_exit(1);
2231
                    }
2232
                    ost->logfile = f;
2233
                } else {
2234
                    char  *logbuffer;
2235
                    size_t logbuffer_size;
2236
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2237
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2238
                        ffmpeg_exit(1);
2239
                    }
2240
                    codec->stats_in = logbuffer;
2241
                }
2242
            }
2243
        }
2244
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2245
            int size= codec->width * codec->height;
2246
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2247
        }
2248
    }
2249

    
2250
    if (!bit_buffer)
2251
        bit_buffer = av_malloc(bit_buffer_size);
2252
    if (!bit_buffer) {
2253
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2254
                bit_buffer_size);
2255
        ret = AVERROR(ENOMEM);
2256
        goto fail;
2257
    }
2258

    
2259
    /* open each encoder */
2260
    for(i=0;i<nb_ostreams;i++) {
2261
        ost = ost_table[i];
2262
        if (ost->encoding_needed) {
2263
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2264
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2265
            if (!codec)
2266
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2267
            if (!codec) {
2268
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2269
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2270
                ret = AVERROR(EINVAL);
2271
                goto dump_format;
2272
            }
2273
            if (dec->subtitle_header) {
2274
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2275
                if (!ost->st->codec->subtitle_header) {
2276
                    ret = AVERROR(ENOMEM);
2277
                    goto dump_format;
2278
                }
2279
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2280
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2281
            }
2282
            if (avcodec_open(ost->st->codec, codec) < 0) {
2283
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2284
                        ost->file_index, ost->index);
2285
                ret = AVERROR(EINVAL);
2286
                goto dump_format;
2287
            }
2288
            extra_size += ost->st->codec->extradata_size;
2289
        }
2290
    }
2291

    
2292
    /* open each decoder */
2293
    for(i=0;i<nb_istreams;i++) {
2294
        ist = ist_table[i];
2295
        if (ist->decoding_needed) {
2296
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2297
            if (!codec)
2298
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2299
            if (!codec) {
2300
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2301
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2302
                ret = AVERROR(EINVAL);
2303
                goto dump_format;
2304
            }
2305
            if (avcodec_open(ist->st->codec, codec) < 0) {
2306
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2307
                        ist->file_index, ist->index);
2308
                ret = AVERROR(EINVAL);
2309
                goto dump_format;
2310
            }
2311
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2312
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2313
        }
2314
    }
2315

    
2316
    /* init pts */
2317
    for(i=0;i<nb_istreams;i++) {
2318
        AVStream *st;
2319
        ist = ist_table[i];
2320
        st= ist->st;
2321
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2322
        ist->next_pts = AV_NOPTS_VALUE;
2323
        init_pts_correction(&ist->pts_ctx);
2324
        ist->is_start = 1;
2325
    }
2326

    
2327
    /* set meta data information from input file if required */
2328
    for (i=0;i<nb_meta_data_maps;i++) {
2329
        AVFormatContext *files[2];
2330
        AVMetadata      **meta[2];
2331
        int j;
2332

    
2333
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2334
        if ((index) < 0 || (index) >= (nb_elems)) {\
2335
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2336
                     (desc), (index));\
2337
            ret = AVERROR(EINVAL);\
2338
            goto dump_format;\
2339
        }
2340

    
2341
        int out_file_index = meta_data_maps[i][0].file;
2342
        int in_file_index = meta_data_maps[i][1].file;
2343
        if (in_file_index < 0 || out_file_index < 0)
2344
            continue;
2345
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2346
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2347

    
2348
        files[0] = output_files[out_file_index];
2349
        files[1] = input_files[in_file_index];
2350

    
2351
        for (j = 0; j < 2; j++) {
2352
            AVMetaDataMap *map = &meta_data_maps[i][j];
2353

    
2354
            switch (map->type) {
2355
            case 'g':
2356
                meta[j] = &files[j]->metadata;
2357
                break;
2358
            case 's':
2359
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2360
                meta[j] = &files[j]->streams[map->index]->metadata;
2361
                break;
2362
            case 'c':
2363
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2364
                meta[j] = &files[j]->chapters[map->index]->metadata;
2365
                break;
2366
            case 'p':
2367
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2368
                meta[j] = &files[j]->programs[map->index]->metadata;
2369
                break;
2370
            }
2371
        }
2372

    
2373
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2374
    }
2375

    
2376
    /* copy global metadata by default */
2377
    if (metadata_global_autocopy) {
2378

    
2379
        for (i = 0; i < nb_output_files; i++)
2380
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2381
                             AV_METADATA_DONT_OVERWRITE);
2382
    }
2383

    
2384
    /* copy chapters according to chapter maps */
2385
    for (i = 0; i < nb_chapter_maps; i++) {
2386
        int infile  = chapter_maps[i].in_file;
2387
        int outfile = chapter_maps[i].out_file;
2388

    
2389
        if (infile < 0 || outfile < 0)
2390
            continue;
2391
        if (infile >= nb_input_files) {
2392
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2393
            ret = AVERROR(EINVAL);
2394
            goto dump_format;
2395
        }
2396
        if (outfile >= nb_output_files) {
2397
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2398
            ret = AVERROR(EINVAL);
2399
            goto dump_format;
2400
        }
2401
        copy_chapters(infile, outfile);
2402
    }
2403

    
2404
    /* copy chapters from the first input file that has them*/
2405
    if (!nb_chapter_maps)
2406
        for (i = 0; i < nb_input_files; i++) {
2407
            if (!input_files[i]->nb_chapters)
2408
                continue;
2409

    
2410
            for (j = 0; j < nb_output_files; j++)
2411
                if ((ret = copy_chapters(i, j)) < 0)
2412
                    goto dump_format;
2413
            break;
2414
        }
2415

    
2416
    /* open files and write file headers */
2417
    for(i=0;i<nb_output_files;i++) {
2418
        os = output_files[i];
2419
        if (av_write_header(os) < 0) {
2420
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2421
            ret = AVERROR(EINVAL);
2422
            goto dump_format;
2423
        }
2424
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2425
            want_sdp = 0;
2426
        }
2427
    }
2428

    
2429
 dump_format:
2430
    /* dump the file output parameters - cannot be done before in case
2431
       of stream copy */
2432
    for(i=0;i<nb_output_files;i++) {
2433
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2434
    }
2435

    
2436
    /* dump the stream mapping */
2437
    if (verbose >= 0) {
2438
        fprintf(stderr, "Stream mapping:\n");
2439
        for(i=0;i<nb_ostreams;i++) {
2440
            ost = ost_table[i];
2441
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2442
                    ist_table[ost->source_index]->file_index,
2443
                    ist_table[ost->source_index]->index,
2444
                    ost->file_index,
2445
                    ost->index);
2446
            if (ost->sync_ist != ist_table[ost->source_index])
2447
                fprintf(stderr, " [sync #%d.%d]",
2448
                        ost->sync_ist->file_index,
2449
                        ost->sync_ist->index);
2450
            fprintf(stderr, "\n");
2451
        }
2452
    }
2453

    
2454
    if (ret) {
2455
        fprintf(stderr, "%s\n", error);
2456
        goto fail;
2457
    }
2458

    
2459
    if (want_sdp) {
2460
        print_sdp(output_files, nb_output_files);
2461
    }
2462

    
2463
    if (!using_stdin && verbose >= 0) {
2464
#if HAVE_KBHIT
2465
        fprintf(stderr, "Press [q] to stop encoding\n");
2466
#else
2467
        fprintf(stderr, "Press ctrl-c to stop encoding\n");
2468
#endif
2469
        avio_set_interrupt_cb(decode_interrupt_cb);
2470
    }
2471
    term_init();
2472

    
2473
    timer_start = av_gettime();
2474

    
2475
    for(; received_sigterm == 0;) {
2476
        int file_index, ist_index;
2477
        AVPacket pkt;
2478
        double ipts_min;
2479
        double opts_min;
2480

    
2481
    redo:
2482
        ipts_min= 1e100;
2483
        opts_min= 1e100;
2484
        /* if 'q' pressed, exits */
2485
        if (!using_stdin) {
2486
            if (q_pressed)
2487
                break;
2488
            /* read_key() returns 0 on EOF */
2489
            key = read_key();
2490
            if (key == 'q')
2491
                break;
2492
        }
2493

    
2494
        /* select the stream that we must read now by looking at the
2495
           smallest output pts */
2496
        file_index = -1;
2497
        for(i=0;i<nb_ostreams;i++) {
2498
            double ipts, opts;
2499
            ost = ost_table[i];
2500
            os = output_files[ost->file_index];
2501
            ist = ist_table[ost->source_index];
2502
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2503
                continue;
2504
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2505
            ipts = (double)ist->pts;
2506
            if (!file_table[ist->file_index].eof_reached){
2507
                if(ipts < ipts_min) {
2508
                    ipts_min = ipts;
2509
                    if(input_sync ) file_index = ist->file_index;
2510
                }
2511
                if(opts < opts_min) {
2512
                    opts_min = opts;
2513
                    if(!input_sync) file_index = ist->file_index;
2514
                }
2515
            }
2516
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2517
                file_index= -1;
2518
                break;
2519
            }
2520
        }
2521
        /* if none, if is finished */
2522
        if (file_index < 0) {
2523
            if(no_packet_count){
2524
                no_packet_count=0;
2525
                memset(no_packet, 0, sizeof(no_packet));
2526
                usleep(10000);
2527
                continue;
2528
            }
2529
            break;
2530
        }
2531

    
2532
        /* finish if limit size exhausted */
2533
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2534
            break;
2535

    
2536
        /* read a frame from it and output it in the fifo */
2537
        is = input_files[file_index];
2538
        ret= av_read_frame(is, &pkt);
2539
        if(ret == AVERROR(EAGAIN)){
2540
            no_packet[file_index]=1;
2541
            no_packet_count++;
2542
            continue;
2543
        }
2544
        if (ret < 0) {
2545
            file_table[file_index].eof_reached = 1;
2546
            if (opt_shortest)
2547
                break;
2548
            else
2549
                continue;
2550
        }
2551

    
2552
        no_packet_count=0;
2553
        memset(no_packet, 0, sizeof(no_packet));
2554

    
2555
        if (do_pkt_dump) {
2556
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2557
                             is->streams[pkt.stream_index]);
2558
        }
2559
        /* the following test is needed in case new streams appear
2560
           dynamically in stream : we ignore them */
2561
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2562
            goto discard_packet;
2563
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2564
        ist = ist_table[ist_index];
2565
        if (ist->discard)
2566
            goto discard_packet;
2567

    
2568
        if (pkt.dts != AV_NOPTS_VALUE)
2569
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2570
        if (pkt.pts != AV_NOPTS_VALUE)
2571
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2572

    
2573
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2574
            && input_files_ts_scale[file_index][pkt.stream_index]){
2575
            if(pkt.pts != AV_NOPTS_VALUE)
2576
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2577
            if(pkt.dts != AV_NOPTS_VALUE)
2578
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2579
        }
2580

    
2581
//        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);
2582
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2583
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2584
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2585
            int64_t delta= pkt_dts - ist->next_pts;
2586
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2587
                input_files_ts_offset[ist->file_index]-= delta;
2588
                if (verbose > 2)
2589
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2590
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2591
                if(pkt.pts != AV_NOPTS_VALUE)
2592
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2593
            }
2594
        }
2595

    
2596
        /* finish if recording time exhausted */
2597
        if (recording_time != INT64_MAX &&
2598
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2599
            ist->is_past_recording_time = 1;
2600
            goto discard_packet;
2601
        }
2602

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

    
2606
            if (verbose >= 0)
2607
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2608
                        ist->file_index, ist->index);
2609
            if (exit_on_error)
2610
                ffmpeg_exit(1);
2611
            av_free_packet(&pkt);
2612
            goto redo;
2613
        }
2614

    
2615
    discard_packet:
2616
        av_free_packet(&pkt);
2617

    
2618
        /* dump report by using the output first video and audio streams */
2619
        print_report(output_files, ost_table, nb_ostreams, 0);
2620
    }
2621

    
2622
    /* at the end of stream, we must flush the decoder buffers */
2623
    for(i=0;i<nb_istreams;i++) {
2624
        ist = ist_table[i];
2625
        if (ist->decoding_needed) {
2626
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2627
        }
2628
    }
2629

    
2630
    term_exit();
2631

    
2632
    /* write the trailer if needed and close file */
2633
    for(i=0;i<nb_output_files;i++) {
2634
        os = output_files[i];
2635
        av_write_trailer(os);
2636
    }
2637

    
2638
    /* dump report by using the first video and audio streams */
2639
    print_report(output_files, ost_table, nb_ostreams, 1);
2640

    
2641
    /* close each encoder */
2642
    for(i=0;i<nb_ostreams;i++) {
2643
        ost = ost_table[i];
2644
        if (ost->encoding_needed) {
2645
            av_freep(&ost->st->codec->stats_in);
2646
            avcodec_close(ost->st->codec);
2647
        }
2648
    }
2649

    
2650
    /* close each decoder */
2651
    for(i=0;i<nb_istreams;i++) {
2652
        ist = ist_table[i];
2653
        if (ist->decoding_needed) {
2654
            avcodec_close(ist->st->codec);
2655
        }
2656
    }
2657
#if CONFIG_AVFILTER
2658
    avfilter_graph_free(&graph);
2659
#endif
2660

    
2661
    /* finished ! */
2662
    ret = 0;
2663

    
2664
 fail:
2665
    av_freep(&bit_buffer);
2666
    av_free(file_table);
2667

    
2668
    if (ist_table) {
2669
        for(i=0;i<nb_istreams;i++) {
2670
            ist = ist_table[i];
2671
            av_free(ist);
2672
        }
2673
        av_free(ist_table);
2674
    }
2675
    if (ost_table) {
2676
        for(i=0;i<nb_ostreams;i++) {
2677
            ost = ost_table[i];
2678
            if (ost) {
2679
                if (ost->st->stream_copy)
2680
                    av_freep(&ost->st->codec->extradata);
2681
                if (ost->logfile) {
2682
                    fclose(ost->logfile);
2683
                    ost->logfile = NULL;
2684
                }
2685
                av_fifo_free(ost->fifo); /* works even if fifo is not
2686
                                             initialized but set to zero */
2687
                av_freep(&ost->st->codec->subtitle_header);
2688
                av_free(ost->pict_tmp.data[0]);
2689
                av_free(ost->forced_kf_pts);
2690
                if (ost->video_resample)
2691
                    sws_freeContext(ost->img_resample_ctx);
2692
                if (ost->resample)
2693
                    audio_resample_close(ost->resample);
2694
                if (ost->reformat_ctx)
2695
                    av_audio_convert_free(ost->reformat_ctx);
2696
                av_free(ost);
2697
            }
2698
        }
2699
        av_free(ost_table);
2700
    }
2701
    return ret;
2702
}
2703

    
2704
static void opt_format(const char *arg)
2705
{
2706
    last_asked_format = arg;
2707
}
2708

    
2709
static void opt_video_rc_override_string(const char *arg)
2710
{
2711
    video_rc_override_string = arg;
2712
}
2713

    
2714
static int opt_me_threshold(const char *opt, const char *arg)
2715
{
2716
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2717
    return 0;
2718
}
2719

    
2720
static int opt_verbose(const char *opt, const char *arg)
2721
{
2722
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2723
    return 0;
2724
}
2725

    
2726
static int opt_frame_rate(const char *opt, const char *arg)
2727
{
2728
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2729
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2730
        ffmpeg_exit(1);
2731
    }
2732
    return 0;
2733
}
2734

    
2735
static int opt_bitrate(const char *opt, const char *arg)
2736
{
2737
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2738

    
2739
    opt_default(opt, arg);
2740

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

    
2744
    return 0;
2745
}
2746

    
2747
static int opt_frame_crop(const char *opt, const char *arg)
2748
{
2749
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2750
    return AVERROR(EINVAL);
2751
}
2752

    
2753
static void opt_frame_size(const char *arg)
2754
{
2755
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2756
        fprintf(stderr, "Incorrect frame size\n");
2757
        ffmpeg_exit(1);
2758
    }
2759
}
2760

    
2761
static int opt_pad(const char *opt, const char *arg) {
2762
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2763
    return -1;
2764
}
2765

    
2766
static void opt_frame_pix_fmt(const char *arg)
2767
{
2768
    if (strcmp(arg, "list")) {
2769
        frame_pix_fmt = av_get_pix_fmt(arg);
2770
        if (frame_pix_fmt == PIX_FMT_NONE) {
2771
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2772
            ffmpeg_exit(1);
2773
        }
2774
    } else {
2775
        show_pix_fmts();
2776
        ffmpeg_exit(0);
2777
    }
2778
}
2779

    
2780
static void opt_frame_aspect_ratio(const char *arg)
2781
{
2782
    int x = 0, y = 0;
2783
    double ar = 0;
2784
    const char *p;
2785
    char *end;
2786

    
2787
    p = strchr(arg, ':');
2788
    if (p) {
2789
        x = strtol(arg, &end, 10);
2790
        if (end == p)
2791
            y = strtol(end+1, &end, 10);
2792
        if (x > 0 && y > 0)
2793
            ar = (double)x / (double)y;
2794
    } else
2795
        ar = strtod(arg, NULL);
2796

    
2797
    if (!ar) {
2798
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2799
        ffmpeg_exit(1);
2800
    }
2801
    frame_aspect_ratio = ar;
2802

    
2803
#if CONFIG_AVFILTER
2804
    x = vfilters ? strlen(vfilters) : 0;
2805
    vfilters = av_realloc(vfilters, x+100);
2806
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2807
#endif
2808
}
2809

    
2810
static int opt_metadata(const char *opt, const char *arg)
2811
{
2812
    char *mid= strchr(arg, '=');
2813

    
2814
    if(!mid){
2815
        fprintf(stderr, "Missing =\n");
2816
        ffmpeg_exit(1);
2817
    }
2818
    *mid++= 0;
2819

    
2820
    av_metadata_set2(&metadata, arg, mid, 0);
2821

    
2822
    return 0;
2823
}
2824

    
2825
static void opt_qscale(const char *arg)
2826
{
2827
    video_qscale = atof(arg);
2828
    if (video_qscale <= 0 ||
2829
        video_qscale > 255) {
2830
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2831
        ffmpeg_exit(1);
2832
    }
2833
}
2834

    
2835
static void opt_top_field_first(const char *arg)
2836
{
2837
    top_field_first= atoi(arg);
2838
}
2839

    
2840
static int opt_thread_count(const char *opt, const char *arg)
2841
{
2842
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2843
#if !HAVE_THREADS
2844
    if (verbose >= 0)
2845
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2846
#endif
2847
    return 0;
2848
}
2849

    
2850
static void opt_audio_sample_fmt(const char *arg)
2851
{
2852
    if (strcmp(arg, "list")) {
2853
        audio_sample_fmt = av_get_sample_fmt(arg);
2854
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2855
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2856
            ffmpeg_exit(1);
2857
        }
2858
    } else {
2859
        int i;
2860
        char fmt_str[128];
2861
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2862
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2863
        ffmpeg_exit(0);
2864
    }
2865
}
2866

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

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

    
2879
static void opt_video_channel(const char *arg)
2880
{
2881
    video_channel = strtol(arg, NULL, 0);
2882
}
2883

    
2884
static void opt_video_standard(const char *arg)
2885
{
2886
    video_standard = av_strdup(arg);
2887
}
2888

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

    
2900
static void opt_audio_codec(const char *arg)
2901
{
2902
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2903
}
2904

    
2905
static void opt_video_codec(const char *arg)
2906
{
2907
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2908
}
2909

    
2910
static void opt_subtitle_codec(const char *arg)
2911
{
2912
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2913
}
2914

    
2915
static void opt_data_codec(const char *arg)
2916
{
2917
    opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2918
}
2919

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

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

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

    
2935
    return 0;
2936
}
2937

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

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

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

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

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

    
2984
static void opt_map_metadata(const char *arg)
2985
{
2986
    AVMetaDataMap *m, *m1;
2987
    char *p;
2988

    
2989
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2990
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2991

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

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

    
3002
    if (m->type == 'g' || m1->type == 'g')
3003
        metadata_global_autocopy = 0;
3004
    if (m->type == 's' || m1->type == 's')
3005
        metadata_streams_autocopy = 0;
3006
    if (m->type == 'c' || m1->type == 'c')
3007
        metadata_chapters_autocopy = 0;
3008
}
3009

    
3010
static void opt_map_meta_data(const char *arg)
3011
{
3012
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3013
                    "Use -map_metadata instead.\n");
3014
    opt_map_metadata(arg);
3015
}
3016

    
3017
static void opt_map_chapters(const char *arg)
3018
{
3019
    AVChapterMap *c;
3020
    char *p;
3021

    
3022
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3023
                              nb_chapter_maps + 1);
3024
    c = &chapter_maps[nb_chapter_maps - 1];
3025
    c->out_file = strtol(arg, &p, 0);
3026
    if (*p)
3027
        p++;
3028

    
3029
    c->in_file = strtol(p, &p, 0);
3030
}
3031

    
3032
static void opt_input_ts_scale(const char *arg)
3033
{
3034
    unsigned int stream;
3035
    double scale;
3036
    char *p;
3037

    
3038
    stream = strtol(arg, &p, 0);
3039
    if (*p)
3040
        p++;
3041
    scale= strtod(p, &p);
3042

    
3043
    if(stream >= MAX_STREAMS)
3044
        ffmpeg_exit(1);
3045

    
3046
    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);
3047
    input_files_ts_scale[nb_input_files][stream]= scale;
3048
}
3049

    
3050
static int opt_recording_time(const char *opt, const char *arg)
3051
{
3052
    recording_time = parse_time_or_die(opt, arg, 1);
3053
    return 0;
3054
}
3055

    
3056
static int opt_start_time(const char *opt, const char *arg)
3057
{
3058
    start_time = parse_time_or_die(opt, arg, 1);
3059
    return 0;
3060
}
3061

    
3062
static int opt_recording_timestamp(const char *opt, const char *arg)
3063
{
3064
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3065
    return 0;
3066
}
3067

    
3068
static int opt_input_ts_offset(const char *opt, const char *arg)
3069
{
3070
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3071
    return 0;
3072
}
3073

    
3074
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3075
{
3076
    const char *codec_string = encoder ? "encoder" : "decoder";
3077
    AVCodec *codec;
3078

    
3079
    if(!name)
3080
        return CODEC_ID_NONE;
3081
    codec = encoder ?
3082
        avcodec_find_encoder_by_name(name) :
3083
        avcodec_find_decoder_by_name(name);
3084
    if(!codec) {
3085
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3086
        ffmpeg_exit(1);
3087
    }
3088
    if(codec->type != type) {
3089
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3090
        ffmpeg_exit(1);
3091
    }
3092
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3093
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3094
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3095
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3096
                codec_string, codec->name);
3097
        codec = encoder ?
3098
            avcodec_find_encoder(codec->id) :
3099
            avcodec_find_decoder(codec->id);
3100
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3101
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3102
                    codec_string, codec->name);
3103
        ffmpeg_exit(1);
3104
    }
3105
    return codec->id;
3106
}
3107

    
3108
static void opt_input_file(const char *filename)
3109
{
3110
    AVFormatContext *ic;
3111
    AVFormatParameters params, *ap = &params;
3112
    AVInputFormat *file_iformat = NULL;
3113
    int err, i, ret, rfps, rfps_base;
3114
    int64_t timestamp;
3115

    
3116
    if (last_asked_format) {
3117
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3118
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3119
            ffmpeg_exit(1);
3120
        }
3121
        last_asked_format = NULL;
3122
    }
3123

    
3124
    if (!strcmp(filename, "-"))
3125
        filename = "pipe:";
3126

    
3127
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3128
                    !strcmp(filename, "/dev/stdin");
3129

    
3130
    /* get default parameters from command line */
3131
    ic = avformat_alloc_context();
3132
    if (!ic) {
3133
        print_error(filename, AVERROR(ENOMEM));
3134
        ffmpeg_exit(1);
3135
    }
3136

    
3137
    memset(ap, 0, sizeof(*ap));
3138
    ap->prealloced_context = 1;
3139
    ap->sample_rate = audio_sample_rate;
3140
    ap->channels = audio_channels;
3141
    ap->time_base.den = frame_rate.num;
3142
    ap->time_base.num = frame_rate.den;
3143
    ap->width = frame_width;
3144
    ap->height = frame_height;
3145
    ap->pix_fmt = frame_pix_fmt;
3146
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3147
    ap->channel = video_channel;
3148
    ap->standard = video_standard;
3149

    
3150
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3151

    
3152
    ic->video_codec_id   =
3153
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3154
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3155
    ic->audio_codec_id   =
3156
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3157
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3158
    ic->subtitle_codec_id=
3159
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3160
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3161
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3162

    
3163
    /* open the input file with generic libav function */
3164
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3165
    if (err < 0) {
3166
        print_error(filename, err);
3167
        ffmpeg_exit(1);
3168
    }
3169
    if(opt_programid) {
3170
        int i, j;
3171
        int found=0;
3172
        for(i=0; i<ic->nb_streams; i++){
3173
            ic->streams[i]->discard= AVDISCARD_ALL;
3174
        }
3175
        for(i=0; i<ic->nb_programs; i++){
3176
            AVProgram *p= ic->programs[i];
3177
            if(p->id != opt_programid){
3178
                p->discard = AVDISCARD_ALL;
3179
            }else{
3180
                found=1;
3181
                for(j=0; j<p->nb_stream_indexes; j++){
3182
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3183
                }
3184
            }
3185
        }
3186
        if(!found){
3187
            fprintf(stderr, "Specified program id not found\n");
3188
            ffmpeg_exit(1);
3189
        }
3190
        opt_programid=0;
3191
    }
3192

    
3193
    ic->loop_input = loop_input;
3194

    
3195
    /* If not enough info to get the stream parameters, we decode the
3196
       first frames to get it. (used in mpeg case for example) */
3197
    ret = av_find_stream_info(ic);
3198
    if (ret < 0 && verbose >= 0) {
3199
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3200
        av_close_input_file(ic);
3201
        ffmpeg_exit(1);
3202
    }
3203

    
3204
    timestamp = start_time;
3205
    /* add the stream start time */
3206
    if (ic->start_time != AV_NOPTS_VALUE)
3207
        timestamp += ic->start_time;
3208

    
3209
    /* if seeking requested, we execute it */
3210
    if (start_time != 0) {
3211
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3212
        if (ret < 0) {
3213
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3214
                    filename, (double)timestamp / AV_TIME_BASE);
3215
        }
3216
        /* reset seek info */
3217
        start_time = 0;
3218
    }
3219

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

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

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

    
3271
                    (float)rfps / rfps_base, rfps, rfps_base);
3272
            }
3273
            /* update the current frame rate to match the stream frame rate */
3274
            frame_rate.num = rfps;
3275
            frame_rate.den = rfps_base;
3276

    
3277
            if(video_disable)
3278
                st->discard= AVDISCARD_ALL;
3279
            else if(video_discard)
3280
                st->discard= video_discard;
3281
            break;
3282
        case AVMEDIA_TYPE_DATA:
3283
            break;
3284
        case AVMEDIA_TYPE_SUBTITLE:
3285
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3286
            if(subtitle_disable)
3287
                st->discard = AVDISCARD_ALL;
3288
            break;
3289
        case AVMEDIA_TYPE_ATTACHMENT:
3290
        case AVMEDIA_TYPE_UNKNOWN:
3291
            break;
3292
        default:
3293
            abort();
3294
        }
3295
    }
3296

    
3297
    input_files[nb_input_files] = ic;
3298
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3299
    /* dump the file content */
3300
    if (verbose >= 0)
3301
        av_dump_format(ic, nb_input_files, filename, 0);
3302

    
3303
    nb_input_files++;
3304

    
3305
    video_channel = 0;
3306

    
3307
    av_freep(&video_codec_name);
3308
    av_freep(&audio_codec_name);
3309
    av_freep(&subtitle_codec_name);
3310
    uninit_opts();
3311
    init_opts();
3312
}
3313

    
3314
static void check_inputs(int *has_video_ptr,
3315
                         int *has_audio_ptr,
3316
                         int *has_subtitle_ptr,
3317
                         int *has_data_ptr)
3318
{
3319
    int has_video, has_audio, has_subtitle, has_data, i, j;
3320
    AVFormatContext *ic;
3321

    
3322
    has_video = 0;
3323
    has_audio = 0;
3324
    has_subtitle = 0;
3325
    has_data = 0;
3326

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

    
3357
static void new_video_stream(AVFormatContext *oc, int file_idx)
3358
{
3359
    AVStream *st;
3360
    AVOutputStream *ost;
3361
    AVCodecContext *video_enc;
3362
    enum CodecID codec_id = CODEC_ID_NONE;
3363
    AVCodec *codec= NULL;
3364

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

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

    
3385
    avcodec_get_context_defaults3(st->codec, codec);
3386
    ost->bitstream_filters = video_bitstream_filters;
3387
    video_bitstream_filters= NULL;
3388

    
3389
    st->codec->thread_count= thread_count;
3390

    
3391
    video_enc = st->codec;
3392

    
3393
    if(video_codec_tag)
3394
        video_enc->codec_tag= video_codec_tag;
3395

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

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

    
3416
        video_enc->codec_id = codec_id;
3417
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3418

    
3419
        if (codec && codec->supported_framerates && !force_fps)
3420
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3421
        video_enc->time_base.den = fps.num;
3422
        video_enc->time_base.num = fps.den;
3423

    
3424
        video_enc->width = frame_width;
3425
        video_enc->height = frame_height;
3426
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3427
        video_enc->pix_fmt = frame_pix_fmt;
3428
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3429

    
3430
        choose_pixel_fmt(st, codec);
3431

    
3432
        if (intra_only)
3433
            video_enc->gop_size = 0;
3434
        if (video_qscale || same_quality) {
3435
            video_enc->flags |= CODEC_FLAG_QSCALE;
3436
            video_enc->global_quality=
3437
                st->quality = FF_QP2LAMBDA * video_qscale;
3438
        }
3439

    
3440
        if(intra_matrix)
3441
            video_enc->intra_matrix = intra_matrix;
3442
        if(inter_matrix)
3443
            video_enc->inter_matrix = inter_matrix;
3444

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

    
3475
        if (do_psnr)
3476
            video_enc->flags|= CODEC_FLAG_PSNR;
3477

    
3478
        /* two pass mode */
3479
        if (do_pass) {
3480
            if (do_pass == 1) {
3481
                video_enc->flags |= CODEC_FLAG_PASS1;
3482
            } else {
3483
                video_enc->flags |= CODEC_FLAG_PASS2;
3484
            }
3485
        }
3486

    
3487
        if (forced_key_frames)
3488
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3489
    }
3490
    if (video_language) {
3491
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3492
        av_freep(&video_language);
3493
    }
3494

    
3495
    /* reset some key parameters */
3496
    video_disable = 0;
3497
    av_freep(&video_codec_name);
3498
    av_freep(&forced_key_frames);
3499
    video_stream_copy = 0;
3500
    frame_pix_fmt = PIX_FMT_NONE;
3501
}
3502

    
3503
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3504
{
3505
    AVStream *st;
3506
    AVOutputStream *ost;
3507
    AVCodec *codec= NULL;
3508
    AVCodecContext *audio_enc;
3509
    enum CodecID codec_id = CODEC_ID_NONE;
3510

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

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

    
3531
    avcodec_get_context_defaults3(st->codec, codec);
3532

    
3533
    ost->bitstream_filters = audio_bitstream_filters;
3534
    audio_bitstream_filters= NULL;
3535

    
3536
    st->codec->thread_count= thread_count;
3537

    
3538
    audio_enc = st->codec;
3539
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3540

    
3541
    if(audio_codec_tag)
3542
        audio_enc->codec_tag= audio_codec_tag;
3543

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

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

    
3575
    /* reset some key parameters */
3576
    audio_disable = 0;
3577
    av_freep(&audio_codec_name);
3578
    audio_stream_copy = 0;
3579
}
3580

    
3581
static void new_data_stream(AVFormatContext *oc, int file_idx)
3582
{
3583
    AVStream *st;
3584
    AVOutputStream *ost;
3585
    AVCodec *codec=NULL;
3586
    AVCodecContext *data_enc;
3587

    
3588
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3589
    if (!st) {
3590
        fprintf(stderr, "Could not alloc stream\n");
3591
        ffmpeg_exit(1);
3592
    }
3593
    ost = new_output_stream(oc, file_idx);
3594
    data_enc = st->codec;
3595
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3596
    if (!data_stream_copy) {
3597
        fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3598
        ffmpeg_exit(1);
3599
    }
3600
    avcodec_get_context_defaults3(st->codec, codec);
3601

    
3602
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3603

    
3604
    if (data_codec_tag)
3605
        data_enc->codec_tag= data_codec_tag;
3606

    
3607
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3608
        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3609
        avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3610
    }
3611
    if (data_stream_copy) {
3612
        st->stream_copy = 1;
3613
    }
3614

    
3615
    data_disable = 0;
3616
    av_freep(&data_codec_name);
3617
    data_stream_copy = 0;
3618
}
3619

    
3620
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3621
{
3622
    AVStream *st;
3623
    AVOutputStream *ost;
3624
    AVCodec *codec=NULL;
3625
    AVCodecContext *subtitle_enc;
3626
    enum CodecID codec_id = CODEC_ID_NONE;
3627

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

    
3648
    ost->bitstream_filters = subtitle_bitstream_filters;
3649
    subtitle_bitstream_filters= NULL;
3650

    
3651
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3652

    
3653
    if(subtitle_codec_tag)
3654
        subtitle_enc->codec_tag= subtitle_codec_tag;
3655

    
3656
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3657
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3658
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3659
    }
3660
    if (subtitle_stream_copy) {
3661
        st->stream_copy = 1;
3662
    } else {
3663
        subtitle_enc->codec_id = codec_id;
3664
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3665
    }
3666

    
3667
    if (subtitle_language) {
3668
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3669
        av_freep(&subtitle_language);
3670
    }
3671

    
3672
    subtitle_disable = 0;
3673
    av_freep(&subtitle_codec_name);
3674
    subtitle_stream_copy = 0;
3675
}
3676

    
3677
static int opt_new_stream(const char *opt, const char *arg)
3678
{
3679
    AVFormatContext *oc;
3680
    int file_idx = nb_output_files - 1;
3681
    if (nb_output_files <= 0) {
3682
        fprintf(stderr, "At least one output file must be specified\n");
3683
        ffmpeg_exit(1);
3684
    }
3685
    oc = output_files[file_idx];
3686

    
3687
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3688
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3689
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3690
    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3691
    else av_assert0(0);
3692
    return 0;
3693
}
3694

    
3695
/* arg format is "output-stream-index:streamid-value". */
3696
static int opt_streamid(const char *opt, const char *arg)
3697
{
3698
    int idx;
3699
    char *p;
3700
    char idx_str[16];
3701

    
3702
    av_strlcpy(idx_str, arg, sizeof(idx_str));
3703
    p = strchr(idx_str, ':');
3704
    if (!p) {
3705
        fprintf(stderr,
3706
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3707
                arg, opt);
3708
        ffmpeg_exit(1);
3709
    }
3710
    *p++ = '\0';
3711
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3712
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3713
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3714
    return 0;
3715
}
3716

    
3717
static void opt_output_file(const char *filename)
3718
{
3719
    AVFormatContext *oc;
3720
    int err, use_video, use_audio, use_subtitle, use_data;
3721
    int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3722
    AVFormatParameters params, *ap = &params;
3723
    AVOutputFormat *file_oformat;
3724

    
3725
    if (!strcmp(filename, "-"))
3726
        filename = "pipe:";
3727

    
3728
    oc = avformat_alloc_context();
3729
    if (!oc) {
3730
        print_error(filename, AVERROR(ENOMEM));
3731
        ffmpeg_exit(1);
3732
    }
3733

    
3734
    if (last_asked_format) {
3735
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3736
        if (!file_oformat) {
3737
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3738
            ffmpeg_exit(1);
3739
        }
3740
        last_asked_format = NULL;
3741
    } else {
3742
        file_oformat = av_guess_format(NULL, filename, NULL);
3743
        if (!file_oformat) {
3744
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3745
                    filename);
3746
            ffmpeg_exit(1);
3747
        }
3748
    }
3749

    
3750
    oc->oformat = file_oformat;
3751
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3752

    
3753
    if (!strcmp(file_oformat->name, "ffm") &&
3754
        av_strstart(filename, "http:", NULL)) {
3755
        /* special case for files sent to ffserver: we get the stream
3756
           parameters from ffserver */
3757
        int err = read_ffserver_streams(oc, filename);
3758
        if (err < 0) {
3759
            print_error(filename, err);
3760
            ffmpeg_exit(1);
3761
        }
3762
    } else {
3763
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3764
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3765
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3766
        use_data = data_stream_copy ||  data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3767

    
3768
        /* disable if no corresponding type found and at least one
3769
           input file */
3770
        if (nb_input_files > 0) {
3771
            check_inputs(&input_has_video,
3772
                         &input_has_audio,
3773
                         &input_has_subtitle,
3774
                         &input_has_data);
3775

    
3776
            if (!input_has_video)
3777
                use_video = 0;
3778
            if (!input_has_audio)
3779
                use_audio = 0;
3780
            if (!input_has_subtitle)
3781
                use_subtitle = 0;
3782
            if (!input_has_data)
3783
                use_data = 0;
3784
        }
3785

    
3786
        /* manual disable */
3787
        if (audio_disable)    use_audio    = 0;
3788
        if (video_disable)    use_video    = 0;
3789
        if (subtitle_disable) use_subtitle = 0;
3790
        if (data_disable)     use_data     = 0;
3791

    
3792
        if (use_video)    new_video_stream(oc, nb_output_files);
3793
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3794
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3795
        if (use_data)     new_data_stream(oc, nb_output_files);
3796

    
3797
        oc->timestamp = recording_timestamp;
3798

    
3799
        av_metadata_copy(&oc->metadata, metadata, 0);
3800
        av_metadata_free(&metadata);
3801
    }
3802

    
3803
    output_files[nb_output_files++] = oc;
3804

    
3805
    /* check filename in case of an image number is expected */
3806
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3807
        if (!av_filename_number_test(oc->filename)) {
3808
            print_error(oc->filename, AVERROR(EINVAL));
3809
            ffmpeg_exit(1);
3810
        }
3811
    }
3812

    
3813
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3814
        /* test if it already exists to avoid loosing precious files */
3815
        if (!file_overwrite &&
3816
            (strchr(filename, ':') == NULL ||
3817
             filename[1] == ':' ||
3818
             av_strstart(filename, "file:", NULL))) {
3819
            if (avio_check(filename, 0) == 0) {
3820
                if (!using_stdin) {
3821
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3822
                    fflush(stderr);
3823
                    if (!read_yesno()) {
3824
                        fprintf(stderr, "Not overwriting - exiting\n");
3825
                        ffmpeg_exit(1);
3826
                    }
3827
                }
3828
                else {
3829
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3830
                    ffmpeg_exit(1);
3831
                }
3832
            }
3833
        }
3834

    
3835
        /* open the file */
3836
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3837
            print_error(filename, err);
3838
            ffmpeg_exit(1);
3839
        }
3840
    }
3841

    
3842
    memset(ap, 0, sizeof(*ap));
3843
    if (av_set_parameters(oc, ap) < 0) {
3844
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3845
                oc->filename);
3846
        ffmpeg_exit(1);
3847
    }
3848

    
3849
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3850
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3851
    oc->loop_output = loop_output;
3852
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3853

    
3854
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3855

    
3856
    av_freep(&forced_key_frames);
3857
    uninit_opts();
3858
    init_opts();
3859
}
3860

    
3861
/* same option as mencoder */
3862
static void opt_pass(const char *pass_str)
3863
{
3864
    int pass;
3865
    pass = atoi(pass_str);
3866
    if (pass != 1 && pass != 2) {
3867
        fprintf(stderr, "pass number can be only 1 or 2\n");
3868
        ffmpeg_exit(1);
3869
    }
3870
    do_pass = pass;
3871
}
3872

    
3873
static int64_t getutime(void)
3874
{
3875
#if HAVE_GETRUSAGE
3876
    struct rusage rusage;
3877

    
3878
    getrusage(RUSAGE_SELF, &rusage);
3879
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3880
#elif HAVE_GETPROCESSTIMES
3881
    HANDLE proc;
3882
    FILETIME c, e, k, u;
3883
    proc = GetCurrentProcess();
3884
    GetProcessTimes(proc, &c, &e, &k, &u);
3885
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3886
#else
3887
    return av_gettime();
3888
#endif
3889
}
3890

    
3891
static int64_t getmaxrss(void)
3892
{
3893
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3894
    struct rusage rusage;
3895
    getrusage(RUSAGE_SELF, &rusage);
3896
    return (int64_t)rusage.ru_maxrss * 1024;
3897
#elif HAVE_GETPROCESSMEMORYINFO
3898
    HANDLE proc;
3899
    PROCESS_MEMORY_COUNTERS memcounters;
3900
    proc = GetCurrentProcess();
3901
    memcounters.cb = sizeof(memcounters);
3902
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3903
    return memcounters.PeakPagefileUsage;
3904
#else
3905
    return 0;
3906
#endif
3907
}
3908

    
3909
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3910
{
3911
    int i;
3912
    const char *p = str;
3913
    for(i = 0;; i++) {
3914
        dest[i] = atoi(p);
3915
        if(i == 63)
3916
            break;
3917
        p = strchr(p, ',');
3918
        if(!p) {
3919
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3920
            ffmpeg_exit(1);
3921
        }
3922
        p++;
3923
    }
3924
}
3925

    
3926
static void opt_inter_matrix(const char *arg)
3927
{
3928
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3929
    parse_matrix_coeffs(inter_matrix, arg);
3930
}
3931

    
3932
static void opt_intra_matrix(const char *arg)
3933
{
3934
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3935
    parse_matrix_coeffs(intra_matrix, arg);
3936
}
3937

    
3938
static void show_usage(void)
3939
{
3940
    printf("Hyper fast Audio and Video encoder\n");
3941
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3942
    printf("\n");
3943
}
3944

    
3945
static void show_help(void)
3946
{
3947
    AVCodec *c;
3948
    AVOutputFormat *oformat = NULL;
3949

    
3950
    av_log_set_callback(log_callback_help);
3951
    show_usage();
3952
    show_help_options(options, "Main options:\n",
3953
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3954
    show_help_options(options, "\nAdvanced options:\n",
3955
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3956
                      OPT_EXPERT);
3957
    show_help_options(options, "\nVideo options:\n",
3958
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3959
                      OPT_VIDEO);
3960
    show_help_options(options, "\nAdvanced Video options:\n",
3961
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3962
                      OPT_VIDEO | OPT_EXPERT);
3963
    show_help_options(options, "\nAudio options:\n",
3964
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3965
                      OPT_AUDIO);
3966
    show_help_options(options, "\nAdvanced Audio options:\n",
3967
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3968
                      OPT_AUDIO | OPT_EXPERT);
3969
    show_help_options(options, "\nSubtitle options:\n",
3970
                      OPT_SUBTITLE | OPT_GRAB,
3971
                      OPT_SUBTITLE);
3972
    show_help_options(options, "\nAudio/Video grab options:\n",
3973
                      OPT_GRAB,
3974
                      OPT_GRAB);
3975
    printf("\n");
3976
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3977
    printf("\n");
3978

    
3979
    /* individual codec options */
3980
    c = NULL;
3981
    while ((c = av_codec_next(c))) {
3982
        if (c->priv_class) {
3983
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3984
            printf("\n");
3985
        }
3986
    }
3987

    
3988
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3989
    printf("\n");
3990

    
3991
    /* individual muxer options */
3992
    while ((oformat = av_oformat_next(oformat))) {
3993
        if (oformat->priv_class) {
3994
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3995
            printf("\n");
3996
        }
3997
    }
3998

    
3999
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4000
}
4001

    
4002
static void opt_target(const char *arg)
4003
{
4004
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4005
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4006

    
4007
    if(!strncmp(arg, "pal-", 4)) {
4008
        norm = PAL;
4009
        arg += 4;
4010
    } else if(!strncmp(arg, "ntsc-", 5)) {
4011
        norm = NTSC;
4012
        arg += 5;
4013
    } else if(!strncmp(arg, "film-", 5)) {
4014
        norm = FILM;
4015
        arg += 5;
4016
    } else {
4017
        int fr;
4018
        /* Calculate FR via float to avoid int overflow */
4019
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4020
        if(fr == 25000) {
4021
            norm = PAL;
4022
        } else if((fr == 29970) || (fr == 23976)) {
4023
            norm = NTSC;
4024
        } else {
4025
            /* Try to determine PAL/NTSC by peeking in the input files */
4026
            if(nb_input_files) {
4027
                int i, j;
4028
                for(j = 0; j < nb_input_files; j++) {
4029
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4030
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4031
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4032
                            continue;
4033
                        fr = c->time_base.den * 1000 / c->time_base.num;
4034
                        if(fr == 25000) {
4035
                            norm = PAL;
4036
                            break;
4037
                        } else if((fr == 29970) || (fr == 23976)) {
4038
                            norm = NTSC;
4039
                            break;
4040
                        }
4041
                    }
4042
                    if(norm != UNKNOWN)
4043
                        break;
4044
                }
4045
            }
4046
        }
4047
        if(verbose > 0 && norm != UNKNOWN)
4048
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4049
    }
4050

    
4051
    if(norm == UNKNOWN) {
4052
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4053
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4054
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4055
        ffmpeg_exit(1);
4056
    }
4057

    
4058
    if(!strcmp(arg, "vcd")) {
4059

    
4060
        opt_video_codec("mpeg1video");
4061
        opt_audio_codec("mp2");
4062
        opt_format("vcd");
4063

    
4064
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4065
        opt_frame_rate(NULL, frame_rates[norm]);
4066
        opt_default("g", norm == PAL ? "15" : "18");
4067

    
4068
        opt_default("b", "1150000");
4069
        opt_default("maxrate", "1150000");
4070
        opt_default("minrate", "1150000");
4071
        opt_default("bufsize", "327680"); // 40*1024*8;
4072

    
4073
        opt_default("ab", "224000");
4074
        audio_sample_rate = 44100;
4075
        audio_channels = 2;
4076

    
4077
        opt_default("packetsize", "2324");
4078
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4079

    
4080
        /* We have to offset the PTS, so that it is consistent with the SCR.
4081
           SCR starts at 36000, but the first two packs contain only padding
4082
           and the first pack from the other stream, respectively, may also have
4083
           been written before.
4084
           So the real data starts at SCR 36000+3*1200. */
4085
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4086
    } else if(!strcmp(arg, "svcd")) {
4087

    
4088
        opt_video_codec("mpeg2video");
4089
        opt_audio_codec("mp2");
4090
        opt_format("svcd");
4091

    
4092
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4093
        opt_frame_rate(NULL, frame_rates[norm]);
4094
        opt_default("g", norm == PAL ? "15" : "18");
4095

    
4096
        opt_default("b", "2040000");
4097
        opt_default("maxrate", "2516000");
4098
        opt_default("minrate", "0"); //1145000;
4099
        opt_default("bufsize", "1835008"); //224*1024*8;
4100
        opt_default("flags", "+scan_offset");
4101

    
4102

    
4103
        opt_default("ab", "224000");
4104
        audio_sample_rate = 44100;
4105

    
4106
        opt_default("packetsize", "2324");
4107

    
4108
    } else if(!strcmp(arg, "dvd")) {
4109

    
4110
        opt_video_codec("mpeg2video");
4111
        opt_audio_codec("ac3");
4112
        opt_format("dvd");
4113

    
4114
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4115
        opt_frame_rate(NULL, frame_rates[norm]);
4116
        opt_default("g", norm == PAL ? "15" : "18");
4117

    
4118
        opt_default("b", "6000000");
4119
        opt_default("maxrate", "9000000");
4120
        opt_default("minrate", "0"); //1500000;
4121
        opt_default("bufsize", "1835008"); //224*1024*8;
4122

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

    
4126
        opt_default("ab", "448000");
4127
        audio_sample_rate = 48000;
4128

    
4129
    } else if(!strncmp(arg, "dv", 2)) {
4130

    
4131
        opt_format("dv");
4132

    
4133
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4134
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4135
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4136
        opt_frame_rate(NULL, frame_rates[norm]);
4137

    
4138
        audio_sample_rate = 48000;
4139
        audio_channels = 2;
4140

    
4141
    } else {
4142
        fprintf(stderr, "Unknown target: %s\n", arg);
4143
        ffmpeg_exit(1);
4144
    }
4145
}
4146

    
4147
static void opt_vstats_file (const char *arg)
4148
{
4149
    av_free (vstats_filename);
4150
    vstats_filename=av_strdup (arg);
4151
}
4152

    
4153
static void opt_vstats (void)
4154
{
4155
    char filename[40];
4156
    time_t today2 = time(NULL);
4157
    struct tm *today = localtime(&today2);
4158

    
4159
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4160
             today->tm_sec);
4161
    opt_vstats_file(filename);
4162
}
4163

    
4164
static int opt_bsf(const char *opt, const char *arg)
4165
{
4166
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4167
    AVBitStreamFilterContext **bsfp;
4168

    
4169
    if(!bsfc){
4170
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4171
        ffmpeg_exit(1);
4172
    }
4173

    
4174
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4175
          *opt == 'a' ? &audio_bitstream_filters :
4176
                        &subtitle_bitstream_filters;
4177
    while(*bsfp)
4178
        bsfp= &(*bsfp)->next;
4179

    
4180
    *bsfp= bsfc;
4181

    
4182
    return 0;
4183
}
4184

    
4185
static int opt_preset(const char *opt, const char *arg)
4186
{
4187
    FILE *f=NULL;
4188
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4189
    char *codec_name = *opt == 'v' ? video_codec_name :
4190
                       *opt == 'a' ? audio_codec_name :
4191
                                     subtitle_codec_name;
4192

    
4193
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4194
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4195
        ffmpeg_exit(1);
4196
    }
4197

    
4198
    while(!feof(f)){
4199
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4200
        if(line[0] == '#' && !e)
4201
            continue;
4202
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4203
        if(e){
4204
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4205
            ffmpeg_exit(1);
4206
        }
4207
        if(!strcmp(tmp, "acodec")){
4208
            opt_audio_codec(tmp2);
4209
        }else if(!strcmp(tmp, "vcodec")){
4210
            opt_video_codec(tmp2);
4211
        }else if(!strcmp(tmp, "scodec")){
4212
            opt_subtitle_codec(tmp2);
4213
        }else if(!strcmp(tmp, "dcodec")){
4214
            opt_data_codec(tmp2);
4215
        }else if(opt_default(tmp, tmp2) < 0){
4216
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4217
            ffmpeg_exit(1);
4218
        }
4219
    }
4220

    
4221
    fclose(f);
4222

    
4223
    return 0;
4224
}
4225

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

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

    
4319
    /* audio options */
4320
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4321
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4322
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4323
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4324
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4325
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4326
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4327
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4328
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4329
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4330
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4331
    { "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" },
4332

    
4333
    /* subtitle options */
4334
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4335
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4336
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4337
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4338
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4339

    
4340
    /* grab options */
4341
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4342
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4343
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4344

    
4345
    /* muxer options */
4346
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4347
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4348

    
4349
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4350
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4351
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4352

    
4353
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4354
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4355
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4356
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4357
    /* data codec support */
4358
    { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4359

    
4360
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4361
    { NULL, },
4362
};
4363

    
4364
int main(int argc, char **argv)
4365
{
4366
    int64_t ti;
4367

    
4368
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4369

    
4370
    avcodec_register_all();
4371
#if CONFIG_AVDEVICE
4372
    avdevice_register_all();
4373
#endif
4374
#if CONFIG_AVFILTER
4375
    avfilter_register_all();
4376
#endif
4377
    av_register_all();
4378

    
4379
#if HAVE_ISATTY
4380
    if(isatty(STDIN_FILENO))
4381
        avio_set_interrupt_cb(decode_interrupt_cb);
4382
#endif
4383

    
4384
    init_opts();
4385

    
4386
    show_banner();
4387

    
4388
    /* parse options */
4389
    parse_options(argc, argv, options, opt_output_file);
4390

    
4391
    if(nb_output_files <= 0 && nb_input_files == 0) {
4392
        show_usage();
4393
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4394
        ffmpeg_exit(1);
4395
    }
4396

    
4397
    /* file converter / grab */
4398
    if (nb_output_files <= 0) {
4399
        fprintf(stderr, "At least one output file must be specified\n");
4400
        ffmpeg_exit(1);
4401
    }
4402

    
4403
    if (nb_input_files == 0) {
4404
        fprintf(stderr, "At least one input file must be specified\n");
4405
        ffmpeg_exit(1);
4406
    }
4407

    
4408
    ti = getutime();
4409
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4410
                  stream_maps, nb_stream_maps) < 0)
4411
        ffmpeg_exit(1);
4412
    ti = getutime() - ti;
4413
    if (do_benchmark) {
4414
        int maxrss = getmaxrss() / 1024;
4415
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4416
    }
4417

    
4418
    return ffmpeg_exit(0);
4419
}