Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 2839dc97

History | View | Annotate | Download (154 KB)

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

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

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

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

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

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

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

    
81
#include "cmdutils.h"
82

    
83
#include "libavutil/avassert.h"
84

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

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

    
96
/**
97
 * select an input file for an output file
98
 */
99
typedef struct AVMetaDataMap {
100
    int out_file;
101
    int in_file;
102
} AVMetaDataMap;
103

    
104
static const OptionDef options[];
105

    
106
#define MAX_FILES 100
107
#if !FF_API_MAX_STREAMS
108
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
109
#endif
110

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

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

    
125
static AVStreamMap *stream_maps = NULL;
126
static int nb_stream_maps;
127

    
128
static AVMetaDataMap *meta_data_maps = NULL;
129
static int nb_meta_data_maps;
130

    
131
/* indexed by output file stream index */
132
static int *streamid_map = NULL;
133
static int nb_streamid_map = 0;
134

    
135
static int frame_width  = 0;
136
static int frame_height = 0;
137
static float frame_aspect_ratio = 0;
138
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
139
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
140
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
141
static AVRational frame_rate;
142
static float video_qscale = 0;
143
static uint16_t *intra_matrix = NULL;
144
static uint16_t *inter_matrix = NULL;
145
static const char *video_rc_override_string=NULL;
146
static int video_disable = 0;
147
static int video_discard = 0;
148
static char *video_codec_name = NULL;
149
static unsigned int video_codec_tag = 0;
150
static char *video_language = NULL;
151
static int same_quality = 0;
152
static int do_deinterlace = 0;
153
static int top_field_first = -1;
154
static int me_threshold = 0;
155
static int intra_dc_precision = 8;
156
static int loop_input = 0;
157
static int loop_output = AVFMT_NOOUTPUTLOOP;
158
static int qp_hist = 0;
159
#if CONFIG_AVFILTER
160
static char *vfilters = NULL;
161
AVFilterGraph *graph = NULL;
162
#endif
163

    
164
static int intra_only = 0;
165
static int audio_sample_rate = 44100;
166
static int64_t channel_layout = 0;
167
#define QSCALE_NONE -99999
168
static float audio_qscale = QSCALE_NONE;
169
static int audio_disable = 0;
170
static int audio_channels = 1;
171
static char  *audio_codec_name = NULL;
172
static unsigned int audio_codec_tag = 0;
173
static char *audio_language = NULL;
174

    
175
static int subtitle_disable = 0;
176
static char *subtitle_codec_name = NULL;
177
static char *subtitle_language = NULL;
178
static unsigned int subtitle_codec_tag = 0;
179

    
180
static float mux_preload= 0.5;
181
static float mux_max_delay= 0.7;
182

    
183
static int64_t recording_time = INT64_MAX;
184
static int64_t start_time = 0;
185
static int64_t recording_timestamp = 0;
186
static int64_t input_ts_offset = 0;
187
static int file_overwrite = 0;
188
static AVMetadata *metadata;
189
static int do_benchmark = 0;
190
static int do_hex_dump = 0;
191
static int do_pkt_dump = 0;
192
static int do_psnr = 0;
193
static int do_pass = 0;
194
static char *pass_logfilename_prefix = NULL;
195
static int audio_stream_copy = 0;
196
static int video_stream_copy = 0;
197
static int subtitle_stream_copy = 0;
198
static int video_sync_method= -1;
199
static int audio_sync_method= 0;
200
static float audio_drift_threshold= 0.1;
201
static int copy_ts= 0;
202
static int opt_shortest = 0;
203
static int video_global_header = 0;
204
static char *vstats_filename;
205
static FILE *vstats_file;
206
static int opt_programid = 0;
207
static int copy_initial_nonkeyframes = 0;
208

    
209
static int rate_emu = 0;
210

    
211
static int  video_channel = 0;
212
static char *video_standard;
213

    
214
static int audio_volume = 256;
215

    
216
static int exit_on_error = 0;
217
static int using_stdin = 0;
218
static int verbose = 1;
219
static int thread_count= 1;
220
static int q_pressed = 0;
221
static int64_t video_size = 0;
222
static int64_t audio_size = 0;
223
static int64_t extra_size = 0;
224
static int nb_frames_dup = 0;
225
static int nb_frames_drop = 0;
226
static int input_sync;
227
static uint64_t limit_filesize = 0;
228
static int force_fps = 0;
229
static char *forced_key_frames = NULL;
230

    
231
static int pgmyuv_compatibility_hack=0;
232
static float dts_delta_threshold = 10;
233

    
234
static unsigned int sws_flags = SWS_BICUBIC;
235

    
236
static int64_t timer_start;
237

    
238
static uint8_t *audio_buf;
239
static uint8_t *audio_out;
240
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
241

    
242
static short *samples;
243

    
244
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
245
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
246
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
247

    
248
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
249

    
250
struct AVInputStream;
251

    
252
typedef struct AVOutputStream {
253
    int file_index;          /* file index */
254
    int index;               /* stream index in the output file */
255
    int source_index;        /* AVInputStream index */
256
    AVStream *st;            /* stream in the output file */
257
    int encoding_needed;     /* true if encoding needed for this stream */
258
    int frame_number;
259
    /* input pts and corresponding output pts
260
       for A/V sync */
261
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
262
    struct AVInputStream *sync_ist; /* input stream to sync against */
263
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
264
    AVBitStreamFilterContext *bitstream_filters;
265
    /* video only */
266
    int video_resample;
267
    AVFrame pict_tmp;      /* temporary image for resampling */
268
    struct SwsContext *img_resample_ctx; /* for image resampling */
269
    int resample_height;
270
    int resample_width;
271
    int resample_pix_fmt;
272

    
273
    /* full frame size of first frame */
274
    int original_height;
275
    int original_width;
276

    
277
    /* forced key frames */
278
    int64_t *forced_kf_pts;
279
    int forced_kf_count;
280
    int forced_kf_index;
281

    
282
    /* audio only */
283
    int audio_resample;
284
    ReSampleContext *resample; /* for audio resampling */
285
    int reformat_pair;
286
    AVAudioConvert *reformat_ctx;
287
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
288
    FILE *logfile;
289
} AVOutputStream;
290

    
291
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
292
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
293

    
294
typedef struct AVInputStream {
295
    int file_index;
296
    int index;
297
    AVStream *st;
298
    int discard;             /* true if stream data should be discarded */
299
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
300
    int64_t sample_index;      /* current sample */
301

    
302
    int64_t       start;     /* time when read started */
303
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
304
                                is not defined */
305
    int64_t       pts;       /* current pts */
306
    PtsCorrectionContext pts_ctx;
307
    int is_start;            /* is 1 at the start and after a discontinuity */
308
    int showed_multi_packet_warning;
309
    int is_past_recording_time;
310
#if CONFIG_AVFILTER
311
    AVFilterContext *output_video_filter;
312
    AVFilterContext *input_video_filter;
313
    AVFrame *filter_frame;
314
    int has_filter_frame;
315
    AVFilterBufferRef *picref;
316
#endif
317
} AVInputStream;
318

    
319
typedef struct AVInputFile {
320
    int eof_reached;      /* true if eof reached */
321
    int ist_index;        /* index of first stream in ist_table */
322
    int buffer_size;      /* current total buffer size */
323
    int nb_streams;       /* nb streams we are aware of */
324
} AVInputFile;
325

    
326
#if HAVE_TERMIOS_H
327

    
328
/* init terminal so that we can grab keys */
329
static struct termios oldtty;
330
#endif
331

    
332
#if CONFIG_AVFILTER
333

    
334
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
335
{
336
    AVFilterContext *last_filter, *filter;
337
    /** filter graph containing all filters including input & output */
338
    AVCodecContext *codec = ost->st->codec;
339
    AVCodecContext *icodec = ist->st->codec;
340
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
341
    char args[255];
342
    int ret;
343

    
344
    graph = av_mallocz(sizeof(AVFilterGraph));
345

    
346
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
347
        return ret;
348
    if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
349
        return ret;
350

    
351
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
352
             ist->st->codec->height, ist->st->codec->pix_fmt,
353
             ist->st->time_base.num, ist->st->time_base.den);
354
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
355
        return ret;
356
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
357
        return ret;
358

    
359
    /* add input and output filters to the overall graph */
360
    avfilter_graph_add_filter(graph, ist->input_video_filter);
361
    avfilter_graph_add_filter(graph, ist->output_video_filter);
362

    
363
    last_filter = ist->input_video_filter;
364

    
365
    if (codec->width  != icodec->width || codec->height != icodec->height) {
366
        snprintf(args, 255, "%d:%d:flags=0x%X",
367
                 codec->width,
368
                 codec->height,
369
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
370
        if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
371
            return ret;
372
        if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
373
            return ret;
374
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
375
            return ret;
376
        last_filter = filter;
377
        avfilter_graph_add_filter(graph, last_filter);
378
    }
379

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

    
383
    if (vfilters) {
384
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
385
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
386

    
387
        outputs->name    = av_strdup("in");
388
        outputs->filter  = last_filter;
389
        outputs->pad_idx = 0;
390
        outputs->next    = NULL;
391

    
392
        inputs->name    = av_strdup("out");
393
        inputs->filter  = ist->output_video_filter;
394
        inputs->pad_idx = 0;
395
        inputs->next    = NULL;
396

    
397
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
398
            return ret;
399
        av_freep(&vfilters);
400
    } else {
401
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
402
            return ret;
403
    }
404

    
405
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
406
        return ret;
407

    
408
    codec->width  = ist->output_video_filter->inputs[0]->w;
409
    codec->height = ist->output_video_filter->inputs[0]->h;
410

    
411
    return 0;
412
}
413
#endif /* CONFIG_AVFILTER */
414

    
415
static void term_exit(void)
416
{
417
    av_log(NULL, AV_LOG_QUIET, "");
418
#if HAVE_TERMIOS_H
419
    tcsetattr (0, TCSANOW, &oldtty);
420
#endif
421
}
422

    
423
static volatile int received_sigterm = 0;
424

    
425
static void
426
sigterm_handler(int sig)
427
{
428
    received_sigterm = sig;
429
    term_exit();
430
}
431

    
432
static void term_init(void)
433
{
434
#if HAVE_TERMIOS_H
435
    struct termios tty;
436

    
437
    tcgetattr (0, &tty);
438
    oldtty = tty;
439
    atexit(term_exit);
440

    
441
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
442
                          |INLCR|IGNCR|ICRNL|IXON);
443
    tty.c_oflag |= OPOST;
444
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
445
    tty.c_cflag &= ~(CSIZE|PARENB);
446
    tty.c_cflag |= CS8;
447
    tty.c_cc[VMIN] = 1;
448
    tty.c_cc[VTIME] = 0;
449

    
450
    tcsetattr (0, TCSANOW, &tty);
451
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
452
#endif
453

    
454
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
455
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
456
#ifdef SIGXCPU
457
    signal(SIGXCPU, sigterm_handler);
458
#endif
459
}
460

    
461
/* read a key without blocking */
462
static int read_key(void)
463
{
464
#if HAVE_TERMIOS_H
465
    int n = 1;
466
    unsigned char ch;
467
    struct timeval tv;
468
    fd_set rfds;
469

    
470
    FD_ZERO(&rfds);
471
    FD_SET(0, &rfds);
472
    tv.tv_sec = 0;
473
    tv.tv_usec = 0;
474
    n = select(1, &rfds, NULL, NULL, &tv);
475
    if (n > 0) {
476
        n = read(0, &ch, 1);
477
        if (n == 1)
478
            return ch;
479

    
480
        return n;
481
    }
482
#elif HAVE_CONIO_H
483
    if(kbhit())
484
        return(getch());
485
#endif
486
    return -1;
487
}
488

    
489
static int decode_interrupt_cb(void)
490
{
491
    return q_pressed || (q_pressed = read_key() == 'q');
492
}
493

    
494
static int ffmpeg_exit(int ret)
495
{
496
    int i;
497

    
498
    /* close files */
499
    for(i=0;i<nb_output_files;i++) {
500
        /* maybe av_close_output_file ??? */
501
        AVFormatContext *s = output_files[i];
502
        int j;
503
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
504
            url_fclose(s->pb);
505
        for(j=0;j<s->nb_streams;j++) {
506
            av_metadata_free(&s->streams[j]->metadata);
507
            av_free(s->streams[j]->codec);
508
            av_free(s->streams[j]->info);
509
            av_free(s->streams[j]);
510
        }
511
        for(j=0;j<s->nb_programs;j++) {
512
            av_metadata_free(&s->programs[j]->metadata);
513
        }
514
        for(j=0;j<s->nb_chapters;j++) {
515
            av_metadata_free(&s->chapters[j]->metadata);
516
        }
517
        av_metadata_free(&s->metadata);
518
        av_free(s);
519
        av_free(output_streams_for_file[i]);
520
    }
521
    for(i=0;i<nb_input_files;i++) {
522
        av_close_input_file(input_files[i]);
523
        av_free(input_files_ts_scale[i]);
524
    }
525

    
526
    av_free(intra_matrix);
527
    av_free(inter_matrix);
528

    
529
    if (vstats_file)
530
        fclose(vstats_file);
531
    av_free(vstats_filename);
532

    
533
    av_free(opt_names);
534
    av_free(streamid_map);
535
    av_free(input_codecs);
536
    av_free(output_codecs);
537
    av_free(stream_maps);
538
    av_free(meta_data_maps);
539

    
540
    av_free(video_codec_name);
541
    av_free(audio_codec_name);
542
    av_free(subtitle_codec_name);
543

    
544
    av_free(video_standard);
545

    
546
    uninit_opts();
547
    av_free(audio_buf);
548
    av_free(audio_out);
549
    allocated_audio_buf_size= allocated_audio_out_size= 0;
550
    av_free(samples);
551

    
552
#if CONFIG_AVFILTER
553
    avfilter_uninit();
554
#endif
555

    
556
    if (received_sigterm) {
557
        fprintf(stderr,
558
            "Received signal %d: terminating.\n",
559
            (int) received_sigterm);
560
        exit (255);
561
    }
562

    
563
    exit(ret); /* not all OS-es handle main() return value */
564
    return ret;
565
}
566

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

    
587
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
588
{
589
    if(codec && codec->sample_fmts){
590
        const enum SampleFormat *p= codec->sample_fmts;
591
        for(; *p!=-1; p++){
592
            if(*p == st->codec->sample_fmt)
593
                break;
594
        }
595
        if(*p == -1)
596
            st->codec->sample_fmt = codec->sample_fmts[0];
597
    }
598
}
599

    
600
static void choose_sample_rate(AVStream *st, AVCodec *codec)
601
{
602
    if(codec && codec->supported_samplerates){
603
        const int *p= codec->supported_samplerates;
604
        int best=0;
605
        int best_dist=INT_MAX;
606
        for(; *p; p++){
607
            int dist= abs(st->codec->sample_rate - *p);
608
            if(dist < best_dist){
609
                best_dist= dist;
610
                best= *p;
611
            }
612
        }
613
        if(best_dist){
614
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
615
        }
616
        st->codec->sample_rate= best;
617
    }
618
}
619

    
620
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
621
{
622
    if(codec && codec->pix_fmts){
623
        const enum PixelFormat *p= codec->pix_fmts;
624
        for(; *p!=-1; p++){
625
            if(*p == st->codec->pix_fmt)
626
                break;
627
        }
628
        if(*p == -1
629
           && !(   st->codec->codec_id==CODEC_ID_MJPEG
630
                && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
631
                && (   st->codec->pix_fmt == PIX_FMT_YUV420P
632
                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))
633
            st->codec->pix_fmt = codec->pix_fmts[0];
634
    }
635
}
636

    
637
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
638
{
639
    int idx = oc->nb_streams - 1;
640
    AVOutputStream *ost;
641

    
642
    output_streams_for_file[file_idx] =
643
        grow_array(output_streams_for_file[file_idx],
644
                   sizeof(*output_streams_for_file[file_idx]),
645
                   &nb_output_streams_for_file[file_idx],
646
                   oc->nb_streams);
647
    ost = output_streams_for_file[file_idx][idx] =
648
        av_mallocz(sizeof(AVOutputStream));
649
    if (!ost) {
650
        fprintf(stderr, "Could not alloc output stream\n");
651
        ffmpeg_exit(1);
652
    }
653
    ost->file_index = file_idx;
654
    ost->index = idx;
655
    return ost;
656
}
657

    
658
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
659
{
660
    int i, err;
661
    AVFormatContext *ic;
662
    int nopts = 0;
663

    
664
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
665
    if (err < 0)
666
        return err;
667
    /* copy stream format */
668
    s->nb_streams = 0;
669
    for(i=0;i<ic->nb_streams;i++) {
670
        AVStream *st;
671
        AVCodec *codec;
672

    
673
        s->nb_streams++;
674

    
675
        // FIXME: a more elegant solution is needed
676
        st = av_mallocz(sizeof(AVStream));
677
        memcpy(st, ic->streams[i], sizeof(AVStream));
678
        st->codec = avcodec_alloc_context();
679
        if (!st->codec) {
680
            print_error(filename, AVERROR(ENOMEM));
681
            ffmpeg_exit(1);
682
        }
683
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
684
        s->streams[i] = st;
685

    
686
        codec = avcodec_find_encoder(st->codec->codec_id);
687
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
688
            if (audio_stream_copy) {
689
                st->stream_copy = 1;
690
            } else
691
                choose_sample_fmt(st, codec);
692
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
693
            if (video_stream_copy) {
694
                st->stream_copy = 1;
695
            } else
696
                choose_pixel_fmt(st, codec);
697
        }
698

    
699
        if(!st->codec->thread_count)
700
            st->codec->thread_count = 1;
701
        if(st->codec->thread_count>1)
702
            avcodec_thread_init(st->codec, st->codec->thread_count);
703

    
704
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
705
            nopts = 1;
706

    
707
        new_output_stream(s, nb_output_files);
708
    }
709

    
710
    if (!nopts)
711
        s->timestamp = av_gettime();
712

    
713
    av_close_input_file(ic);
714
    return 0;
715
}
716

    
717
static double
718
get_sync_ipts(const AVOutputStream *ost)
719
{
720
    const AVInputStream *ist = ost->sync_ist;
721
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
722
}
723

    
724
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
725
    int ret;
726

    
727
    while(bsfc){
728
        AVPacket new_pkt= *pkt;
729
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
730
                                          &new_pkt.data, &new_pkt.size,
731
                                          pkt->data, pkt->size,
732
                                          pkt->flags & AV_PKT_FLAG_KEY);
733
        if(a>0){
734
            av_free_packet(pkt);
735
            new_pkt.destruct= av_destruct_packet;
736
        } else if(a<0){
737
            fprintf(stderr, "%s failed for stream %d, codec %s",
738
                    bsfc->filter->name, pkt->stream_index,
739
                    avctx->codec ? avctx->codec->name : "copy");
740
            print_error("", a);
741
            if (exit_on_error)
742
                ffmpeg_exit(1);
743
        }
744
        *pkt= new_pkt;
745

    
746
        bsfc= bsfc->next;
747
    }
748

    
749
    ret= av_interleaved_write_frame(s, pkt);
750
    if(ret < 0){
751
        print_error("av_interleaved_write_frame()", ret);
752
        ffmpeg_exit(1);
753
    }
754
}
755

    
756
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
757

    
758
static void do_audio_out(AVFormatContext *s,
759
                         AVOutputStream *ost,
760
                         AVInputStream *ist,
761
                         unsigned char *buf, int size)
762
{
763
    uint8_t *buftmp;
764
    int64_t audio_out_size, audio_buf_size;
765
    int64_t allocated_for_size= size;
766

    
767
    int size_out, frame_bytes, ret;
768
    AVCodecContext *enc= ost->st->codec;
769
    AVCodecContext *dec= ist->st->codec;
770
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
771
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
772
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
773

    
774
need_realloc:
775
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
776
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
777
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
778
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
779
    audio_buf_size*= osize*enc->channels;
780

    
781
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
782
    if(coded_bps > 8*osize)
783
        audio_out_size= audio_out_size * coded_bps / (8*osize);
784
    audio_out_size += FF_MIN_BUFFER_SIZE;
785

    
786
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
787
        fprintf(stderr, "Buffer sizes too large\n");
788
        ffmpeg_exit(1);
789
    }
790

    
791
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
792
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
793
    if (!audio_buf || !audio_out){
794
        fprintf(stderr, "Out of memory in do_audio_out\n");
795
        ffmpeg_exit(1);
796
    }
797

    
798
    if (enc->channels != dec->channels)
799
        ost->audio_resample = 1;
800

    
801
    if (ost->audio_resample && !ost->resample) {
802
        if (dec->sample_fmt != SAMPLE_FMT_S16)
803
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
804
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
805
                                               enc->sample_rate, dec->sample_rate,
806
                                               enc->sample_fmt,  dec->sample_fmt,
807
                                               16, 10, 0, 0.8);
808
        if (!ost->resample) {
809
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
810
                    dec->channels, dec->sample_rate,
811
                    enc->channels, enc->sample_rate);
812
            ffmpeg_exit(1);
813
        }
814
    }
815

    
816
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
817
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
818
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
819
        if (ost->reformat_ctx)
820
            av_audio_convert_free(ost->reformat_ctx);
821
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
822
                                                   dec->sample_fmt, 1, NULL, 0);
823
        if (!ost->reformat_ctx) {
824
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
825
                avcodec_get_sample_fmt_name(dec->sample_fmt),
826
                avcodec_get_sample_fmt_name(enc->sample_fmt));
827
            ffmpeg_exit(1);
828
        }
829
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
830
    }
831

    
832
    if(audio_sync_method){
833
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
834
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
835
        double idelta= delta*dec->sample_rate / enc->sample_rate;
836
        int byte_delta= ((int)idelta)*2*dec->channels;
837

    
838
        //FIXME resample delay
839
        if(fabs(delta) > 50){
840
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
841
                if(byte_delta < 0){
842
                    byte_delta= FFMAX(byte_delta, -size);
843
                    size += byte_delta;
844
                    buf  -= byte_delta;
845
                    if(verbose > 2)
846
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
847
                    if(!size)
848
                        return;
849
                    ist->is_start=0;
850
                }else{
851
                    static uint8_t *input_tmp= NULL;
852
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
853

    
854
                    if(byte_delta > allocated_for_size - size){
855
                        allocated_for_size= byte_delta + (int64_t)size;
856
                        goto need_realloc;
857
                    }
858
                    ist->is_start=0;
859

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

    
880
    if (ost->audio_resample) {
881
        buftmp = audio_buf;
882
        size_out = audio_resample(ost->resample,
883
                                  (short *)buftmp, (short *)buf,
884
                                  size / (dec->channels * isize));
885
        size_out = size_out * enc->channels * osize;
886
    } else {
887
        buftmp = buf;
888
        size_out = size;
889
    }
890

    
891
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
892
        const void *ibuf[6]= {buftmp};
893
        void *obuf[6]= {audio_buf};
894
        int istride[6]= {isize};
895
        int ostride[6]= {osize};
896
        int len= size_out/istride[0];
897
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
898
            printf("av_audio_convert() failed\n");
899
            if (exit_on_error)
900
                ffmpeg_exit(1);
901
            return;
902
        }
903
        buftmp = audio_buf;
904
        size_out = len*osize;
905
    }
906

    
907
    /* now encode as many frames as possible */
908
    if (enc->frame_size > 1) {
909
        /* output resampled raw samples */
910
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
911
            fprintf(stderr, "av_fifo_realloc2() failed\n");
912
            ffmpeg_exit(1);
913
        }
914
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
915

    
916
        frame_bytes = enc->frame_size * osize * enc->channels;
917

    
918
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
919
            AVPacket pkt;
920
            av_init_packet(&pkt);
921

    
922
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
923

    
924
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
925

    
926
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
927
                                       (short *)audio_buf);
928
            if (ret < 0) {
929
                fprintf(stderr, "Audio encoding failed\n");
930
                ffmpeg_exit(1);
931
            }
932
            audio_size += ret;
933
            pkt.stream_index= ost->index;
934
            pkt.data= audio_out;
935
            pkt.size= ret;
936
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
937
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
938
            pkt.flags |= AV_PKT_FLAG_KEY;
939
            write_frame(s, &pkt, enc, ost->bitstream_filters);
940

    
941
            ost->sync_opts += enc->frame_size;
942
        }
943
    } else {
944
        AVPacket pkt;
945
        av_init_packet(&pkt);
946

    
947
        ost->sync_opts += size_out / (osize * enc->channels);
948

    
949
        /* output a pcm frame */
950
        /* determine the size of the coded buffer */
951
        size_out /= osize;
952
        if (coded_bps)
953
            size_out = size_out*coded_bps/8;
954

    
955
        if(size_out > audio_out_size){
956
            fprintf(stderr, "Internal error, buffer size too small\n");
957
            ffmpeg_exit(1);
958
        }
959

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

    
978
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
979
{
980
    AVCodecContext *dec;
981
    AVPicture *picture2;
982
    AVPicture picture_tmp;
983
    uint8_t *buf = 0;
984

    
985
    dec = ist->st->codec;
986

    
987
    /* deinterlace : must be done before any resize */
988
    if (do_deinterlace) {
989
        int size;
990

    
991
        /* create temporary picture */
992
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
993
        buf = av_malloc(size);
994
        if (!buf)
995
            return;
996

    
997
        picture2 = &picture_tmp;
998
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
999

    
1000
        if(avpicture_deinterlace(picture2, picture,
1001
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1002
            /* if error, do not deinterlace */
1003
            fprintf(stderr, "Deinterlacing failed\n");
1004
            av_free(buf);
1005
            buf = NULL;
1006
            picture2 = picture;
1007
        }
1008
    } else {
1009
        picture2 = picture;
1010
    }
1011

    
1012
    if (picture != picture2)
1013
        *picture = *picture2;
1014
    *bufp = buf;
1015
}
1016

    
1017
/* we begin to correct av delay at this threshold */
1018
#define AV_DELAY_MAX 0.100
1019

    
1020
static void do_subtitle_out(AVFormatContext *s,
1021
                            AVOutputStream *ost,
1022
                            AVInputStream *ist,
1023
                            AVSubtitle *sub,
1024
                            int64_t pts)
1025
{
1026
    static uint8_t *subtitle_out = NULL;
1027
    int subtitle_out_max_size = 1024 * 1024;
1028
    int subtitle_out_size, nb, i;
1029
    AVCodecContext *enc;
1030
    AVPacket pkt;
1031

    
1032
    if (pts == AV_NOPTS_VALUE) {
1033
        fprintf(stderr, "Subtitle packets must have a pts\n");
1034
        if (exit_on_error)
1035
            ffmpeg_exit(1);
1036
        return;
1037
    }
1038

    
1039
    enc = ost->st->codec;
1040

    
1041
    if (!subtitle_out) {
1042
        subtitle_out = av_malloc(subtitle_out_max_size);
1043
    }
1044

    
1045
    /* Note: DVB subtitle need one packet to draw them and one other
1046
       packet to clear them */
1047
    /* XXX: signal it in the codec context ? */
1048
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1049
        nb = 2;
1050
    else
1051
        nb = 1;
1052

    
1053
    for(i = 0; i < nb; i++) {
1054
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1055
        // start_display_time is required to be 0
1056
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1057
        sub->end_display_time -= sub->start_display_time;
1058
        sub->start_display_time = 0;
1059
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1060
                                                    subtitle_out_max_size, sub);
1061
        if (subtitle_out_size < 0) {
1062
            fprintf(stderr, "Subtitle encoding failed\n");
1063
            ffmpeg_exit(1);
1064
        }
1065

    
1066
        av_init_packet(&pkt);
1067
        pkt.stream_index = ost->index;
1068
        pkt.data = subtitle_out;
1069
        pkt.size = subtitle_out_size;
1070
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1071
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1072
            /* XXX: the pts correction is handled here. Maybe handling
1073
               it in the codec would be better */
1074
            if (i == 0)
1075
                pkt.pts += 90 * sub->start_display_time;
1076
            else
1077
                pkt.pts += 90 * sub->end_display_time;
1078
        }
1079
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1080
    }
1081
}
1082

    
1083
static int bit_buffer_size= 1024*256;
1084
static uint8_t *bit_buffer= NULL;
1085

    
1086
static void do_video_out(AVFormatContext *s,
1087
                         AVOutputStream *ost,
1088
                         AVInputStream *ist,
1089
                         AVFrame *in_picture,
1090
                         int *frame_size)
1091
{
1092
    int nb_frames, i, ret;
1093
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1094
    AVCodecContext *enc, *dec;
1095
    double sync_ipts;
1096

    
1097
    enc = ost->st->codec;
1098
    dec = ist->st->codec;
1099

    
1100
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1101

    
1102
    /* by default, we output a single frame */
1103
    nb_frames = 1;
1104

    
1105
    *frame_size = 0;
1106

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

    
1132
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1133
    if (nb_frames <= 0)
1134
        return;
1135

    
1136
    formatted_picture = in_picture;
1137
    final_picture = formatted_picture;
1138
    padding_src = formatted_picture;
1139
    resampling_dst = &ost->pict_tmp;
1140

    
1141
    if (   ost->resample_height != ist->st->codec->height
1142
        || ost->resample_width  != ist->st->codec->width
1143
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1144

    
1145
        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));
1146
        if(!ost->video_resample)
1147
            ffmpeg_exit(1);
1148
    }
1149

    
1150
#if !CONFIG_AVFILTER
1151
    if (ost->video_resample) {
1152
        padding_src = NULL;
1153
        final_picture = &ost->pict_tmp;
1154
        if(  ost->resample_height != ist->st->codec->height
1155
          || ost->resample_width  != ist->st->codec->width
1156
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1157

    
1158
            /* initialize a new scaler context */
1159
            sws_freeContext(ost->img_resample_ctx);
1160
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1161
            ost->img_resample_ctx = sws_getContext(
1162
                ist->st->codec->width,
1163
                ist->st->codec->height,
1164
                ist->st->codec->pix_fmt,
1165
                ost->st->codec->width,
1166
                ost->st->codec->height,
1167
                ost->st->codec->pix_fmt,
1168
                sws_flags, NULL, NULL, NULL);
1169
            if (ost->img_resample_ctx == NULL) {
1170
                fprintf(stderr, "Cannot get resampling context\n");
1171
                ffmpeg_exit(1);
1172
            }
1173
        }
1174
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1175
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1176
    }
1177
#endif
1178

    
1179
    /* duplicates frame if needed */
1180
    for(i=0;i<nb_frames;i++) {
1181
        AVPacket pkt;
1182
        av_init_packet(&pkt);
1183
        pkt.stream_index= ost->index;
1184

    
1185
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1186
            /* raw pictures are written as AVPicture structure to
1187
               avoid any copies. We support temorarily the older
1188
               method. */
1189
            AVFrame* old_frame = enc->coded_frame;
1190
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1191
            pkt.data= (uint8_t *)final_picture;
1192
            pkt.size=  sizeof(AVPicture);
1193
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1194
            pkt.flags |= AV_PKT_FLAG_KEY;
1195

    
1196
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1197
            enc->coded_frame = old_frame;
1198
        } else {
1199
            AVFrame big_picture;
1200

    
1201
            big_picture= *final_picture;
1202
            /* better than nothing: use input picture interlaced
1203
               settings */
1204
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1205
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1206
                if(top_field_first == -1)
1207
                    big_picture.top_field_first = in_picture->top_field_first;
1208
                else
1209
                    big_picture.top_field_first = top_field_first;
1210
            }
1211

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

    
1234
            if(ret>0){
1235
                pkt.data= bit_buffer;
1236
                pkt.size= ret;
1237
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1238
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1239
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1240
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1241
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1242

    
1243
                if(enc->coded_frame->key_frame)
1244
                    pkt.flags |= AV_PKT_FLAG_KEY;
1245
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1246
                *frame_size = ret;
1247
                video_size += ret;
1248
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1249
                //        enc->frame_number-1, ret, enc->pict_type);
1250
                /* if two pass, output log */
1251
                if (ost->logfile && enc->stats_out) {
1252
                    fprintf(ost->logfile, "%s", enc->stats_out);
1253
                }
1254
            }
1255
        }
1256
        ost->sync_opts++;
1257
        ost->frame_number++;
1258
    }
1259
}
1260

    
1261
static double psnr(double d){
1262
    return -10.0*log(d)/log(10.0);
1263
}
1264

    
1265
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1266
                           int frame_size)
1267
{
1268
    AVCodecContext *enc;
1269
    int frame_number;
1270
    double ti1, bitrate, avg_bitrate;
1271

    
1272
    /* this is executed just the first time do_video_stats is called */
1273
    if (!vstats_file) {
1274
        vstats_file = fopen(vstats_filename, "w");
1275
        if (!vstats_file) {
1276
            perror("fopen");
1277
            ffmpeg_exit(1);
1278
        }
1279
    }
1280

    
1281
    enc = ost->st->codec;
1282
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1283
        frame_number = ost->frame_number;
1284
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1285
        if (enc->flags&CODEC_FLAG_PSNR)
1286
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1287

    
1288
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1289
        /* compute pts value */
1290
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1291
        if (ti1 < 0.01)
1292
            ti1 = 0.01;
1293

    
1294
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1295
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1296
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1297
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1298
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1299
    }
1300
}
1301

    
1302
static void print_report(AVFormatContext **output_files,
1303
                         AVOutputStream **ost_table, int nb_ostreams,
1304
                         int is_last_report)
1305
{
1306
    char buf[1024];
1307
    AVOutputStream *ost;
1308
    AVFormatContext *oc;
1309
    int64_t total_size;
1310
    AVCodecContext *enc;
1311
    int frame_number, vid, i;
1312
    double bitrate, ti1, pts;
1313
    static int64_t last_time = -1;
1314
    static int qp_histogram[52];
1315

    
1316
    if (!is_last_report) {
1317
        int64_t cur_time;
1318
        /* display the report every 0.5 seconds */
1319
        cur_time = av_gettime();
1320
        if (last_time == -1) {
1321
            last_time = cur_time;
1322
            return;
1323
        }
1324
        if ((cur_time - last_time) < 500000)
1325
            return;
1326
        last_time = cur_time;
1327
    }
1328

    
1329

    
1330
    oc = output_files[0];
1331

    
1332
    total_size = url_fsize(oc->pb);
1333
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1334
        total_size= url_ftell(oc->pb);
1335

    
1336
    buf[0] = '\0';
1337
    ti1 = 1e10;
1338
    vid = 0;
1339
    for(i=0;i<nb_ostreams;i++) {
1340
        ost = ost_table[i];
1341
        enc = ost->st->codec;
1342
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1343
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1344
                     !ost->st->stream_copy ?
1345
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1346
        }
1347
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1348
            float t = (av_gettime()-timer_start) / 1000000.0;
1349

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

    
1396
    if (verbose || is_last_report) {
1397
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1398

    
1399
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1400
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1401
            (double)total_size / 1024, ti1, bitrate);
1402

    
1403
        if (nb_frames_dup || nb_frames_drop)
1404
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1405
                  nb_frames_dup, nb_frames_drop);
1406

    
1407
        if (verbose >= 0)
1408
            fprintf(stderr, "%s    \r", buf);
1409

    
1410
        fflush(stderr);
1411
    }
1412

    
1413
    if (is_last_report && verbose >= 0){
1414
        int64_t raw= audio_size + video_size + extra_size;
1415
        fprintf(stderr, "\n");
1416
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1417
                video_size/1024.0,
1418
                audio_size/1024.0,
1419
                extra_size/1024.0,
1420
                100.0*(total_size - raw)/raw
1421
        );
1422
    }
1423
}
1424

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

    
1443
    AVPacket avpkt;
1444
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1445

    
1446
    if(ist->next_pts == AV_NOPTS_VALUE)
1447
        ist->next_pts= ist->pts;
1448

    
1449
    if (pkt == NULL) {
1450
        /* EOF handling */
1451
        av_init_packet(&avpkt);
1452
        avpkt.data = NULL;
1453
        avpkt.size = 0;
1454
        goto handle_eof;
1455
    } else {
1456
        avpkt = *pkt;
1457
    }
1458

    
1459
    if(pkt->dts != AV_NOPTS_VALUE)
1460
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1461
    if(pkt->pts != AV_NOPTS_VALUE)
1462
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1463

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

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

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

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

    
1569
        buffer_to_free = NULL;
1570
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1571
            pre_process_video_frame(ist, (AVPicture *)&picture,
1572
                                    &buffer_to_free);
1573
        }
1574

    
1575
#if CONFIG_AVFILTER
1576
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1577
            // add it to be filtered
1578
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1579
                                     ist->pts,
1580
                                     ist->st->codec->sample_aspect_ratio);
1581
        }
1582
#endif
1583

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

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

    
1623
                ost = ost_table[i];
1624
                if (ost->source_index == ist_index) {
1625
                    os = output_files[ost->file_index];
1626

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

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

    
1657
                        av_init_packet(&opkt);
1658

    
1659
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1660
                            continue;
1661

    
1662
                        /* no reencoding needed : output the packet directly */
1663
                        /* force the input stream PTS */
1664

    
1665
                        avcodec_get_frame_defaults(&avframe);
1666
                        ost->st->codec->coded_frame= &avframe;
1667
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1668

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

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

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

    
1688
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1689
                        opkt.flags= pkt->flags;
1690

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

    
1703
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1704
                        ost->st->codec->frame_number++;
1705
                        ost->frame_number++;
1706
                        av_free_packet(&opkt);
1707
                    }
1708
                }
1709
            }
1710

    
1711
#if CONFIG_AVFILTER
1712
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1713
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1714
            if(ist->picref)
1715
                avfilter_unref_buffer(ist->picref);
1716
        }
1717
#endif
1718
        av_free(buffer_to_free);
1719
        /* XXX: allocate the subtitles in the codec ? */
1720
        if (subtitle_to_free) {
1721
            if (subtitle_to_free->rects != NULL) {
1722
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1723
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1724
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1725
                    av_freep(&subtitle_to_free->rects[i]);
1726
                }
1727
                av_freep(&subtitle_to_free->rects);
1728
            }
1729
            subtitle_to_free->num_rects = 0;
1730
            subtitle_to_free = NULL;
1731
        }
1732
    }
1733
 discard_packet:
1734
    if (pkt == NULL) {
1735
        /* EOF handling */
1736

    
1737
        for(i=0;i<nb_ostreams;i++) {
1738
            ost = ost_table[i];
1739
            if (ost->source_index == ist_index) {
1740
                AVCodecContext *enc= ost->st->codec;
1741
                os = output_files[ost->file_index];
1742

    
1743
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1744
                    continue;
1745
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1746
                    continue;
1747

    
1748
                if (ost->encoding_needed) {
1749
                    for(;;) {
1750
                        AVPacket pkt;
1751
                        int fifo_bytes;
1752
                        av_init_packet(&pkt);
1753
                        pkt.stream_index= ost->index;
1754

    
1755
                        switch(ost->st->codec->codec_type) {
1756
                        case AVMEDIA_TYPE_AUDIO:
1757
                            fifo_bytes = av_fifo_size(ost->fifo);
1758
                            ret = 0;
1759
                            /* encode any samples remaining in fifo */
1760
                            if (fifo_bytes > 0) {
1761
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1762
                                int fs_tmp = enc->frame_size;
1763

    
1764
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1765
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1766
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1767
                                } else { /* pad */
1768
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1769
                                    if (allocated_audio_buf_size < frame_bytes)
1770
                                        ffmpeg_exit(1);
1771
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1772
                                }
1773

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

    
1806
                        if(ret<=0)
1807
                            break;
1808
                        pkt.data= bit_buffer;
1809
                        pkt.size= ret;
1810
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1811
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1812
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1813
                    }
1814
                }
1815
            }
1816
        }
1817
    }
1818

    
1819
    return 0;
1820
 fail_decode:
1821
    return -1;
1822
}
1823

    
1824
static void print_sdp(AVFormatContext **avc, int n)
1825
{
1826
    char sdp[2048];
1827

    
1828
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1829
    printf("SDP:\n%s\n", sdp);
1830
    fflush(stdout);
1831
}
1832

    
1833
static int copy_chapters(int infile, int outfile)
1834
{
1835
    AVFormatContext *is = input_files[infile];
1836
    AVFormatContext *os = output_files[outfile];
1837
    int i;
1838

    
1839
    for (i = 0; i < is->nb_chapters; i++) {
1840
        AVChapter *in_ch = is->chapters[i], *out_ch;
1841
        AVMetadataTag *t = NULL;
1842
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1843
                                      AV_TIME_BASE_Q, in_ch->time_base);
1844
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1845
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1846

    
1847

    
1848
        if (in_ch->end < ts_off)
1849
            continue;
1850
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1851
            break;
1852

    
1853
        out_ch = av_mallocz(sizeof(AVChapter));
1854
        if (!out_ch)
1855
            return AVERROR(ENOMEM);
1856

    
1857
        out_ch->id        = in_ch->id;
1858
        out_ch->time_base = in_ch->time_base;
1859
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1860
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1861

    
1862
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1863
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1864

    
1865
        os->nb_chapters++;
1866
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1867
        if (!os->chapters)
1868
            return AVERROR(ENOMEM);
1869
        os->chapters[os->nb_chapters - 1] = out_ch;
1870
    }
1871
    return 0;
1872
}
1873

    
1874
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1875
                                    AVCodecContext *avctx)
1876
{
1877
    char *p;
1878
    int n = 1, i;
1879
    int64_t t;
1880

    
1881
    for (p = kf; *p; p++)
1882
        if (*p == ',')
1883
            n++;
1884
    ost->forced_kf_count = n;
1885
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1886
    if (!ost->forced_kf_pts) {
1887
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1888
        ffmpeg_exit(1);
1889
    }
1890
    for (i = 0; i < n; i++) {
1891
        p = i ? strchr(p, ',') + 1 : kf;
1892
        t = parse_time_or_die("force_key_frames", p, 1);
1893
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1894
    }
1895
}
1896

    
1897
/*
1898
 * The following code is the main loop of the file converter
1899
 */
1900
static int transcode(AVFormatContext **output_files,
1901
                     int nb_output_files,
1902
                     AVFormatContext **input_files,
1903
                     int nb_input_files,
1904
                     AVStreamMap *stream_maps, int nb_stream_maps)
1905
{
1906
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1907
    AVFormatContext *is, *os;
1908
    AVCodecContext *codec, *icodec;
1909
    AVOutputStream *ost, **ost_table = NULL;
1910
    AVInputStream *ist, **ist_table = NULL;
1911
    AVInputFile *file_table;
1912
    char error[1024];
1913
    int key;
1914
    int want_sdp = 1;
1915
    uint8_t no_packet[MAX_FILES]={0};
1916
    int no_packet_count=0;
1917

    
1918
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1919
    if (!file_table)
1920
        goto fail;
1921

    
1922
    /* input stream init */
1923
    j = 0;
1924
    for(i=0;i<nb_input_files;i++) {
1925
        is = input_files[i];
1926
        file_table[i].ist_index = j;
1927
        file_table[i].nb_streams = is->nb_streams;
1928
        j += is->nb_streams;
1929
    }
1930
    nb_istreams = j;
1931

    
1932
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1933
    if (!ist_table)
1934
        goto fail;
1935

    
1936
    for(i=0;i<nb_istreams;i++) {
1937
        ist = av_mallocz(sizeof(AVInputStream));
1938
        if (!ist)
1939
            goto fail;
1940
        ist_table[i] = ist;
1941
    }
1942
    j = 0;
1943
    for(i=0;i<nb_input_files;i++) {
1944
        is = input_files[i];
1945
        for(k=0;k<is->nb_streams;k++) {
1946
            ist = ist_table[j++];
1947
            ist->st = is->streams[k];
1948
            ist->file_index = i;
1949
            ist->index = k;
1950
            ist->discard = 1; /* the stream is discarded by default
1951
                                 (changed later) */
1952

    
1953
            if (rate_emu) {
1954
                ist->start = av_gettime();
1955
            }
1956
        }
1957
    }
1958

    
1959
    /* output stream init */
1960
    nb_ostreams = 0;
1961
    for(i=0;i<nb_output_files;i++) {
1962
        os = output_files[i];
1963
        if (!os->nb_streams) {
1964
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1965
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1966
            ret = AVERROR(EINVAL);
1967
            goto fail;
1968
        }
1969
        nb_ostreams += os->nb_streams;
1970
    }
1971
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1972
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1973
        ret = AVERROR(EINVAL);
1974
        goto fail;
1975
    }
1976

    
1977
    /* Sanity check the mapping args -- do the input files & streams exist? */
1978
    for(i=0;i<nb_stream_maps;i++) {
1979
        int fi = stream_maps[i].file_index;
1980
        int si = stream_maps[i].stream_index;
1981

    
1982
        if (fi < 0 || fi > nb_input_files - 1 ||
1983
            si < 0 || si > file_table[fi].nb_streams - 1) {
1984
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1985
            ret = AVERROR(EINVAL);
1986
            goto fail;
1987
        }
1988
        fi = stream_maps[i].sync_file_index;
1989
        si = stream_maps[i].sync_stream_index;
1990
        if (fi < 0 || fi > nb_input_files - 1 ||
1991
            si < 0 || si > file_table[fi].nb_streams - 1) {
1992
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1993
            ret = AVERROR(EINVAL);
1994
            goto fail;
1995
        }
1996
    }
1997

    
1998
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1999
    if (!ost_table)
2000
        goto fail;
2001
    n = 0;
2002
    for(k=0;k<nb_output_files;k++) {
2003
        os = output_files[k];
2004
        for(i=0;i<os->nb_streams;i++,n++) {
2005
            int found;
2006
            ost = ost_table[n] = output_streams_for_file[k][i];
2007
            ost->st = os->streams[i];
2008
            if (nb_stream_maps > 0) {
2009
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2010
                    stream_maps[n].stream_index;
2011

    
2012
                /* Sanity check that the stream types match */
2013
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2014
                    int i= ost->file_index;
2015
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2016
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2017
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2018
                        ost->file_index, ost->index);
2019
                    ffmpeg_exit(1);
2020
                }
2021

    
2022
            } else {
2023
                int best_nb_frames=-1;
2024
                /* get corresponding input stream index : we select the first one with the right type */
2025
                found = 0;
2026
                for(j=0;j<nb_istreams;j++) {
2027
                    int skip=0;
2028
                    ist = ist_table[j];
2029
                    if(opt_programid){
2030
                        int pi,si;
2031
                        AVFormatContext *f= input_files[ ist->file_index ];
2032
                        skip=1;
2033
                        for(pi=0; pi<f->nb_programs; pi++){
2034
                            AVProgram *p= f->programs[pi];
2035
                            if(p->id == opt_programid)
2036
                                for(si=0; si<p->nb_stream_indexes; si++){
2037
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2038
                                        skip=0;
2039
                                }
2040
                        }
2041
                    }
2042
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2043
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2044
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2045
                            best_nb_frames= ist->st->codec_info_nb_frames;
2046
                            ost->source_index = j;
2047
                            found = 1;
2048
                        }
2049
                    }
2050
                }
2051

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

    
2081
    /* for each output stream, we compute the right encoding parameters */
2082
    for(i=0;i<nb_ostreams;i++) {
2083
        AVMetadataTag *t = NULL;
2084
        ost = ost_table[i];
2085
        os = output_files[ost->file_index];
2086
        ist = ist_table[ost->source_index];
2087

    
2088
        codec = ost->st->codec;
2089
        icodec = ist->st->codec;
2090

    
2091
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2092
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2093
        }
2094

    
2095
        ost->st->disposition = ist->st->disposition;
2096
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2097
        codec->chroma_sample_location = icodec->chroma_sample_location;
2098

    
2099
        if (ost->st->stream_copy) {
2100
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2101

    
2102
            if (extra_size > INT_MAX)
2103
                goto fail;
2104

    
2105
            /* if stream_copy is selected, no need to decode or encode */
2106
            codec->codec_id = icodec->codec_id;
2107
            codec->codec_type = icodec->codec_type;
2108

    
2109
            if(!codec->codec_tag){
2110
                if(   !os->oformat->codec_tag
2111
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2112
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2113
                    codec->codec_tag = icodec->codec_tag;
2114
            }
2115

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

    
2201
#if !CONFIG_AVFILTER
2202
                    ost->original_height = icodec->height;
2203
                    ost->original_width  = icodec->width;
2204
#endif
2205
                    codec->bits_per_raw_sample= 0;
2206
                }
2207
                ost->resample_height = icodec->height;
2208
                ost->resample_width  = icodec->width;
2209
                ost->resample_pix_fmt= icodec->pix_fmt;
2210
                ost->encoding_needed = 1;
2211
                ist->decoding_needed = 1;
2212

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

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

    
2261
    if (!bit_buffer)
2262
        bit_buffer = av_malloc(bit_buffer_size);
2263
    if (!bit_buffer) {
2264
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2265
                bit_buffer_size);
2266
        ret = AVERROR(ENOMEM);
2267
        goto fail;
2268
    }
2269

    
2270
    /* open each encoder */
2271
    for(i=0;i<nb_ostreams;i++) {
2272
        ost = ost_table[i];
2273
        if (ost->encoding_needed) {
2274
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2275
            if (!codec)
2276
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2277
            if (!codec) {
2278
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2279
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2280
                ret = AVERROR(EINVAL);
2281
                goto dump_format;
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 *out_file;
2331
        AVFormatContext *in_file;
2332
        AVMetadataTag *mtag;
2333

    
2334
        int out_file_index = meta_data_maps[i].out_file;
2335
        int in_file_index = meta_data_maps[i].in_file;
2336
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2337
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2338
                     out_file_index, out_file_index, in_file_index);
2339
            ret = AVERROR(EINVAL);
2340
            goto dump_format;
2341
        }
2342
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2343
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2344
                     in_file_index, out_file_index, in_file_index);
2345
            ret = AVERROR(EINVAL);
2346
            goto dump_format;
2347
        }
2348

    
2349
        out_file = output_files[out_file_index];
2350
        in_file = input_files[in_file_index];
2351

    
2352

    
2353
        mtag=NULL;
2354
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2355
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2356
    }
2357

    
2358
    /* copy chapters from the first input file that has them*/
2359
    for (i = 0; i < nb_input_files; i++) {
2360
        if (!input_files[i]->nb_chapters)
2361
            continue;
2362

    
2363
        for (j = 0; j < nb_output_files; j++)
2364
            if ((ret = copy_chapters(i, j)) < 0)
2365
                goto dump_format;
2366
    }
2367

    
2368
    /* open files and write file headers */
2369
    for(i=0;i<nb_output_files;i++) {
2370
        os = output_files[i];
2371
        if (av_write_header(os) < 0) {
2372
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2373
            ret = AVERROR(EINVAL);
2374
            goto dump_format;
2375
        }
2376
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2377
            want_sdp = 0;
2378
        }
2379
    }
2380

    
2381
 dump_format:
2382
    /* dump the file output parameters - cannot be done before in case
2383
       of stream copy */
2384
    for(i=0;i<nb_output_files;i++) {
2385
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2386
    }
2387

    
2388
    /* dump the stream mapping */
2389
    if (verbose >= 0) {
2390
        fprintf(stderr, "Stream mapping:\n");
2391
        for(i=0;i<nb_ostreams;i++) {
2392
            ost = ost_table[i];
2393
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2394
                    ist_table[ost->source_index]->file_index,
2395
                    ist_table[ost->source_index]->index,
2396
                    ost->file_index,
2397
                    ost->index);
2398
            if (ost->sync_ist != ist_table[ost->source_index])
2399
                fprintf(stderr, " [sync #%d.%d]",
2400
                        ost->sync_ist->file_index,
2401
                        ost->sync_ist->index);
2402
            fprintf(stderr, "\n");
2403
        }
2404
    }
2405

    
2406
    if (ret) {
2407
        fprintf(stderr, "%s\n", error);
2408
        goto fail;
2409
    }
2410

    
2411
    if (want_sdp) {
2412
        print_sdp(output_files, nb_output_files);
2413
    }
2414

    
2415
    if (!using_stdin && verbose >= 0) {
2416
        fprintf(stderr, "Press [q] to stop encoding\n");
2417
        url_set_interrupt_cb(decode_interrupt_cb);
2418
    }
2419
    term_init();
2420

    
2421
    timer_start = av_gettime();
2422

    
2423
    for(; received_sigterm == 0;) {
2424
        int file_index, ist_index;
2425
        AVPacket pkt;
2426
        double ipts_min;
2427
        double opts_min;
2428

    
2429
    redo:
2430
        ipts_min= 1e100;
2431
        opts_min= 1e100;
2432
        /* if 'q' pressed, exits */
2433
        if (!using_stdin) {
2434
            if (q_pressed)
2435
                break;
2436
            /* read_key() returns 0 on EOF */
2437
            key = read_key();
2438
            if (key == 'q')
2439
                break;
2440
        }
2441

    
2442
        /* select the stream that we must read now by looking at the
2443
           smallest output pts */
2444
        file_index = -1;
2445
        for(i=0;i<nb_ostreams;i++) {
2446
            double ipts, opts;
2447
            ost = ost_table[i];
2448
            os = output_files[ost->file_index];
2449
            ist = ist_table[ost->source_index];
2450
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2451
                continue;
2452
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2453
            ipts = (double)ist->pts;
2454
            if (!file_table[ist->file_index].eof_reached){
2455
                if(ipts < ipts_min) {
2456
                    ipts_min = ipts;
2457
                    if(input_sync ) file_index = ist->file_index;
2458
                }
2459
                if(opts < opts_min) {
2460
                    opts_min = opts;
2461
                    if(!input_sync) file_index = ist->file_index;
2462
                }
2463
            }
2464
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2465
                file_index= -1;
2466
                break;
2467
            }
2468
        }
2469
        /* if none, if is finished */
2470
        if (file_index < 0) {
2471
            if(no_packet_count){
2472
                no_packet_count=0;
2473
                memset(no_packet, 0, sizeof(no_packet));
2474
                usleep(10000);
2475
                continue;
2476
            }
2477
            break;
2478
        }
2479

    
2480
        /* finish if limit size exhausted */
2481
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2482
            break;
2483

    
2484
        /* read a frame from it and output it in the fifo */
2485
        is = input_files[file_index];
2486
        ret= av_read_frame(is, &pkt);
2487
        if(ret == AVERROR(EAGAIN)){
2488
            no_packet[file_index]=1;
2489
            no_packet_count++;
2490
            continue;
2491
        }
2492
        if (ret < 0) {
2493
            file_table[file_index].eof_reached = 1;
2494
            if (opt_shortest)
2495
                break;
2496
            else
2497
                continue;
2498
        }
2499

    
2500
        no_packet_count=0;
2501
        memset(no_packet, 0, sizeof(no_packet));
2502

    
2503
        if (do_pkt_dump) {
2504
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2505
        }
2506
        /* the following test is needed in case new streams appear
2507
           dynamically in stream : we ignore them */
2508
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2509
            goto discard_packet;
2510
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2511
        ist = ist_table[ist_index];
2512
        if (ist->discard)
2513
            goto discard_packet;
2514

    
2515
        if (pkt.dts != AV_NOPTS_VALUE)
2516
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2517
        if (pkt.pts != AV_NOPTS_VALUE)
2518
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2519

    
2520
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2521
            && input_files_ts_scale[file_index][pkt.stream_index]){
2522
            if(pkt.pts != AV_NOPTS_VALUE)
2523
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2524
            if(pkt.dts != AV_NOPTS_VALUE)
2525
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2526
        }
2527

    
2528
//        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);
2529
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2530
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2531
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2532
            int64_t delta= pkt_dts - ist->next_pts;
2533
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2534
                input_files_ts_offset[ist->file_index]-= delta;
2535
                if (verbose > 2)
2536
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2537
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2538
                if(pkt.pts != AV_NOPTS_VALUE)
2539
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2540
            }
2541
        }
2542

    
2543
        /* finish if recording time exhausted */
2544
        if (recording_time != INT64_MAX &&
2545
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2546
            ist->is_past_recording_time = 1;
2547
            goto discard_packet;
2548
        }
2549

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

    
2553
            if (verbose >= 0)
2554
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2555
                        ist->file_index, ist->index);
2556
            if (exit_on_error)
2557
                ffmpeg_exit(1);
2558
            av_free_packet(&pkt);
2559
            goto redo;
2560
        }
2561

    
2562
    discard_packet:
2563
        av_free_packet(&pkt);
2564

    
2565
        /* dump report by using the output first video and audio streams */
2566
        print_report(output_files, ost_table, nb_ostreams, 0);
2567
    }
2568

    
2569
    /* at the end of stream, we must flush the decoder buffers */
2570
    for(i=0;i<nb_istreams;i++) {
2571
        ist = ist_table[i];
2572
        if (ist->decoding_needed) {
2573
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2574
        }
2575
    }
2576

    
2577
    term_exit();
2578

    
2579
    /* write the trailer if needed and close file */
2580
    for(i=0;i<nb_output_files;i++) {
2581
        os = output_files[i];
2582
        av_write_trailer(os);
2583
    }
2584

    
2585
    /* dump report by using the first video and audio streams */
2586
    print_report(output_files, ost_table, nb_ostreams, 1);
2587

    
2588
    /* close each encoder */
2589
    for(i=0;i<nb_ostreams;i++) {
2590
        ost = ost_table[i];
2591
        if (ost->encoding_needed) {
2592
            av_freep(&ost->st->codec->stats_in);
2593
            avcodec_close(ost->st->codec);
2594
        }
2595
    }
2596

    
2597
    /* close each decoder */
2598
    for(i=0;i<nb_istreams;i++) {
2599
        ist = ist_table[i];
2600
        if (ist->decoding_needed) {
2601
            avcodec_close(ist->st->codec);
2602
        }
2603
    }
2604
#if CONFIG_AVFILTER
2605
    if (graph) {
2606
        avfilter_graph_destroy(graph);
2607
        av_freep(&graph);
2608
    }
2609
#endif
2610

    
2611
    /* finished ! */
2612
    ret = 0;
2613

    
2614
 fail:
2615
    av_freep(&bit_buffer);
2616
    av_free(file_table);
2617

    
2618
    if (ist_table) {
2619
        for(i=0;i<nb_istreams;i++) {
2620
            ist = ist_table[i];
2621
            av_free(ist);
2622
        }
2623
        av_free(ist_table);
2624
    }
2625
    if (ost_table) {
2626
        for(i=0;i<nb_ostreams;i++) {
2627
            ost = ost_table[i];
2628
            if (ost) {
2629
                if (ost->st->stream_copy)
2630
                    av_freep(&ost->st->codec->extradata);
2631
                if (ost->logfile) {
2632
                    fclose(ost->logfile);
2633
                    ost->logfile = NULL;
2634
                }
2635
                av_fifo_free(ost->fifo); /* works even if fifo is not
2636
                                             initialized but set to zero */
2637
                av_free(ost->pict_tmp.data[0]);
2638
                av_free(ost->forced_kf_pts);
2639
                if (ost->video_resample)
2640
                    sws_freeContext(ost->img_resample_ctx);
2641
                if (ost->resample)
2642
                    audio_resample_close(ost->resample);
2643
                if (ost->reformat_ctx)
2644
                    av_audio_convert_free(ost->reformat_ctx);
2645
                av_free(ost);
2646
            }
2647
        }
2648
        av_free(ost_table);
2649
    }
2650
    return ret;
2651
}
2652

    
2653
static void opt_format(const char *arg)
2654
{
2655
    /* compatibility stuff for pgmyuv */
2656
    if (!strcmp(arg, "pgmyuv")) {
2657
        pgmyuv_compatibility_hack=1;
2658
//        opt_image_format(arg);
2659
        arg = "image2";
2660
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2661
    }
2662

    
2663
    last_asked_format = arg;
2664
}
2665

    
2666
static void opt_video_rc_override_string(const char *arg)
2667
{
2668
    video_rc_override_string = arg;
2669
}
2670

    
2671
static int opt_me_threshold(const char *opt, const char *arg)
2672
{
2673
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2674
    return 0;
2675
}
2676

    
2677
static int opt_verbose(const char *opt, const char *arg)
2678
{
2679
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2680
    return 0;
2681
}
2682

    
2683
static int opt_frame_rate(const char *opt, const char *arg)
2684
{
2685
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2686
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2687
        ffmpeg_exit(1);
2688
    }
2689
    return 0;
2690
}
2691

    
2692
static int opt_bitrate(const char *opt, const char *arg)
2693
{
2694
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2695

    
2696
    opt_default(opt, arg);
2697

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

    
2701
    return 0;
2702
}
2703

    
2704
static int opt_frame_crop(const char *opt, const char *arg)
2705
{
2706
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2707
    return AVERROR(EINVAL);
2708
}
2709

    
2710
static void opt_frame_size(const char *arg)
2711
{
2712
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2713
        fprintf(stderr, "Incorrect frame size\n");
2714
        ffmpeg_exit(1);
2715
    }
2716
}
2717

    
2718
static int opt_pad(const char *opt, const char *arg) {
2719
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2720
    return -1;
2721
}
2722

    
2723
static void opt_frame_pix_fmt(const char *arg)
2724
{
2725
    if (strcmp(arg, "list")) {
2726
        frame_pix_fmt = av_get_pix_fmt(arg);
2727
        if (frame_pix_fmt == PIX_FMT_NONE) {
2728
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2729
            ffmpeg_exit(1);
2730
        }
2731
    } else {
2732
        show_pix_fmts();
2733
        ffmpeg_exit(0);
2734
    }
2735
}
2736

    
2737
static void opt_frame_aspect_ratio(const char *arg)
2738
{
2739
    int x = 0, y = 0;
2740
    double ar = 0;
2741
    const char *p;
2742
    char *end;
2743

    
2744
    p = strchr(arg, ':');
2745
    if (p) {
2746
        x = strtol(arg, &end, 10);
2747
        if (end == p)
2748
            y = strtol(end+1, &end, 10);
2749
        if (x > 0 && y > 0)
2750
            ar = (double)x / (double)y;
2751
    } else
2752
        ar = strtod(arg, NULL);
2753

    
2754
    if (!ar) {
2755
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2756
        ffmpeg_exit(1);
2757
    }
2758
    frame_aspect_ratio = ar;
2759
}
2760

    
2761
static int opt_metadata(const char *opt, const char *arg)
2762
{
2763
    char *mid= strchr(arg, '=');
2764

    
2765
    if(!mid){
2766
        fprintf(stderr, "Missing =\n");
2767
        ffmpeg_exit(1);
2768
    }
2769
    *mid++= 0;
2770

    
2771
    av_metadata_set2(&metadata, arg, mid, 0);
2772

    
2773
    return 0;
2774
}
2775

    
2776
static void opt_qscale(const char *arg)
2777
{
2778
    video_qscale = atof(arg);
2779
    if (video_qscale <= 0 ||
2780
        video_qscale > 255) {
2781
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2782
        ffmpeg_exit(1);
2783
    }
2784
}
2785

    
2786
static void opt_top_field_first(const char *arg)
2787
{
2788
    top_field_first= atoi(arg);
2789
}
2790

    
2791
static int opt_thread_count(const char *opt, const char *arg)
2792
{
2793
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2794
#if !HAVE_THREADS
2795
    if (verbose >= 0)
2796
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2797
#endif
2798
    return 0;
2799
}
2800

    
2801
static void opt_audio_sample_fmt(const char *arg)
2802
{
2803
    if (strcmp(arg, "list"))
2804
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2805
    else {
2806
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2807
        ffmpeg_exit(0);
2808
    }
2809
}
2810

    
2811
static int opt_audio_rate(const char *opt, const char *arg)
2812
{
2813
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2814
    return 0;
2815
}
2816

    
2817
static int opt_audio_channels(const char *opt, const char *arg)
2818
{
2819
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2820
    return 0;
2821
}
2822

    
2823
static void opt_video_channel(const char *arg)
2824
{
2825
    video_channel = strtol(arg, NULL, 0);
2826
}
2827

    
2828
static void opt_video_standard(const char *arg)
2829
{
2830
    video_standard = av_strdup(arg);
2831
}
2832

    
2833
static void opt_codec(int *pstream_copy, char **pcodec_name,
2834
                      int codec_type, const char *arg)
2835
{
2836
    av_freep(pcodec_name);
2837
    if (!strcmp(arg, "copy")) {
2838
        *pstream_copy = 1;
2839
    } else {
2840
        *pcodec_name = av_strdup(arg);
2841
    }
2842
}
2843

    
2844
static void opt_audio_codec(const char *arg)
2845
{
2846
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2847
}
2848

    
2849
static void opt_video_codec(const char *arg)
2850
{
2851
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2852
}
2853

    
2854
static void opt_subtitle_codec(const char *arg)
2855
{
2856
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2857
}
2858

    
2859
static int opt_codec_tag(const char *opt, const char *arg)
2860
{
2861
    char *tail;
2862
    uint32_t *codec_tag;
2863

    
2864
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2865
                !strcmp(opt, "vtag") ? &video_codec_tag :
2866
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2867
    if (!codec_tag)
2868
        return -1;
2869

    
2870
    *codec_tag = strtol(arg, &tail, 0);
2871
    if (!tail || *tail)
2872
        *codec_tag = AV_RL32(arg);
2873

    
2874
    return 0;
2875
}
2876

    
2877
static void opt_map(const char *arg)
2878
{
2879
    AVStreamMap *m;
2880
    char *p;
2881

    
2882
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2883
    m = &stream_maps[nb_stream_maps-1];
2884

    
2885
    m->file_index = strtol(arg, &p, 0);
2886
    if (*p)
2887
        p++;
2888

    
2889
    m->stream_index = strtol(p, &p, 0);
2890
    if (*p) {
2891
        p++;
2892
        m->sync_file_index = strtol(p, &p, 0);
2893
        if (*p)
2894
            p++;
2895
        m->sync_stream_index = strtol(p, &p, 0);
2896
    } else {
2897
        m->sync_file_index = m->file_index;
2898
        m->sync_stream_index = m->stream_index;
2899
    }
2900
}
2901

    
2902
static void opt_map_meta_data(const char *arg)
2903
{
2904
    AVMetaDataMap *m;
2905
    char *p;
2906

    
2907
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2908
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2909

    
2910
    m = &meta_data_maps[nb_meta_data_maps - 1];
2911
    m->out_file = strtol(arg, &p, 0);
2912
    if (*p)
2913
        p++;
2914

    
2915
    m->in_file = strtol(p, &p, 0);
2916
}
2917

    
2918
static void opt_input_ts_scale(const char *arg)
2919
{
2920
    unsigned int stream;
2921
    double scale;
2922
    char *p;
2923

    
2924
    stream = strtol(arg, &p, 0);
2925
    if (*p)
2926
        p++;
2927
    scale= strtod(p, &p);
2928

    
2929
    if(stream >= MAX_STREAMS)
2930
        ffmpeg_exit(1);
2931

    
2932
    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);
2933
    input_files_ts_scale[nb_input_files][stream]= scale;
2934
}
2935

    
2936
static int opt_recording_time(const char *opt, const char *arg)
2937
{
2938
    recording_time = parse_time_or_die(opt, arg, 1);
2939
    return 0;
2940
}
2941

    
2942
static int opt_start_time(const char *opt, const char *arg)
2943
{
2944
    start_time = parse_time_or_die(opt, arg, 1);
2945
    return 0;
2946
}
2947

    
2948
static int opt_recording_timestamp(const char *opt, const char *arg)
2949
{
2950
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2951
    return 0;
2952
}
2953

    
2954
static int opt_input_ts_offset(const char *opt, const char *arg)
2955
{
2956
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2957
    return 0;
2958
}
2959

    
2960
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
2961
{
2962
    const char *codec_string = encoder ? "encoder" : "decoder";
2963
    AVCodec *codec;
2964

    
2965
    if(!name)
2966
        return CODEC_ID_NONE;
2967
    codec = encoder ?
2968
        avcodec_find_encoder_by_name(name) :
2969
        avcodec_find_decoder_by_name(name);
2970
    if(!codec) {
2971
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2972
        ffmpeg_exit(1);
2973
    }
2974
    if(codec->type != type) {
2975
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2976
        ffmpeg_exit(1);
2977
    }
2978
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
2979
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
2980
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
2981
                "results.\nAdd '-strict experimental' if you want to use it.\n",
2982
                codec_string, codec->name);
2983
        codec = encoder ?
2984
            avcodec_find_encoder(codec->id) :
2985
            avcodec_find_decoder(codec->id);
2986
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
2987
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
2988
                    codec_string, codec->name);
2989
        ffmpeg_exit(1);
2990
    }
2991
    return codec->id;
2992
}
2993

    
2994
static void opt_input_file(const char *filename)
2995
{
2996
    AVFormatContext *ic;
2997
    AVFormatParameters params, *ap = &params;
2998
    AVInputFormat *file_iformat = NULL;
2999
    int err, i, ret, rfps, rfps_base;
3000
    int64_t timestamp;
3001

    
3002
    if (last_asked_format) {
3003
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3004
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3005
            ffmpeg_exit(1);
3006
        }
3007
        last_asked_format = NULL;
3008
    }
3009

    
3010
    if (!strcmp(filename, "-"))
3011
        filename = "pipe:";
3012

    
3013
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3014
                    !strcmp(filename, "/dev/stdin");
3015

    
3016
    /* get default parameters from command line */
3017
    ic = avformat_alloc_context();
3018
    if (!ic) {
3019
        print_error(filename, AVERROR(ENOMEM));
3020
        ffmpeg_exit(1);
3021
    }
3022

    
3023
    memset(ap, 0, sizeof(*ap));
3024
    ap->prealloced_context = 1;
3025
    ap->sample_rate = audio_sample_rate;
3026
    ap->channels = audio_channels;
3027
    ap->time_base.den = frame_rate.num;
3028
    ap->time_base.num = frame_rate.den;
3029
    ap->width = frame_width;
3030
    ap->height = frame_height;
3031
    ap->pix_fmt = frame_pix_fmt;
3032
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3033
    ap->channel = video_channel;
3034
    ap->standard = video_standard;
3035

    
3036
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3037

    
3038
    ic->video_codec_id   =
3039
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3040
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3041
    ic->audio_codec_id   =
3042
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3043
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3044
    ic->subtitle_codec_id=
3045
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3046
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3047
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3048

    
3049
    if(pgmyuv_compatibility_hack)
3050
        ic->video_codec_id= CODEC_ID_PGMYUV;
3051

    
3052
    /* open the input file with generic libav function */
3053
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3054
    if (err < 0) {
3055
        print_error(filename, err);
3056
        ffmpeg_exit(1);
3057
    }
3058
    if(opt_programid) {
3059
        int i, j;
3060
        int found=0;
3061
        for(i=0; i<ic->nb_streams; i++){
3062
            ic->streams[i]->discard= AVDISCARD_ALL;
3063
        }
3064
        for(i=0; i<ic->nb_programs; i++){
3065
            AVProgram *p= ic->programs[i];
3066
            if(p->id != opt_programid){
3067
                p->discard = AVDISCARD_ALL;
3068
            }else{
3069
                found=1;
3070
                for(j=0; j<p->nb_stream_indexes; j++){
3071
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3072
                }
3073
            }
3074
        }
3075
        if(!found){
3076
            fprintf(stderr, "Specified program id not found\n");
3077
            ffmpeg_exit(1);
3078
        }
3079
        opt_programid=0;
3080
    }
3081

    
3082
    ic->loop_input = loop_input;
3083

    
3084
    /* If not enough info to get the stream parameters, we decode the
3085
       first frames to get it. (used in mpeg case for example) */
3086
    ret = av_find_stream_info(ic);
3087
    if (ret < 0 && verbose >= 0) {
3088
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3089
        av_close_input_file(ic);
3090
        ffmpeg_exit(1);
3091
    }
3092

    
3093
    timestamp = start_time;
3094
    /* add the stream start time */
3095
    if (ic->start_time != AV_NOPTS_VALUE)
3096
        timestamp += ic->start_time;
3097

    
3098
    /* if seeking requested, we execute it */
3099
    if (start_time != 0) {
3100
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3101
        if (ret < 0) {
3102
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3103
                    filename, (double)timestamp / AV_TIME_BASE);
3104
        }
3105
        /* reset seek info */
3106
        start_time = 0;
3107
    }
3108

    
3109
    /* update the current parameters so that they match the one of the input stream */
3110
    for(i=0;i<ic->nb_streams;i++) {
3111
        AVStream *st = ic->streams[i];
3112
        AVCodecContext *dec = st->codec;
3113
        avcodec_thread_init(dec, thread_count);
3114
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3115
        switch (dec->codec_type) {
3116
        case AVMEDIA_TYPE_AUDIO:
3117
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3118
            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]);
3119
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3120
            channel_layout    = dec->channel_layout;
3121
            audio_channels    = dec->channels;
3122
            audio_sample_rate = dec->sample_rate;
3123
            audio_sample_fmt  = dec->sample_fmt;
3124
            if(audio_disable)
3125
                st->discard= AVDISCARD_ALL;
3126
            /* Note that av_find_stream_info can add more streams, and we
3127
             * currently have no chance of setting up lowres decoding
3128
             * early enough for them. */
3129
            if (dec->lowres)
3130
                audio_sample_rate >>= dec->lowres;
3131
            break;
3132
        case AVMEDIA_TYPE_VIDEO:
3133
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3134
            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]);
3135
            frame_height = dec->height;
3136
            frame_width  = dec->width;
3137
            if(ic->streams[i]->sample_aspect_ratio.num)
3138
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3139
            else
3140
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3141
            frame_aspect_ratio *= (float) dec->width / dec->height;
3142
            frame_pix_fmt = dec->pix_fmt;
3143
            rfps      = ic->streams[i]->r_frame_rate.num;
3144
            rfps_base = ic->streams[i]->r_frame_rate.den;
3145
            if (dec->lowres) {
3146
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3147
                frame_height >>= dec->lowres;
3148
                frame_width  >>= dec->lowres;
3149
            }
3150
            if(me_threshold)
3151
                dec->debug |= FF_DEBUG_MV;
3152

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

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

    
3159
                    (float)rfps / rfps_base, rfps, rfps_base);
3160
            }
3161
            /* update the current frame rate to match the stream frame rate */
3162
            frame_rate.num = rfps;
3163
            frame_rate.den = rfps_base;
3164

    
3165
            if(video_disable)
3166
                st->discard= AVDISCARD_ALL;
3167
            else if(video_discard)
3168
                st->discard= video_discard;
3169
            break;
3170
        case AVMEDIA_TYPE_DATA:
3171
            break;
3172
        case AVMEDIA_TYPE_SUBTITLE:
3173
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3174
            if(subtitle_disable)
3175
                st->discard = AVDISCARD_ALL;
3176
            break;
3177
        case AVMEDIA_TYPE_ATTACHMENT:
3178
        case AVMEDIA_TYPE_UNKNOWN:
3179
            break;
3180
        default:
3181
            abort();
3182
        }
3183
    }
3184

    
3185
    input_files[nb_input_files] = ic;
3186
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3187
    /* dump the file content */
3188
    if (verbose >= 0)
3189
        dump_format(ic, nb_input_files, filename, 0);
3190

    
3191
    nb_input_files++;
3192

    
3193
    video_channel = 0;
3194

    
3195
    av_freep(&video_codec_name);
3196
    av_freep(&audio_codec_name);
3197
    av_freep(&subtitle_codec_name);
3198
}
3199

    
3200
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3201
                                         int *has_subtitle_ptr)
3202
{
3203
    int has_video, has_audio, has_subtitle, i, j;
3204
    AVFormatContext *ic;
3205

    
3206
    has_video = 0;
3207
    has_audio = 0;
3208
    has_subtitle = 0;
3209
    for(j=0;j<nb_input_files;j++) {
3210
        ic = input_files[j];
3211
        for(i=0;i<ic->nb_streams;i++) {
3212
            AVCodecContext *enc = ic->streams[i]->codec;
3213
            switch(enc->codec_type) {
3214
            case AVMEDIA_TYPE_AUDIO:
3215
                has_audio = 1;
3216
                break;
3217
            case AVMEDIA_TYPE_VIDEO:
3218
                has_video = 1;
3219
                break;
3220
            case AVMEDIA_TYPE_SUBTITLE:
3221
                has_subtitle = 1;
3222
                break;
3223
            case AVMEDIA_TYPE_DATA:
3224
            case AVMEDIA_TYPE_ATTACHMENT:
3225
            case AVMEDIA_TYPE_UNKNOWN:
3226
                break;
3227
            default:
3228
                abort();
3229
            }
3230
        }
3231
    }
3232
    *has_video_ptr = has_video;
3233
    *has_audio_ptr = has_audio;
3234
    *has_subtitle_ptr = has_subtitle;
3235
}
3236

    
3237
static void new_video_stream(AVFormatContext *oc, int file_idx)
3238
{
3239
    AVStream *st;
3240
    AVOutputStream *ost;
3241
    AVCodecContext *video_enc;
3242
    enum CodecID codec_id;
3243
    AVCodec *codec= NULL;
3244

    
3245
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3246
    if (!st) {
3247
        fprintf(stderr, "Could not alloc stream\n");
3248
        ffmpeg_exit(1);
3249
    }
3250
    ost = new_output_stream(oc, file_idx);
3251

    
3252
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3253
    if(!video_stream_copy){
3254
        if (video_codec_name) {
3255
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3256
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3257
            codec = avcodec_find_encoder_by_name(video_codec_name);
3258
            output_codecs[nb_output_codecs-1] = codec;
3259
        } else {
3260
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3261
            codec = avcodec_find_encoder(codec_id);
3262
        }
3263
    }
3264

    
3265
    avcodec_get_context_defaults3(st->codec, codec);
3266
    ost->bitstream_filters = video_bitstream_filters;
3267
    video_bitstream_filters= NULL;
3268

    
3269
    avcodec_thread_init(st->codec, thread_count);
3270

    
3271
    video_enc = st->codec;
3272

    
3273
    if(video_codec_tag)
3274
        video_enc->codec_tag= video_codec_tag;
3275

    
3276
    if(   (video_global_header&1)
3277
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3278
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3279
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3280
    }
3281
    if(video_global_header&2){
3282
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3283
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3284
    }
3285

    
3286
    if (video_stream_copy) {
3287
        st->stream_copy = 1;
3288
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3289
        video_enc->sample_aspect_ratio =
3290
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3291
    } else {
3292
        const char *p;
3293
        int i;
3294
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3295

    
3296
        video_enc->codec_id = codec_id;
3297
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3298

    
3299
        if (codec && codec->supported_framerates && !force_fps)
3300
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3301
        video_enc->time_base.den = fps.num;
3302
        video_enc->time_base.num = fps.den;
3303

    
3304
        video_enc->width = frame_width;
3305
        video_enc->height = frame_height;
3306
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3307
        video_enc->pix_fmt = frame_pix_fmt;
3308
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3309

    
3310
        choose_pixel_fmt(st, codec);
3311

    
3312
        if (intra_only)
3313
            video_enc->gop_size = 0;
3314
        if (video_qscale || same_quality) {
3315
            video_enc->flags |= CODEC_FLAG_QSCALE;
3316
            video_enc->global_quality=
3317
                st->quality = FF_QP2LAMBDA * video_qscale;
3318
        }
3319

    
3320
        if(intra_matrix)
3321
            video_enc->intra_matrix = intra_matrix;
3322
        if(inter_matrix)
3323
            video_enc->inter_matrix = inter_matrix;
3324

    
3325
        p= video_rc_override_string;
3326
        for(i=0; p; i++){
3327
            int start, end, q;
3328
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3329
            if(e!=3){
3330
                fprintf(stderr, "error parsing rc_override\n");
3331
                ffmpeg_exit(1);
3332
            }
3333
            video_enc->rc_override=
3334
                av_realloc(video_enc->rc_override,
3335
                           sizeof(RcOverride)*(i+1));
3336
            video_enc->rc_override[i].start_frame= start;
3337
            video_enc->rc_override[i].end_frame  = end;
3338
            if(q>0){
3339
                video_enc->rc_override[i].qscale= q;
3340
                video_enc->rc_override[i].quality_factor= 1.0;
3341
            }
3342
            else{
3343
                video_enc->rc_override[i].qscale= 0;
3344
                video_enc->rc_override[i].quality_factor= -q/100.0;
3345
            }
3346
            p= strchr(p, '/');
3347
            if(p) p++;
3348
        }
3349
        video_enc->rc_override_count=i;
3350
        if (!video_enc->rc_initial_buffer_occupancy)
3351
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3352
        video_enc->me_threshold= me_threshold;
3353
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3354

    
3355
        if (do_psnr)
3356
            video_enc->flags|= CODEC_FLAG_PSNR;
3357

    
3358
        /* two pass mode */
3359
        if (do_pass) {
3360
            if (do_pass == 1) {
3361
                video_enc->flags |= CODEC_FLAG_PASS1;
3362
            } else {
3363
                video_enc->flags |= CODEC_FLAG_PASS2;
3364
            }
3365
        }
3366

    
3367
        if (forced_key_frames)
3368
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3369
    }
3370
    if (video_language) {
3371
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3372
        av_freep(&video_language);
3373
    }
3374

    
3375
    /* reset some key parameters */
3376
    video_disable = 0;
3377
    av_freep(&video_codec_name);
3378
    av_freep(&forced_key_frames);
3379
    video_stream_copy = 0;
3380
    frame_pix_fmt = PIX_FMT_NONE;
3381
}
3382

    
3383
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3384
{
3385
    AVStream *st;
3386
    AVOutputStream *ost;
3387
    AVCodec *codec= NULL;
3388
    AVCodecContext *audio_enc;
3389
    enum CodecID codec_id;
3390

    
3391
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3392
    if (!st) {
3393
        fprintf(stderr, "Could not alloc stream\n");
3394
        ffmpeg_exit(1);
3395
    }
3396
    ost = new_output_stream(oc, file_idx);
3397

    
3398
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3399
    if(!audio_stream_copy){
3400
        if (audio_codec_name) {
3401
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3402
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3403
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3404
            output_codecs[nb_output_codecs-1] = codec;
3405
        } else {
3406
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3407
            codec = avcodec_find_encoder(codec_id);
3408
        }
3409
    }
3410

    
3411
    avcodec_get_context_defaults3(st->codec, codec);
3412

    
3413
    ost->bitstream_filters = audio_bitstream_filters;
3414
    audio_bitstream_filters= NULL;
3415

    
3416
    avcodec_thread_init(st->codec, thread_count);
3417

    
3418
    audio_enc = st->codec;
3419
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3420

    
3421
    if(audio_codec_tag)
3422
        audio_enc->codec_tag= audio_codec_tag;
3423

    
3424
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3425
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3426
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3427
    }
3428
    if (audio_stream_copy) {
3429
        st->stream_copy = 1;
3430
        audio_enc->channels = audio_channels;
3431
        audio_enc->sample_rate = audio_sample_rate;
3432
    } else {
3433
        audio_enc->codec_id = codec_id;
3434
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3435

    
3436
        if (audio_qscale > QSCALE_NONE) {
3437
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3438
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3439
        }
3440
        audio_enc->channels = audio_channels;
3441
        audio_enc->sample_fmt = audio_sample_fmt;
3442
        audio_enc->sample_rate = audio_sample_rate;
3443
        audio_enc->channel_layout = channel_layout;
3444
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3445
            audio_enc->channel_layout = 0;
3446
        choose_sample_fmt(st, codec);
3447
        choose_sample_rate(st, codec);
3448
    }
3449
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3450
    if (audio_language) {
3451
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3452
        av_freep(&audio_language);
3453
    }
3454

    
3455
    /* reset some key parameters */
3456
    audio_disable = 0;
3457
    av_freep(&audio_codec_name);
3458
    audio_stream_copy = 0;
3459
}
3460

    
3461
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3462
{
3463
    AVStream *st;
3464
    AVOutputStream *ost;
3465
    AVCodec *codec=NULL;
3466
    AVCodecContext *subtitle_enc;
3467

    
3468
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3469
    if (!st) {
3470
        fprintf(stderr, "Could not alloc stream\n");
3471
        ffmpeg_exit(1);
3472
    }
3473
    ost = new_output_stream(oc, file_idx);
3474
    subtitle_enc = st->codec;
3475
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3476
    if(!subtitle_stream_copy){
3477
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3478
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3479
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3480
    }
3481
    avcodec_get_context_defaults3(st->codec, codec);
3482

    
3483
    ost->bitstream_filters = subtitle_bitstream_filters;
3484
    subtitle_bitstream_filters= NULL;
3485

    
3486
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3487

    
3488
    if(subtitle_codec_tag)
3489
        subtitle_enc->codec_tag= subtitle_codec_tag;
3490

    
3491
    if (subtitle_stream_copy) {
3492
        st->stream_copy = 1;
3493
    } else {
3494
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3495
    }
3496

    
3497
    if (subtitle_language) {
3498
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3499
        av_freep(&subtitle_language);
3500
    }
3501

    
3502
    subtitle_disable = 0;
3503
    av_freep(&subtitle_codec_name);
3504
    subtitle_stream_copy = 0;
3505
}
3506

    
3507
static int opt_new_stream(const char *opt, const char *arg)
3508
{
3509
    AVFormatContext *oc;
3510
    int file_idx = nb_output_files - 1;
3511
    if (nb_output_files <= 0) {
3512
        fprintf(stderr, "At least one output file must be specified\n");
3513
        ffmpeg_exit(1);
3514
    }
3515
    oc = output_files[file_idx];
3516

    
3517
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3518
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3519
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3520
    else av_assert0(0);
3521
    return 0;
3522
}
3523

    
3524
/* arg format is "output-stream-index:streamid-value". */
3525
static int opt_streamid(const char *opt, const char *arg)
3526
{
3527
    int idx;
3528
    char *p;
3529
    char idx_str[16];
3530

    
3531
    strncpy(idx_str, arg, sizeof(idx_str));
3532
    idx_str[sizeof(idx_str)-1] = '\0';
3533
    p = strchr(idx_str, ':');
3534
    if (!p) {
3535
        fprintf(stderr,
3536
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3537
                arg, opt);
3538
        ffmpeg_exit(1);
3539
    }
3540
    *p++ = '\0';
3541
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3542
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3543
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3544
    return 0;
3545
}
3546

    
3547
static void opt_output_file(const char *filename)
3548
{
3549
    AVFormatContext *oc;
3550
    int err, use_video, use_audio, use_subtitle;
3551
    int input_has_video, input_has_audio, input_has_subtitle;
3552
    AVFormatParameters params, *ap = &params;
3553
    AVOutputFormat *file_oformat;
3554
    AVMetadataTag *tag = NULL;
3555

    
3556
    if (!strcmp(filename, "-"))
3557
        filename = "pipe:";
3558

    
3559
    oc = avformat_alloc_context();
3560
    if (!oc) {
3561
        print_error(filename, AVERROR(ENOMEM));
3562
        ffmpeg_exit(1);
3563
    }
3564

    
3565
    if (last_asked_format) {
3566
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3567
        if (!file_oformat) {
3568
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3569
            ffmpeg_exit(1);
3570
        }
3571
        last_asked_format = NULL;
3572
    } else {
3573
        file_oformat = av_guess_format(NULL, filename, NULL);
3574
        if (!file_oformat) {
3575
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3576
                    filename);
3577
            ffmpeg_exit(1);
3578
        }
3579
    }
3580

    
3581
    oc->oformat = file_oformat;
3582
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3583

    
3584
    if (!strcmp(file_oformat->name, "ffm") &&
3585
        av_strstart(filename, "http:", NULL)) {
3586
        /* special case for files sent to ffserver: we get the stream
3587
           parameters from ffserver */
3588
        int err = read_ffserver_streams(oc, filename);
3589
        if (err < 0) {
3590
            print_error(filename, err);
3591
            ffmpeg_exit(1);
3592
        }
3593
    } else {
3594
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3595
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3596
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3597

    
3598
        /* disable if no corresponding type found and at least one
3599
           input file */
3600
        if (nb_input_files > 0) {
3601
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3602
                                         &input_has_subtitle);
3603
            if (!input_has_video)
3604
                use_video = 0;
3605
            if (!input_has_audio)
3606
                use_audio = 0;
3607
            if (!input_has_subtitle)
3608
                use_subtitle = 0;
3609
        }
3610

    
3611
        /* manual disable */
3612
        if (audio_disable)    use_audio    = 0;
3613
        if (video_disable)    use_video    = 0;
3614
        if (subtitle_disable) use_subtitle = 0;
3615

    
3616
        if (use_video)    new_video_stream(oc, nb_output_files);
3617
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3618
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3619

    
3620
        oc->timestamp = recording_timestamp;
3621

    
3622
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3623
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3624
        av_metadata_free(&metadata);
3625
    }
3626

    
3627
    output_files[nb_output_files++] = oc;
3628

    
3629
    /* check filename in case of an image number is expected */
3630
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3631
        if (!av_filename_number_test(oc->filename)) {
3632
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3633
            ffmpeg_exit(1);
3634
        }
3635
    }
3636

    
3637
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3638
        /* test if it already exists to avoid loosing precious files */
3639
        if (!file_overwrite &&
3640
            (strchr(filename, ':') == NULL ||
3641
             filename[1] == ':' ||
3642
             av_strstart(filename, "file:", NULL))) {
3643
            if (url_exist(filename)) {
3644
                if (!using_stdin) {
3645
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3646
                    fflush(stderr);
3647
                    if (!read_yesno()) {
3648
                        fprintf(stderr, "Not overwriting - exiting\n");
3649
                        ffmpeg_exit(1);
3650
                    }
3651
                }
3652
                else {
3653
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3654
                    ffmpeg_exit(1);
3655
                }
3656
            }
3657
        }
3658

    
3659
        /* open the file */
3660
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3661
            print_error(filename, err);
3662
            ffmpeg_exit(1);
3663
        }
3664
    }
3665

    
3666
    memset(ap, 0, sizeof(*ap));
3667
    if (av_set_parameters(oc, ap) < 0) {
3668
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3669
                oc->filename);
3670
        ffmpeg_exit(1);
3671
    }
3672

    
3673
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3674
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3675
    oc->loop_output = loop_output;
3676
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3677

    
3678
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3679

    
3680
    nb_streamid_map = 0;
3681
    av_freep(&forced_key_frames);
3682
}
3683

    
3684
/* same option as mencoder */
3685
static void opt_pass(const char *pass_str)
3686
{
3687
    int pass;
3688
    pass = atoi(pass_str);
3689
    if (pass != 1 && pass != 2) {
3690
        fprintf(stderr, "pass number can be only 1 or 2\n");
3691
        ffmpeg_exit(1);
3692
    }
3693
    do_pass = pass;
3694
}
3695

    
3696
static int64_t getutime(void)
3697
{
3698
#if HAVE_GETRUSAGE
3699
    struct rusage rusage;
3700

    
3701
    getrusage(RUSAGE_SELF, &rusage);
3702
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3703
#elif HAVE_GETPROCESSTIMES
3704
    HANDLE proc;
3705
    FILETIME c, e, k, u;
3706
    proc = GetCurrentProcess();
3707
    GetProcessTimes(proc, &c, &e, &k, &u);
3708
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3709
#else
3710
    return av_gettime();
3711
#endif
3712
}
3713

    
3714
static int64_t getmaxrss(void)
3715
{
3716
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3717
    struct rusage rusage;
3718
    getrusage(RUSAGE_SELF, &rusage);
3719
    return (int64_t)rusage.ru_maxrss * 1024;
3720
#elif HAVE_GETPROCESSMEMORYINFO
3721
    HANDLE proc;
3722
    PROCESS_MEMORY_COUNTERS memcounters;
3723
    proc = GetCurrentProcess();
3724
    memcounters.cb = sizeof(memcounters);
3725
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3726
    return memcounters.PeakPagefileUsage;
3727
#else
3728
    return 0;
3729
#endif
3730
}
3731

    
3732
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3733
{
3734
    int i;
3735
    const char *p = str;
3736
    for(i = 0;; i++) {
3737
        dest[i] = atoi(p);
3738
        if(i == 63)
3739
            break;
3740
        p = strchr(p, ',');
3741
        if(!p) {
3742
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3743
            ffmpeg_exit(1);
3744
        }
3745
        p++;
3746
    }
3747
}
3748

    
3749
static void opt_inter_matrix(const char *arg)
3750
{
3751
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3752
    parse_matrix_coeffs(inter_matrix, arg);
3753
}
3754

    
3755
static void opt_intra_matrix(const char *arg)
3756
{
3757
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3758
    parse_matrix_coeffs(intra_matrix, arg);
3759
}
3760

    
3761
static void show_usage(void)
3762
{
3763
    printf("Hyper fast Audio and Video encoder\n");
3764
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3765
    printf("\n");
3766
}
3767

    
3768
static void show_help(void)
3769
{
3770
    av_log_set_callback(log_callback_help);
3771
    show_usage();
3772
    show_help_options(options, "Main options:\n",
3773
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3774
    show_help_options(options, "\nAdvanced options:\n",
3775
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3776
                      OPT_EXPERT);
3777
    show_help_options(options, "\nVideo options:\n",
3778
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3779
                      OPT_VIDEO);
3780
    show_help_options(options, "\nAdvanced Video options:\n",
3781
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3782
                      OPT_VIDEO | OPT_EXPERT);
3783
    show_help_options(options, "\nAudio options:\n",
3784
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3785
                      OPT_AUDIO);
3786
    show_help_options(options, "\nAdvanced Audio options:\n",
3787
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3788
                      OPT_AUDIO | OPT_EXPERT);
3789
    show_help_options(options, "\nSubtitle options:\n",
3790
                      OPT_SUBTITLE | OPT_GRAB,
3791
                      OPT_SUBTITLE);
3792
    show_help_options(options, "\nAudio/Video grab options:\n",
3793
                      OPT_GRAB,
3794
                      OPT_GRAB);
3795
    printf("\n");
3796
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3797
    printf("\n");
3798
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3799
    printf("\n");
3800
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3801
}
3802

    
3803
static void opt_target(const char *arg)
3804
{
3805
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3806
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3807

    
3808
    if(!strncmp(arg, "pal-", 4)) {
3809
        norm = PAL;
3810
        arg += 4;
3811
    } else if(!strncmp(arg, "ntsc-", 5)) {
3812
        norm = NTSC;
3813
        arg += 5;
3814
    } else if(!strncmp(arg, "film-", 5)) {
3815
        norm = FILM;
3816
        arg += 5;
3817
    } else {
3818
        int fr;
3819
        /* Calculate FR via float to avoid int overflow */
3820
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3821
        if(fr == 25000) {
3822
            norm = PAL;
3823
        } else if((fr == 29970) || (fr == 23976)) {
3824
            norm = NTSC;
3825
        } else {
3826
            /* Try to determine PAL/NTSC by peeking in the input files */
3827
            if(nb_input_files) {
3828
                int i, j;
3829
                for(j = 0; j < nb_input_files; j++) {
3830
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3831
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3832
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3833
                            continue;
3834
                        fr = c->time_base.den * 1000 / c->time_base.num;
3835
                        if(fr == 25000) {
3836
                            norm = PAL;
3837
                            break;
3838
                        } else if((fr == 29970) || (fr == 23976)) {
3839
                            norm = NTSC;
3840
                            break;
3841
                        }
3842
                    }
3843
                    if(norm != UNKNOWN)
3844
                        break;
3845
                }
3846
            }
3847
        }
3848
        if(verbose && norm != UNKNOWN)
3849
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3850
    }
3851

    
3852
    if(norm == UNKNOWN) {
3853
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3854
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3855
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3856
        ffmpeg_exit(1);
3857
    }
3858

    
3859
    if(!strcmp(arg, "vcd")) {
3860

    
3861
        opt_video_codec("mpeg1video");
3862
        opt_audio_codec("mp2");
3863
        opt_format("vcd");
3864

    
3865
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3866
        opt_frame_rate(NULL, frame_rates[norm]);
3867
        opt_default("g", norm == PAL ? "15" : "18");
3868

    
3869
        opt_default("b", "1150000");
3870
        opt_default("maxrate", "1150000");
3871
        opt_default("minrate", "1150000");
3872
        opt_default("bufsize", "327680"); // 40*1024*8;
3873

    
3874
        opt_default("ab", "224000");
3875
        audio_sample_rate = 44100;
3876
        audio_channels = 2;
3877

    
3878
        opt_default("packetsize", "2324");
3879
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3880

    
3881
        /* We have to offset the PTS, so that it is consistent with the SCR.
3882
           SCR starts at 36000, but the first two packs contain only padding
3883
           and the first pack from the other stream, respectively, may also have
3884
           been written before.
3885
           So the real data starts at SCR 36000+3*1200. */
3886
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3887
    } else if(!strcmp(arg, "svcd")) {
3888

    
3889
        opt_video_codec("mpeg2video");
3890
        opt_audio_codec("mp2");
3891
        opt_format("svcd");
3892

    
3893
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3894
        opt_frame_rate(NULL, frame_rates[norm]);
3895
        opt_default("g", norm == PAL ? "15" : "18");
3896

    
3897
        opt_default("b", "2040000");
3898
        opt_default("maxrate", "2516000");
3899
        opt_default("minrate", "0"); //1145000;
3900
        opt_default("bufsize", "1835008"); //224*1024*8;
3901
        opt_default("flags", "+scan_offset");
3902

    
3903

    
3904
        opt_default("ab", "224000");
3905
        audio_sample_rate = 44100;
3906

    
3907
        opt_default("packetsize", "2324");
3908

    
3909
    } else if(!strcmp(arg, "dvd")) {
3910

    
3911
        opt_video_codec("mpeg2video");
3912
        opt_audio_codec("ac3");
3913
        opt_format("dvd");
3914

    
3915
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3916
        opt_frame_rate(NULL, frame_rates[norm]);
3917
        opt_default("g", norm == PAL ? "15" : "18");
3918

    
3919
        opt_default("b", "6000000");
3920
        opt_default("maxrate", "9000000");
3921
        opt_default("minrate", "0"); //1500000;
3922
        opt_default("bufsize", "1835008"); //224*1024*8;
3923

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

    
3927
        opt_default("ab", "448000");
3928
        audio_sample_rate = 48000;
3929

    
3930
    } else if(!strncmp(arg, "dv", 2)) {
3931

    
3932
        opt_format("dv");
3933

    
3934
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3935
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3936
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3937
        opt_frame_rate(NULL, frame_rates[norm]);
3938

    
3939
        audio_sample_rate = 48000;
3940
        audio_channels = 2;
3941

    
3942
    } else {
3943
        fprintf(stderr, "Unknown target: %s\n", arg);
3944
        ffmpeg_exit(1);
3945
    }
3946
}
3947

    
3948
static void opt_vstats_file (const char *arg)
3949
{
3950
    av_free (vstats_filename);
3951
    vstats_filename=av_strdup (arg);
3952
}
3953

    
3954
static void opt_vstats (void)
3955
{
3956
    char filename[40];
3957
    time_t today2 = time(NULL);
3958
    struct tm *today = localtime(&today2);
3959

    
3960
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3961
             today->tm_sec);
3962
    opt_vstats_file(filename);
3963
}
3964

    
3965
static int opt_bsf(const char *opt, const char *arg)
3966
{
3967
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3968
    AVBitStreamFilterContext **bsfp;
3969

    
3970
    if(!bsfc){
3971
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3972
        ffmpeg_exit(1);
3973
    }
3974

    
3975
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3976
          *opt == 'a' ? &audio_bitstream_filters :
3977
                        &subtitle_bitstream_filters;
3978
    while(*bsfp)
3979
        bsfp= &(*bsfp)->next;
3980

    
3981
    *bsfp= bsfc;
3982

    
3983
    return 0;
3984
}
3985

    
3986
static int opt_preset(const char *opt, const char *arg)
3987
{
3988
    FILE *f=NULL;
3989
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3990
    int i;
3991
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
3992
                           getenv("HOME"),
3993
                           FFMPEG_DATADIR,
3994
                         };
3995

    
3996
    if (*opt != 'f') {
3997
        for(i=0; i<3 && !f; i++){
3998
            if(!base[i])
3999
                continue;
4000
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4001
            f= fopen(filename, "r");
4002
            if(!f){
4003
                char *codec_name= *opt == 'v' ? video_codec_name :
4004
                                  *opt == 'a' ? audio_codec_name :
4005
                                                subtitle_codec_name;
4006
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4007
                f= fopen(filename, "r");
4008
            }
4009
        }
4010
    } else {
4011
        av_strlcpy(filename, arg, sizeof(filename));
4012
        f= fopen(filename, "r");
4013
    }
4014

    
4015
    if(!f){
4016
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4017
        ffmpeg_exit(1);
4018
    }
4019

    
4020
    while(!feof(f)){
4021
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4022
        if(line[0] == '#' && !e)
4023
            continue;
4024
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4025
        if(e){
4026
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4027
            ffmpeg_exit(1);
4028
        }
4029
        if(!strcmp(tmp, "acodec")){
4030
            opt_audio_codec(tmp2);
4031
        }else if(!strcmp(tmp, "vcodec")){
4032
            opt_video_codec(tmp2);
4033
        }else if(!strcmp(tmp, "scodec")){
4034
            opt_subtitle_codec(tmp2);
4035
        }else if(opt_default(tmp, tmp2) < 0){
4036
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4037
            ffmpeg_exit(1);
4038
        }
4039
    }
4040

    
4041
    fclose(f);
4042

    
4043
    return 0;
4044
}
4045

    
4046
static const OptionDef options[] = {
4047
    /* main options */
4048
#include "cmdutils_common_opts.h"
4049
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4050
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4051
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4052
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4053
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4054
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4055
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4056
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4057
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4058
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4059
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4060
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4061
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4062
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4063
      "add timings for benchmarking" },
4064
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4065
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4066
      "dump each input packet" },
4067
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4068
      "when dumping packets, also dump the payload" },
4069
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4070
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4071
    { "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)", "" },
4072
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4073
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4074
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4075
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4076
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4077
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4078
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4079
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4080
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4081
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4082
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4083
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4084
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4085

    
4086
    /* video options */
4087
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4088
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4089
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4090
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4091
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4092
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4093
    { "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" },
4094
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4095
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4096
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4097
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4098
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4099
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4100
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4101
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4102
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4103
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4104
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4105
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4106
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4107
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4108
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4109
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4110
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4111
      "use same video quality as source (implies VBR)" },
4112
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4113
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4114
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4115
      "deinterlace pictures" },
4116
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4117
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4118
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4119
#if CONFIG_AVFILTER
4120
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4121
#endif
4122
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4123
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4124
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4125
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4126
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4127
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4128
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4129
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4130
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4131
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4132
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4133

    
4134
    /* audio options */
4135
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4136
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4137
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4138
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4139
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4140
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4141
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4142
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4143
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4144
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4145
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4146
    { "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" },
4147

    
4148
    /* subtitle options */
4149
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4150
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4151
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4152
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4153
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4154

    
4155
    /* grab options */
4156
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4157
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4158
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4159

    
4160
    /* muxer options */
4161
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4162
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4163

    
4164
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4165
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4166
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4167

    
4168
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4169
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4170
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4171
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4172

    
4173
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4174
    { NULL, },
4175
};
4176

    
4177
int main(int argc, char **argv)
4178
{
4179
    int64_t ti;
4180

    
4181
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4182

    
4183
    avcodec_register_all();
4184
#if CONFIG_AVDEVICE
4185
    avdevice_register_all();
4186
#endif
4187
#if CONFIG_AVFILTER
4188
    avfilter_register_all();
4189
#endif
4190
    av_register_all();
4191

    
4192
#if HAVE_ISATTY
4193
    if(isatty(STDIN_FILENO))
4194
        url_set_interrupt_cb(decode_interrupt_cb);
4195
#endif
4196

    
4197
    init_opts();
4198

    
4199
    show_banner();
4200

    
4201
    /* parse options */
4202
    parse_options(argc, argv, options, opt_output_file);
4203

    
4204
    if(nb_output_files <= 0 && nb_input_files == 0) {
4205
        show_usage();
4206
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4207
        ffmpeg_exit(1);
4208
    }
4209

    
4210
    /* file converter / grab */
4211
    if (nb_output_files <= 0) {
4212
        fprintf(stderr, "At least one output file must be specified\n");
4213
        ffmpeg_exit(1);
4214
    }
4215

    
4216
    if (nb_input_files == 0) {
4217
        fprintf(stderr, "At least one input file must be specified\n");
4218
        ffmpeg_exit(1);
4219
    }
4220

    
4221
    ti = getutime();
4222
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4223
                  stream_maps, nb_stream_maps) < 0)
4224
        ffmpeg_exit(1);
4225
    ti = getutime() - ti;
4226
    if (do_benchmark) {
4227
        int maxrss = getmaxrss() / 1024;
4228
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4229
    }
4230

    
4231
    return ffmpeg_exit(0);
4232
}