Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ d0242e74

History | View | Annotate | Download (153 KB)

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

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

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

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

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

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

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

    
80
#include "cmdutils.h"
81

    
82
#include "libavutil/avassert.h"
83

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

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

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

    
103
static const OptionDef options[];
104

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

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

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

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

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

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

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

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

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

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

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

    
208
static int rate_emu = 0;
209

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

    
213
static int audio_volume = 256;
214

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

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

    
542
    av_free(video_standard);
543

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

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

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

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

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

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

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

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

    
635
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
636
{
637
    int i, err;
638
    AVFormatContext *ic;
639
    int nopts = 0;
640

    
641
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
642
    if (err < 0)
643
        return err;
644
    /* copy stream format */
645
    s->nb_streams = ic->nb_streams;
646
    for(i=0;i<ic->nb_streams;i++) {
647
        AVStream *st;
648
        AVCodec *codec;
649

    
650
        // FIXME: a more elegant solution is needed
651
        st = av_mallocz(sizeof(AVStream));
652
        memcpy(st, ic->streams[i], sizeof(AVStream));
653
        st->codec = avcodec_alloc_context();
654
        if (!st->codec) {
655
            print_error(filename, AVERROR(ENOMEM));
656
            ffmpeg_exit(1);
657
        }
658
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
659
        s->streams[i] = st;
660

    
661
        codec = avcodec_find_encoder(st->codec->codec_id);
662
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
663
            if (audio_stream_copy) {
664
                st->stream_copy = 1;
665
            } else
666
                choose_sample_fmt(st, codec);
667
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
668
            if (video_stream_copy) {
669
                st->stream_copy = 1;
670
            } else
671
                choose_pixel_fmt(st, codec);
672
        }
673

    
674
        if(!st->codec->thread_count)
675
            st->codec->thread_count = 1;
676
        if(st->codec->thread_count>1)
677
            avcodec_thread_init(st->codec, st->codec->thread_count);
678

    
679
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
680
            nopts = 1;
681
    }
682

    
683
    if (!nopts)
684
        s->timestamp = av_gettime();
685

    
686
    av_close_input_file(ic);
687
    return 0;
688
}
689

    
690
static double
691
get_sync_ipts(const AVOutputStream *ost)
692
{
693
    const AVInputStream *ist = ost->sync_ist;
694
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
695
}
696

    
697
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
698
    int ret;
699

    
700
    while(bsfc){
701
        AVPacket new_pkt= *pkt;
702
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
703
                                          &new_pkt.data, &new_pkt.size,
704
                                          pkt->data, pkt->size,
705
                                          pkt->flags & AV_PKT_FLAG_KEY);
706
        if(a>0){
707
            av_free_packet(pkt);
708
            new_pkt.destruct= av_destruct_packet;
709
        } else if(a<0){
710
            fprintf(stderr, "%s failed for stream %d, codec %s",
711
                    bsfc->filter->name, pkt->stream_index,
712
                    avctx->codec ? avctx->codec->name : "copy");
713
            print_error("", a);
714
            if (exit_on_error)
715
                ffmpeg_exit(1);
716
        }
717
        *pkt= new_pkt;
718

    
719
        bsfc= bsfc->next;
720
    }
721

    
722
    ret= av_interleaved_write_frame(s, pkt);
723
    if(ret < 0){
724
        print_error("av_interleaved_write_frame()", ret);
725
        ffmpeg_exit(1);
726
    }
727
}
728

    
729
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
730

    
731
static void do_audio_out(AVFormatContext *s,
732
                         AVOutputStream *ost,
733
                         AVInputStream *ist,
734
                         unsigned char *buf, int size)
735
{
736
    uint8_t *buftmp;
737
    int64_t audio_out_size, audio_buf_size;
738
    int64_t allocated_for_size= size;
739

    
740
    int size_out, frame_bytes, ret;
741
    AVCodecContext *enc= ost->st->codec;
742
    AVCodecContext *dec= ist->st->codec;
743
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
744
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
745
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
746

    
747
need_realloc:
748
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
749
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
750
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
751
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
752
    audio_buf_size*= osize*enc->channels;
753

    
754
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
755
    if(coded_bps > 8*osize)
756
        audio_out_size= audio_out_size * coded_bps / (8*osize);
757
    audio_out_size += FF_MIN_BUFFER_SIZE;
758

    
759
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
760
        fprintf(stderr, "Buffer sizes too large\n");
761
        ffmpeg_exit(1);
762
    }
763

    
764
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
765
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
766
    if (!audio_buf || !audio_out){
767
        fprintf(stderr, "Out of memory in do_audio_out\n");
768
        ffmpeg_exit(1);
769
    }
770

    
771
    if (enc->channels != dec->channels)
772
        ost->audio_resample = 1;
773

    
774
    if (ost->audio_resample && !ost->resample) {
775
        if (dec->sample_fmt != SAMPLE_FMT_S16)
776
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
777
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
778
                                               enc->sample_rate, dec->sample_rate,
779
                                               enc->sample_fmt,  dec->sample_fmt,
780
                                               16, 10, 0, 0.8);
781
        if (!ost->resample) {
782
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
783
                    dec->channels, dec->sample_rate,
784
                    enc->channels, enc->sample_rate);
785
            ffmpeg_exit(1);
786
        }
787
    }
788

    
789
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
790
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
791
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
792
        if (ost->reformat_ctx)
793
            av_audio_convert_free(ost->reformat_ctx);
794
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
795
                                                   dec->sample_fmt, 1, NULL, 0);
796
        if (!ost->reformat_ctx) {
797
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
798
                avcodec_get_sample_fmt_name(dec->sample_fmt),
799
                avcodec_get_sample_fmt_name(enc->sample_fmt));
800
            ffmpeg_exit(1);
801
        }
802
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
803
    }
804

    
805
    if(audio_sync_method){
806
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
807
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
808
        double idelta= delta*dec->sample_rate / enc->sample_rate;
809
        int byte_delta= ((int)idelta)*2*dec->channels;
810

    
811
        //FIXME resample delay
812
        if(fabs(delta) > 50){
813
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
814
                if(byte_delta < 0){
815
                    byte_delta= FFMAX(byte_delta, -size);
816
                    size += byte_delta;
817
                    buf  -= byte_delta;
818
                    if(verbose > 2)
819
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
820
                    if(!size)
821
                        return;
822
                    ist->is_start=0;
823
                }else{
824
                    static uint8_t *input_tmp= NULL;
825
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
826

    
827
                    if(byte_delta > allocated_for_size - size){
828
                        allocated_for_size= byte_delta + (int64_t)size;
829
                        goto need_realloc;
830
                    }
831
                    ist->is_start=0;
832

    
833
                    memset(input_tmp, 0, byte_delta);
834
                    memcpy(input_tmp + byte_delta, buf, size);
835
                    buf= input_tmp;
836
                    size += byte_delta;
837
                    if(verbose > 2)
838
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
839
                }
840
            }else if(audio_sync_method>1){
841
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
842
                av_assert0(ost->audio_resample);
843
                if(verbose > 2)
844
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
845
//                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));
846
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
847
            }
848
        }
849
    }else
850
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
851
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
852

    
853
    if (ost->audio_resample) {
854
        buftmp = audio_buf;
855
        size_out = audio_resample(ost->resample,
856
                                  (short *)buftmp, (short *)buf,
857
                                  size / (dec->channels * isize));
858
        size_out = size_out * enc->channels * osize;
859
    } else {
860
        buftmp = buf;
861
        size_out = size;
862
    }
863

    
864
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
865
        const void *ibuf[6]= {buftmp};
866
        void *obuf[6]= {audio_buf};
867
        int istride[6]= {isize};
868
        int ostride[6]= {osize};
869
        int len= size_out/istride[0];
870
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
871
            printf("av_audio_convert() failed\n");
872
            if (exit_on_error)
873
                ffmpeg_exit(1);
874
            return;
875
        }
876
        buftmp = audio_buf;
877
        size_out = len*osize;
878
    }
879

    
880
    /* now encode as many frames as possible */
881
    if (enc->frame_size > 1) {
882
        /* output resampled raw samples */
883
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
884
            fprintf(stderr, "av_fifo_realloc2() failed\n");
885
            ffmpeg_exit(1);
886
        }
887
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
888

    
889
        frame_bytes = enc->frame_size * osize * enc->channels;
890

    
891
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
892
            AVPacket pkt;
893
            av_init_packet(&pkt);
894

    
895
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
896

    
897
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
898

    
899
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
900
                                       (short *)audio_buf);
901
            if (ret < 0) {
902
                fprintf(stderr, "Audio encoding failed\n");
903
                ffmpeg_exit(1);
904
            }
905
            audio_size += ret;
906
            pkt.stream_index= ost->index;
907
            pkt.data= audio_out;
908
            pkt.size= ret;
909
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
910
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
911
            pkt.flags |= AV_PKT_FLAG_KEY;
912
            write_frame(s, &pkt, enc, ost->bitstream_filters);
913

    
914
            ost->sync_opts += enc->frame_size;
915
        }
916
    } else {
917
        AVPacket pkt;
918
        av_init_packet(&pkt);
919

    
920
        ost->sync_opts += size_out / (osize * enc->channels);
921

    
922
        /* output a pcm frame */
923
        /* determine the size of the coded buffer */
924
        size_out /= osize;
925
        if (coded_bps)
926
            size_out = size_out*coded_bps/8;
927

    
928
        if(size_out > audio_out_size){
929
            fprintf(stderr, "Internal error, buffer size too small\n");
930
            ffmpeg_exit(1);
931
        }
932

    
933
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
934
        ret = avcodec_encode_audio(enc, audio_out, size_out,
935
                                   (short *)buftmp);
936
        if (ret < 0) {
937
            fprintf(stderr, "Audio encoding failed\n");
938
            ffmpeg_exit(1);
939
        }
940
        audio_size += ret;
941
        pkt.stream_index= ost->index;
942
        pkt.data= audio_out;
943
        pkt.size= ret;
944
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
945
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
946
        pkt.flags |= AV_PKT_FLAG_KEY;
947
        write_frame(s, &pkt, enc, ost->bitstream_filters);
948
    }
949
}
950

    
951
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
952
{
953
    AVCodecContext *dec;
954
    AVPicture *picture2;
955
    AVPicture picture_tmp;
956
    uint8_t *buf = 0;
957

    
958
    dec = ist->st->codec;
959

    
960
    /* deinterlace : must be done before any resize */
961
    if (do_deinterlace) {
962
        int size;
963

    
964
        /* create temporary picture */
965
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
966
        buf = av_malloc(size);
967
        if (!buf)
968
            return;
969

    
970
        picture2 = &picture_tmp;
971
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
972

    
973
        if(avpicture_deinterlace(picture2, picture,
974
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
975
            /* if error, do not deinterlace */
976
            fprintf(stderr, "Deinterlacing failed\n");
977
            av_free(buf);
978
            buf = NULL;
979
            picture2 = picture;
980
        }
981
    } else {
982
        picture2 = picture;
983
    }
984

    
985
    if (picture != picture2)
986
        *picture = *picture2;
987
    *bufp = buf;
988
}
989

    
990
/* we begin to correct av delay at this threshold */
991
#define AV_DELAY_MAX 0.100
992

    
993
static void do_subtitle_out(AVFormatContext *s,
994
                            AVOutputStream *ost,
995
                            AVInputStream *ist,
996
                            AVSubtitle *sub,
997
                            int64_t pts)
998
{
999
    static uint8_t *subtitle_out = NULL;
1000
    int subtitle_out_max_size = 1024 * 1024;
1001
    int subtitle_out_size, nb, i;
1002
    AVCodecContext *enc;
1003
    AVPacket pkt;
1004

    
1005
    if (pts == AV_NOPTS_VALUE) {
1006
        fprintf(stderr, "Subtitle packets must have a pts\n");
1007
        if (exit_on_error)
1008
            ffmpeg_exit(1);
1009
        return;
1010
    }
1011

    
1012
    enc = ost->st->codec;
1013

    
1014
    if (!subtitle_out) {
1015
        subtitle_out = av_malloc(subtitle_out_max_size);
1016
    }
1017

    
1018
    /* Note: DVB subtitle need one packet to draw them and one other
1019
       packet to clear them */
1020
    /* XXX: signal it in the codec context ? */
1021
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1022
        nb = 2;
1023
    else
1024
        nb = 1;
1025

    
1026
    for(i = 0; i < nb; i++) {
1027
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1028
        // start_display_time is required to be 0
1029
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1030
        sub->end_display_time -= sub->start_display_time;
1031
        sub->start_display_time = 0;
1032
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1033
                                                    subtitle_out_max_size, sub);
1034
        if (subtitle_out_size < 0) {
1035
            fprintf(stderr, "Subtitle encoding failed\n");
1036
            ffmpeg_exit(1);
1037
        }
1038

    
1039
        av_init_packet(&pkt);
1040
        pkt.stream_index = ost->index;
1041
        pkt.data = subtitle_out;
1042
        pkt.size = subtitle_out_size;
1043
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1044
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1045
            /* XXX: the pts correction is handled here. Maybe handling
1046
               it in the codec would be better */
1047
            if (i == 0)
1048
                pkt.pts += 90 * sub->start_display_time;
1049
            else
1050
                pkt.pts += 90 * sub->end_display_time;
1051
        }
1052
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1053
    }
1054
}
1055

    
1056
static int bit_buffer_size= 1024*256;
1057
static uint8_t *bit_buffer= NULL;
1058

    
1059
static void do_video_out(AVFormatContext *s,
1060
                         AVOutputStream *ost,
1061
                         AVInputStream *ist,
1062
                         AVFrame *in_picture,
1063
                         int *frame_size)
1064
{
1065
    int nb_frames, i, ret;
1066
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1067
    AVCodecContext *enc, *dec;
1068
    double sync_ipts;
1069

    
1070
    enc = ost->st->codec;
1071
    dec = ist->st->codec;
1072

    
1073
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1074

    
1075
    /* by default, we output a single frame */
1076
    nb_frames = 1;
1077

    
1078
    *frame_size = 0;
1079

    
1080
    if(video_sync_method){
1081
        double vdelta = sync_ipts - ost->sync_opts;
1082
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1083
        if (vdelta < -1.1)
1084
            nb_frames = 0;
1085
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1086
            if(vdelta<=-0.6){
1087
                nb_frames=0;
1088
            }else if(vdelta>0.6)
1089
            ost->sync_opts= lrintf(sync_ipts);
1090
        }else if (vdelta > 1.1)
1091
            nb_frames = lrintf(vdelta);
1092
//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);
1093
        if (nb_frames == 0){
1094
            ++nb_frames_drop;
1095
            if (verbose>2)
1096
                fprintf(stderr, "*** drop!\n");
1097
        }else if (nb_frames > 1) {
1098
            nb_frames_dup += nb_frames - 1;
1099
            if (verbose>2)
1100
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1101
        }
1102
    }else
1103
        ost->sync_opts= lrintf(sync_ipts);
1104

    
1105
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1106
    if (nb_frames <= 0)
1107
        return;
1108

    
1109
    formatted_picture = in_picture;
1110
    final_picture = formatted_picture;
1111
    padding_src = formatted_picture;
1112
    resampling_dst = &ost->pict_tmp;
1113

    
1114
    if (   ost->resample_height != ist->st->codec->height
1115
        || ost->resample_width  != ist->st->codec->width
1116
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1117

    
1118
        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));
1119
        if(!ost->video_resample)
1120
            ffmpeg_exit(1);
1121
    }
1122

    
1123
#if !CONFIG_AVFILTER
1124
    if (ost->video_resample) {
1125
        padding_src = NULL;
1126
        final_picture = &ost->pict_tmp;
1127
        if(  ost->resample_height != ist->st->codec->height
1128
          || ost->resample_width  != ist->st->codec->width
1129
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1130

    
1131
            /* initialize a new scaler context */
1132
            sws_freeContext(ost->img_resample_ctx);
1133
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1134
            ost->img_resample_ctx = sws_getContext(
1135
                ist->st->codec->width,
1136
                ist->st->codec->height,
1137
                ist->st->codec->pix_fmt,
1138
                ost->st->codec->width,
1139
                ost->st->codec->height,
1140
                ost->st->codec->pix_fmt,
1141
                sws_flags, NULL, NULL, NULL);
1142
            if (ost->img_resample_ctx == NULL) {
1143
                fprintf(stderr, "Cannot get resampling context\n");
1144
                ffmpeg_exit(1);
1145
            }
1146
        }
1147
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1148
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1149
    }
1150
#endif
1151

    
1152
    /* duplicates frame if needed */
1153
    for(i=0;i<nb_frames;i++) {
1154
        AVPacket pkt;
1155
        av_init_packet(&pkt);
1156
        pkt.stream_index= ost->index;
1157

    
1158
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1159
            /* raw pictures are written as AVPicture structure to
1160
               avoid any copies. We support temorarily the older
1161
               method. */
1162
            AVFrame* old_frame = enc->coded_frame;
1163
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1164
            pkt.data= (uint8_t *)final_picture;
1165
            pkt.size=  sizeof(AVPicture);
1166
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1167
            pkt.flags |= AV_PKT_FLAG_KEY;
1168

    
1169
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1170
            enc->coded_frame = old_frame;
1171
        } else {
1172
            AVFrame big_picture;
1173

    
1174
            big_picture= *final_picture;
1175
            /* better than nothing: use input picture interlaced
1176
               settings */
1177
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1178
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1179
                if(top_field_first == -1)
1180
                    big_picture.top_field_first = in_picture->top_field_first;
1181
                else
1182
                    big_picture.top_field_first = top_field_first;
1183
            }
1184

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

    
1207
            if(ret>0){
1208
                pkt.data= bit_buffer;
1209
                pkt.size= ret;
1210
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1211
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1212
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1213
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1214
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1215

    
1216
                if(enc->coded_frame->key_frame)
1217
                    pkt.flags |= AV_PKT_FLAG_KEY;
1218
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1219
                *frame_size = ret;
1220
                video_size += ret;
1221
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1222
                //        enc->frame_number-1, ret, enc->pict_type);
1223
                /* if two pass, output log */
1224
                if (ost->logfile && enc->stats_out) {
1225
                    fprintf(ost->logfile, "%s", enc->stats_out);
1226
                }
1227
            }
1228
        }
1229
        ost->sync_opts++;
1230
        ost->frame_number++;
1231
    }
1232
}
1233

    
1234
static double psnr(double d){
1235
    return -10.0*log(d)/log(10.0);
1236
}
1237

    
1238
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1239
                           int frame_size)
1240
{
1241
    AVCodecContext *enc;
1242
    int frame_number;
1243
    double ti1, bitrate, avg_bitrate;
1244

    
1245
    /* this is executed just the first time do_video_stats is called */
1246
    if (!vstats_file) {
1247
        vstats_file = fopen(vstats_filename, "w");
1248
        if (!vstats_file) {
1249
            perror("fopen");
1250
            ffmpeg_exit(1);
1251
        }
1252
    }
1253

    
1254
    enc = ost->st->codec;
1255
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1256
        frame_number = ost->frame_number;
1257
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1258
        if (enc->flags&CODEC_FLAG_PSNR)
1259
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1260

    
1261
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1262
        /* compute pts value */
1263
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1264
        if (ti1 < 0.01)
1265
            ti1 = 0.01;
1266

    
1267
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1268
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1269
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1270
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1271
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1272
    }
1273
}
1274

    
1275
static void print_report(AVFormatContext **output_files,
1276
                         AVOutputStream **ost_table, int nb_ostreams,
1277
                         int is_last_report)
1278
{
1279
    char buf[1024];
1280
    AVOutputStream *ost;
1281
    AVFormatContext *oc;
1282
    int64_t total_size;
1283
    AVCodecContext *enc;
1284
    int frame_number, vid, i;
1285
    double bitrate, ti1, pts;
1286
    static int64_t last_time = -1;
1287
    static int qp_histogram[52];
1288

    
1289
    if (!is_last_report) {
1290
        int64_t cur_time;
1291
        /* display the report every 0.5 seconds */
1292
        cur_time = av_gettime();
1293
        if (last_time == -1) {
1294
            last_time = cur_time;
1295
            return;
1296
        }
1297
        if ((cur_time - last_time) < 500000)
1298
            return;
1299
        last_time = cur_time;
1300
    }
1301

    
1302

    
1303
    oc = output_files[0];
1304

    
1305
    total_size = url_fsize(oc->pb);
1306
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1307
        total_size= url_ftell(oc->pb);
1308

    
1309
    buf[0] = '\0';
1310
    ti1 = 1e10;
1311
    vid = 0;
1312
    for(i=0;i<nb_ostreams;i++) {
1313
        ost = ost_table[i];
1314
        enc = ost->st->codec;
1315
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1316
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1317
                     !ost->st->stream_copy ?
1318
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1319
        }
1320
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1321
            float t = (av_gettime()-timer_start) / 1000000.0;
1322

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

    
1369
    if (verbose || is_last_report) {
1370
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1371

    
1372
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1373
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1374
            (double)total_size / 1024, ti1, bitrate);
1375

    
1376
        if (nb_frames_dup || nb_frames_drop)
1377
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1378
                  nb_frames_dup, nb_frames_drop);
1379

    
1380
        if (verbose >= 0)
1381
            fprintf(stderr, "%s    \r", buf);
1382

    
1383
        fflush(stderr);
1384
    }
1385

    
1386
    if (is_last_report && verbose >= 0){
1387
        int64_t raw= audio_size + video_size + extra_size;
1388
        fprintf(stderr, "\n");
1389
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1390
                video_size/1024.0,
1391
                audio_size/1024.0,
1392
                extra_size/1024.0,
1393
                100.0*(total_size - raw)/raw
1394
        );
1395
    }
1396
}
1397

    
1398
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1399
static int output_packet(AVInputStream *ist, int ist_index,
1400
                         AVOutputStream **ost_table, int nb_ostreams,
1401
                         const AVPacket *pkt)
1402
{
1403
    AVFormatContext *os;
1404
    AVOutputStream *ost;
1405
    int ret, i;
1406
    int got_picture;
1407
    AVFrame picture;
1408
    void *buffer_to_free;
1409
    static unsigned int samples_size= 0;
1410
    AVSubtitle subtitle, *subtitle_to_free;
1411
    int64_t pkt_pts = AV_NOPTS_VALUE;
1412
#if CONFIG_AVFILTER
1413
    int frame_available;
1414
#endif
1415

    
1416
    AVPacket avpkt;
1417
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1418

    
1419
    if(ist->next_pts == AV_NOPTS_VALUE)
1420
        ist->next_pts= ist->pts;
1421

    
1422
    if (pkt == NULL) {
1423
        /* EOF handling */
1424
        av_init_packet(&avpkt);
1425
        avpkt.data = NULL;
1426
        avpkt.size = 0;
1427
        goto handle_eof;
1428
    } else {
1429
        avpkt = *pkt;
1430
    }
1431

    
1432
    if(pkt->dts != AV_NOPTS_VALUE)
1433
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1434
    if(pkt->pts != AV_NOPTS_VALUE)
1435
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1436

    
1437
    //while we have more to decode or while the decoder did output something on EOF
1438
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1439
        uint8_t *data_buf, *decoded_data_buf;
1440
        int data_size, decoded_data_size;
1441
    handle_eof:
1442
        ist->pts= ist->next_pts;
1443

    
1444
        if(avpkt.size && avpkt.size != pkt->size &&
1445
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1446
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1447
            ist->showed_multi_packet_warning=1;
1448
        }
1449

    
1450
        /* decode the packet if needed */
1451
        decoded_data_buf = NULL; /* fail safe */
1452
        decoded_data_size= 0;
1453
        data_buf  = avpkt.data;
1454
        data_size = avpkt.size;
1455
        subtitle_to_free = NULL;
1456
        if (ist->decoding_needed) {
1457
            switch(ist->st->codec->codec_type) {
1458
            case AVMEDIA_TYPE_AUDIO:{
1459
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1460
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1461
                    av_free(samples);
1462
                    samples= av_malloc(samples_size);
1463
                }
1464
                decoded_data_size= samples_size;
1465
                    /* XXX: could avoid copy if PCM 16 bits with same
1466
                       endianness as CPU */
1467
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1468
                                            &avpkt);
1469
                if (ret < 0)
1470
                    goto fail_decode;
1471
                avpkt.data += ret;
1472
                avpkt.size -= ret;
1473
                data_size   = ret;
1474
                /* Some bug in mpeg audio decoder gives */
1475
                /* decoded_data_size < 0, it seems they are overflows */
1476
                if (decoded_data_size <= 0) {
1477
                    /* no audio frame */
1478
                    continue;
1479
                }
1480
                decoded_data_buf = (uint8_t *)samples;
1481
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1482
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1483
                break;}
1484
            case AVMEDIA_TYPE_VIDEO:
1485
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1486
                    /* XXX: allocate picture correctly */
1487
                    avcodec_get_frame_defaults(&picture);
1488
                    ist->st->codec->reordered_opaque = pkt_pts;
1489
                    pkt_pts = AV_NOPTS_VALUE;
1490

    
1491
                    ret = avcodec_decode_video2(ist->st->codec,
1492
                                                &picture, &got_picture, &avpkt);
1493
                    ist->st->quality= picture.quality;
1494
                    if (ret < 0)
1495
                        goto fail_decode;
1496
                    if (!got_picture) {
1497
                        /* no picture yet */
1498
                        goto discard_packet;
1499
                    }
1500
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1501
                    if (ist->st->codec->time_base.num != 0) {
1502
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1503
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1504
                                          ist->st->codec->time_base.num * ticks) /
1505
                            ist->st->codec->time_base.den;
1506
                    }
1507
                    avpkt.size = 0;
1508
                    break;
1509
            case AVMEDIA_TYPE_SUBTITLE:
1510
                ret = avcodec_decode_subtitle2(ist->st->codec,
1511
                                               &subtitle, &got_picture, &avpkt);
1512
                if (ret < 0)
1513
                    goto fail_decode;
1514
                if (!got_picture) {
1515
                    goto discard_packet;
1516
                }
1517
                subtitle_to_free = &subtitle;
1518
                avpkt.size = 0;
1519
                break;
1520
            default:
1521
                goto fail_decode;
1522
            }
1523
        } else {
1524
            switch(ist->st->codec->codec_type) {
1525
            case AVMEDIA_TYPE_AUDIO:
1526
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1527
                    ist->st->codec->sample_rate;
1528
                break;
1529
            case AVMEDIA_TYPE_VIDEO:
1530
                if (ist->st->codec->time_base.num != 0) {
1531
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1532
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1533
                                      ist->st->codec->time_base.num * ticks) /
1534
                        ist->st->codec->time_base.den;
1535
                }
1536
                break;
1537
            }
1538
            ret = avpkt.size;
1539
            avpkt.size = 0;
1540
        }
1541

    
1542
        buffer_to_free = NULL;
1543
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1544
            pre_process_video_frame(ist, (AVPicture *)&picture,
1545
                                    &buffer_to_free);
1546
        }
1547

    
1548
#if CONFIG_AVFILTER
1549
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1550
            // add it to be filtered
1551
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1552
                                     ist->pts,
1553
                                     ist->st->codec->sample_aspect_ratio);
1554
        }
1555
#endif
1556

    
1557
        // preprocess audio (volume)
1558
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1559
            if (audio_volume != 256) {
1560
                short *volp;
1561
                volp = samples;
1562
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1563
                    int v = ((*volp) * audio_volume + 128) >> 8;
1564
                    if (v < -32768) v = -32768;
1565
                    if (v >  32767) v = 32767;
1566
                    *volp++ = v;
1567
                }
1568
            }
1569
        }
1570

    
1571
        /* frame rate emulation */
1572
        if (rate_emu) {
1573
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1574
            int64_t now = av_gettime() - ist->start;
1575
            if (pts > now)
1576
                usleep(pts - now);
1577
        }
1578
#if CONFIG_AVFILTER
1579
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1580
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1581
#endif
1582
        /* if output time reached then transcode raw format,
1583
           encode packets and output them */
1584
        if (start_time == 0 || ist->pts >= start_time)
1585
#if CONFIG_AVFILTER
1586
        while (frame_available) {
1587
            AVRational ist_pts_tb;
1588
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1589
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1590
            if (ist->picref)
1591
                ist->pts = ist->picref->pts;
1592
#endif
1593
            for(i=0;i<nb_ostreams;i++) {
1594
                int frame_size;
1595

    
1596
                ost = ost_table[i];
1597
                if (ost->source_index == ist_index) {
1598
                    os = output_files[ost->file_index];
1599

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

    
1603
                    if (ost->encoding_needed) {
1604
                        av_assert0(ist->decoding_needed);
1605
                        switch(ost->st->codec->codec_type) {
1606
                        case AVMEDIA_TYPE_AUDIO:
1607
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1608
                            break;
1609
                        case AVMEDIA_TYPE_VIDEO:
1610
#if CONFIG_AVFILTER
1611
                            if (ist->picref->video)
1612
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1613
#endif
1614
                            do_video_out(os, ost, ist, &picture, &frame_size);
1615
                            if (vstats_filename && frame_size)
1616
                                do_video_stats(os, ost, frame_size);
1617
                            break;
1618
                        case AVMEDIA_TYPE_SUBTITLE:
1619
                            do_subtitle_out(os, ost, ist, &subtitle,
1620
                                            pkt->pts);
1621
                            break;
1622
                        default:
1623
                            abort();
1624
                        }
1625
                    } else {
1626
                        AVFrame avframe; //FIXME/XXX remove this
1627
                        AVPacket opkt;
1628
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1629

    
1630
                        av_init_packet(&opkt);
1631

    
1632
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1633
                            continue;
1634

    
1635
                        /* no reencoding needed : output the packet directly */
1636
                        /* force the input stream PTS */
1637

    
1638
                        avcodec_get_frame_defaults(&avframe);
1639
                        ost->st->codec->coded_frame= &avframe;
1640
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1641

    
1642
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1643
                            audio_size += data_size;
1644
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1645
                            video_size += data_size;
1646
                            ost->sync_opts++;
1647
                        }
1648

    
1649
                        opkt.stream_index= ost->index;
1650
                        if(pkt->pts != AV_NOPTS_VALUE)
1651
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1652
                        else
1653
                            opkt.pts= AV_NOPTS_VALUE;
1654

    
1655
                        if (pkt->dts == AV_NOPTS_VALUE)
1656
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1657
                        else
1658
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1659
                        opkt.dts -= ost_tb_start_time;
1660

    
1661
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1662
                        opkt.flags= pkt->flags;
1663

    
1664
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1665
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1666
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1667
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1668
                           ) {
1669
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1670
                                opkt.destruct= av_destruct_packet;
1671
                        } else {
1672
                            opkt.data = data_buf;
1673
                            opkt.size = data_size;
1674
                        }
1675

    
1676
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1677
                        ost->st->codec->frame_number++;
1678
                        ost->frame_number++;
1679
                        av_free_packet(&opkt);
1680
                    }
1681
                }
1682
            }
1683

    
1684
#if CONFIG_AVFILTER
1685
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1686
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1687
            if(ist->picref)
1688
                avfilter_unref_buffer(ist->picref);
1689
        }
1690
#endif
1691
        av_free(buffer_to_free);
1692
        /* XXX: allocate the subtitles in the codec ? */
1693
        if (subtitle_to_free) {
1694
            if (subtitle_to_free->rects != NULL) {
1695
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1696
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1697
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1698
                    av_freep(&subtitle_to_free->rects[i]);
1699
                }
1700
                av_freep(&subtitle_to_free->rects);
1701
            }
1702
            subtitle_to_free->num_rects = 0;
1703
            subtitle_to_free = NULL;
1704
        }
1705
    }
1706
 discard_packet:
1707
    if (pkt == NULL) {
1708
        /* EOF handling */
1709

    
1710
        for(i=0;i<nb_ostreams;i++) {
1711
            ost = ost_table[i];
1712
            if (ost->source_index == ist_index) {
1713
                AVCodecContext *enc= ost->st->codec;
1714
                os = output_files[ost->file_index];
1715

    
1716
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1717
                    continue;
1718
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1719
                    continue;
1720

    
1721
                if (ost->encoding_needed) {
1722
                    for(;;) {
1723
                        AVPacket pkt;
1724
                        int fifo_bytes;
1725
                        av_init_packet(&pkt);
1726
                        pkt.stream_index= ost->index;
1727

    
1728
                        switch(ost->st->codec->codec_type) {
1729
                        case AVMEDIA_TYPE_AUDIO:
1730
                            fifo_bytes = av_fifo_size(ost->fifo);
1731
                            ret = 0;
1732
                            /* encode any samples remaining in fifo */
1733
                            if (fifo_bytes > 0) {
1734
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1735
                                int fs_tmp = enc->frame_size;
1736

    
1737
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1738
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1739
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1740
                                } else { /* pad */
1741
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1742
                                    if (allocated_audio_buf_size < frame_bytes)
1743
                                        ffmpeg_exit(1);
1744
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1745
                                }
1746

    
1747
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1748
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1749
                                                          ost->st->time_base.num, enc->sample_rate);
1750
                                enc->frame_size = fs_tmp;
1751
                            }
1752
                            if(ret <= 0) {
1753
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1754
                            }
1755
                            if (ret < 0) {
1756
                                fprintf(stderr, "Audio encoding failed\n");
1757
                                ffmpeg_exit(1);
1758
                            }
1759
                            audio_size += ret;
1760
                            pkt.flags |= AV_PKT_FLAG_KEY;
1761
                            break;
1762
                        case AVMEDIA_TYPE_VIDEO:
1763
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1764
                            if (ret < 0) {
1765
                                fprintf(stderr, "Video encoding failed\n");
1766
                                ffmpeg_exit(1);
1767
                            }
1768
                            video_size += ret;
1769
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1770
                                pkt.flags |= AV_PKT_FLAG_KEY;
1771
                            if (ost->logfile && enc->stats_out) {
1772
                                fprintf(ost->logfile, "%s", enc->stats_out);
1773
                            }
1774
                            break;
1775
                        default:
1776
                            ret=-1;
1777
                        }
1778

    
1779
                        if(ret<=0)
1780
                            break;
1781
                        pkt.data= bit_buffer;
1782
                        pkt.size= ret;
1783
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1784
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1785
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1786
                    }
1787
                }
1788
            }
1789
        }
1790
    }
1791

    
1792
    return 0;
1793
 fail_decode:
1794
    return -1;
1795
}
1796

    
1797
static void print_sdp(AVFormatContext **avc, int n)
1798
{
1799
    char sdp[2048];
1800

    
1801
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1802
    printf("SDP:\n%s\n", sdp);
1803
    fflush(stdout);
1804
}
1805

    
1806
static int copy_chapters(int infile, int outfile)
1807
{
1808
    AVFormatContext *is = input_files[infile];
1809
    AVFormatContext *os = output_files[outfile];
1810
    int i;
1811

    
1812
    for (i = 0; i < is->nb_chapters; i++) {
1813
        AVChapter *in_ch = is->chapters[i], *out_ch;
1814
        AVMetadataTag *t = NULL;
1815
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1816
                                      AV_TIME_BASE_Q, in_ch->time_base);
1817
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1818
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1819

    
1820

    
1821
        if (in_ch->end < ts_off)
1822
            continue;
1823
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1824
            break;
1825

    
1826
        out_ch = av_mallocz(sizeof(AVChapter));
1827
        if (!out_ch)
1828
            return AVERROR(ENOMEM);
1829

    
1830
        out_ch->id        = in_ch->id;
1831
        out_ch->time_base = in_ch->time_base;
1832
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1833
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1834

    
1835
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1836
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1837

    
1838
        os->nb_chapters++;
1839
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1840
        if (!os->chapters)
1841
            return AVERROR(ENOMEM);
1842
        os->chapters[os->nb_chapters - 1] = out_ch;
1843
    }
1844
    return 0;
1845
}
1846

    
1847
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1848
                                    AVCodecContext *avctx)
1849
{
1850
    char *p;
1851
    int n = 1, i;
1852
    int64_t t;
1853

    
1854
    for (p = kf; *p; p++)
1855
        if (*p == ',')
1856
            n++;
1857
    ost->forced_kf_count = n;
1858
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1859
    if (!ost->forced_kf_pts) {
1860
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1861
        ffmpeg_exit(1);
1862
    }
1863
    for (i = 0; i < n; i++) {
1864
        p = i ? strchr(p, ',') + 1 : kf;
1865
        t = parse_time_or_die("force_key_frames", p, 1);
1866
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1867
    }
1868
}
1869

    
1870
/*
1871
 * The following code is the main loop of the file converter
1872
 */
1873
static int transcode(AVFormatContext **output_files,
1874
                     int nb_output_files,
1875
                     AVFormatContext **input_files,
1876
                     int nb_input_files,
1877
                     AVStreamMap *stream_maps, int nb_stream_maps)
1878
{
1879
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1880
    AVFormatContext *is, *os;
1881
    AVCodecContext *codec, *icodec;
1882
    AVOutputStream *ost, **ost_table = NULL;
1883
    AVInputStream *ist, **ist_table = NULL;
1884
    AVInputFile *file_table;
1885
    char error[1024];
1886
    int key;
1887
    int want_sdp = 1;
1888
    uint8_t no_packet[MAX_FILES]={0};
1889
    int no_packet_count=0;
1890

    
1891
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1892
    if (!file_table)
1893
        goto fail;
1894

    
1895
    /* input stream init */
1896
    j = 0;
1897
    for(i=0;i<nb_input_files;i++) {
1898
        is = input_files[i];
1899
        file_table[i].ist_index = j;
1900
        file_table[i].nb_streams = is->nb_streams;
1901
        j += is->nb_streams;
1902
    }
1903
    nb_istreams = j;
1904

    
1905
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1906
    if (!ist_table)
1907
        goto fail;
1908

    
1909
    for(i=0;i<nb_istreams;i++) {
1910
        ist = av_mallocz(sizeof(AVInputStream));
1911
        if (!ist)
1912
            goto fail;
1913
        ist_table[i] = ist;
1914
    }
1915
    j = 0;
1916
    for(i=0;i<nb_input_files;i++) {
1917
        is = input_files[i];
1918
        for(k=0;k<is->nb_streams;k++) {
1919
            ist = ist_table[j++];
1920
            ist->st = is->streams[k];
1921
            ist->file_index = i;
1922
            ist->index = k;
1923
            ist->discard = 1; /* the stream is discarded by default
1924
                                 (changed later) */
1925

    
1926
            if (rate_emu) {
1927
                ist->start = av_gettime();
1928
            }
1929
        }
1930
    }
1931

    
1932
    /* output stream init */
1933
    nb_ostreams = 0;
1934
    for(i=0;i<nb_output_files;i++) {
1935
        os = output_files[i];
1936
        if (!os->nb_streams) {
1937
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1938
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1939
            ret = AVERROR(EINVAL);
1940
            goto fail;
1941
        }
1942
        nb_ostreams += os->nb_streams;
1943
    }
1944
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1945
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1946
        ret = AVERROR(EINVAL);
1947
        goto fail;
1948
    }
1949

    
1950
    /* Sanity check the mapping args -- do the input files & streams exist? */
1951
    for(i=0;i<nb_stream_maps;i++) {
1952
        int fi = stream_maps[i].file_index;
1953
        int si = stream_maps[i].stream_index;
1954

    
1955
        if (fi < 0 || fi > nb_input_files - 1 ||
1956
            si < 0 || si > file_table[fi].nb_streams - 1) {
1957
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1958
            ret = AVERROR(EINVAL);
1959
            goto fail;
1960
        }
1961
        fi = stream_maps[i].sync_file_index;
1962
        si = stream_maps[i].sync_stream_index;
1963
        if (fi < 0 || fi > nb_input_files - 1 ||
1964
            si < 0 || si > file_table[fi].nb_streams - 1) {
1965
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1966
            ret = AVERROR(EINVAL);
1967
            goto fail;
1968
        }
1969
    }
1970

    
1971
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1972
    if (!ost_table)
1973
        goto fail;
1974
    n = 0;
1975
    for(k=0;k<nb_output_files;k++) {
1976
        os = output_files[k];
1977
        for(i=0;i<os->nb_streams;i++,n++) {
1978
            int found;
1979
            ost = ost_table[n] = output_streams_for_file[k][i];
1980
            ost->st = os->streams[i];
1981
            if (nb_stream_maps > 0) {
1982
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1983
                    stream_maps[n].stream_index;
1984

    
1985
                /* Sanity check that the stream types match */
1986
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1987
                    int i= ost->file_index;
1988
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1989
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1990
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1991
                        ost->file_index, ost->index);
1992
                    ffmpeg_exit(1);
1993
                }
1994

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

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

    
2054
    /* for each output stream, we compute the right encoding parameters */
2055
    for(i=0;i<nb_ostreams;i++) {
2056
        AVMetadataTag *t = NULL;
2057
        ost = ost_table[i];
2058
        os = output_files[ost->file_index];
2059
        ist = ist_table[ost->source_index];
2060

    
2061
        codec = ost->st->codec;
2062
        icodec = ist->st->codec;
2063

    
2064
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2065
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2066
        }
2067

    
2068
        ost->st->disposition = ist->st->disposition;
2069
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2070
        codec->chroma_sample_location = icodec->chroma_sample_location;
2071

    
2072
        if (ost->st->stream_copy) {
2073
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2074

    
2075
            if (extra_size > INT_MAX)
2076
                goto fail;
2077

    
2078
            /* if stream_copy is selected, no need to decode or encode */
2079
            codec->codec_id = icodec->codec_id;
2080
            codec->codec_type = icodec->codec_type;
2081

    
2082
            if(!codec->codec_tag){
2083
                if(   !os->oformat->codec_tag
2084
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2085
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2086
                    codec->codec_tag = icodec->codec_tag;
2087
            }
2088

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

    
2174
#if !CONFIG_AVFILTER
2175
                    ost->original_height = icodec->height;
2176
                    ost->original_width  = icodec->width;
2177
#endif
2178
                    codec->bits_per_raw_sample= 0;
2179
                }
2180
                ost->resample_height = icodec->height;
2181
                ost->resample_width  = icodec->width;
2182
                ost->resample_pix_fmt= icodec->pix_fmt;
2183
                ost->encoding_needed = 1;
2184
                ist->decoding_needed = 1;
2185

    
2186
#if CONFIG_AVFILTER
2187
                if (configure_filters(ist, ost)) {
2188
                    fprintf(stderr, "Error opening filters!\n");
2189
                    exit(1);
2190
                }
2191
#endif
2192
                break;
2193
            case AVMEDIA_TYPE_SUBTITLE:
2194
                ost->encoding_needed = 1;
2195
                ist->decoding_needed = 1;
2196
                break;
2197
            default:
2198
                abort();
2199
                break;
2200
            }
2201
            /* two pass mode */
2202
            if (ost->encoding_needed &&
2203
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2204
                char logfilename[1024];
2205
                FILE *f;
2206

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

    
2234
    if (!bit_buffer)
2235
        bit_buffer = av_malloc(bit_buffer_size);
2236
    if (!bit_buffer) {
2237
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2238
                bit_buffer_size);
2239
        ret = AVERROR(ENOMEM);
2240
        goto fail;
2241
    }
2242

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

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

    
2290
    /* init pts */
2291
    for(i=0;i<nb_istreams;i++) {
2292
        AVStream *st;
2293
        ist = ist_table[i];
2294
        st= ist->st;
2295
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2296
        ist->next_pts = AV_NOPTS_VALUE;
2297
        init_pts_correction(&ist->pts_ctx);
2298
        ist->is_start = 1;
2299
    }
2300

    
2301
    /* set meta data information from input file if required */
2302
    for (i=0;i<nb_meta_data_maps;i++) {
2303
        AVFormatContext *out_file;
2304
        AVFormatContext *in_file;
2305
        AVMetadataTag *mtag;
2306

    
2307
        int out_file_index = meta_data_maps[i].out_file;
2308
        int in_file_index = meta_data_maps[i].in_file;
2309
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2310
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2311
                     out_file_index, out_file_index, in_file_index);
2312
            ret = AVERROR(EINVAL);
2313
            goto dump_format;
2314
        }
2315
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2316
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2317
                     in_file_index, out_file_index, in_file_index);
2318
            ret = AVERROR(EINVAL);
2319
            goto dump_format;
2320
        }
2321

    
2322
        out_file = output_files[out_file_index];
2323
        in_file = input_files[in_file_index];
2324

    
2325

    
2326
        mtag=NULL;
2327
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2328
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2329
    }
2330

    
2331
    /* copy chapters from the first input file that has them*/
2332
    for (i = 0; i < nb_input_files; i++) {
2333
        if (!input_files[i]->nb_chapters)
2334
            continue;
2335

    
2336
        for (j = 0; j < nb_output_files; j++)
2337
            if ((ret = copy_chapters(i, j)) < 0)
2338
                goto dump_format;
2339
    }
2340

    
2341
    /* open files and write file headers */
2342
    for(i=0;i<nb_output_files;i++) {
2343
        os = output_files[i];
2344
        if (av_write_header(os) < 0) {
2345
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2346
            ret = AVERROR(EINVAL);
2347
            goto dump_format;
2348
        }
2349
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2350
            want_sdp = 0;
2351
        }
2352
    }
2353

    
2354
 dump_format:
2355
    /* dump the file output parameters - cannot be done before in case
2356
       of stream copy */
2357
    for(i=0;i<nb_output_files;i++) {
2358
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2359
    }
2360

    
2361
    /* dump the stream mapping */
2362
    if (verbose >= 0) {
2363
        fprintf(stderr, "Stream mapping:\n");
2364
        for(i=0;i<nb_ostreams;i++) {
2365
            ost = ost_table[i];
2366
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2367
                    ist_table[ost->source_index]->file_index,
2368
                    ist_table[ost->source_index]->index,
2369
                    ost->file_index,
2370
                    ost->index);
2371
            if (ost->sync_ist != ist_table[ost->source_index])
2372
                fprintf(stderr, " [sync #%d.%d]",
2373
                        ost->sync_ist->file_index,
2374
                        ost->sync_ist->index);
2375
            fprintf(stderr, "\n");
2376
        }
2377
    }
2378

    
2379
    if (ret) {
2380
        fprintf(stderr, "%s\n", error);
2381
        goto fail;
2382
    }
2383

    
2384
    if (want_sdp) {
2385
        print_sdp(output_files, nb_output_files);
2386
    }
2387

    
2388
    if (!using_stdin && verbose >= 0) {
2389
        fprintf(stderr, "Press [q] to stop encoding\n");
2390
        url_set_interrupt_cb(decode_interrupt_cb);
2391
    }
2392
    term_init();
2393

    
2394
    timer_start = av_gettime();
2395

    
2396
    for(; received_sigterm == 0;) {
2397
        int file_index, ist_index;
2398
        AVPacket pkt;
2399
        double ipts_min;
2400
        double opts_min;
2401

    
2402
    redo:
2403
        ipts_min= 1e100;
2404
        opts_min= 1e100;
2405
        /* if 'q' pressed, exits */
2406
        if (!using_stdin) {
2407
            if (q_pressed)
2408
                break;
2409
            /* read_key() returns 0 on EOF */
2410
            key = read_key();
2411
            if (key == 'q')
2412
                break;
2413
        }
2414

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

    
2453
        /* finish if limit size exhausted */
2454
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2455
            break;
2456

    
2457
        /* read a frame from it and output it in the fifo */
2458
        is = input_files[file_index];
2459
        ret= av_read_frame(is, &pkt);
2460
        if(ret == AVERROR(EAGAIN)){
2461
            no_packet[file_index]=1;
2462
            no_packet_count++;
2463
            continue;
2464
        }
2465
        if (ret < 0) {
2466
            file_table[file_index].eof_reached = 1;
2467
            if (opt_shortest)
2468
                break;
2469
            else
2470
                continue;
2471
        }
2472

    
2473
        no_packet_count=0;
2474
        memset(no_packet, 0, sizeof(no_packet));
2475

    
2476
        if (do_pkt_dump) {
2477
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2478
        }
2479
        /* the following test is needed in case new streams appear
2480
           dynamically in stream : we ignore them */
2481
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2482
            goto discard_packet;
2483
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2484
        ist = ist_table[ist_index];
2485
        if (ist->discard)
2486
            goto discard_packet;
2487

    
2488
        if (pkt.dts != AV_NOPTS_VALUE)
2489
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2490
        if (pkt.pts != AV_NOPTS_VALUE)
2491
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2492

    
2493
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2494
            && input_files_ts_scale[file_index][pkt.stream_index]){
2495
            if(pkt.pts != AV_NOPTS_VALUE)
2496
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2497
            if(pkt.dts != AV_NOPTS_VALUE)
2498
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2499
        }
2500

    
2501
//        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);
2502
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2503
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2504
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2505
            int64_t delta= pkt_dts - ist->next_pts;
2506
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2507
                input_files_ts_offset[ist->file_index]-= delta;
2508
                if (verbose > 2)
2509
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2510
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2511
                if(pkt.pts != AV_NOPTS_VALUE)
2512
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2513
            }
2514
        }
2515

    
2516
        /* finish if recording time exhausted */
2517
        if (recording_time != INT64_MAX &&
2518
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2519
            ist->is_past_recording_time = 1;
2520
            goto discard_packet;
2521
        }
2522

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

    
2526
            if (verbose >= 0)
2527
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2528
                        ist->file_index, ist->index);
2529
            if (exit_on_error)
2530
                ffmpeg_exit(1);
2531
            av_free_packet(&pkt);
2532
            goto redo;
2533
        }
2534

    
2535
    discard_packet:
2536
        av_free_packet(&pkt);
2537

    
2538
        /* dump report by using the output first video and audio streams */
2539
        print_report(output_files, ost_table, nb_ostreams, 0);
2540
    }
2541

    
2542
    /* at the end of stream, we must flush the decoder buffers */
2543
    for(i=0;i<nb_istreams;i++) {
2544
        ist = ist_table[i];
2545
        if (ist->decoding_needed) {
2546
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2547
        }
2548
    }
2549

    
2550
    term_exit();
2551

    
2552
    /* write the trailer if needed and close file */
2553
    for(i=0;i<nb_output_files;i++) {
2554
        os = output_files[i];
2555
        av_write_trailer(os);
2556
    }
2557

    
2558
    /* dump report by using the first video and audio streams */
2559
    print_report(output_files, ost_table, nb_ostreams, 1);
2560

    
2561
    /* close each encoder */
2562
    for(i=0;i<nb_ostreams;i++) {
2563
        ost = ost_table[i];
2564
        if (ost->encoding_needed) {
2565
            av_freep(&ost->st->codec->stats_in);
2566
            avcodec_close(ost->st->codec);
2567
        }
2568
    }
2569

    
2570
    /* close each decoder */
2571
    for(i=0;i<nb_istreams;i++) {
2572
        ist = ist_table[i];
2573
        if (ist->decoding_needed) {
2574
            avcodec_close(ist->st->codec);
2575
        }
2576
    }
2577
#if CONFIG_AVFILTER
2578
    if (graph) {
2579
        avfilter_graph_destroy(graph);
2580
        av_freep(&graph);
2581
    }
2582
#endif
2583

    
2584
    /* finished ! */
2585
    ret = 0;
2586

    
2587
 fail:
2588
    av_freep(&bit_buffer);
2589
    av_free(file_table);
2590

    
2591
    if (ist_table) {
2592
        for(i=0;i<nb_istreams;i++) {
2593
            ist = ist_table[i];
2594
            av_free(ist);
2595
        }
2596
        av_free(ist_table);
2597
    }
2598
    if (ost_table) {
2599
        for(i=0;i<nb_ostreams;i++) {
2600
            ost = ost_table[i];
2601
            if (ost) {
2602
                if (ost->st->stream_copy)
2603
                    av_freep(&ost->st->codec->extradata);
2604
                if (ost->logfile) {
2605
                    fclose(ost->logfile);
2606
                    ost->logfile = NULL;
2607
                }
2608
                av_fifo_free(ost->fifo); /* works even if fifo is not
2609
                                             initialized but set to zero */
2610
                av_free(ost->pict_tmp.data[0]);
2611
                av_free(ost->forced_kf_pts);
2612
                if (ost->video_resample)
2613
                    sws_freeContext(ost->img_resample_ctx);
2614
                if (ost->resample)
2615
                    audio_resample_close(ost->resample);
2616
                if (ost->reformat_ctx)
2617
                    av_audio_convert_free(ost->reformat_ctx);
2618
                av_free(ost);
2619
            }
2620
        }
2621
        av_free(ost_table);
2622
    }
2623
    return ret;
2624
}
2625

    
2626
static void opt_format(const char *arg)
2627
{
2628
    /* compatibility stuff for pgmyuv */
2629
    if (!strcmp(arg, "pgmyuv")) {
2630
        pgmyuv_compatibility_hack=1;
2631
//        opt_image_format(arg);
2632
        arg = "image2";
2633
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2634
    }
2635

    
2636
    last_asked_format = arg;
2637
}
2638

    
2639
static void opt_video_rc_override_string(const char *arg)
2640
{
2641
    video_rc_override_string = arg;
2642
}
2643

    
2644
static int opt_me_threshold(const char *opt, const char *arg)
2645
{
2646
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2647
    return 0;
2648
}
2649

    
2650
static int opt_verbose(const char *opt, const char *arg)
2651
{
2652
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2653
    return 0;
2654
}
2655

    
2656
static int opt_frame_rate(const char *opt, const char *arg)
2657
{
2658
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2659
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2660
        ffmpeg_exit(1);
2661
    }
2662
    return 0;
2663
}
2664

    
2665
static int opt_bitrate(const char *opt, const char *arg)
2666
{
2667
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2668

    
2669
    opt_default(opt, arg);
2670

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

    
2674
    return 0;
2675
}
2676

    
2677
static int opt_frame_crop(const char *opt, const char *arg)
2678
{
2679
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2680
    return AVERROR(EINVAL);
2681
}
2682

    
2683
static void opt_frame_size(const char *arg)
2684
{
2685
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2686
        fprintf(stderr, "Incorrect frame size\n");
2687
        ffmpeg_exit(1);
2688
    }
2689
}
2690

    
2691
static int opt_pad(const char *opt, const char *arg) {
2692
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2693
    return -1;
2694
}
2695

    
2696
static void opt_frame_pix_fmt(const char *arg)
2697
{
2698
    if (strcmp(arg, "list")) {
2699
        frame_pix_fmt = av_get_pix_fmt(arg);
2700
        if (frame_pix_fmt == PIX_FMT_NONE) {
2701
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2702
            ffmpeg_exit(1);
2703
        }
2704
    } else {
2705
        show_pix_fmts();
2706
        ffmpeg_exit(0);
2707
    }
2708
}
2709

    
2710
static void opt_frame_aspect_ratio(const char *arg)
2711
{
2712
    int x = 0, y = 0;
2713
    double ar = 0;
2714
    const char *p;
2715
    char *end;
2716

    
2717
    p = strchr(arg, ':');
2718
    if (p) {
2719
        x = strtol(arg, &end, 10);
2720
        if (end == p)
2721
            y = strtol(end+1, &end, 10);
2722
        if (x > 0 && y > 0)
2723
            ar = (double)x / (double)y;
2724
    } else
2725
        ar = strtod(arg, NULL);
2726

    
2727
    if (!ar) {
2728
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2729
        ffmpeg_exit(1);
2730
    }
2731
    frame_aspect_ratio = ar;
2732
}
2733

    
2734
static int opt_metadata(const char *opt, const char *arg)
2735
{
2736
    char *mid= strchr(arg, '=');
2737

    
2738
    if(!mid){
2739
        fprintf(stderr, "Missing =\n");
2740
        ffmpeg_exit(1);
2741
    }
2742
    *mid++= 0;
2743

    
2744
    av_metadata_set2(&metadata, arg, mid, 0);
2745

    
2746
    return 0;
2747
}
2748

    
2749
static void opt_qscale(const char *arg)
2750
{
2751
    video_qscale = atof(arg);
2752
    if (video_qscale <= 0 ||
2753
        video_qscale > 255) {
2754
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2755
        ffmpeg_exit(1);
2756
    }
2757
}
2758

    
2759
static void opt_top_field_first(const char *arg)
2760
{
2761
    top_field_first= atoi(arg);
2762
}
2763

    
2764
static int opt_thread_count(const char *opt, const char *arg)
2765
{
2766
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2767
#if !HAVE_THREADS
2768
    if (verbose >= 0)
2769
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2770
#endif
2771
    return 0;
2772
}
2773

    
2774
static void opt_audio_sample_fmt(const char *arg)
2775
{
2776
    if (strcmp(arg, "list"))
2777
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2778
    else {
2779
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2780
        ffmpeg_exit(0);
2781
    }
2782
}
2783

    
2784
static int opt_audio_rate(const char *opt, const char *arg)
2785
{
2786
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2787
    return 0;
2788
}
2789

    
2790
static int opt_audio_channels(const char *opt, const char *arg)
2791
{
2792
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2793
    return 0;
2794
}
2795

    
2796
static void opt_video_channel(const char *arg)
2797
{
2798
    video_channel = strtol(arg, NULL, 0);
2799
}
2800

    
2801
static void opt_video_standard(const char *arg)
2802
{
2803
    video_standard = av_strdup(arg);
2804
}
2805

    
2806
static void opt_codec(int *pstream_copy, char **pcodec_name,
2807
                      int codec_type, const char *arg)
2808
{
2809
    av_freep(pcodec_name);
2810
    if (!strcmp(arg, "copy")) {
2811
        *pstream_copy = 1;
2812
    } else {
2813
        *pcodec_name = av_strdup(arg);
2814
    }
2815
}
2816

    
2817
static void opt_audio_codec(const char *arg)
2818
{
2819
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2820
}
2821

    
2822
static void opt_video_codec(const char *arg)
2823
{
2824
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2825
}
2826

    
2827
static void opt_subtitle_codec(const char *arg)
2828
{
2829
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2830
}
2831

    
2832
static void opt_codec_tag(const char *opt, const char *arg)
2833
{
2834
    char *tail;
2835
    uint32_t *codec_tag;
2836

    
2837
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2838
                !strcmp(opt, "vtag") ? &video_codec_tag :
2839
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2840

    
2841
    *codec_tag = strtol(arg, &tail, 0);
2842
    if (!tail || *tail)
2843
        *codec_tag = arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2844
}
2845

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

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

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

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

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

    
2876
    m = &meta_data_maps[nb_meta_data_maps++];
2877

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

    
2882
    m->in_file = strtol(p, &p, 0);
2883
}
2884

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

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

    
2896
    if(stream >= MAX_STREAMS)
2897
        ffmpeg_exit(1);
2898

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

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

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

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

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

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

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

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

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

    
2977
    if (!strcmp(filename, "-"))
2978
        filename = "pipe:";
2979

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

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

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

    
3003
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3004

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

    
3016
    if(pgmyuv_compatibility_hack)
3017
        ic->video_codec_id= CODEC_ID_PGMYUV;
3018

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

    
3049
    ic->loop_input = loop_input;
3050

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

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

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

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

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

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

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

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

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

    
3158
    nb_input_files++;
3159

    
3160
    video_channel = 0;
3161

    
3162
    av_freep(&video_codec_name);
3163
    av_freep(&audio_codec_name);
3164
    av_freep(&subtitle_codec_name);
3165
}
3166

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

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

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

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

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

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

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

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

    
3257
    avcodec_thread_init(st->codec, thread_count);
3258

    
3259
    video_enc = st->codec;
3260

    
3261
    if(video_codec_tag)
3262
        video_enc->codec_tag= video_codec_tag;
3263

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

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

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

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

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

    
3298
        choose_pixel_fmt(st, codec);
3299

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

    
3308
        if(intra_matrix)
3309
            video_enc->intra_matrix = intra_matrix;
3310
        if(inter_matrix)
3311
            video_enc->inter_matrix = inter_matrix;
3312

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

    
3343
        if (do_psnr)
3344
            video_enc->flags|= CODEC_FLAG_PSNR;
3345

    
3346
        /* two pass mode */
3347
        if (do_pass) {
3348
            if (do_pass == 1) {
3349
                video_enc->flags |= CODEC_FLAG_PASS1;
3350
            } else {
3351
                video_enc->flags |= CODEC_FLAG_PASS2;
3352
            }
3353
        }
3354

    
3355
        if (forced_key_frames)
3356
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3357
    }
3358
    if (video_language) {
3359
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3360
        av_freep(&video_language);
3361
    }
3362

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

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

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

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

    
3399
    avcodec_get_context_defaults3(st->codec, codec);
3400

    
3401
    ost->bitstream_filters = audio_bitstream_filters;
3402
    audio_bitstream_filters= NULL;
3403

    
3404
    avcodec_thread_init(st->codec, thread_count);
3405

    
3406
    audio_enc = st->codec;
3407
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3408

    
3409
    if(audio_codec_tag)
3410
        audio_enc->codec_tag= audio_codec_tag;
3411

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

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

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

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

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

    
3471
    ost->bitstream_filters = subtitle_bitstream_filters;
3472
    subtitle_bitstream_filters= NULL;
3473

    
3474
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3475

    
3476
    if(subtitle_codec_tag)
3477
        subtitle_enc->codec_tag= subtitle_codec_tag;
3478

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

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

    
3490
    subtitle_disable = 0;
3491
    av_freep(&subtitle_codec_name);
3492
    subtitle_stream_copy = 0;
3493
}
3494

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

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

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

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

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

    
3544
    if (!strcmp(filename, "-"))
3545
        filename = "pipe:";
3546

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

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

    
3569
    oc->oformat = file_oformat;
3570
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3571

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

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

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

    
3604
        if (use_video)    new_video_stream(oc, nb_output_files);
3605
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3606
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3607

    
3608
        oc->timestamp = recording_timestamp;
3609

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

    
3615
    output_files[nb_output_files++] = oc;
3616

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

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

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

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

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

    
3666
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3667

    
3668
    nb_streamid_map = 0;
3669
    av_freep(&forced_key_frames);
3670
}
3671

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

    
3684
static int64_t getutime(void)
3685
{
3686
#if HAVE_GETRUSAGE
3687
    struct rusage rusage;
3688

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

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

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

    
3737
static void opt_inter_matrix(const char *arg)
3738
{
3739
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3740
    parse_matrix_coeffs(inter_matrix, arg);
3741
}
3742

    
3743
static void opt_intra_matrix(const char *arg)
3744
{
3745
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3746
    parse_matrix_coeffs(intra_matrix, arg);
3747
}
3748

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

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

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

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

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

    
3847
    if(!strcmp(arg, "vcd")) {
3848

    
3849
        opt_video_codec("mpeg1video");
3850
        opt_audio_codec("mp2");
3851
        opt_format("vcd");
3852

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

    
3857
        opt_default("b", "1150000");
3858
        opt_default("maxrate", "1150000");
3859
        opt_default("minrate", "1150000");
3860
        opt_default("bufsize", "327680"); // 40*1024*8;
3861

    
3862
        opt_default("ab", "224000");
3863
        audio_sample_rate = 44100;
3864
        audio_channels = 2;
3865

    
3866
        opt_default("packetsize", "2324");
3867
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3868

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

    
3877
        opt_video_codec("mpeg2video");
3878
        opt_audio_codec("mp2");
3879
        opt_format("svcd");
3880

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

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

    
3891

    
3892
        opt_default("ab", "224000");
3893
        audio_sample_rate = 44100;
3894

    
3895
        opt_default("packetsize", "2324");
3896

    
3897
    } else if(!strcmp(arg, "dvd")) {
3898

    
3899
        opt_video_codec("mpeg2video");
3900
        opt_audio_codec("ac3");
3901
        opt_format("dvd");
3902

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

    
3907
        opt_default("b", "6000000");
3908
        opt_default("maxrate", "9000000");
3909
        opt_default("minrate", "0"); //1500000;
3910
        opt_default("bufsize", "1835008"); //224*1024*8;
3911

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

    
3915
        opt_default("ab", "448000");
3916
        audio_sample_rate = 48000;
3917

    
3918
    } else if(!strncmp(arg, "dv", 2)) {
3919

    
3920
        opt_format("dv");
3921

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

    
3927
        audio_sample_rate = 48000;
3928
        audio_channels = 2;
3929

    
3930
    } else {
3931
        fprintf(stderr, "Unknown target: %s\n", arg);
3932
        ffmpeg_exit(1);
3933
    }
3934
}
3935

    
3936
static void opt_vstats_file (const char *arg)
3937
{
3938
    av_free (vstats_filename);
3939
    vstats_filename=av_strdup (arg);
3940
}
3941

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

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

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

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

    
3963
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3964
          *opt == 'a' ? &audio_bitstream_filters :
3965
                        &subtitle_bitstream_filters;
3966
    while(*bsfp)
3967
        bsfp= &(*bsfp)->next;
3968

    
3969
    *bsfp= bsfc;
3970

    
3971
    return 0;
3972
}
3973

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

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

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

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

    
4029
    fclose(f);
4030

    
4031
    return 0;
4032
}
4033

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

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

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

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

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

    
4148
    /* muxer options */
4149
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4150
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4151

    
4152
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4153
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4154
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4155

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

    
4161
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4162
    { NULL, },
4163
};
4164

    
4165
int main(int argc, char **argv)
4166
{
4167
    int64_t ti;
4168

    
4169
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4170

    
4171
    avcodec_register_all();
4172
#if CONFIG_AVDEVICE
4173
    avdevice_register_all();
4174
#endif
4175
#if CONFIG_AVFILTER
4176
    avfilter_register_all();
4177
#endif
4178
    av_register_all();
4179

    
4180
#if HAVE_ISATTY
4181
    if(isatty(STDIN_FILENO))
4182
        url_set_interrupt_cb(decode_interrupt_cb);
4183
#endif
4184

    
4185
    init_opts();
4186

    
4187
    show_banner();
4188

    
4189
    /* parse options */
4190
    parse_options(argc, argv, options, opt_output_file);
4191

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

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

    
4204
    if (nb_input_files == 0) {
4205
        fprintf(stderr, "At least one input file must be specified\n");
4206
        ffmpeg_exit(1);
4207
    }
4208

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

    
4219
    return ffmpeg_exit(0);
4220
}