Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ f38d900f

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 int64_t timer_start;
249

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

    
254
static short *samples;
255

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

    
260
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
261

    
262
struct AVInputStream;
263

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

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

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

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

    
305
   int sws_flags;
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_video_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
                 ost->sws_flags);
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", ost->sws_flags);
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

    
621
    ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
622
    return ost;
623
}
624

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

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

    
640
        s->nb_streams++;
641

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

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

    
666
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
667
            nopts = 1;
668

    
669
        new_output_stream(s, nb_output_files);
670
    }
671

    
672
    if (!nopts)
673
        s->timestamp = av_gettime();
674

    
675
    av_close_input_file(ic);
676
    return 0;
677
}
678

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

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

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

    
708
        bsfc= bsfc->next;
709
    }
710

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

    
718
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
719

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

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

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

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

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

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

    
760
    if (enc->channels != dec->channels)
761
        ost->audio_resample = 1;
762

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

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

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

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

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

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

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

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

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

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

    
902
        frame_bytes = enc->frame_size * osize * enc->channels;
903

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

    
908
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
909

    
910
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
911

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

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

    
933
        ost->sync_opts += size_out / (osize * enc->channels);
934

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

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

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

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

    
971
    dec = ist->st->codec;
972

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

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

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

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

    
998
    if (picture != picture2)
999
        *picture = *picture2;
1000
    *bufp = buf;
1001
}
1002

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

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

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

    
1025
    enc = ost->st->codec;
1026

    
1027
    if (!subtitle_out) {
1028
        subtitle_out = av_malloc(subtitle_out_max_size);
1029
    }
1030

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

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

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

    
1069
static int bit_buffer_size= 1024*256;
1070
static uint8_t *bit_buffer= NULL;
1071

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

    
1083
    enc = ost->st->codec;
1084
    dec = ist->st->codec;
1085

    
1086
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1087

    
1088
    /* by default, we output a single frame */
1089
    nb_frames = 1;
1090

    
1091
    *frame_size = 0;
1092

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

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

    
1122
    formatted_picture = in_picture;
1123
    final_picture = formatted_picture;
1124
    resampling_dst = &ost->pict_tmp;
1125

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

    
1130
        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));
1131
        if(!ost->video_resample)
1132
            ffmpeg_exit(1);
1133
    }
1134

    
1135
#if !CONFIG_AVFILTER
1136
    if (ost->video_resample) {
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
            ost->img_resample_ctx = sws_getContext(
1145
                ist->st->codec->width,
1146
                ist->st->codec->height,
1147
                ist->st->codec->pix_fmt,
1148
                ost->st->codec->width,
1149
                ost->st->codec->height,
1150
                ost->st->codec->pix_fmt,
1151
                ost->sws_flags, NULL, NULL, NULL);
1152
            if (ost->img_resample_ctx == NULL) {
1153
                fprintf(stderr, "Cannot get resampling context\n");
1154
                ffmpeg_exit(1);
1155
            }
1156
        }
1157
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1158
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1159
    }
1160
#endif
1161

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1312

    
1313
    oc = output_files[0];
1314

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

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

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

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

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

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

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

    
1393
        fflush(stderr);
1394
    }
1395

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1652
                        av_init_packet(&opkt);
1653

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1833

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2474
    timer_start = av_gettime();
2475

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2616
    discard_packet:
2617
        av_free_packet(&pkt);
2618

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

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

    
2631
    term_exit();
2632

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2740
    opt_default(opt, arg);
2741

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

    
2745
    return 0;
2746
}
2747

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

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

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

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

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

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

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

    
2804
#if CONFIG_AVFILTER
2805
    x = vfilters ? strlen(vfilters) : 0;
2806
    vfilters = av_realloc(vfilters, x+100);
2807
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2808
#endif
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
        int i;
2861
        char fmt_str[128];
2862
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2863
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2864
        ffmpeg_exit(0);
2865
    }
2866
}
2867

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

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

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

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

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

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

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

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

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

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

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

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

    
2936
    return 0;
2937
}
2938

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3194
    ic->loop_input = loop_input;
3195

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

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

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

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

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

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

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

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

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

    
3304
    nb_input_files++;
3305

    
3306
    video_channel = 0;
3307

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

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

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

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

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

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

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

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

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

    
3392
    video_enc = st->codec;
3393

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

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

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

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

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

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

    
3431
        choose_pixel_fmt(st, codec);
3432

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3603
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3604

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

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

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

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

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

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

    
3652
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3653

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3798
        oc->timestamp = recording_timestamp;
3799

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

    
3804
    output_files[nb_output_files++] = oc;
3805

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4103

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

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

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

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

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

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

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

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

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

    
4132
        opt_format("dv");
4133

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

    
4139
        audio_sample_rate = 48000;
4140
        audio_channels = 2;
4141

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

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

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

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

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

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

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

    
4181
    *bsfp= bsfc;
4182

    
4183
    return 0;
4184
}
4185

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

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

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

    
4222
    fclose(f);
4223

    
4224
    return 0;
4225
}
4226

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

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

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

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

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

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

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

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

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

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

    
4369
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4370

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

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

    
4385
    init_opts();
4386

    
4387
    show_banner();
4388

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

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

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

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

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

    
4419
    return ffmpeg_exit(0);
4420
}