Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 5879ea6d

History | View | Annotate | Download (153 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/pixdesc.h"
43
#include "libavutil/avstring.h"
44
#include "libavutil/libm.h"
45
#include "libavformat/os_support.h"
46

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

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

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

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

    
80
#include "cmdutils.h"
81

    
82
#include "libavutil/avassert.h"
83

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

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

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

    
103
static const OptionDef options[];
104

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

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

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

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

    
127
static AVMetaDataMap meta_data_maps[MAX_FILES];
128
static int nb_meta_data_maps;
129

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

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

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

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

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

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

    
208
static int rate_emu = 0;
209

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

    
213
static int audio_volume = 256;
214

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

    
229
static int pgmyuv_compatibility_hack=0;
230
static float dts_delta_threshold = 10;
231

    
232
static unsigned int sws_flags = SWS_BICUBIC;
233

    
234
static int64_t timer_start;
235

    
236
static uint8_t *audio_buf;
237
static uint8_t *audio_out;
238
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
239

    
240
static short *samples;
241

    
242
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
243
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
244
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
245

    
246
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
247

    
248
struct AVInputStream;
249

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

    
271
    /* full frame size of first frame */
272
    int original_height;
273
    int original_width;
274

    
275
    /* audio only */
276
    int audio_resample;
277
    ReSampleContext *resample; /* for audio resampling */
278
    int reformat_pair;
279
    AVAudioConvert *reformat_ctx;
280
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
281
    FILE *logfile;
282
} AVOutputStream;
283

    
284
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
285
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
286

    
287
typedef struct AVInputStream {
288
    int file_index;
289
    int index;
290
    AVStream *st;
291
    int discard;             /* true if stream data should be discarded */
292
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
293
    int64_t sample_index;      /* current sample */
294

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

    
312
typedef struct AVInputFile {
313
    int eof_reached;      /* true if eof reached */
314
    int ist_index;        /* index of first stream in ist_table */
315
    int buffer_size;      /* current total buffer size */
316
    int nb_streams;       /* nb streams we are aware of */
317
} AVInputFile;
318

    
319
#if HAVE_TERMIOS_H
320

    
321
/* init terminal so that we can grab keys */
322
static struct termios oldtty;
323
#endif
324

    
325
#if CONFIG_AVFILTER
326

    
327
static int get_filtered_video_pic(AVFilterContext *ctx,
328
                                  AVFilterBufferRef **picref, AVFrame *pic2,
329
                                  uint64_t *pts)
330
{
331
    AVFilterBufferRef *pic;
332

    
333
    if(avfilter_request_frame(ctx->inputs[0]))
334
        return -1;
335
    if(!(pic = ctx->inputs[0]->cur_buf))
336
        return -1;
337
    *picref = pic;
338
    ctx->inputs[0]->cur_buf = NULL;
339

    
340
    *pts          = pic->pts;
341

    
342
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
343
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
344
    pic2->interlaced_frame = pic->video->interlaced;
345
    pic2->top_field_first  = pic->video->top_field_first;
346

    
347
    return 1;
348
}
349

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

    
360
    graph = av_mallocz(sizeof(AVFilterGraph));
361

    
362
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
363
        return ret;
364
    if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
365
        return ret;
366

    
367
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
368
             ist->st->codec->height, ist->st->codec->pix_fmt,
369
             ist->st->time_base.num, ist->st->time_base.den);
370
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
371
        return ret;
372
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
373
        return ret;
374

    
375
    /* add input and output filters to the overall graph */
376
    avfilter_graph_add_filter(graph, ist->input_video_filter);
377
    avfilter_graph_add_filter(graph, ist->output_video_filter);
378

    
379
    last_filter = ist->input_video_filter;
380

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

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

    
399
    if (vfilters) {
400
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
401
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
402

    
403
        outputs->name    = av_strdup("in");
404
        outputs->filter  = last_filter;
405
        outputs->pad_idx = 0;
406
        outputs->next    = NULL;
407

    
408
        inputs->name    = av_strdup("out");
409
        inputs->filter  = ist->output_video_filter;
410
        inputs->pad_idx = 0;
411
        inputs->next    = NULL;
412

    
413
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
414
            return ret;
415
        av_freep(&vfilters);
416
    } else {
417
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
418
            return ret;
419
    }
420

    
421
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
422
        return ret;
423

    
424
    codec->width  = ist->output_video_filter->inputs[0]->w;
425
    codec->height = ist->output_video_filter->inputs[0]->h;
426

    
427
    return 0;
428
}
429
#endif /* CONFIG_AVFILTER */
430

    
431
static void term_exit(void)
432
{
433
    av_log(NULL, AV_LOG_QUIET, "");
434
#if HAVE_TERMIOS_H
435
    tcsetattr (0, TCSANOW, &oldtty);
436
#endif
437
}
438

    
439
static volatile int received_sigterm = 0;
440

    
441
static void
442
sigterm_handler(int sig)
443
{
444
    received_sigterm = sig;
445
    term_exit();
446
}
447

    
448
static void term_init(void)
449
{
450
#if HAVE_TERMIOS_H
451
    struct termios tty;
452

    
453
    tcgetattr (0, &tty);
454
    oldtty = tty;
455
    atexit(term_exit);
456

    
457
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
458
                          |INLCR|IGNCR|ICRNL|IXON);
459
    tty.c_oflag |= OPOST;
460
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
461
    tty.c_cflag &= ~(CSIZE|PARENB);
462
    tty.c_cflag |= CS8;
463
    tty.c_cc[VMIN] = 1;
464
    tty.c_cc[VTIME] = 0;
465

    
466
    tcsetattr (0, TCSANOW, &tty);
467
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
468
#endif
469

    
470
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
471
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
472
#ifdef SIGXCPU
473
    signal(SIGXCPU, sigterm_handler);
474
#endif
475
}
476

    
477
/* read a key without blocking */
478
static int read_key(void)
479
{
480
#if HAVE_TERMIOS_H
481
    int n = 1;
482
    unsigned char ch;
483
    struct timeval tv;
484
    fd_set rfds;
485

    
486
    FD_ZERO(&rfds);
487
    FD_SET(0, &rfds);
488
    tv.tv_sec = 0;
489
    tv.tv_usec = 0;
490
    n = select(1, &rfds, NULL, NULL, &tv);
491
    if (n > 0) {
492
        n = read(0, &ch, 1);
493
        if (n == 1)
494
            return ch;
495

    
496
        return n;
497
    }
498
#elif HAVE_CONIO_H
499
    if(kbhit())
500
        return(getch());
501
#endif
502
    return -1;
503
}
504

    
505
static int decode_interrupt_cb(void)
506
{
507
    return q_pressed || (q_pressed = read_key() == 'q');
508
}
509

    
510
static int ffmpeg_exit(int ret)
511
{
512
    int i;
513

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

    
542
    av_free(intra_matrix);
543
    av_free(inter_matrix);
544

    
545
    if (vstats_file)
546
        fclose(vstats_file);
547
    av_free(vstats_filename);
548

    
549
    av_free(opt_names);
550
    av_free(streamid_map);
551
    av_free(input_codecs);
552
    av_free(output_codecs);
553
    av_free(stream_maps);
554

    
555
    av_free(video_codec_name);
556
    av_free(audio_codec_name);
557
    av_free(subtitle_codec_name);
558

    
559
    av_free(video_standard);
560

    
561
    uninit_opts();
562
    av_free(audio_buf);
563
    av_free(audio_out);
564
    allocated_audio_buf_size= allocated_audio_out_size= 0;
565
    av_free(samples);
566

    
567
#if CONFIG_AVFILTER
568
    avfilter_uninit();
569
#endif
570

    
571
    if (received_sigterm) {
572
        fprintf(stderr,
573
            "Received signal %d: terminating.\n",
574
            (int) received_sigterm);
575
        exit (255);
576
    }
577

    
578
    exit(ret); /* not all OS-es handle main() return value */
579
    return ret;
580
}
581

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

    
602
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
603
{
604
    if(codec && codec->sample_fmts){
605
        const enum SampleFormat *p= codec->sample_fmts;
606
        for(; *p!=-1; p++){
607
            if(*p == st->codec->sample_fmt)
608
                break;
609
        }
610
        if(*p == -1)
611
            st->codec->sample_fmt = codec->sample_fmts[0];
612
    }
613
}
614

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

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

    
652
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
653
{
654
    int i, err;
655
    AVFormatContext *ic;
656
    int nopts = 0;
657

    
658
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
659
    if (err < 0)
660
        return err;
661
    /* copy stream format */
662
    s->nb_streams = ic->nb_streams;
663
    for(i=0;i<ic->nb_streams;i++) {
664
        AVStream *st;
665
        AVCodec *codec;
666

    
667
        // FIXME: a more elegant solution is needed
668
        st = av_mallocz(sizeof(AVStream));
669
        memcpy(st, ic->streams[i], sizeof(AVStream));
670
        st->codec = avcodec_alloc_context();
671
        if (!st->codec) {
672
            print_error(filename, AVERROR(ENOMEM));
673
            ffmpeg_exit(1);
674
        }
675
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
676
        s->streams[i] = st;
677

    
678
        codec = avcodec_find_encoder(st->codec->codec_id);
679
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
680
            if (audio_stream_copy) {
681
                st->stream_copy = 1;
682
            } else
683
                choose_sample_fmt(st, codec);
684
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
685
            if (video_stream_copy) {
686
                st->stream_copy = 1;
687
            } else
688
                choose_pixel_fmt(st, codec);
689
        }
690

    
691
        if(!st->codec->thread_count)
692
            st->codec->thread_count = 1;
693
        if(st->codec->thread_count>1)
694
            avcodec_thread_init(st->codec, st->codec->thread_count);
695

    
696
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
697
            nopts = 1;
698
    }
699

    
700
    if (!nopts)
701
        s->timestamp = av_gettime();
702

    
703
    av_close_input_file(ic);
704
    return 0;
705
}
706

    
707
static double
708
get_sync_ipts(const AVOutputStream *ost)
709
{
710
    const AVInputStream *ist = ost->sync_ist;
711
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
712
}
713

    
714
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
715
    int ret;
716

    
717
    while(bsfc){
718
        AVPacket new_pkt= *pkt;
719
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
720
                                          &new_pkt.data, &new_pkt.size,
721
                                          pkt->data, pkt->size,
722
                                          pkt->flags & AV_PKT_FLAG_KEY);
723
        if(a>0){
724
            av_free_packet(pkt);
725
            new_pkt.destruct= av_destruct_packet;
726
        } else if(a<0){
727
            fprintf(stderr, "%s failed for stream %d, codec %s",
728
                    bsfc->filter->name, pkt->stream_index,
729
                    avctx->codec ? avctx->codec->name : "copy");
730
            print_error("", a);
731
            if (exit_on_error)
732
                ffmpeg_exit(1);
733
        }
734
        *pkt= new_pkt;
735

    
736
        bsfc= bsfc->next;
737
    }
738

    
739
    ret= av_interleaved_write_frame(s, pkt);
740
    if(ret < 0){
741
        print_error("av_interleaved_write_frame()", ret);
742
        ffmpeg_exit(1);
743
    }
744
}
745

    
746
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
747

    
748
static void do_audio_out(AVFormatContext *s,
749
                         AVOutputStream *ost,
750
                         AVInputStream *ist,
751
                         unsigned char *buf, int size)
752
{
753
    uint8_t *buftmp;
754
    int64_t audio_out_size, audio_buf_size;
755
    int64_t allocated_for_size= size;
756

    
757
    int size_out, frame_bytes, ret;
758
    AVCodecContext *enc= ost->st->codec;
759
    AVCodecContext *dec= ist->st->codec;
760
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
761
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
762
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
763

    
764
need_realloc:
765
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
766
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
767
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
768
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
769
    audio_buf_size*= osize*enc->channels;
770

    
771
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
772
    if(coded_bps > 8*osize)
773
        audio_out_size= audio_out_size * coded_bps / (8*osize);
774
    audio_out_size += FF_MIN_BUFFER_SIZE;
775

    
776
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
777
        fprintf(stderr, "Buffer sizes too large\n");
778
        ffmpeg_exit(1);
779
    }
780

    
781
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
782
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
783
    if (!audio_buf || !audio_out){
784
        fprintf(stderr, "Out of memory in do_audio_out\n");
785
        ffmpeg_exit(1);
786
    }
787

    
788
    if (enc->channels != dec->channels)
789
        ost->audio_resample = 1;
790

    
791
    if (ost->audio_resample && !ost->resample) {
792
        if (dec->sample_fmt != SAMPLE_FMT_S16)
793
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
794
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
795
                                               enc->sample_rate, dec->sample_rate,
796
                                               enc->sample_fmt,  dec->sample_fmt,
797
                                               16, 10, 0, 0.8);
798
        if (!ost->resample) {
799
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
800
                    dec->channels, dec->sample_rate,
801
                    enc->channels, enc->sample_rate);
802
            ffmpeg_exit(1);
803
        }
804
    }
805

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1088
    avcodec_get_frame_defaults(&picture_crop_temp);
1089
    avcodec_get_frame_defaults(&picture_pad_temp);
1090

    
1091
    enc = ost->st->codec;
1092
    dec = ist->st->codec;
1093

    
1094
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1095

    
1096
    /* by default, we output a single frame */
1097
    nb_frames = 1;
1098

    
1099
    *frame_size = 0;
1100

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

    
1126
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1127
    if (nb_frames <= 0)
1128
        return;
1129

    
1130
    formatted_picture = in_picture;
1131
    final_picture = formatted_picture;
1132
    padding_src = formatted_picture;
1133
    resampling_dst = &ost->pict_tmp;
1134

    
1135
    if (   ost->resample_height != ist->st->codec->height
1136
        || ost->resample_width  != ist->st->codec->width
1137
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1138

    
1139
        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));
1140
        if(!ost->video_resample)
1141
            ffmpeg_exit(1);
1142
    }
1143

    
1144
#if !CONFIG_AVFILTER
1145
    if (ost->video_resample) {
1146
        padding_src = NULL;
1147
        final_picture = &ost->pict_tmp;
1148
        if(  ost->resample_height != ist->st->codec->height
1149
          || ost->resample_width  != ist->st->codec->width
1150
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1151

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

    
1173
    /* duplicates frame if needed */
1174
    for(i=0;i<nb_frames;i++) {
1175
        AVPacket pkt;
1176
        av_init_packet(&pkt);
1177
        pkt.stream_index= ost->index;
1178

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

    
1190
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1191
            enc->coded_frame = old_frame;
1192
        } else {
1193
            AVFrame big_picture;
1194

    
1195
            big_picture= *final_picture;
1196
            /* better than nothing: use input picture interlaced
1197
               settings */
1198
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1199
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1200
                if(top_field_first == -1)
1201
                    big_picture.top_field_first = in_picture->top_field_first;
1202
                else
1203
                    big_picture.top_field_first = top_field_first;
1204
            }
1205

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

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

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

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

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

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

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

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

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

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

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

    
1318

    
1319
    oc = output_files[0];
1320

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

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

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

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

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

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

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

    
1399
        fflush(stderr);
1400
    }
1401

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

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

    
1432
    AVPacket avpkt;
1433
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1434

    
1435
    if(ist->next_pts == AV_NOPTS_VALUE)
1436
        ist->next_pts= ist->pts;
1437

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

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

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

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

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

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

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

    
1564
#if CONFIG_AVFILTER
1565
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1566
            // add it to be filtered
1567
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1568
                                     ist->pts,
1569
                                     ist->st->codec->sample_aspect_ratio);
1570
        }
1571
#endif
1572

    
1573
        // preprocess audio (volume)
1574
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1575
            if (audio_volume != 256) {
1576
                short *volp;
1577
                volp = samples;
1578
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1579
                    int v = ((*volp) * audio_volume + 128) >> 8;
1580
                    if (v < -32768) v = -32768;
1581
                    if (v >  32767) v = 32767;
1582
                    *volp++ = v;
1583
                }
1584
            }
1585
        }
1586

    
1587
        /* frame rate emulation */
1588
        if (rate_emu) {
1589
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1590
            int64_t now = av_gettime() - ist->start;
1591
            if (pts > now)
1592
                usleep(pts - now);
1593
        }
1594
#if CONFIG_AVFILTER
1595
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1596
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1597
#endif
1598
        /* if output time reached then transcode raw format,
1599
           encode packets and output them */
1600
        if (start_time == 0 || ist->pts >= start_time)
1601
#if CONFIG_AVFILTER
1602
        while (frame_available) {
1603
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1604
                get_filtered_video_pic(ist->output_video_filter, &ist->picref, &picture, &ist->pts);
1605
#endif
1606
            for(i=0;i<nb_ostreams;i++) {
1607
                int frame_size;
1608

    
1609
                ost = ost_table[i];
1610
                if (ost->source_index == ist_index) {
1611
                    os = output_files[ost->file_index];
1612

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

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

    
1643
                        av_init_packet(&opkt);
1644

    
1645
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1646
                            continue;
1647

    
1648
                        /* no reencoding needed : output the packet directly */
1649
                        /* force the input stream PTS */
1650

    
1651
                        avcodec_get_frame_defaults(&avframe);
1652
                        ost->st->codec->coded_frame= &avframe;
1653
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1654

    
1655
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1656
                            audio_size += data_size;
1657
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1658
                            video_size += data_size;
1659
                            ost->sync_opts++;
1660
                        }
1661

    
1662
                        opkt.stream_index= ost->index;
1663
                        if(pkt->pts != AV_NOPTS_VALUE)
1664
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1665
                        else
1666
                            opkt.pts= AV_NOPTS_VALUE;
1667

    
1668
                        if (pkt->dts == AV_NOPTS_VALUE)
1669
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1670
                        else
1671
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1672
                        opkt.dts -= ost_tb_start_time;
1673

    
1674
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1675
                        opkt.flags= pkt->flags;
1676

    
1677
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1678
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1679
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1680
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1681
                           ) {
1682
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1683
                                opkt.destruct= av_destruct_packet;
1684
                        } else {
1685
                            opkt.data = data_buf;
1686
                            opkt.size = data_size;
1687
                        }
1688

    
1689
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1690
                        ost->st->codec->frame_number++;
1691
                        ost->frame_number++;
1692
                        av_free_packet(&opkt);
1693
                    }
1694
                }
1695
            }
1696

    
1697
#if CONFIG_AVFILTER
1698
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1699
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1700
            if(ist->picref)
1701
                avfilter_unref_buffer(ist->picref);
1702
        }
1703
#endif
1704
        av_free(buffer_to_free);
1705
        /* XXX: allocate the subtitles in the codec ? */
1706
        if (subtitle_to_free) {
1707
            if (subtitle_to_free->rects != NULL) {
1708
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1709
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1710
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1711
                    av_freep(&subtitle_to_free->rects[i]);
1712
                }
1713
                av_freep(&subtitle_to_free->rects);
1714
            }
1715
            subtitle_to_free->num_rects = 0;
1716
            subtitle_to_free = NULL;
1717
        }
1718
    }
1719
 discard_packet:
1720
    if (pkt == NULL) {
1721
        /* EOF handling */
1722

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

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

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

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

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

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

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

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

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

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

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

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

    
1833

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

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

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

    
1848
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1849
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1850

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

    
1860
/*
1861
 * The following code is the main loop of the file converter
1862
 */
1863
static int transcode(AVFormatContext **output_files,
1864
                     int nb_output_files,
1865
                     AVFormatContext **input_files,
1866
                     int nb_input_files,
1867
                     AVStreamMap *stream_maps, int nb_stream_maps)
1868
{
1869
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1870
    AVFormatContext *is, *os;
1871
    AVCodecContext *codec, *icodec;
1872
    AVOutputStream *ost, **ost_table = NULL;
1873
    AVInputStream *ist, **ist_table = NULL;
1874
    AVInputFile *file_table;
1875
    char error[1024];
1876
    int key;
1877
    int want_sdp = 1;
1878
    uint8_t no_packet[MAX_FILES]={0};
1879
    int no_packet_count=0;
1880

    
1881
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1882
    if (!file_table)
1883
        goto fail;
1884

    
1885
    /* input stream init */
1886
    j = 0;
1887
    for(i=0;i<nb_input_files;i++) {
1888
        is = input_files[i];
1889
        file_table[i].ist_index = j;
1890
        file_table[i].nb_streams = is->nb_streams;
1891
        j += is->nb_streams;
1892
    }
1893
    nb_istreams = j;
1894

    
1895
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1896
    if (!ist_table)
1897
        goto fail;
1898

    
1899
    for(i=0;i<nb_istreams;i++) {
1900
        ist = av_mallocz(sizeof(AVInputStream));
1901
        if (!ist)
1902
            goto fail;
1903
        ist_table[i] = ist;
1904
    }
1905
    j = 0;
1906
    for(i=0;i<nb_input_files;i++) {
1907
        is = input_files[i];
1908
        for(k=0;k<is->nb_streams;k++) {
1909
            ist = ist_table[j++];
1910
            ist->st = is->streams[k];
1911
            ist->file_index = i;
1912
            ist->index = k;
1913
            ist->discard = 1; /* the stream is discarded by default
1914
                                 (changed later) */
1915

    
1916
            if (rate_emu) {
1917
                ist->start = av_gettime();
1918
            }
1919
        }
1920
    }
1921

    
1922
    /* output stream init */
1923
    nb_ostreams = 0;
1924
    for(i=0;i<nb_output_files;i++) {
1925
        os = output_files[i];
1926
        if (!os->nb_streams) {
1927
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1928
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1929
            ret = AVERROR(EINVAL);
1930
            goto fail;
1931
        }
1932
        nb_ostreams += os->nb_streams;
1933
    }
1934
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1935
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1936
        ret = AVERROR(EINVAL);
1937
        goto fail;
1938
    }
1939

    
1940
    /* Sanity check the mapping args -- do the input files & streams exist? */
1941
    for(i=0;i<nb_stream_maps;i++) {
1942
        int fi = stream_maps[i].file_index;
1943
        int si = stream_maps[i].stream_index;
1944

    
1945
        if (fi < 0 || fi > nb_input_files - 1 ||
1946
            si < 0 || si > file_table[fi].nb_streams - 1) {
1947
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1948
            ret = AVERROR(EINVAL);
1949
            goto fail;
1950
        }
1951
        fi = stream_maps[i].sync_file_index;
1952
        si = stream_maps[i].sync_stream_index;
1953
        if (fi < 0 || fi > nb_input_files - 1 ||
1954
            si < 0 || si > file_table[fi].nb_streams - 1) {
1955
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1956
            ret = AVERROR(EINVAL);
1957
            goto fail;
1958
        }
1959
    }
1960

    
1961
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1962
    if (!ost_table)
1963
        goto fail;
1964
    n = 0;
1965
    for(k=0;k<nb_output_files;k++) {
1966
        os = output_files[k];
1967
        for(i=0;i<os->nb_streams;i++,n++) {
1968
            int found;
1969
            ost = ost_table[n] = output_streams_for_file[k][i];
1970
            ost->st = os->streams[i];
1971
            if (nb_stream_maps > 0) {
1972
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1973
                    stream_maps[n].stream_index;
1974

    
1975
                /* Sanity check that the stream types match */
1976
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1977
                    int i= ost->file_index;
1978
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1979
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1980
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1981
                        ost->file_index, ost->index);
1982
                    ffmpeg_exit(1);
1983
                }
1984

    
1985
            } else {
1986
                int best_nb_frames=-1;
1987
                /* get corresponding input stream index : we select the first one with the right type */
1988
                found = 0;
1989
                for(j=0;j<nb_istreams;j++) {
1990
                    int skip=0;
1991
                    ist = ist_table[j];
1992
                    if(opt_programid){
1993
                        int pi,si;
1994
                        AVFormatContext *f= input_files[ ist->file_index ];
1995
                        skip=1;
1996
                        for(pi=0; pi<f->nb_programs; pi++){
1997
                            AVProgram *p= f->programs[pi];
1998
                            if(p->id == opt_programid)
1999
                                for(si=0; si<p->nb_stream_indexes; si++){
2000
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2001
                                        skip=0;
2002
                                }
2003
                        }
2004
                    }
2005
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2006
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2007
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2008
                            best_nb_frames= ist->st->codec_info_nb_frames;
2009
                            ost->source_index = j;
2010
                            found = 1;
2011
                        }
2012
                    }
2013
                }
2014

    
2015
                if (!found) {
2016
                    if(! opt_programid) {
2017
                        /* try again and reuse existing stream */
2018
                        for(j=0;j<nb_istreams;j++) {
2019
                            ist = ist_table[j];
2020
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2021
                                && ist->st->discard != AVDISCARD_ALL) {
2022
                                ost->source_index = j;
2023
                                found = 1;
2024
                            }
2025
                        }
2026
                    }
2027
                    if (!found) {
2028
                        int i= ost->file_index;
2029
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2030
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2031
                                ost->file_index, ost->index);
2032
                        ffmpeg_exit(1);
2033
                    }
2034
                }
2035
            }
2036
            ist = ist_table[ost->source_index];
2037
            ist->discard = 0;
2038
            ost->sync_ist = (nb_stream_maps > 0) ?
2039
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2040
                         stream_maps[n].sync_stream_index] : ist;
2041
        }
2042
    }
2043

    
2044
    /* for each output stream, we compute the right encoding parameters */
2045
    for(i=0;i<nb_ostreams;i++) {
2046
        AVMetadataTag *t = NULL;
2047
        ost = ost_table[i];
2048
        os = output_files[ost->file_index];
2049
        ist = ist_table[ost->source_index];
2050

    
2051
        codec = ost->st->codec;
2052
        icodec = ist->st->codec;
2053

    
2054
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2055
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2056
        }
2057

    
2058
        ost->st->disposition = ist->st->disposition;
2059
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2060
        codec->chroma_sample_location = icodec->chroma_sample_location;
2061

    
2062
        if (ost->st->stream_copy) {
2063
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2064

    
2065
            if (extra_size > INT_MAX)
2066
                goto fail;
2067

    
2068
            /* if stream_copy is selected, no need to decode or encode */
2069
            codec->codec_id = icodec->codec_id;
2070
            codec->codec_type = icodec->codec_type;
2071

    
2072
            if(!codec->codec_tag){
2073
                if(   !os->oformat->codec_tag
2074
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2075
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2076
                    codec->codec_tag = icodec->codec_tag;
2077
            }
2078

    
2079
            codec->bit_rate = icodec->bit_rate;
2080
            codec->rc_max_rate    = icodec->rc_max_rate;
2081
            codec->rc_buffer_size = icodec->rc_buffer_size;
2082
            codec->extradata= av_mallocz(extra_size);
2083
            if (!codec->extradata)
2084
                goto fail;
2085
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2086
            codec->extradata_size= icodec->extradata_size;
2087
            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){
2088
                codec->time_base = icodec->time_base;
2089
                codec->time_base.num *= icodec->ticks_per_frame;
2090
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2091
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2092
            }else
2093
                codec->time_base = ist->st->time_base;
2094
            switch(codec->codec_type) {
2095
            case AVMEDIA_TYPE_AUDIO:
2096
                if(audio_volume != 256) {
2097
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2098
                    ffmpeg_exit(1);
2099
                }
2100
                codec->channel_layout = icodec->channel_layout;
2101
                codec->sample_rate = icodec->sample_rate;
2102
                codec->channels = icodec->channels;
2103
                codec->frame_size = icodec->frame_size;
2104
                codec->block_align= icodec->block_align;
2105
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2106
                    codec->block_align= 0;
2107
                if(codec->codec_id == CODEC_ID_AC3)
2108
                    codec->block_align= 0;
2109
                break;
2110
            case AVMEDIA_TYPE_VIDEO:
2111
                codec->pix_fmt = icodec->pix_fmt;
2112
                codec->width = icodec->width;
2113
                codec->height = icodec->height;
2114
                codec->has_b_frames = icodec->has_b_frames;
2115
                break;
2116
            case AVMEDIA_TYPE_SUBTITLE:
2117
                codec->width = icodec->width;
2118
                codec->height = icodec->height;
2119
                break;
2120
            default:
2121
                abort();
2122
            }
2123
        } else {
2124
            switch(codec->codec_type) {
2125
            case AVMEDIA_TYPE_AUDIO:
2126
                ost->fifo= av_fifo_alloc(1024);
2127
                if(!ost->fifo)
2128
                    goto fail;
2129
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2130
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2131
                icodec->request_channels = codec->channels;
2132
                ist->decoding_needed = 1;
2133
                ost->encoding_needed = 1;
2134
                break;
2135
            case AVMEDIA_TYPE_VIDEO:
2136
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2137
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2138
                    ffmpeg_exit(1);
2139
                }
2140
                ost->video_resample = (codec->width != icodec->width   ||
2141
                                       codec->height != icodec->height ||
2142
                        (codec->pix_fmt != icodec->pix_fmt));
2143
                if (ost->video_resample) {
2144
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2145
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2146
                                         codec->width, codec->height)) {
2147
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2148
                        ffmpeg_exit(1);
2149
                    }
2150
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2151
                    ost->img_resample_ctx = sws_getContext(
2152
                        icodec->width,
2153
                        icodec->height,
2154
                            icodec->pix_fmt,
2155
                            codec->width,
2156
                            codec->height,
2157
                            codec->pix_fmt,
2158
                            sws_flags, NULL, NULL, NULL);
2159
                    if (ost->img_resample_ctx == NULL) {
2160
                        fprintf(stderr, "Cannot get resampling context\n");
2161
                        ffmpeg_exit(1);
2162
                    }
2163

    
2164
#if !CONFIG_AVFILTER
2165
                    ost->original_height = icodec->height;
2166
                    ost->original_width  = icodec->width;
2167
#endif
2168
                    codec->bits_per_raw_sample= 0;
2169
                }
2170
                ost->resample_height = icodec->height;
2171
                ost->resample_width  = icodec->width;
2172
                ost->resample_pix_fmt= icodec->pix_fmt;
2173
                ost->encoding_needed = 1;
2174
                ist->decoding_needed = 1;
2175

    
2176
#if CONFIG_AVFILTER
2177
                if (configure_filters(ist, ost)) {
2178
                    fprintf(stderr, "Error opening filters!\n");
2179
                    exit(1);
2180
                }
2181
#endif
2182
                break;
2183
            case AVMEDIA_TYPE_SUBTITLE:
2184
                ost->encoding_needed = 1;
2185
                ist->decoding_needed = 1;
2186
                break;
2187
            default:
2188
                abort();
2189
                break;
2190
            }
2191
            /* two pass mode */
2192
            if (ost->encoding_needed &&
2193
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2194
                char logfilename[1024];
2195
                FILE *f;
2196

    
2197
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2198
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2199
                         i);
2200
                if (codec->flags & CODEC_FLAG_PASS1) {
2201
                    f = fopen(logfilename, "wb");
2202
                    if (!f) {
2203
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2204
                        ffmpeg_exit(1);
2205
                    }
2206
                    ost->logfile = f;
2207
                } else {
2208
                    char  *logbuffer;
2209
                    size_t logbuffer_size;
2210
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2211
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2212
                        ffmpeg_exit(1);
2213
                    }
2214
                    codec->stats_in = logbuffer;
2215
                }
2216
            }
2217
        }
2218
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2219
            int size= codec->width * codec->height;
2220
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2221
        }
2222
    }
2223

    
2224
    if (!bit_buffer)
2225
        bit_buffer = av_malloc(bit_buffer_size);
2226
    if (!bit_buffer) {
2227
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2228
                bit_buffer_size);
2229
        ret = AVERROR(ENOMEM);
2230
        goto fail;
2231
    }
2232

    
2233
    /* open each encoder */
2234
    for(i=0;i<nb_ostreams;i++) {
2235
        ost = ost_table[i];
2236
        if (ost->encoding_needed) {
2237
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2238
            if (!codec)
2239
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2240
            if (!codec) {
2241
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2242
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2243
                ret = AVERROR(EINVAL);
2244
                goto dump_format;
2245
            }
2246
            if (avcodec_open(ost->st->codec, codec) < 0) {
2247
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2248
                        ost->file_index, ost->index);
2249
                ret = AVERROR(EINVAL);
2250
                goto dump_format;
2251
            }
2252
            extra_size += ost->st->codec->extradata_size;
2253
        }
2254
    }
2255

    
2256
    /* open each decoder */
2257
    for(i=0;i<nb_istreams;i++) {
2258
        ist = ist_table[i];
2259
        if (ist->decoding_needed) {
2260
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2261
            if (!codec)
2262
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2263
            if (!codec) {
2264
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2265
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2266
                ret = AVERROR(EINVAL);
2267
                goto dump_format;
2268
            }
2269
            if (avcodec_open(ist->st->codec, codec) < 0) {
2270
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2271
                        ist->file_index, ist->index);
2272
                ret = AVERROR(EINVAL);
2273
                goto dump_format;
2274
            }
2275
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2276
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2277
        }
2278
    }
2279

    
2280
    /* init pts */
2281
    for(i=0;i<nb_istreams;i++) {
2282
        AVStream *st;
2283
        ist = ist_table[i];
2284
        st= ist->st;
2285
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2286
        ist->next_pts = AV_NOPTS_VALUE;
2287
        init_pts_correction(&ist->pts_ctx);
2288
        ist->is_start = 1;
2289
    }
2290

    
2291
    /* set meta data information from input file if required */
2292
    for (i=0;i<nb_meta_data_maps;i++) {
2293
        AVFormatContext *out_file;
2294
        AVFormatContext *in_file;
2295
        AVMetadataTag *mtag;
2296

    
2297
        int out_file_index = meta_data_maps[i].out_file;
2298
        int in_file_index = meta_data_maps[i].in_file;
2299
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2300
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2301
                     out_file_index, out_file_index, in_file_index);
2302
            ret = AVERROR(EINVAL);
2303
            goto dump_format;
2304
        }
2305
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2306
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2307
                     in_file_index, out_file_index, in_file_index);
2308
            ret = AVERROR(EINVAL);
2309
            goto dump_format;
2310
        }
2311

    
2312
        out_file = output_files[out_file_index];
2313
        in_file = input_files[in_file_index];
2314

    
2315

    
2316
        mtag=NULL;
2317
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2318
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2319
    }
2320

    
2321
    /* copy chapters from the first input file that has them*/
2322
    for (i = 0; i < nb_input_files; i++) {
2323
        if (!input_files[i]->nb_chapters)
2324
            continue;
2325

    
2326
        for (j = 0; j < nb_output_files; j++)
2327
            if ((ret = copy_chapters(i, j)) < 0)
2328
                goto dump_format;
2329
    }
2330

    
2331
    /* open files and write file headers */
2332
    for(i=0;i<nb_output_files;i++) {
2333
        os = output_files[i];
2334
        if (av_write_header(os) < 0) {
2335
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2336
            ret = AVERROR(EINVAL);
2337
            goto dump_format;
2338
        }
2339
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2340
            want_sdp = 0;
2341
        }
2342
    }
2343

    
2344
 dump_format:
2345
    /* dump the file output parameters - cannot be done before in case
2346
       of stream copy */
2347
    for(i=0;i<nb_output_files;i++) {
2348
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2349
    }
2350

    
2351
    /* dump the stream mapping */
2352
    if (verbose >= 0) {
2353
        fprintf(stderr, "Stream mapping:\n");
2354
        for(i=0;i<nb_ostreams;i++) {
2355
            ost = ost_table[i];
2356
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2357
                    ist_table[ost->source_index]->file_index,
2358
                    ist_table[ost->source_index]->index,
2359
                    ost->file_index,
2360
                    ost->index);
2361
            if (ost->sync_ist != ist_table[ost->source_index])
2362
                fprintf(stderr, " [sync #%d.%d]",
2363
                        ost->sync_ist->file_index,
2364
                        ost->sync_ist->index);
2365
            fprintf(stderr, "\n");
2366
        }
2367
    }
2368

    
2369
    if (ret) {
2370
        fprintf(stderr, "%s\n", error);
2371
        goto fail;
2372
    }
2373

    
2374
    if (want_sdp) {
2375
        print_sdp(output_files, nb_output_files);
2376
    }
2377

    
2378
    if (!using_stdin && verbose >= 0) {
2379
        fprintf(stderr, "Press [q] to stop encoding\n");
2380
        url_set_interrupt_cb(decode_interrupt_cb);
2381
    }
2382
    term_init();
2383

    
2384
    timer_start = av_gettime();
2385

    
2386
    for(; received_sigterm == 0;) {
2387
        int file_index, ist_index;
2388
        AVPacket pkt;
2389
        double ipts_min;
2390
        double opts_min;
2391

    
2392
    redo:
2393
        ipts_min= 1e100;
2394
        opts_min= 1e100;
2395
        /* if 'q' pressed, exits */
2396
        if (!using_stdin) {
2397
            if (q_pressed)
2398
                break;
2399
            /* read_key() returns 0 on EOF */
2400
            key = read_key();
2401
            if (key == 'q')
2402
                break;
2403
        }
2404

    
2405
        /* select the stream that we must read now by looking at the
2406
           smallest output pts */
2407
        file_index = -1;
2408
        for(i=0;i<nb_ostreams;i++) {
2409
            double ipts, opts;
2410
            ost = ost_table[i];
2411
            os = output_files[ost->file_index];
2412
            ist = ist_table[ost->source_index];
2413
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2414
                continue;
2415
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2416
            ipts = (double)ist->pts;
2417
            if (!file_table[ist->file_index].eof_reached){
2418
                if(ipts < ipts_min) {
2419
                    ipts_min = ipts;
2420
                    if(input_sync ) file_index = ist->file_index;
2421
                }
2422
                if(opts < opts_min) {
2423
                    opts_min = opts;
2424
                    if(!input_sync) file_index = ist->file_index;
2425
                }
2426
            }
2427
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2428
                file_index= -1;
2429
                break;
2430
            }
2431
        }
2432
        /* if none, if is finished */
2433
        if (file_index < 0) {
2434
            if(no_packet_count){
2435
                no_packet_count=0;
2436
                memset(no_packet, 0, sizeof(no_packet));
2437
                usleep(10000);
2438
                continue;
2439
            }
2440
            break;
2441
        }
2442

    
2443
        /* finish if limit size exhausted */
2444
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2445
            break;
2446

    
2447
        /* read a frame from it and output it in the fifo */
2448
        is = input_files[file_index];
2449
        ret= av_read_frame(is, &pkt);
2450
        if(ret == AVERROR(EAGAIN)){
2451
            no_packet[file_index]=1;
2452
            no_packet_count++;
2453
            continue;
2454
        }
2455
        if (ret < 0) {
2456
            file_table[file_index].eof_reached = 1;
2457
            if (opt_shortest)
2458
                break;
2459
            else
2460
                continue;
2461
        }
2462

    
2463
        no_packet_count=0;
2464
        memset(no_packet, 0, sizeof(no_packet));
2465

    
2466
        if (do_pkt_dump) {
2467
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2468
        }
2469
        /* the following test is needed in case new streams appear
2470
           dynamically in stream : we ignore them */
2471
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2472
            goto discard_packet;
2473
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2474
        ist = ist_table[ist_index];
2475
        if (ist->discard)
2476
            goto discard_packet;
2477

    
2478
        if (pkt.dts != AV_NOPTS_VALUE)
2479
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2480
        if (pkt.pts != AV_NOPTS_VALUE)
2481
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2482

    
2483
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2484
            && input_files_ts_scale[file_index][pkt.stream_index]){
2485
            if(pkt.pts != AV_NOPTS_VALUE)
2486
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2487
            if(pkt.dts != AV_NOPTS_VALUE)
2488
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2489
        }
2490

    
2491
//        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);
2492
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2493
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2494
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2495
            int64_t delta= pkt_dts - ist->next_pts;
2496
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2497
                input_files_ts_offset[ist->file_index]-= delta;
2498
                if (verbose > 2)
2499
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2500
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2501
                if(pkt.pts != AV_NOPTS_VALUE)
2502
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2503
            }
2504
        }
2505

    
2506
        /* finish if recording time exhausted */
2507
        if (recording_time != INT64_MAX &&
2508
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2509
            ist->is_past_recording_time = 1;
2510
            goto discard_packet;
2511
        }
2512

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

    
2516
            if (verbose >= 0)
2517
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2518
                        ist->file_index, ist->index);
2519
            if (exit_on_error)
2520
                ffmpeg_exit(1);
2521
            av_free_packet(&pkt);
2522
            goto redo;
2523
        }
2524

    
2525
    discard_packet:
2526
        av_free_packet(&pkt);
2527

    
2528
        /* dump report by using the output first video and audio streams */
2529
        print_report(output_files, ost_table, nb_ostreams, 0);
2530
    }
2531

    
2532
    /* at the end of stream, we must flush the decoder buffers */
2533
    for(i=0;i<nb_istreams;i++) {
2534
        ist = ist_table[i];
2535
        if (ist->decoding_needed) {
2536
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2537
        }
2538
    }
2539

    
2540
    term_exit();
2541

    
2542
    /* write the trailer if needed and close file */
2543
    for(i=0;i<nb_output_files;i++) {
2544
        os = output_files[i];
2545
        av_write_trailer(os);
2546
    }
2547

    
2548
    /* dump report by using the first video and audio streams */
2549
    print_report(output_files, ost_table, nb_ostreams, 1);
2550

    
2551
    /* close each encoder */
2552
    for(i=0;i<nb_ostreams;i++) {
2553
        ost = ost_table[i];
2554
        if (ost->encoding_needed) {
2555
            av_freep(&ost->st->codec->stats_in);
2556
            avcodec_close(ost->st->codec);
2557
        }
2558
    }
2559

    
2560
    /* close each decoder */
2561
    for(i=0;i<nb_istreams;i++) {
2562
        ist = ist_table[i];
2563
        if (ist->decoding_needed) {
2564
            avcodec_close(ist->st->codec);
2565
        }
2566
    }
2567
#if CONFIG_AVFILTER
2568
    if (graph) {
2569
        avfilter_graph_destroy(graph);
2570
        av_freep(&graph);
2571
    }
2572
#endif
2573

    
2574
    /* finished ! */
2575
    ret = 0;
2576

    
2577
 fail:
2578
    av_freep(&bit_buffer);
2579
    av_free(file_table);
2580

    
2581
    if (ist_table) {
2582
        for(i=0;i<nb_istreams;i++) {
2583
            ist = ist_table[i];
2584
            av_free(ist);
2585
        }
2586
        av_free(ist_table);
2587
    }
2588
    if (ost_table) {
2589
        for(i=0;i<nb_ostreams;i++) {
2590
            ost = ost_table[i];
2591
            if (ost) {
2592
                if (ost->st->stream_copy)
2593
                    av_freep(&ost->st->codec->extradata);
2594
                if (ost->logfile) {
2595
                    fclose(ost->logfile);
2596
                    ost->logfile = NULL;
2597
                }
2598
                av_fifo_free(ost->fifo); /* works even if fifo is not
2599
                                             initialized but set to zero */
2600
                av_free(ost->pict_tmp.data[0]);
2601
                if (ost->video_resample)
2602
                    sws_freeContext(ost->img_resample_ctx);
2603
                if (ost->resample)
2604
                    audio_resample_close(ost->resample);
2605
                if (ost->reformat_ctx)
2606
                    av_audio_convert_free(ost->reformat_ctx);
2607
                av_free(ost);
2608
            }
2609
        }
2610
        av_free(ost_table);
2611
    }
2612
    return ret;
2613
}
2614

    
2615
static void opt_format(const char *arg)
2616
{
2617
    /* compatibility stuff for pgmyuv */
2618
    if (!strcmp(arg, "pgmyuv")) {
2619
        pgmyuv_compatibility_hack=1;
2620
//        opt_image_format(arg);
2621
        arg = "image2";
2622
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2623
    }
2624

    
2625
    last_asked_format = arg;
2626
}
2627

    
2628
static void opt_video_rc_override_string(const char *arg)
2629
{
2630
    video_rc_override_string = arg;
2631
}
2632

    
2633
static int opt_me_threshold(const char *opt, const char *arg)
2634
{
2635
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2636
    return 0;
2637
}
2638

    
2639
static int opt_verbose(const char *opt, const char *arg)
2640
{
2641
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2642
    return 0;
2643
}
2644

    
2645
static int opt_frame_rate(const char *opt, const char *arg)
2646
{
2647
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2648
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2649
        ffmpeg_exit(1);
2650
    }
2651
    return 0;
2652
}
2653

    
2654
static int opt_bitrate(const char *opt, const char *arg)
2655
{
2656
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2657

    
2658
    opt_default(opt, arg);
2659

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

    
2663
    return 0;
2664
}
2665

    
2666
static int opt_frame_crop(const char *opt, const char *arg)
2667
{
2668
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2669
    return AVERROR(EINVAL);
2670
}
2671

    
2672
static void opt_frame_size(const char *arg)
2673
{
2674
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2675
        fprintf(stderr, "Incorrect frame size\n");
2676
        ffmpeg_exit(1);
2677
    }
2678
}
2679

    
2680
static int opt_pad(const char *opt, const char *arg) {
2681
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2682
    return -1;
2683
}
2684

    
2685
static void opt_frame_pix_fmt(const char *arg)
2686
{
2687
    if (strcmp(arg, "list")) {
2688
        frame_pix_fmt = av_get_pix_fmt(arg);
2689
        if (frame_pix_fmt == PIX_FMT_NONE) {
2690
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2691
            ffmpeg_exit(1);
2692
        }
2693
    } else {
2694
        show_pix_fmts();
2695
        ffmpeg_exit(0);
2696
    }
2697
}
2698

    
2699
static void opt_frame_aspect_ratio(const char *arg)
2700
{
2701
    int x = 0, y = 0;
2702
    double ar = 0;
2703
    const char *p;
2704
    char *end;
2705

    
2706
    p = strchr(arg, ':');
2707
    if (p) {
2708
        x = strtol(arg, &end, 10);
2709
        if (end == p)
2710
            y = strtol(end+1, &end, 10);
2711
        if (x > 0 && y > 0)
2712
            ar = (double)x / (double)y;
2713
    } else
2714
        ar = strtod(arg, NULL);
2715

    
2716
    if (!ar) {
2717
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2718
        ffmpeg_exit(1);
2719
    }
2720
    frame_aspect_ratio = ar;
2721
}
2722

    
2723
static int opt_metadata(const char *opt, const char *arg)
2724
{
2725
    char *mid= strchr(arg, '=');
2726

    
2727
    if(!mid){
2728
        fprintf(stderr, "Missing =\n");
2729
        ffmpeg_exit(1);
2730
    }
2731
    *mid++= 0;
2732

    
2733
    av_metadata_set2(&metadata, arg, mid, 0);
2734

    
2735
    return 0;
2736
}
2737

    
2738
static void opt_qscale(const char *arg)
2739
{
2740
    video_qscale = atof(arg);
2741
    if (video_qscale <= 0 ||
2742
        video_qscale > 255) {
2743
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2744
        ffmpeg_exit(1);
2745
    }
2746
}
2747

    
2748
static void opt_top_field_first(const char *arg)
2749
{
2750
    top_field_first= atoi(arg);
2751
}
2752

    
2753
static int opt_thread_count(const char *opt, const char *arg)
2754
{
2755
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2756
#if !HAVE_THREADS
2757
    if (verbose >= 0)
2758
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2759
#endif
2760
    return 0;
2761
}
2762

    
2763
static void opt_audio_sample_fmt(const char *arg)
2764
{
2765
    if (strcmp(arg, "list"))
2766
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2767
    else {
2768
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2769
        ffmpeg_exit(0);
2770
    }
2771
}
2772

    
2773
static int opt_audio_rate(const char *opt, const char *arg)
2774
{
2775
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2776
    return 0;
2777
}
2778

    
2779
static int opt_audio_channels(const char *opt, const char *arg)
2780
{
2781
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2782
    return 0;
2783
}
2784

    
2785
static void opt_video_channel(const char *arg)
2786
{
2787
    video_channel = strtol(arg, NULL, 0);
2788
}
2789

    
2790
static void opt_video_standard(const char *arg)
2791
{
2792
    video_standard = av_strdup(arg);
2793
}
2794

    
2795
static void opt_codec(int *pstream_copy, char **pcodec_name,
2796
                      int codec_type, const char *arg)
2797
{
2798
    av_freep(pcodec_name);
2799
    if (!strcmp(arg, "copy")) {
2800
        *pstream_copy = 1;
2801
    } else {
2802
        *pcodec_name = av_strdup(arg);
2803
    }
2804
}
2805

    
2806
static void opt_audio_codec(const char *arg)
2807
{
2808
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2809
}
2810

    
2811
static void opt_audio_tag(const char *arg)
2812
{
2813
    char *tail;
2814
    audio_codec_tag= strtol(arg, &tail, 0);
2815

    
2816
    if(!tail || *tail)
2817
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2818
}
2819

    
2820
static void opt_video_tag(const char *arg)
2821
{
2822
    char *tail;
2823
    video_codec_tag= strtol(arg, &tail, 0);
2824

    
2825
    if(!tail || *tail)
2826
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2827
}
2828

    
2829
static void opt_video_codec(const char *arg)
2830
{
2831
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2832
}
2833

    
2834
static void opt_subtitle_codec(const char *arg)
2835
{
2836
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2837
}
2838

    
2839
static void opt_subtitle_tag(const char *arg)
2840
{
2841
    char *tail;
2842
    subtitle_codec_tag= strtol(arg, &tail, 0);
2843

    
2844
    if(!tail || *tail)
2845
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2846
}
2847

    
2848
static void opt_map(const char *arg)
2849
{
2850
    AVStreamMap *m;
2851
    char *p;
2852

    
2853
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2854
    m = &stream_maps[nb_stream_maps-1];
2855

    
2856
    m->file_index = strtol(arg, &p, 0);
2857
    if (*p)
2858
        p++;
2859

    
2860
    m->stream_index = strtol(p, &p, 0);
2861
    if (*p) {
2862
        p++;
2863
        m->sync_file_index = strtol(p, &p, 0);
2864
        if (*p)
2865
            p++;
2866
        m->sync_stream_index = strtol(p, &p, 0);
2867
    } else {
2868
        m->sync_file_index = m->file_index;
2869
        m->sync_stream_index = m->stream_index;
2870
    }
2871
}
2872

    
2873
static void opt_map_meta_data(const char *arg)
2874
{
2875
    AVMetaDataMap *m;
2876
    char *p;
2877

    
2878
    m = &meta_data_maps[nb_meta_data_maps++];
2879

    
2880
    m->out_file = strtol(arg, &p, 0);
2881
    if (*p)
2882
        p++;
2883

    
2884
    m->in_file = strtol(p, &p, 0);
2885
}
2886

    
2887
static void opt_input_ts_scale(const char *arg)
2888
{
2889
    unsigned int stream;
2890
    double scale;
2891
    char *p;
2892

    
2893
    stream = strtol(arg, &p, 0);
2894
    if (*p)
2895
        p++;
2896
    scale= strtod(p, &p);
2897

    
2898
    if(stream >= MAX_STREAMS)
2899
        ffmpeg_exit(1);
2900

    
2901
    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);
2902
    input_files_ts_scale[nb_input_files][stream]= scale;
2903
}
2904

    
2905
static int opt_recording_time(const char *opt, const char *arg)
2906
{
2907
    recording_time = parse_time_or_die(opt, arg, 1);
2908
    return 0;
2909
}
2910

    
2911
static int opt_start_time(const char *opt, const char *arg)
2912
{
2913
    start_time = parse_time_or_die(opt, arg, 1);
2914
    return 0;
2915
}
2916

    
2917
static int opt_recording_timestamp(const char *opt, const char *arg)
2918
{
2919
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2920
    return 0;
2921
}
2922

    
2923
static int opt_input_ts_offset(const char *opt, const char *arg)
2924
{
2925
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2926
    return 0;
2927
}
2928

    
2929
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
2930
{
2931
    const char *codec_string = encoder ? "encoder" : "decoder";
2932
    AVCodec *codec;
2933

    
2934
    if(!name)
2935
        return CODEC_ID_NONE;
2936
    codec = encoder ?
2937
        avcodec_find_encoder_by_name(name) :
2938
        avcodec_find_decoder_by_name(name);
2939
    if(!codec) {
2940
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2941
        ffmpeg_exit(1);
2942
    }
2943
    if(codec->type != type) {
2944
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2945
        ffmpeg_exit(1);
2946
    }
2947
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
2948
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
2949
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
2950
                "results.\nAdd '-strict experimental' if you want to use it.\n",
2951
                codec_string, codec->name);
2952
        codec = encoder ?
2953
            avcodec_find_encoder(codec->id) :
2954
            avcodec_find_decoder(codec->id);
2955
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
2956
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
2957
                    codec_string, codec->name);
2958
        ffmpeg_exit(1);
2959
    }
2960
    return codec->id;
2961
}
2962

    
2963
static void opt_input_file(const char *filename)
2964
{
2965
    AVFormatContext *ic;
2966
    AVFormatParameters params, *ap = &params;
2967
    AVInputFormat *file_iformat = NULL;
2968
    int err, i, ret, rfps, rfps_base;
2969
    int64_t timestamp;
2970

    
2971
    if (last_asked_format) {
2972
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
2973
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2974
            ffmpeg_exit(1);
2975
        }
2976
        last_asked_format = NULL;
2977
    }
2978

    
2979
    if (!strcmp(filename, "-"))
2980
        filename = "pipe:";
2981

    
2982
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2983
                    !strcmp(filename, "/dev/stdin");
2984

    
2985
    /* get default parameters from command line */
2986
    ic = avformat_alloc_context();
2987
    if (!ic) {
2988
        print_error(filename, AVERROR(ENOMEM));
2989
        ffmpeg_exit(1);
2990
    }
2991

    
2992
    memset(ap, 0, sizeof(*ap));
2993
    ap->prealloced_context = 1;
2994
    ap->sample_rate = audio_sample_rate;
2995
    ap->channels = audio_channels;
2996
    ap->time_base.den = frame_rate.num;
2997
    ap->time_base.num = frame_rate.den;
2998
    ap->width = frame_width;
2999
    ap->height = frame_height;
3000
    ap->pix_fmt = frame_pix_fmt;
3001
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3002
    ap->channel = video_channel;
3003
    ap->standard = video_standard;
3004

    
3005
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3006

    
3007
    ic->video_codec_id   =
3008
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3009
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3010
    ic->audio_codec_id   =
3011
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3012
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3013
    ic->subtitle_codec_id=
3014
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3015
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3016
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3017

    
3018
    if(pgmyuv_compatibility_hack)
3019
        ic->video_codec_id= CODEC_ID_PGMYUV;
3020

    
3021
    /* open the input file with generic libav function */
3022
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3023
    if (err < 0) {
3024
        print_error(filename, err);
3025
        ffmpeg_exit(1);
3026
    }
3027
    if(opt_programid) {
3028
        int i, j;
3029
        int found=0;
3030
        for(i=0; i<ic->nb_streams; i++){
3031
            ic->streams[i]->discard= AVDISCARD_ALL;
3032
        }
3033
        for(i=0; i<ic->nb_programs; i++){
3034
            AVProgram *p= ic->programs[i];
3035
            if(p->id != opt_programid){
3036
                p->discard = AVDISCARD_ALL;
3037
            }else{
3038
                found=1;
3039
                for(j=0; j<p->nb_stream_indexes; j++){
3040
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3041
                }
3042
            }
3043
        }
3044
        if(!found){
3045
            fprintf(stderr, "Specified program id not found\n");
3046
            ffmpeg_exit(1);
3047
        }
3048
        opt_programid=0;
3049
    }
3050

    
3051
    ic->loop_input = loop_input;
3052

    
3053
    /* If not enough info to get the stream parameters, we decode the
3054
       first frames to get it. (used in mpeg case for example) */
3055
    ret = av_find_stream_info(ic);
3056
    if (ret < 0 && verbose >= 0) {
3057
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3058
        av_close_input_file(ic);
3059
        ffmpeg_exit(1);
3060
    }
3061

    
3062
    timestamp = start_time;
3063
    /* add the stream start time */
3064
    if (ic->start_time != AV_NOPTS_VALUE)
3065
        timestamp += ic->start_time;
3066

    
3067
    /* if seeking requested, we execute it */
3068
    if (start_time != 0) {
3069
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3070
        if (ret < 0) {
3071
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3072
                    filename, (double)timestamp / AV_TIME_BASE);
3073
        }
3074
        /* reset seek info */
3075
        start_time = 0;
3076
    }
3077

    
3078
    /* update the current parameters so that they match the one of the input stream */
3079
    for(i=0;i<ic->nb_streams;i++) {
3080
        AVStream *st = ic->streams[i];
3081
        AVCodecContext *dec = st->codec;
3082
        avcodec_thread_init(dec, thread_count);
3083
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3084
        switch (dec->codec_type) {
3085
        case AVMEDIA_TYPE_AUDIO:
3086
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3087
            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]);
3088
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3089
            channel_layout    = dec->channel_layout;
3090
            audio_channels    = dec->channels;
3091
            audio_sample_rate = dec->sample_rate;
3092
            audio_sample_fmt  = dec->sample_fmt;
3093
            if(audio_disable)
3094
                st->discard= AVDISCARD_ALL;
3095
            /* Note that av_find_stream_info can add more streams, and we
3096
             * currently have no chance of setting up lowres decoding
3097
             * early enough for them. */
3098
            if (dec->lowres)
3099
                audio_sample_rate >>= dec->lowres;
3100
            break;
3101
        case AVMEDIA_TYPE_VIDEO:
3102
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3103
            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]);
3104
            frame_height = dec->height;
3105
            frame_width  = dec->width;
3106
            if(ic->streams[i]->sample_aspect_ratio.num)
3107
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3108
            else
3109
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3110
            frame_aspect_ratio *= (float) dec->width / dec->height;
3111
            frame_pix_fmt = dec->pix_fmt;
3112
            rfps      = ic->streams[i]->r_frame_rate.num;
3113
            rfps_base = ic->streams[i]->r_frame_rate.den;
3114
            if (dec->lowres) {
3115
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3116
                frame_height >>= dec->lowres;
3117
                frame_width  >>= dec->lowres;
3118
            }
3119
            if(me_threshold)
3120
                dec->debug |= FF_DEBUG_MV;
3121

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

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

    
3128
                    (float)rfps / rfps_base, rfps, rfps_base);
3129
            }
3130
            /* update the current frame rate to match the stream frame rate */
3131
            frame_rate.num = rfps;
3132
            frame_rate.den = rfps_base;
3133

    
3134
            if(video_disable)
3135
                st->discard= AVDISCARD_ALL;
3136
            else if(video_discard)
3137
                st->discard= video_discard;
3138
            break;
3139
        case AVMEDIA_TYPE_DATA:
3140
            break;
3141
        case AVMEDIA_TYPE_SUBTITLE:
3142
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3143
            if(subtitle_disable)
3144
                st->discard = AVDISCARD_ALL;
3145
            break;
3146
        case AVMEDIA_TYPE_ATTACHMENT:
3147
        case AVMEDIA_TYPE_UNKNOWN:
3148
            break;
3149
        default:
3150
            abort();
3151
        }
3152
    }
3153

    
3154
    input_files[nb_input_files] = ic;
3155
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3156
    /* dump the file content */
3157
    if (verbose >= 0)
3158
        dump_format(ic, nb_input_files, filename, 0);
3159

    
3160
    nb_input_files++;
3161

    
3162
    video_channel = 0;
3163

    
3164
    av_freep(&video_codec_name);
3165
    av_freep(&audio_codec_name);
3166
    av_freep(&subtitle_codec_name);
3167
}
3168

    
3169
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3170
                                         int *has_subtitle_ptr)
3171
{
3172
    int has_video, has_audio, has_subtitle, i, j;
3173
    AVFormatContext *ic;
3174

    
3175
    has_video = 0;
3176
    has_audio = 0;
3177
    has_subtitle = 0;
3178
    for(j=0;j<nb_input_files;j++) {
3179
        ic = input_files[j];
3180
        for(i=0;i<ic->nb_streams;i++) {
3181
            AVCodecContext *enc = ic->streams[i]->codec;
3182
            switch(enc->codec_type) {
3183
            case AVMEDIA_TYPE_AUDIO:
3184
                has_audio = 1;
3185
                break;
3186
            case AVMEDIA_TYPE_VIDEO:
3187
                has_video = 1;
3188
                break;
3189
            case AVMEDIA_TYPE_SUBTITLE:
3190
                has_subtitle = 1;
3191
                break;
3192
            case AVMEDIA_TYPE_DATA:
3193
            case AVMEDIA_TYPE_ATTACHMENT:
3194
            case AVMEDIA_TYPE_UNKNOWN:
3195
                break;
3196
            default:
3197
                abort();
3198
            }
3199
        }
3200
    }
3201
    *has_video_ptr = has_video;
3202
    *has_audio_ptr = has_audio;
3203
    *has_subtitle_ptr = has_subtitle;
3204
}
3205

    
3206
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
3207
{
3208
    int idx = oc->nb_streams - 1;
3209
    AVOutputStream *ost;
3210

    
3211
    output_streams_for_file[file_idx] =
3212
        grow_array(output_streams_for_file[file_idx],
3213
                   sizeof(*output_streams_for_file[file_idx]),
3214
                   &nb_output_streams_for_file[file_idx],
3215
                   oc->nb_streams);
3216
    ost = output_streams_for_file[file_idx][idx] =
3217
        av_mallocz(sizeof(AVOutputStream));
3218
    if (!ost) {
3219
        fprintf(stderr, "Could not alloc output stream\n");
3220
        ffmpeg_exit(1);
3221
    }
3222
    ost->file_index = file_idx;
3223
    ost->index = idx;
3224
    return ost;
3225
}
3226

    
3227
static void new_video_stream(AVFormatContext *oc, int file_idx)
3228
{
3229
    AVStream *st;
3230
    AVOutputStream *ost;
3231
    AVCodecContext *video_enc;
3232
    enum CodecID codec_id;
3233
    AVCodec *codec= NULL;
3234

    
3235
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3236
    if (!st) {
3237
        fprintf(stderr, "Could not alloc stream\n");
3238
        ffmpeg_exit(1);
3239
    }
3240
    ost = new_output_stream(oc, file_idx);
3241

    
3242
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3243
    if(!video_stream_copy){
3244
        if (video_codec_name) {
3245
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3246
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3247
            codec = avcodec_find_encoder_by_name(video_codec_name);
3248
            output_codecs[nb_output_codecs-1] = codec;
3249
        } else {
3250
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3251
            codec = avcodec_find_encoder(codec_id);
3252
        }
3253
    }
3254

    
3255
    avcodec_get_context_defaults3(st->codec, codec);
3256
    ost->bitstream_filters = video_bitstream_filters;
3257
    video_bitstream_filters= NULL;
3258

    
3259
    avcodec_thread_init(st->codec, thread_count);
3260

    
3261
    video_enc = st->codec;
3262

    
3263
    if(video_codec_tag)
3264
        video_enc->codec_tag= video_codec_tag;
3265

    
3266
    if(   (video_global_header&1)
3267
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3268
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3269
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3270
    }
3271
    if(video_global_header&2){
3272
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3273
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3274
    }
3275

    
3276
    if (video_stream_copy) {
3277
        st->stream_copy = 1;
3278
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3279
        video_enc->sample_aspect_ratio =
3280
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3281
    } else {
3282
        const char *p;
3283
        int i;
3284
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3285

    
3286
        video_enc->codec_id = codec_id;
3287
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3288

    
3289
        if (codec && codec->supported_framerates && !force_fps)
3290
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3291
        video_enc->time_base.den = fps.num;
3292
        video_enc->time_base.num = fps.den;
3293

    
3294
        video_enc->width = frame_width;
3295
        video_enc->height = frame_height;
3296
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3297
        video_enc->pix_fmt = frame_pix_fmt;
3298
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3299

    
3300
        choose_pixel_fmt(st, codec);
3301

    
3302
        if (intra_only)
3303
            video_enc->gop_size = 0;
3304
        if (video_qscale || same_quality) {
3305
            video_enc->flags |= CODEC_FLAG_QSCALE;
3306
            video_enc->global_quality=
3307
                st->quality = FF_QP2LAMBDA * video_qscale;
3308
        }
3309

    
3310
        if(intra_matrix)
3311
            video_enc->intra_matrix = intra_matrix;
3312
        if(inter_matrix)
3313
            video_enc->inter_matrix = inter_matrix;
3314

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

    
3345
        if (do_psnr)
3346
            video_enc->flags|= CODEC_FLAG_PSNR;
3347

    
3348
        /* two pass mode */
3349
        if (do_pass) {
3350
            if (do_pass == 1) {
3351
                video_enc->flags |= CODEC_FLAG_PASS1;
3352
            } else {
3353
                video_enc->flags |= CODEC_FLAG_PASS2;
3354
            }
3355
        }
3356
    }
3357
    if (video_language) {
3358
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3359
        av_freep(&video_language);
3360
    }
3361

    
3362
    /* reset some key parameters */
3363
    video_disable = 0;
3364
    av_freep(&video_codec_name);
3365
    video_stream_copy = 0;
3366
    frame_pix_fmt = PIX_FMT_NONE;
3367
}
3368

    
3369
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3370
{
3371
    AVStream *st;
3372
    AVOutputStream *ost;
3373
    AVCodec *codec= NULL;
3374
    AVCodecContext *audio_enc;
3375
    enum CodecID codec_id;
3376

    
3377
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3378
    if (!st) {
3379
        fprintf(stderr, "Could not alloc stream\n");
3380
        ffmpeg_exit(1);
3381
    }
3382
    ost = new_output_stream(oc, file_idx);
3383

    
3384
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3385
    if(!audio_stream_copy){
3386
        if (audio_codec_name) {
3387
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3388
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3389
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3390
            output_codecs[nb_output_codecs-1] = codec;
3391
        } else {
3392
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3393
            codec = avcodec_find_encoder(codec_id);
3394
        }
3395
    }
3396

    
3397
    avcodec_get_context_defaults3(st->codec, codec);
3398

    
3399
    ost->bitstream_filters = audio_bitstream_filters;
3400
    audio_bitstream_filters= NULL;
3401

    
3402
    avcodec_thread_init(st->codec, thread_count);
3403

    
3404
    audio_enc = st->codec;
3405
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3406

    
3407
    if(audio_codec_tag)
3408
        audio_enc->codec_tag= audio_codec_tag;
3409

    
3410
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3411
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3412
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3413
    }
3414
    if (audio_stream_copy) {
3415
        st->stream_copy = 1;
3416
        audio_enc->channels = audio_channels;
3417
        audio_enc->sample_rate = audio_sample_rate;
3418
    } else {
3419
        audio_enc->codec_id = codec_id;
3420
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3421

    
3422
        if (audio_qscale > QSCALE_NONE) {
3423
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3424
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3425
        }
3426
        audio_enc->channels = audio_channels;
3427
        audio_enc->sample_fmt = audio_sample_fmt;
3428
        audio_enc->sample_rate = audio_sample_rate;
3429
        audio_enc->channel_layout = channel_layout;
3430
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3431
            audio_enc->channel_layout = 0;
3432
        choose_sample_fmt(st, codec);
3433
        choose_sample_rate(st, codec);
3434
    }
3435
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3436
    if (audio_language) {
3437
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3438
        av_freep(&audio_language);
3439
    }
3440

    
3441
    /* reset some key parameters */
3442
    audio_disable = 0;
3443
    av_freep(&audio_codec_name);
3444
    audio_stream_copy = 0;
3445
}
3446

    
3447
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3448
{
3449
    AVStream *st;
3450
    AVOutputStream *ost;
3451
    AVCodec *codec=NULL;
3452
    AVCodecContext *subtitle_enc;
3453

    
3454
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3455
    if (!st) {
3456
        fprintf(stderr, "Could not alloc stream\n");
3457
        ffmpeg_exit(1);
3458
    }
3459
    ost = new_output_stream(oc, file_idx);
3460
    subtitle_enc = st->codec;
3461
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3462
    if(!subtitle_stream_copy){
3463
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3464
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3465
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3466
    }
3467
    avcodec_get_context_defaults3(st->codec, codec);
3468

    
3469
    ost->bitstream_filters = subtitle_bitstream_filters;
3470
    subtitle_bitstream_filters= NULL;
3471

    
3472
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3473

    
3474
    if(subtitle_codec_tag)
3475
        subtitle_enc->codec_tag= subtitle_codec_tag;
3476

    
3477
    if (subtitle_stream_copy) {
3478
        st->stream_copy = 1;
3479
    } else {
3480
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3481
    }
3482

    
3483
    if (subtitle_language) {
3484
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3485
        av_freep(&subtitle_language);
3486
    }
3487

    
3488
    subtitle_disable = 0;
3489
    av_freep(&subtitle_codec_name);
3490
    subtitle_stream_copy = 0;
3491
}
3492

    
3493
static int opt_new_stream(const char *opt, const char *arg)
3494
{
3495
    AVFormatContext *oc;
3496
    int file_idx = nb_output_files - 1;
3497
    if (nb_output_files <= 0) {
3498
        fprintf(stderr, "At least one output file must be specified\n");
3499
        ffmpeg_exit(1);
3500
    }
3501
    oc = output_files[file_idx];
3502

    
3503
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3504
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3505
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3506
    else av_assert0(0);
3507
    return 0;
3508
}
3509

    
3510
/* arg format is "output-stream-index:streamid-value". */
3511
static int opt_streamid(const char *opt, const char *arg)
3512
{
3513
    int idx;
3514
    char *p;
3515
    char idx_str[16];
3516

    
3517
    strncpy(idx_str, arg, sizeof(idx_str));
3518
    idx_str[sizeof(idx_str)-1] = '\0';
3519
    p = strchr(idx_str, ':');
3520
    if (!p) {
3521
        fprintf(stderr,
3522
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3523
                arg, opt);
3524
        ffmpeg_exit(1);
3525
    }
3526
    *p++ = '\0';
3527
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3528
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3529
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3530
    return 0;
3531
}
3532

    
3533
static void opt_output_file(const char *filename)
3534
{
3535
    AVFormatContext *oc;
3536
    int err, use_video, use_audio, use_subtitle;
3537
    int input_has_video, input_has_audio, input_has_subtitle;
3538
    AVFormatParameters params, *ap = &params;
3539
    AVOutputFormat *file_oformat;
3540
    AVMetadataTag *tag = NULL;
3541

    
3542
    if (!strcmp(filename, "-"))
3543
        filename = "pipe:";
3544

    
3545
    oc = avformat_alloc_context();
3546
    if (!oc) {
3547
        print_error(filename, AVERROR(ENOMEM));
3548
        ffmpeg_exit(1);
3549
    }
3550

    
3551
    if (last_asked_format) {
3552
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3553
        if (!file_oformat) {
3554
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3555
            ffmpeg_exit(1);
3556
        }
3557
        last_asked_format = NULL;
3558
    } else {
3559
        file_oformat = av_guess_format(NULL, filename, NULL);
3560
        if (!file_oformat) {
3561
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3562
                    filename);
3563
            ffmpeg_exit(1);
3564
        }
3565
    }
3566

    
3567
    oc->oformat = file_oformat;
3568
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3569

    
3570
    if (!strcmp(file_oformat->name, "ffm") &&
3571
        av_strstart(filename, "http:", NULL)) {
3572
        /* special case for files sent to ffserver: we get the stream
3573
           parameters from ffserver */
3574
        int err = read_ffserver_streams(oc, filename);
3575
        if (err < 0) {
3576
            print_error(filename, err);
3577
            ffmpeg_exit(1);
3578
        }
3579
    } else {
3580
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3581
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3582
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3583

    
3584
        /* disable if no corresponding type found and at least one
3585
           input file */
3586
        if (nb_input_files > 0) {
3587
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3588
                                         &input_has_subtitle);
3589
            if (!input_has_video)
3590
                use_video = 0;
3591
            if (!input_has_audio)
3592
                use_audio = 0;
3593
            if (!input_has_subtitle)
3594
                use_subtitle = 0;
3595
        }
3596

    
3597
        /* manual disable */
3598
        if (audio_disable)    use_audio    = 0;
3599
        if (video_disable)    use_video    = 0;
3600
        if (subtitle_disable) use_subtitle = 0;
3601

    
3602
        if (use_video)    new_video_stream(oc, nb_output_files);
3603
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3604
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3605

    
3606
        oc->timestamp = recording_timestamp;
3607

    
3608
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3609
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3610
        av_metadata_free(&metadata);
3611
    }
3612

    
3613
    output_files[nb_output_files++] = oc;
3614

    
3615
    /* check filename in case of an image number is expected */
3616
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3617
        if (!av_filename_number_test(oc->filename)) {
3618
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3619
            ffmpeg_exit(1);
3620
        }
3621
    }
3622

    
3623
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3624
        /* test if it already exists to avoid loosing precious files */
3625
        if (!file_overwrite &&
3626
            (strchr(filename, ':') == NULL ||
3627
             filename[1] == ':' ||
3628
             av_strstart(filename, "file:", NULL))) {
3629
            if (url_exist(filename)) {
3630
                if (!using_stdin) {
3631
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3632
                    fflush(stderr);
3633
                    if (!read_yesno()) {
3634
                        fprintf(stderr, "Not overwriting - exiting\n");
3635
                        ffmpeg_exit(1);
3636
                    }
3637
                }
3638
                else {
3639
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3640
                    ffmpeg_exit(1);
3641
                }
3642
            }
3643
        }
3644

    
3645
        /* open the file */
3646
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3647
            print_error(filename, err);
3648
            ffmpeg_exit(1);
3649
        }
3650
    }
3651

    
3652
    memset(ap, 0, sizeof(*ap));
3653
    if (av_set_parameters(oc, ap) < 0) {
3654
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3655
                oc->filename);
3656
        ffmpeg_exit(1);
3657
    }
3658

    
3659
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3660
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3661
    oc->loop_output = loop_output;
3662
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3663

    
3664
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3665

    
3666
    nb_streamid_map = 0;
3667
}
3668

    
3669
/* same option as mencoder */
3670
static void opt_pass(const char *pass_str)
3671
{
3672
    int pass;
3673
    pass = atoi(pass_str);
3674
    if (pass != 1 && pass != 2) {
3675
        fprintf(stderr, "pass number can be only 1 or 2\n");
3676
        ffmpeg_exit(1);
3677
    }
3678
    do_pass = pass;
3679
}
3680

    
3681
static int64_t getutime(void)
3682
{
3683
#if HAVE_GETRUSAGE
3684
    struct rusage rusage;
3685

    
3686
    getrusage(RUSAGE_SELF, &rusage);
3687
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3688
#elif HAVE_GETPROCESSTIMES
3689
    HANDLE proc;
3690
    FILETIME c, e, k, u;
3691
    proc = GetCurrentProcess();
3692
    GetProcessTimes(proc, &c, &e, &k, &u);
3693
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3694
#else
3695
    return av_gettime();
3696
#endif
3697
}
3698

    
3699
static int64_t getmaxrss(void)
3700
{
3701
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3702
    struct rusage rusage;
3703
    getrusage(RUSAGE_SELF, &rusage);
3704
    return (int64_t)rusage.ru_maxrss * 1024;
3705
#elif HAVE_GETPROCESSMEMORYINFO
3706
    HANDLE proc;
3707
    PROCESS_MEMORY_COUNTERS memcounters;
3708
    proc = GetCurrentProcess();
3709
    memcounters.cb = sizeof(memcounters);
3710
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3711
    return memcounters.PeakPagefileUsage;
3712
#else
3713
    return 0;
3714
#endif
3715
}
3716

    
3717
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3718
{
3719
    int i;
3720
    const char *p = str;
3721
    for(i = 0;; i++) {
3722
        dest[i] = atoi(p);
3723
        if(i == 63)
3724
            break;
3725
        p = strchr(p, ',');
3726
        if(!p) {
3727
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3728
            ffmpeg_exit(1);
3729
        }
3730
        p++;
3731
    }
3732
}
3733

    
3734
static void opt_inter_matrix(const char *arg)
3735
{
3736
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3737
    parse_matrix_coeffs(inter_matrix, arg);
3738
}
3739

    
3740
static void opt_intra_matrix(const char *arg)
3741
{
3742
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3743
    parse_matrix_coeffs(intra_matrix, arg);
3744
}
3745

    
3746
static void show_usage(void)
3747
{
3748
    printf("Hyper fast Audio and Video encoder\n");
3749
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3750
    printf("\n");
3751
}
3752

    
3753
static void show_help(void)
3754
{
3755
    av_log_set_callback(log_callback_help);
3756
    show_usage();
3757
    show_help_options(options, "Main options:\n",
3758
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3759
    show_help_options(options, "\nAdvanced options:\n",
3760
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3761
                      OPT_EXPERT);
3762
    show_help_options(options, "\nVideo options:\n",
3763
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3764
                      OPT_VIDEO);
3765
    show_help_options(options, "\nAdvanced Video options:\n",
3766
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3767
                      OPT_VIDEO | OPT_EXPERT);
3768
    show_help_options(options, "\nAudio options:\n",
3769
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3770
                      OPT_AUDIO);
3771
    show_help_options(options, "\nAdvanced Audio options:\n",
3772
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3773
                      OPT_AUDIO | OPT_EXPERT);
3774
    show_help_options(options, "\nSubtitle options:\n",
3775
                      OPT_SUBTITLE | OPT_GRAB,
3776
                      OPT_SUBTITLE);
3777
    show_help_options(options, "\nAudio/Video grab options:\n",
3778
                      OPT_GRAB,
3779
                      OPT_GRAB);
3780
    printf("\n");
3781
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3782
    printf("\n");
3783
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3784
    printf("\n");
3785
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3786
}
3787

    
3788
static void opt_target(const char *arg)
3789
{
3790
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3791
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3792

    
3793
    if(!strncmp(arg, "pal-", 4)) {
3794
        norm = PAL;
3795
        arg += 4;
3796
    } else if(!strncmp(arg, "ntsc-", 5)) {
3797
        norm = NTSC;
3798
        arg += 5;
3799
    } else if(!strncmp(arg, "film-", 5)) {
3800
        norm = FILM;
3801
        arg += 5;
3802
    } else {
3803
        int fr;
3804
        /* Calculate FR via float to avoid int overflow */
3805
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3806
        if(fr == 25000) {
3807
            norm = PAL;
3808
        } else if((fr == 29970) || (fr == 23976)) {
3809
            norm = NTSC;
3810
        } else {
3811
            /* Try to determine PAL/NTSC by peeking in the input files */
3812
            if(nb_input_files) {
3813
                int i, j;
3814
                for(j = 0; j < nb_input_files; j++) {
3815
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3816
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3817
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3818
                            continue;
3819
                        fr = c->time_base.den * 1000 / c->time_base.num;
3820
                        if(fr == 25000) {
3821
                            norm = PAL;
3822
                            break;
3823
                        } else if((fr == 29970) || (fr == 23976)) {
3824
                            norm = NTSC;
3825
                            break;
3826
                        }
3827
                    }
3828
                    if(norm != UNKNOWN)
3829
                        break;
3830
                }
3831
            }
3832
        }
3833
        if(verbose && norm != UNKNOWN)
3834
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3835
    }
3836

    
3837
    if(norm == UNKNOWN) {
3838
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3839
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3840
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3841
        ffmpeg_exit(1);
3842
    }
3843

    
3844
    if(!strcmp(arg, "vcd")) {
3845

    
3846
        opt_video_codec("mpeg1video");
3847
        opt_audio_codec("mp2");
3848
        opt_format("vcd");
3849

    
3850
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3851
        opt_frame_rate(NULL, frame_rates[norm]);
3852
        opt_default("g", norm == PAL ? "15" : "18");
3853

    
3854
        opt_default("b", "1150000");
3855
        opt_default("maxrate", "1150000");
3856
        opt_default("minrate", "1150000");
3857
        opt_default("bufsize", "327680"); // 40*1024*8;
3858

    
3859
        opt_default("ab", "224000");
3860
        audio_sample_rate = 44100;
3861
        audio_channels = 2;
3862

    
3863
        opt_default("packetsize", "2324");
3864
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3865

    
3866
        /* We have to offset the PTS, so that it is consistent with the SCR.
3867
           SCR starts at 36000, but the first two packs contain only padding
3868
           and the first pack from the other stream, respectively, may also have
3869
           been written before.
3870
           So the real data starts at SCR 36000+3*1200. */
3871
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3872
    } else if(!strcmp(arg, "svcd")) {
3873

    
3874
        opt_video_codec("mpeg2video");
3875
        opt_audio_codec("mp2");
3876
        opt_format("svcd");
3877

    
3878
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3879
        opt_frame_rate(NULL, frame_rates[norm]);
3880
        opt_default("g", norm == PAL ? "15" : "18");
3881

    
3882
        opt_default("b", "2040000");
3883
        opt_default("maxrate", "2516000");
3884
        opt_default("minrate", "0"); //1145000;
3885
        opt_default("bufsize", "1835008"); //224*1024*8;
3886
        opt_default("flags", "+scan_offset");
3887

    
3888

    
3889
        opt_default("ab", "224000");
3890
        audio_sample_rate = 44100;
3891

    
3892
        opt_default("packetsize", "2324");
3893

    
3894
    } else if(!strcmp(arg, "dvd")) {
3895

    
3896
        opt_video_codec("mpeg2video");
3897
        opt_audio_codec("ac3");
3898
        opt_format("dvd");
3899

    
3900
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3901
        opt_frame_rate(NULL, frame_rates[norm]);
3902
        opt_default("g", norm == PAL ? "15" : "18");
3903

    
3904
        opt_default("b", "6000000");
3905
        opt_default("maxrate", "9000000");
3906
        opt_default("minrate", "0"); //1500000;
3907
        opt_default("bufsize", "1835008"); //224*1024*8;
3908

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

    
3912
        opt_default("ab", "448000");
3913
        audio_sample_rate = 48000;
3914

    
3915
    } else if(!strncmp(arg, "dv", 2)) {
3916

    
3917
        opt_format("dv");
3918

    
3919
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3920
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3921
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3922
        opt_frame_rate(NULL, frame_rates[norm]);
3923

    
3924
        audio_sample_rate = 48000;
3925
        audio_channels = 2;
3926

    
3927
    } else {
3928
        fprintf(stderr, "Unknown target: %s\n", arg);
3929
        ffmpeg_exit(1);
3930
    }
3931
}
3932

    
3933
static void opt_vstats_file (const char *arg)
3934
{
3935
    av_free (vstats_filename);
3936
    vstats_filename=av_strdup (arg);
3937
}
3938

    
3939
static void opt_vstats (void)
3940
{
3941
    char filename[40];
3942
    time_t today2 = time(NULL);
3943
    struct tm *today = localtime(&today2);
3944

    
3945
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3946
             today->tm_sec);
3947
    opt_vstats_file(filename);
3948
}
3949

    
3950
static int opt_bsf(const char *opt, const char *arg)
3951
{
3952
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3953
    AVBitStreamFilterContext **bsfp;
3954

    
3955
    if(!bsfc){
3956
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3957
        ffmpeg_exit(1);
3958
    }
3959

    
3960
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3961
          *opt == 'a' ? &audio_bitstream_filters :
3962
                        &subtitle_bitstream_filters;
3963
    while(*bsfp)
3964
        bsfp= &(*bsfp)->next;
3965

    
3966
    *bsfp= bsfc;
3967

    
3968
    return 0;
3969
}
3970

    
3971
static int opt_preset(const char *opt, const char *arg)
3972
{
3973
    FILE *f=NULL;
3974
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3975
    int i;
3976
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
3977
                           getenv("HOME"),
3978
                           FFMPEG_DATADIR,
3979
                         };
3980

    
3981
    if (*opt != 'f') {
3982
        for(i=0; i<3 && !f; i++){
3983
            if(!base[i])
3984
                continue;
3985
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
3986
            f= fopen(filename, "r");
3987
            if(!f){
3988
                char *codec_name= *opt == 'v' ? video_codec_name :
3989
                                  *opt == 'a' ? audio_codec_name :
3990
                                                subtitle_codec_name;
3991
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
3992
                f= fopen(filename, "r");
3993
            }
3994
        }
3995
    } else {
3996
        av_strlcpy(filename, arg, sizeof(filename));
3997
        f= fopen(filename, "r");
3998
    }
3999

    
4000
    if(!f){
4001
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4002
        ffmpeg_exit(1);
4003
    }
4004

    
4005
    while(!feof(f)){
4006
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4007
        if(line[0] == '#' && !e)
4008
            continue;
4009
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4010
        if(e){
4011
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4012
            ffmpeg_exit(1);
4013
        }
4014
        if(!strcmp(tmp, "acodec")){
4015
            opt_audio_codec(tmp2);
4016
        }else if(!strcmp(tmp, "vcodec")){
4017
            opt_video_codec(tmp2);
4018
        }else if(!strcmp(tmp, "scodec")){
4019
            opt_subtitle_codec(tmp2);
4020
        }else if(opt_default(tmp, tmp2) < 0){
4021
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4022
            ffmpeg_exit(1);
4023
        }
4024
    }
4025

    
4026
    fclose(f);
4027

    
4028
    return 0;
4029
}
4030

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

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

    
4118
    /* audio options */
4119
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4120
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4121
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4122
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4123
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4124
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4125
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4126
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4127
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4128
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4129
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4130
    { "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" },
4131

    
4132
    /* subtitle options */
4133
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4134
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4135
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4136
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4137
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4138

    
4139
    /* grab options */
4140
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4141
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4142
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4143

    
4144
    /* muxer options */
4145
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4146
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4147

    
4148
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4149
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4150
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4151

    
4152
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4153
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4154
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4155
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4156

    
4157
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4158
    { NULL, },
4159
};
4160

    
4161
int main(int argc, char **argv)
4162
{
4163
    int64_t ti;
4164

    
4165
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4166

    
4167
    avcodec_register_all();
4168
#if CONFIG_AVDEVICE
4169
    avdevice_register_all();
4170
#endif
4171
#if CONFIG_AVFILTER
4172
    avfilter_register_all();
4173
#endif
4174
    av_register_all();
4175

    
4176
#if HAVE_ISATTY
4177
    if(isatty(STDIN_FILENO))
4178
        url_set_interrupt_cb(decode_interrupt_cb);
4179
#endif
4180

    
4181
    init_opts();
4182

    
4183
    show_banner();
4184

    
4185
    /* parse options */
4186
    parse_options(argc, argv, options, opt_output_file);
4187

    
4188
    if(nb_output_files <= 0 && nb_input_files == 0) {
4189
        show_usage();
4190
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4191
        ffmpeg_exit(1);
4192
    }
4193

    
4194
    /* file converter / grab */
4195
    if (nb_output_files <= 0) {
4196
        fprintf(stderr, "At least one output file must be specified\n");
4197
        ffmpeg_exit(1);
4198
    }
4199

    
4200
    if (nb_input_files == 0) {
4201
        fprintf(stderr, "At least one input file must be specified\n");
4202
        ffmpeg_exit(1);
4203
    }
4204

    
4205
    ti = getutime();
4206
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4207
                  stream_maps, nb_stream_maps) < 0)
4208
        ffmpeg_exit(1);
4209
    ti = getutime() - ti;
4210
    if (do_benchmark) {
4211
        int maxrss = getmaxrss() / 1024;
4212
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4213
    }
4214

    
4215
    return ffmpeg_exit(0);
4216
}