Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 1a5e4fd8

History | View | Annotate | Download (161 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 unsigned int sws_flags = SWS_BICUBIC;
249

    
250
static int64_t timer_start;
251

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

    
256
static short *samples;
257

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

    
262
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263

    
264
struct AVInputStream;
265

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

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

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

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

    
308
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
310

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

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

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

    
343
#if CONFIG_AVFILTER
344

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

    
356
    graph = avfilter_graph_alloc();
357

    
358
    if (ist->st->sample_aspect_ratio.num){
359
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
360
    }else
361
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
362

    
363
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
364
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
365
             sample_aspect_ratio.num, sample_aspect_ratio.den);
366

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

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

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

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

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

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

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

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

    
418
    codec->width  = ist->output_video_filter->inputs[0]->w;
419
    codec->height = ist->output_video_filter->inputs[0]->h;
420
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
421
        ist->output_video_filter->inputs[0]->sample_aspect_ratio;
422

    
423
    return 0;
424
}
425
#endif /* CONFIG_AVFILTER */
426

    
427
static void term_exit(void)
428
{
429
    av_log(NULL, AV_LOG_QUIET, "");
430
}
431

    
432
static volatile int received_sigterm = 0;
433

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

    
441
static void term_init(void)
442
{
443
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
444
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
445
#ifdef SIGXCPU
446
    signal(SIGXCPU, sigterm_handler);
447
#endif
448
}
449

    
450
/* read a key without blocking */
451
static int read_key(void)
452
{
453
#if HAVE_KBHIT
454
    if(kbhit())
455
        return(getch());
456
#endif
457
    return -1;
458
}
459

    
460
static int decode_interrupt_cb(void)
461
{
462
    return q_pressed || (q_pressed = read_key() == 'q');
463
}
464

    
465
static int ffmpeg_exit(int ret)
466
{
467
    int i;
468

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

    
482
    av_free(intra_matrix);
483
    av_free(inter_matrix);
484

    
485
    if (vstats_file)
486
        fclose(vstats_file);
487
    av_free(vstats_filename);
488

    
489
    av_free(streamid_map);
490
    av_free(input_codecs);
491
    av_free(output_codecs);
492
    av_free(stream_maps);
493
    av_free(meta_data_maps);
494

    
495
    av_free(video_codec_name);
496
    av_free(audio_codec_name);
497
    av_free(subtitle_codec_name);
498
    av_free(data_codec_name);
499

    
500
    av_free(video_standard);
501

    
502
    uninit_opts();
503
    av_free(audio_buf);
504
    av_free(audio_out);
505
    allocated_audio_buf_size= allocated_audio_out_size= 0;
506
    av_free(samples);
507

    
508
#if CONFIG_AVFILTER
509
    avfilter_uninit();
510
#endif
511

    
512
    if (received_sigterm) {
513
        fprintf(stderr,
514
            "Received signal %d: terminating.\n",
515
            (int) received_sigterm);
516
        exit (255);
517
    }
518

    
519
    exit(ret); /* not all OS-es handle main() return value */
520
    return ret;
521
}
522

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

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

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

    
582
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
583
{
584
    if(codec && codec->pix_fmts){
585
        const enum PixelFormat *p= codec->pix_fmts;
586
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
587
            if(st->codec->codec_id==CODEC_ID_MJPEG){
588
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
589
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
590
                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};
591
            }
592
        }
593
        for(; *p!=-1; p++){
594
            if(*p == st->codec->pix_fmt)
595
                break;
596
        }
597
        if(*p == -1)
598
            st->codec->pix_fmt = codec->pix_fmts[0];
599
    }
600
}
601

    
602
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
603
{
604
    int idx = oc->nb_streams - 1;
605
    AVOutputStream *ost;
606

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

    
623
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
624
{
625
    int i, err;
626
    AVFormatContext *ic;
627
    int nopts = 0;
628

    
629
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
630
    if (err < 0)
631
        return err;
632
    /* copy stream format */
633
    s->nb_streams = 0;
634
    for(i=0;i<ic->nb_streams;i++) {
635
        AVStream *st;
636
        AVCodec *codec;
637

    
638
        s->nb_streams++;
639

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

    
651
        codec = avcodec_find_encoder(st->codec->codec_id);
652
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
653
            if (audio_stream_copy) {
654
                st->stream_copy = 1;
655
            } else
656
                choose_sample_fmt(st, codec);
657
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
658
            if (video_stream_copy) {
659
                st->stream_copy = 1;
660
            } else
661
                choose_pixel_fmt(st, codec);
662
        }
663

    
664
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
665
            nopts = 1;
666

    
667
        new_output_stream(s, nb_output_files);
668
    }
669

    
670
    if (!nopts)
671
        s->timestamp = av_gettime();
672

    
673
    av_close_input_file(ic);
674
    return 0;
675
}
676

    
677
static double
678
get_sync_ipts(const AVOutputStream *ost)
679
{
680
    const AVInputStream *ist = ost->sync_ist;
681
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
682
}
683

    
684
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
685
    int ret;
686

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

    
706
        bsfc= bsfc->next;
707
    }
708

    
709
    ret= av_interleaved_write_frame(s, pkt);
710
    if(ret < 0){
711
        print_error("av_interleaved_write_frame()", ret);
712
        ffmpeg_exit(1);
713
    }
714
}
715

    
716
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
717

    
718
static void do_audio_out(AVFormatContext *s,
719
                         AVOutputStream *ost,
720
                         AVInputStream *ist,
721
                         unsigned char *buf, int size)
722
{
723
    uint8_t *buftmp;
724
    int64_t audio_out_size, audio_buf_size;
725
    int64_t allocated_for_size= size;
726

    
727
    int size_out, frame_bytes, ret, resample_changed;
728
    AVCodecContext *enc= ost->st->codec;
729
    AVCodecContext *dec= ist->st->codec;
730
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
731
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
732
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
733

    
734
need_realloc:
735
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
736
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
737
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
738
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
739
    audio_buf_size*= osize*enc->channels;
740

    
741
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
742
    if(coded_bps > 8*osize)
743
        audio_out_size= audio_out_size * coded_bps / (8*osize);
744
    audio_out_size += FF_MIN_BUFFER_SIZE;
745

    
746
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
747
        fprintf(stderr, "Buffer sizes too large\n");
748
        ffmpeg_exit(1);
749
    }
750

    
751
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
752
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
753
    if (!audio_buf || !audio_out){
754
        fprintf(stderr, "Out of memory in do_audio_out\n");
755
        ffmpeg_exit(1);
756
    }
757

    
758
    if (enc->channels != dec->channels)
759
        ost->audio_resample = 1;
760

    
761
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
762
                       ost->resample_channels    != dec->channels   ||
763
                       ost->resample_sample_rate != dec->sample_rate;
764

    
765
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
766
        if (resample_changed) {
767
            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",
768
                   ist->file_index, ist->index,
769
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
770
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
771
            ost->resample_sample_fmt  = dec->sample_fmt;
772
            ost->resample_channels    = dec->channels;
773
            ost->resample_sample_rate = dec->sample_rate;
774
            if (ost->resample)
775
                audio_resample_close(ost->resample);
776
        }
777
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
778
        if (audio_sync_method <= 1 &&
779
            ost->resample_sample_fmt  == enc->sample_fmt &&
780
            ost->resample_channels    == enc->channels   &&
781
            ost->resample_sample_rate == enc->sample_rate) {
782
            ost->resample = NULL;
783
            ost->audio_resample = 0;
784
        } else {
785
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
786
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
787
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
788
                                                   enc->sample_rate, dec->sample_rate,
789
                                                   enc->sample_fmt,  dec->sample_fmt,
790
                                                   16, 10, 0, 0.8);
791
            if (!ost->resample) {
792
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
793
                        dec->channels, dec->sample_rate,
794
                        enc->channels, enc->sample_rate);
795
                ffmpeg_exit(1);
796
            }
797
        }
798
    }
799

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

    
816
    if(audio_sync_method){
817
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
818
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
819
        double idelta= delta*dec->sample_rate / enc->sample_rate;
820
        int byte_delta= ((int)idelta)*2*dec->channels;
821

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

    
838
                    if(byte_delta > allocated_for_size - size){
839
                        allocated_for_size= byte_delta + (int64_t)size;
840
                        goto need_realloc;
841
                    }
842
                    ist->is_start=0;
843

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

    
864
    if (ost->audio_resample) {
865
        buftmp = audio_buf;
866
        size_out = audio_resample(ost->resample,
867
                                  (short *)buftmp, (short *)buf,
868
                                  size / (dec->channels * isize));
869
        size_out = size_out * enc->channels * osize;
870
    } else {
871
        buftmp = buf;
872
        size_out = size;
873
    }
874

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

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

    
900
        frame_bytes = enc->frame_size * osize * enc->channels;
901

    
902
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
903
            AVPacket pkt;
904
            av_init_packet(&pkt);
905

    
906
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
907

    
908
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
909

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

    
925
            ost->sync_opts += enc->frame_size;
926
        }
927
    } else {
928
        AVPacket pkt;
929
        av_init_packet(&pkt);
930

    
931
        ost->sync_opts += size_out / (osize * enc->channels);
932

    
933
        /* output a pcm frame */
934
        /* determine the size of the coded buffer */
935
        size_out /= osize;
936
        if (coded_bps)
937
            size_out = size_out*coded_bps/8;
938

    
939
        if(size_out > audio_out_size){
940
            fprintf(stderr, "Internal error, buffer size too small\n");
941
            ffmpeg_exit(1);
942
        }
943

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

    
962
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
963
{
964
    AVCodecContext *dec;
965
    AVPicture *picture2;
966
    AVPicture picture_tmp;
967
    uint8_t *buf = 0;
968

    
969
    dec = ist->st->codec;
970

    
971
    /* deinterlace : must be done before any resize */
972
    if (do_deinterlace) {
973
        int size;
974

    
975
        /* create temporary picture */
976
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
977
        buf = av_malloc(size);
978
        if (!buf)
979
            return;
980

    
981
        picture2 = &picture_tmp;
982
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
983

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

    
996
    if (picture != picture2)
997
        *picture = *picture2;
998
    *bufp = buf;
999
}
1000

    
1001
/* we begin to correct av delay at this threshold */
1002
#define AV_DELAY_MAX 0.100
1003

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

    
1016
    if (pts == AV_NOPTS_VALUE) {
1017
        fprintf(stderr, "Subtitle packets must have a pts\n");
1018
        if (exit_on_error)
1019
            ffmpeg_exit(1);
1020
        return;
1021
    }
1022

    
1023
    enc = ost->st->codec;
1024

    
1025
    if (!subtitle_out) {
1026
        subtitle_out = av_malloc(subtitle_out_max_size);
1027
    }
1028

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

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

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

    
1067
static int bit_buffer_size= 1024*256;
1068
static uint8_t *bit_buffer= NULL;
1069

    
1070
static void do_video_out(AVFormatContext *s,
1071
                         AVOutputStream *ost,
1072
                         AVInputStream *ist,
1073
                         AVFrame *in_picture,
1074
                         int *frame_size)
1075
{
1076
    int nb_frames, i, ret;
1077
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1078
    AVCodecContext *enc, *dec;
1079
    double sync_ipts;
1080

    
1081
    enc = ost->st->codec;
1082
    dec = ist->st->codec;
1083

    
1084
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1085

    
1086
    /* by default, we output a single frame */
1087
    nb_frames = 1;
1088

    
1089
    *frame_size = 0;
1090

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

    
1116
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1117
    if (nb_frames <= 0)
1118
        return;
1119

    
1120
    formatted_picture = in_picture;
1121
    final_picture = formatted_picture;
1122
    padding_src = formatted_picture;
1123
    resampling_dst = &ost->pict_tmp;
1124

    
1125
    if (   ost->resample_height != ist->st->codec->height
1126
        || ost->resample_width  != ist->st->codec->width
1127
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1128

    
1129
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1130
        if(!ost->video_resample)
1131
            ffmpeg_exit(1);
1132
    }
1133

    
1134
#if !CONFIG_AVFILTER
1135
    if (ost->video_resample) {
1136
        padding_src = NULL;
1137
        final_picture = &ost->pict_tmp;
1138
        if(  ost->resample_height != ist->st->codec->height
1139
          || ost->resample_width  != ist->st->codec->width
1140
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1141

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

    
1163
    /* duplicates frame if needed */
1164
    for(i=0;i<nb_frames;i++) {
1165
        AVPacket pkt;
1166
        av_init_packet(&pkt);
1167
        pkt.stream_index= ost->index;
1168

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

    
1180
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1181
            enc->coded_frame = old_frame;
1182
        } else {
1183
            AVFrame big_picture;
1184

    
1185
            big_picture= *final_picture;
1186
            /* better than nothing: use input picture interlaced
1187
               settings */
1188
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1189
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1190
                if(top_field_first == -1)
1191
                    big_picture.top_field_first = in_picture->top_field_first;
1192
                else
1193
                    big_picture.top_field_first = top_field_first;
1194
            }
1195

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

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

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

    
1245
static double psnr(double d){
1246
    return -10.0*log(d)/log(10.0);
1247
}
1248

    
1249
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1250
                           int frame_size)
1251
{
1252
    AVCodecContext *enc;
1253
    int frame_number;
1254
    double ti1, bitrate, avg_bitrate;
1255

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

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

    
1272
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1273
        /* compute pts value */
1274
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1275
        if (ti1 < 0.01)
1276
            ti1 = 0.01;
1277

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

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

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

    
1313

    
1314
    oc = output_files[0];
1315

    
1316
    total_size = avio_size(oc->pb);
1317
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1318
        total_size= avio_tell(oc->pb);
1319

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

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

    
1380
    if (verbose || is_last_report) {
1381
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1382

    
1383
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1384
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1385
            (double)total_size / 1024, ti1, bitrate);
1386

    
1387
        if (nb_frames_dup || nb_frames_drop)
1388
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1389
                  nb_frames_dup, nb_frames_drop);
1390

    
1391
        if (verbose >= 0)
1392
            fprintf(stderr, "%s    \r", buf);
1393

    
1394
        fflush(stderr);
1395
    }
1396

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

    
1409
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1410
{
1411
    int fill_char = 0x00;
1412
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1413
        fill_char = 0x80;
1414
    memset(buf, fill_char, size);
1415
}
1416

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

    
1435
    AVPacket avpkt;
1436
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1437

    
1438
    if(ist->next_pts == AV_NOPTS_VALUE)
1439
        ist->next_pts= ist->pts;
1440

    
1441
    if (pkt == NULL) {
1442
        /* EOF handling */
1443
        av_init_packet(&avpkt);
1444
        avpkt.data = NULL;
1445
        avpkt.size = 0;
1446
        goto handle_eof;
1447
    } else {
1448
        avpkt = *pkt;
1449
    }
1450

    
1451
    if(pkt->dts != AV_NOPTS_VALUE)
1452
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1453
    if(pkt->pts != AV_NOPTS_VALUE)
1454
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1455

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

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

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

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

    
1562
        buffer_to_free = NULL;
1563
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1564
            pre_process_video_frame(ist, (AVPicture *)&picture,
1565
                                    &buffer_to_free);
1566
        }
1567

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

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

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

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

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

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

    
1653
                        av_init_packet(&opkt);
1654

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1834

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2194
                    ost->original_height = icodec->height;
2195
                    ost->original_width  = icodec->width;
2196
#endif
2197
                    codec->bits_per_raw_sample= 0;
2198
                }
2199
                ost->resample_height = icodec->height;
2200
                ost->resample_width  = icodec->width;
2201
                ost->resample_pix_fmt= icodec->pix_fmt;
2202
                ost->encoding_needed = 1;
2203
                ist->decoding_needed = 1;
2204

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

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

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

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

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

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

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

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

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

    
2351
        files[0] = output_files[out_file_index];
2352
        files[1] = input_files[in_file_index];
2353

    
2354
        for (j = 0; j < 2; j++) {
2355
            AVMetaDataMap *map = &meta_data_maps[i][j];
2356

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

    
2376
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2377
    }
2378

    
2379
    /* copy global metadata by default */
2380
    if (metadata_global_autocopy) {
2381

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

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

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

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

    
2413
            for (j = 0; j < nb_output_files; j++)
2414
                if ((ret = copy_chapters(i, j)) < 0)
2415
                    goto dump_format;
2416
            break;
2417
        }
2418

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

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

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

    
2457
    if (ret) {
2458
        fprintf(stderr, "%s\n", error);
2459
        goto fail;
2460
    }
2461

    
2462
    if (want_sdp) {
2463
        print_sdp(output_files, nb_output_files);
2464
    }
2465

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

    
2476
    timer_start = av_gettime();
2477

    
2478
    for(; received_sigterm == 0;) {
2479
        int file_index, ist_index;
2480
        AVPacket pkt;
2481
        double ipts_min;
2482
        double opts_min;
2483

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

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

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

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

    
2555
        no_packet_count=0;
2556
        memset(no_packet, 0, sizeof(no_packet));
2557

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

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

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

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

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

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

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

    
2618
    discard_packet:
2619
        av_free_packet(&pkt);
2620

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

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

    
2633
    term_exit();
2634

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

    
2641
    /* dump report by using the first video and audio streams */
2642
    print_report(output_files, ost_table, nb_ostreams, 1);
2643

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

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

    
2664
    /* finished ! */
2665
    ret = 0;
2666

    
2667
 fail:
2668
    av_freep(&bit_buffer);
2669
    av_free(file_table);
2670

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

    
2707
static void opt_format(const char *arg)
2708
{
2709
    last_asked_format = arg;
2710
}
2711

    
2712
static void opt_video_rc_override_string(const char *arg)
2713
{
2714
    video_rc_override_string = arg;
2715
}
2716

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

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

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

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

    
2742
    opt_default(opt, arg);
2743

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

    
2747
    return 0;
2748
}
2749

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

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

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

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

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

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

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

    
2806
    x = vfilters ? strlen(vfilters) : 0;
2807
    vfilters = av_realloc(vfilters, x+100);
2808
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2809
}
2810

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

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

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

    
2823
    return 0;
2824
}
2825

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

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

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

    
2851
static void opt_audio_sample_fmt(const char *arg)
2852
{
2853
    if (strcmp(arg, "list")) {
2854
        audio_sample_fmt = av_get_sample_fmt(arg);
2855
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2856
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2857
            ffmpeg_exit(1);
2858
        }
2859
    } else {
2860
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2861
        ffmpeg_exit(0);
2862
    }
2863
}
2864

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

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

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

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

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

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

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

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

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

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

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

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

    
2933
    return 0;
2934
}
2935

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3027
    c->in_file = strtol(p, &p, 0);
3028
}
3029

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

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

    
3041
    if(stream >= MAX_STREAMS)
3042
        ffmpeg_exit(1);
3043

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

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

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

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

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

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

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

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

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

    
3122
    if (!strcmp(filename, "-"))
3123
        filename = "pipe:";
3124

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

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

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

    
3148
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3149

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

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

    
3191
    ic->loop_input = loop_input;
3192

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

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

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

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

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

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

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

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

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

    
3301
    nb_input_files++;
3302

    
3303
    video_channel = 0;
3304

    
3305
    av_freep(&video_codec_name);
3306
    av_freep(&audio_codec_name);
3307
    av_freep(&subtitle_codec_name);
3308
}
3309

    
3310
static void check_inputs(int *has_video_ptr,
3311
                         int *has_audio_ptr,
3312
                         int *has_subtitle_ptr,
3313
                         int *has_data_ptr)
3314
{
3315
    int has_video, has_audio, has_subtitle, has_data, i, j;
3316
    AVFormatContext *ic;
3317

    
3318
    has_video = 0;
3319
    has_audio = 0;
3320
    has_subtitle = 0;
3321
    has_data = 0;
3322

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

    
3353
static void new_video_stream(AVFormatContext *oc, int file_idx)
3354
{
3355
    AVStream *st;
3356
    AVOutputStream *ost;
3357
    AVCodecContext *video_enc;
3358
    enum CodecID codec_id = CODEC_ID_NONE;
3359
    AVCodec *codec= NULL;
3360

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

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

    
3381
    avcodec_get_context_defaults3(st->codec, codec);
3382
    ost->bitstream_filters = video_bitstream_filters;
3383
    video_bitstream_filters= NULL;
3384

    
3385
    st->codec->thread_count= thread_count;
3386

    
3387
    video_enc = st->codec;
3388

    
3389
    if(video_codec_tag)
3390
        video_enc->codec_tag= video_codec_tag;
3391

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

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

    
3412
        video_enc->codec_id = codec_id;
3413
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3414

    
3415
        if (codec && codec->supported_framerates && !force_fps)
3416
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3417
        video_enc->time_base.den = fps.num;
3418
        video_enc->time_base.num = fps.den;
3419

    
3420
        video_enc->width = frame_width;
3421
        video_enc->height = frame_height;
3422
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3423
        video_enc->pix_fmt = frame_pix_fmt;
3424
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3425

    
3426
        choose_pixel_fmt(st, codec);
3427

    
3428
        if (intra_only)
3429
            video_enc->gop_size = 0;
3430
        if (video_qscale || same_quality) {
3431
            video_enc->flags |= CODEC_FLAG_QSCALE;
3432
            video_enc->global_quality=
3433
                st->quality = FF_QP2LAMBDA * video_qscale;
3434
        }
3435

    
3436
        if(intra_matrix)
3437
            video_enc->intra_matrix = intra_matrix;
3438
        if(inter_matrix)
3439
            video_enc->inter_matrix = inter_matrix;
3440

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

    
3471
        if (do_psnr)
3472
            video_enc->flags|= CODEC_FLAG_PSNR;
3473

    
3474
        /* two pass mode */
3475
        if (do_pass) {
3476
            if (do_pass == 1) {
3477
                video_enc->flags |= CODEC_FLAG_PASS1;
3478
            } else {
3479
                video_enc->flags |= CODEC_FLAG_PASS2;
3480
            }
3481
        }
3482

    
3483
        if (forced_key_frames)
3484
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3485
    }
3486
    if (video_language) {
3487
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3488
        av_freep(&video_language);
3489
    }
3490

    
3491
    /* reset some key parameters */
3492
    video_disable = 0;
3493
    av_freep(&video_codec_name);
3494
    av_freep(&forced_key_frames);
3495
    video_stream_copy = 0;
3496
    frame_pix_fmt = PIX_FMT_NONE;
3497
}
3498

    
3499
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3500
{
3501
    AVStream *st;
3502
    AVOutputStream *ost;
3503
    AVCodec *codec= NULL;
3504
    AVCodecContext *audio_enc;
3505
    enum CodecID codec_id = CODEC_ID_NONE;
3506

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

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

    
3527
    avcodec_get_context_defaults3(st->codec, codec);
3528

    
3529
    ost->bitstream_filters = audio_bitstream_filters;
3530
    audio_bitstream_filters= NULL;
3531

    
3532
    st->codec->thread_count= thread_count;
3533

    
3534
    audio_enc = st->codec;
3535
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3536

    
3537
    if(audio_codec_tag)
3538
        audio_enc->codec_tag= audio_codec_tag;
3539

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

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

    
3571
    /* reset some key parameters */
3572
    audio_disable = 0;
3573
    av_freep(&audio_codec_name);
3574
    audio_stream_copy = 0;
3575
}
3576

    
3577
static void new_data_stream(AVFormatContext *oc, int file_idx)
3578
{
3579
    AVStream *st;
3580
    AVOutputStream *ost;
3581
    AVCodec *codec=NULL;
3582
    AVCodecContext *data_enc;
3583

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

    
3598
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3599

    
3600
    if (data_codec_tag)
3601
        data_enc->codec_tag= data_codec_tag;
3602

    
3603
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3604
        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3605
        avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3606
    }
3607
    if (data_stream_copy) {
3608
        st->stream_copy = 1;
3609
    }
3610

    
3611
    data_disable = 0;
3612
    av_freep(&data_codec_name);
3613
    data_stream_copy = 0;
3614
}
3615

    
3616
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3617
{
3618
    AVStream *st;
3619
    AVOutputStream *ost;
3620
    AVCodec *codec=NULL;
3621
    AVCodecContext *subtitle_enc;
3622
    enum CodecID codec_id = CODEC_ID_NONE;
3623

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

    
3644
    ost->bitstream_filters = subtitle_bitstream_filters;
3645
    subtitle_bitstream_filters= NULL;
3646

    
3647
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3648

    
3649
    if(subtitle_codec_tag)
3650
        subtitle_enc->codec_tag= subtitle_codec_tag;
3651

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

    
3663
    if (subtitle_language) {
3664
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3665
        av_freep(&subtitle_language);
3666
    }
3667

    
3668
    subtitle_disable = 0;
3669
    av_freep(&subtitle_codec_name);
3670
    subtitle_stream_copy = 0;
3671
}
3672

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

    
3683
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3684
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3685
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3686
    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3687
    else av_assert0(0);
3688
    return 0;
3689
}
3690

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

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

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

    
3721
    if (!strcmp(filename, "-"))
3722
        filename = "pipe:";
3723

    
3724
    oc = avformat_alloc_context();
3725
    if (!oc) {
3726
        print_error(filename, AVERROR(ENOMEM));
3727
        ffmpeg_exit(1);
3728
    }
3729

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

    
3746
    oc->oformat = file_oformat;
3747
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3748

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

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

    
3772
            if (!input_has_video)
3773
                use_video = 0;
3774
            if (!input_has_audio)
3775
                use_audio = 0;
3776
            if (!input_has_subtitle)
3777
                use_subtitle = 0;
3778
            if (!input_has_data)
3779
                use_data = 0;
3780
        }
3781

    
3782
        /* manual disable */
3783
        if (audio_disable)    use_audio    = 0;
3784
        if (video_disable)    use_video    = 0;
3785
        if (subtitle_disable) use_subtitle = 0;
3786
        if (data_disable)     use_data     = 0;
3787

    
3788
        if (use_video)    new_video_stream(oc, nb_output_files);
3789
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3790
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3791
        if (use_data)     new_data_stream(oc, nb_output_files);
3792

    
3793
        oc->timestamp = recording_timestamp;
3794

    
3795
        av_metadata_copy(&oc->metadata, metadata, 0);
3796
        av_metadata_free(&metadata);
3797
    }
3798

    
3799
    output_files[nb_output_files++] = oc;
3800

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

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

    
3831
        /* open the file */
3832
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3833
            print_error(filename, err);
3834
            ffmpeg_exit(1);
3835
        }
3836
    }
3837

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

    
3845
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3846
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3847
    oc->loop_output = loop_output;
3848
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3849

    
3850
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3851

    
3852
    av_freep(&forced_key_frames);
3853
}
3854

    
3855
/* same option as mencoder */
3856
static void opt_pass(const char *pass_str)
3857
{
3858
    int pass;
3859
    pass = atoi(pass_str);
3860
    if (pass != 1 && pass != 2) {
3861
        fprintf(stderr, "pass number can be only 1 or 2\n");
3862
        ffmpeg_exit(1);
3863
    }
3864
    do_pass = pass;
3865
}
3866

    
3867
static int64_t getutime(void)
3868
{
3869
#if HAVE_GETRUSAGE
3870
    struct rusage rusage;
3871

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

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

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

    
3920
static void opt_inter_matrix(const char *arg)
3921
{
3922
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3923
    parse_matrix_coeffs(inter_matrix, arg);
3924
}
3925

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

    
3932
static void show_usage(void)
3933
{
3934
    printf("Hyper fast Audio and Video encoder\n");
3935
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3936
    printf("\n");
3937
}
3938

    
3939
static void show_help(void)
3940
{
3941
    AVCodec *c;
3942
    AVOutputFormat *oformat = NULL;
3943

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

    
3973
    /* individual codec options */
3974
    c = NULL;
3975
    while ((c = av_codec_next(c))) {
3976
        if (c->priv_class) {
3977
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3978
            printf("\n");
3979
        }
3980
    }
3981

    
3982
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3983
    printf("\n");
3984

    
3985
    /* individual muxer options */
3986
    while ((oformat = av_oformat_next(oformat))) {
3987
        if (oformat->priv_class) {
3988
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3989
            printf("\n");
3990
        }
3991
    }
3992

    
3993
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3994
}
3995

    
3996
static void opt_target(const char *arg)
3997
{
3998
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3999
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4000

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

    
4045
    if(norm == UNKNOWN) {
4046
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4047
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4048
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4049
        ffmpeg_exit(1);
4050
    }
4051

    
4052
    if(!strcmp(arg, "vcd")) {
4053

    
4054
        opt_video_codec("mpeg1video");
4055
        opt_audio_codec("mp2");
4056
        opt_format("vcd");
4057

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

    
4062
        opt_default("b", "1150000");
4063
        opt_default("maxrate", "1150000");
4064
        opt_default("minrate", "1150000");
4065
        opt_default("bufsize", "327680"); // 40*1024*8;
4066

    
4067
        opt_default("ab", "224000");
4068
        audio_sample_rate = 44100;
4069
        audio_channels = 2;
4070

    
4071
        opt_default("packetsize", "2324");
4072
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4073

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

    
4082
        opt_video_codec("mpeg2video");
4083
        opt_audio_codec("mp2");
4084
        opt_format("svcd");
4085

    
4086
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4087
        opt_frame_rate(NULL, frame_rates[norm]);
4088
        opt_default("g", norm == PAL ? "15" : "18");
4089

    
4090
        opt_default("b", "2040000");
4091
        opt_default("maxrate", "2516000");
4092
        opt_default("minrate", "0"); //1145000;
4093
        opt_default("bufsize", "1835008"); //224*1024*8;
4094
        opt_default("flags", "+scan_offset");
4095

    
4096

    
4097
        opt_default("ab", "224000");
4098
        audio_sample_rate = 44100;
4099

    
4100
        opt_default("packetsize", "2324");
4101

    
4102
    } else if(!strcmp(arg, "dvd")) {
4103

    
4104
        opt_video_codec("mpeg2video");
4105
        opt_audio_codec("ac3");
4106
        opt_format("dvd");
4107

    
4108
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4109
        opt_frame_rate(NULL, frame_rates[norm]);
4110
        opt_default("g", norm == PAL ? "15" : "18");
4111

    
4112
        opt_default("b", "6000000");
4113
        opt_default("maxrate", "9000000");
4114
        opt_default("minrate", "0"); //1500000;
4115
        opt_default("bufsize", "1835008"); //224*1024*8;
4116

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

    
4120
        opt_default("ab", "448000");
4121
        audio_sample_rate = 48000;
4122

    
4123
    } else if(!strncmp(arg, "dv", 2)) {
4124

    
4125
        opt_format("dv");
4126

    
4127
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4128
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4129
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4130
        opt_frame_rate(NULL, frame_rates[norm]);
4131

    
4132
        audio_sample_rate = 48000;
4133
        audio_channels = 2;
4134

    
4135
    } else {
4136
        fprintf(stderr, "Unknown target: %s\n", arg);
4137
        ffmpeg_exit(1);
4138
    }
4139
}
4140

    
4141
static void opt_vstats_file (const char *arg)
4142
{
4143
    av_free (vstats_filename);
4144
    vstats_filename=av_strdup (arg);
4145
}
4146

    
4147
static void opt_vstats (void)
4148
{
4149
    char filename[40];
4150
    time_t today2 = time(NULL);
4151
    struct tm *today = localtime(&today2);
4152

    
4153
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4154
             today->tm_sec);
4155
    opt_vstats_file(filename);
4156
}
4157

    
4158
static int opt_bsf(const char *opt, const char *arg)
4159
{
4160
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4161
    AVBitStreamFilterContext **bsfp;
4162

    
4163
    if(!bsfc){
4164
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4165
        ffmpeg_exit(1);
4166
    }
4167

    
4168
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4169
          *opt == 'a' ? &audio_bitstream_filters :
4170
                        &subtitle_bitstream_filters;
4171
    while(*bsfp)
4172
        bsfp= &(*bsfp)->next;
4173

    
4174
    *bsfp= bsfc;
4175

    
4176
    return 0;
4177
}
4178

    
4179
static int opt_preset(const char *opt, const char *arg)
4180
{
4181
    FILE *f=NULL;
4182
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4183
    char *codec_name = *opt == 'v' ? video_codec_name :
4184
                       *opt == 'a' ? audio_codec_name :
4185
                                     subtitle_codec_name;
4186

    
4187
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4188
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4189
        ffmpeg_exit(1);
4190
    }
4191

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

    
4215
    fclose(f);
4216

    
4217
    return 0;
4218
}
4219

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

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

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

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

    
4334
    /* grab options */
4335
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4336
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4337
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4338

    
4339
    /* muxer options */
4340
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4341
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4342

    
4343
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4344
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4345
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4346

    
4347
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4348
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4349
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4350
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4351
    /* data codec support */
4352
    { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4353

    
4354
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4355
    { NULL, },
4356
};
4357

    
4358
int main(int argc, char **argv)
4359
{
4360
    int64_t ti;
4361

    
4362
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4363

    
4364
    avcodec_register_all();
4365
#if CONFIG_AVDEVICE
4366
    avdevice_register_all();
4367
#endif
4368
#if CONFIG_AVFILTER
4369
    avfilter_register_all();
4370
#endif
4371
    av_register_all();
4372

    
4373
#if HAVE_ISATTY
4374
    if(isatty(STDIN_FILENO))
4375
        avio_set_interrupt_cb(decode_interrupt_cb);
4376
#endif
4377

    
4378
    init_opts();
4379

    
4380
    show_banner();
4381

    
4382
    /* parse options */
4383
    parse_options(argc, argv, options, opt_output_file);
4384

    
4385
    if(nb_output_files <= 0 && nb_input_files == 0) {
4386
        show_usage();
4387
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4388
        ffmpeg_exit(1);
4389
    }
4390

    
4391
    /* file converter / grab */
4392
    if (nb_output_files <= 0) {
4393
        fprintf(stderr, "At least one output file must be specified\n");
4394
        ffmpeg_exit(1);
4395
    }
4396

    
4397
    if (nb_input_files == 0) {
4398
        fprintf(stderr, "At least one input file must be specified\n");
4399
        ffmpeg_exit(1);
4400
    }
4401

    
4402
    ti = getutime();
4403
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4404
                  stream_maps, nb_stream_maps) < 0)
4405
        ffmpeg_exit(1);
4406
    ti = getutime() - ti;
4407
    if (do_benchmark) {
4408
        int maxrss = getmaxrss() / 1024;
4409
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4410
    }
4411

    
4412
    return ffmpeg_exit(0);
4413
}