Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0d0778b0

History | View | Annotate | Download (154 KB)

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

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

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavcore/parseutils.h"
40
#include "libavutil/colorspace.h"
41
#include "libavutil/fifo.h"
42
#include "libavutil/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 = NULL;
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
static char *forced_key_frames = NULL;
229

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

    
233
static unsigned int sws_flags = SWS_BICUBIC;
234

    
235
static int64_t timer_start;
236

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

    
241
static short *samples;
242

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

    
247
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
248

    
249
struct AVInputStream;
250

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

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

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

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

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

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

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

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

    
325
#if HAVE_TERMIOS_H
326

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

    
331
#if CONFIG_AVFILTER
332

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

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

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

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

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

    
362
    last_filter = ist->input_video_filter;
363

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

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

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

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

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

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

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

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

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

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

    
422
static volatile int received_sigterm = 0;
423

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
543
    av_free(video_standard);
544

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

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

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

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

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

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

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

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

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

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

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

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

    
672
        s->nb_streams++;
673

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

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

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

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

    
706
        new_output_stream(s, nb_output_files);
707
    }
708

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

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

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

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

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

    
745
        bsfc= bsfc->next;
746
    }
747

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

    
755
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
756

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1104
    *frame_size = 0;
1105

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1328

    
1329
    oc = output_files[0];
1330

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

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

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

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

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

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

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

    
1409
        fflush(stderr);
1410
    }
1411

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1656
                        av_init_packet(&opkt);
1657

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1846

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2327
    /* set meta data information from input file if required */
2328
    for (i=0;i<nb_meta_data_maps;i++) {
2329
        AVFormatContext *out_file;
2330
        AVFormatContext *in_file;
2331
        AVMetadataTag *mtag;
2332

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

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

    
2351

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

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

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

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

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

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

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

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

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

    
2420
    timer_start = av_gettime();
2421

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2561
    discard_packet:
2562
        av_free_packet(&pkt);
2563

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

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

    
2576
    term_exit();
2577

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

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

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

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

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

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

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

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

    
2662
    last_asked_format = arg;
2663
}
2664

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

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

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

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

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

    
2695
    opt_default(opt, arg);
2696

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

    
2700
    return 0;
2701
}
2702

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

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

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

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

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

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

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

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

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

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

    
2772
    return 0;
2773
}
2774

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2869
    *codec_tag = strtol(arg, &tail, 0);
2870
    if (!tail || *tail)
2871
        *codec_tag = arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2872

    
2873
    return 0;
2874
}
2875

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3081
    ic->loop_input = loop_input;
3082

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

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

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

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

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

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

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

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

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

    
3190
    nb_input_files++;
3191

    
3192
    video_channel = 0;
3193

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

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

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

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

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

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

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

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

    
3270
    video_enc = st->codec;
3271

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

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

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

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

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

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

    
3309
        choose_pixel_fmt(st, codec);
3310

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3485
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3486

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3619
        oc->timestamp = recording_timestamp;
3620

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

    
3626
    output_files[nb_output_files++] = oc;
3627

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3902

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

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

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

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

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

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

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

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

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

    
3931
        opt_format("dv");
3932

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

    
3938
        audio_sample_rate = 48000;
3939
        audio_channels = 2;
3940

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

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

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

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

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

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

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

    
3980
    *bsfp= bsfc;
3981

    
3982
    return 0;
3983
}
3984

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

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

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

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

    
4040
    fclose(f);
4041

    
4042
    return 0;
4043
}
4044

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

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

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

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

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

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

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

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

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

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

    
4180
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4181

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

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

    
4196
    init_opts();
4197

    
4198
    show_banner();
4199

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

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

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

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

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

    
4230
    return ffmpeg_exit(0);
4231
}