Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4ad08021

History | View | Annotate | Download (154 KB)

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

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

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

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

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

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

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

    
80
#include "cmdutils.h"
81

    
82
#include "libavutil/avassert.h"
83

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

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

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

    
103
static const OptionDef options[];
104

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

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

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

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

    
127
static AVMetaDataMap meta_data_maps[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
    AVFrame picture_crop_temp, picture_pad_temp;
1068
    AVCodecContext *enc, *dec;
1069
    double sync_ipts;
1070

    
1071
    avcodec_get_frame_defaults(&picture_crop_temp);
1072
    avcodec_get_frame_defaults(&picture_pad_temp);
1073

    
1074
    enc = ost->st->codec;
1075
    dec = ist->st->codec;
1076

    
1077
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1078

    
1079
    /* by default, we output a single frame */
1080
    nb_frames = 1;
1081

    
1082
    *frame_size = 0;
1083

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

    
1109
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1110
    if (nb_frames <= 0)
1111
        return;
1112

    
1113
    formatted_picture = in_picture;
1114
    final_picture = formatted_picture;
1115
    padding_src = formatted_picture;
1116
    resampling_dst = &ost->pict_tmp;
1117

    
1118
    if (   ost->resample_height != ist->st->codec->height
1119
        || ost->resample_width  != ist->st->codec->width
1120
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1121

    
1122
        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));
1123
        if(!ost->video_resample)
1124
            ffmpeg_exit(1);
1125
    }
1126

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

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

    
1156
    /* duplicates frame if needed */
1157
    for(i=0;i<nb_frames;i++) {
1158
        AVPacket pkt;
1159
        av_init_packet(&pkt);
1160
        pkt.stream_index= ost->index;
1161

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

    
1173
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1174
            enc->coded_frame = old_frame;
1175
        } else {
1176
            AVFrame big_picture;
1177

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

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

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

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

    
1238
static double psnr(double d){
1239
    return -10.0*log(d)/log(10.0);
1240
}
1241

    
1242
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1243
                           int frame_size)
1244
{
1245
    AVCodecContext *enc;
1246
    int frame_number;
1247
    double ti1, bitrate, avg_bitrate;
1248

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

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

    
1265
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1266
        /* compute pts value */
1267
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1268
        if (ti1 < 0.01)
1269
            ti1 = 0.01;
1270

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

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

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

    
1306

    
1307
    oc = output_files[0];
1308

    
1309
    total_size = url_fsize(oc->pb);
1310
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1311
        total_size= url_ftell(oc->pb);
1312

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

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

    
1373
    if (verbose || is_last_report) {
1374
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1375

    
1376
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1377
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1378
            (double)total_size / 1024, ti1, bitrate);
1379

    
1380
        if (nb_frames_dup || nb_frames_drop)
1381
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1382
                  nb_frames_dup, nb_frames_drop);
1383

    
1384
        if (verbose >= 0)
1385
            fprintf(stderr, "%s    \r", buf);
1386

    
1387
        fflush(stderr);
1388
    }
1389

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

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

    
1420
    AVPacket avpkt;
1421
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1422

    
1423
    if(ist->next_pts == AV_NOPTS_VALUE)
1424
        ist->next_pts= ist->pts;
1425

    
1426
    if (pkt == NULL) {
1427
        /* EOF handling */
1428
        av_init_packet(&avpkt);
1429
        avpkt.data = NULL;
1430
        avpkt.size = 0;
1431
        goto handle_eof;
1432
    } else {
1433
        avpkt = *pkt;
1434
    }
1435

    
1436
    if(pkt->dts != AV_NOPTS_VALUE)
1437
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1438
    if(pkt->pts != AV_NOPTS_VALUE)
1439
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1440

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

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

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

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

    
1546
        buffer_to_free = NULL;
1547
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1548
            pre_process_video_frame(ist, (AVPicture *)&picture,
1549
                                    &buffer_to_free);
1550
        }
1551

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

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

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

    
1600
                ost = ost_table[i];
1601
                if (ost->source_index == ist_index) {
1602
                    os = output_files[ost->file_index];
1603

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

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

    
1634
                        av_init_packet(&opkt);
1635

    
1636
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1637
                            continue;
1638

    
1639
                        /* no reencoding needed : output the packet directly */
1640
                        /* force the input stream PTS */
1641

    
1642
                        avcodec_get_frame_defaults(&avframe);
1643
                        ost->st->codec->coded_frame= &avframe;
1644
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1645

    
1646
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1647
                            audio_size += data_size;
1648
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1649
                            video_size += data_size;
1650
                            ost->sync_opts++;
1651
                        }
1652

    
1653
                        opkt.stream_index= ost->index;
1654
                        if(pkt->pts != AV_NOPTS_VALUE)
1655
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1656
                        else
1657
                            opkt.pts= AV_NOPTS_VALUE;
1658

    
1659
                        if (pkt->dts == AV_NOPTS_VALUE)
1660
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1661
                        else
1662
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1663
                        opkt.dts -= ost_tb_start_time;
1664

    
1665
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1666
                        opkt.flags= pkt->flags;
1667

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

    
1680
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1681
                        ost->st->codec->frame_number++;
1682
                        ost->frame_number++;
1683
                        av_free_packet(&opkt);
1684
                    }
1685
                }
1686
            }
1687

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

    
1714
        for(i=0;i<nb_ostreams;i++) {
1715
            ost = ost_table[i];
1716
            if (ost->source_index == ist_index) {
1717
                AVCodecContext *enc= ost->st->codec;
1718
                os = output_files[ost->file_index];
1719

    
1720
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1721
                    continue;
1722
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1723
                    continue;
1724

    
1725
                if (ost->encoding_needed) {
1726
                    for(;;) {
1727
                        AVPacket pkt;
1728
                        int fifo_bytes;
1729
                        av_init_packet(&pkt);
1730
                        pkt.stream_index= ost->index;
1731

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

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

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

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

    
1796
    return 0;
1797
 fail_decode:
1798
    return -1;
1799
}
1800

    
1801
static void print_sdp(AVFormatContext **avc, int n)
1802
{
1803
    char sdp[2048];
1804

    
1805
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1806
    printf("SDP:\n%s\n", sdp);
1807
    fflush(stdout);
1808
}
1809

    
1810
static int copy_chapters(int infile, int outfile)
1811
{
1812
    AVFormatContext *is = input_files[infile];
1813
    AVFormatContext *os = output_files[outfile];
1814
    int i;
1815

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

    
1824

    
1825
        if (in_ch->end < ts_off)
1826
            continue;
1827
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1828
            break;
1829

    
1830
        out_ch = av_mallocz(sizeof(AVChapter));
1831
        if (!out_ch)
1832
            return AVERROR(ENOMEM);
1833

    
1834
        out_ch->id        = in_ch->id;
1835
        out_ch->time_base = in_ch->time_base;
1836
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1837
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1838

    
1839
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1840
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1841

    
1842
        os->nb_chapters++;
1843
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1844
        if (!os->chapters)
1845
            return AVERROR(ENOMEM);
1846
        os->chapters[os->nb_chapters - 1] = out_ch;
1847
    }
1848
    return 0;
1849
}
1850

    
1851
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1852
                                    AVCodecContext *avctx)
1853
{
1854
    char *p;
1855
    int n = 1, i;
1856
    int64_t t;
1857

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

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

    
1895
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1896
    if (!file_table)
1897
        goto fail;
1898

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

    
1909
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1910
    if (!ist_table)
1911
        goto fail;
1912

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

    
1930
            if (rate_emu) {
1931
                ist->start = av_gettime();
1932
            }
1933
        }
1934
    }
1935

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

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

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

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

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

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

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

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

    
2065
        codec = ost->st->codec;
2066
        icodec = ist->st->codec;
2067

    
2068
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2069
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2070
        }
2071

    
2072
        ost->st->disposition = ist->st->disposition;
2073
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2074
        codec->chroma_sample_location = icodec->chroma_sample_location;
2075

    
2076
        if (ost->st->stream_copy) {
2077
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2078

    
2079
            if (extra_size > INT_MAX)
2080
                goto fail;
2081

    
2082
            /* if stream_copy is selected, no need to decode or encode */
2083
            codec->codec_id = icodec->codec_id;
2084
            codec->codec_type = icodec->codec_type;
2085

    
2086
            if(!codec->codec_tag){
2087
                if(   !os->oformat->codec_tag
2088
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2089
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2090
                    codec->codec_tag = icodec->codec_tag;
2091
            }
2092

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

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

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

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

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

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

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

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

    
2305
    /* set meta data information from input file if required */
2306
    for (i=0;i<nb_meta_data_maps;i++) {
2307
        AVFormatContext *out_file;
2308
        AVFormatContext *in_file;
2309
        AVMetadataTag *mtag;
2310

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

    
2326
        out_file = output_files[out_file_index];
2327
        in_file = input_files[in_file_index];
2328

    
2329

    
2330
        mtag=NULL;
2331
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2332
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2333
    }
2334

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

    
2340
        for (j = 0; j < nb_output_files; j++)
2341
            if ((ret = copy_chapters(i, j)) < 0)
2342
                goto dump_format;
2343
    }
2344

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

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

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

    
2383
    if (ret) {
2384
        fprintf(stderr, "%s\n", error);
2385
        goto fail;
2386
    }
2387

    
2388
    if (want_sdp) {
2389
        print_sdp(output_files, nb_output_files);
2390
    }
2391

    
2392
    if (!using_stdin && verbose >= 0) {
2393
        fprintf(stderr, "Press [q] to stop encoding\n");
2394
        url_set_interrupt_cb(decode_interrupt_cb);
2395
    }
2396
    term_init();
2397

    
2398
    timer_start = av_gettime();
2399

    
2400
    for(; received_sigterm == 0;) {
2401
        int file_index, ist_index;
2402
        AVPacket pkt;
2403
        double ipts_min;
2404
        double opts_min;
2405

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

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

    
2457
        /* finish if limit size exhausted */
2458
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2459
            break;
2460

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

    
2477
        no_packet_count=0;
2478
        memset(no_packet, 0, sizeof(no_packet));
2479

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

    
2492
        if (pkt.dts != AV_NOPTS_VALUE)
2493
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2494
        if (pkt.pts != AV_NOPTS_VALUE)
2495
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2496

    
2497
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2498
            && input_files_ts_scale[file_index][pkt.stream_index]){
2499
            if(pkt.pts != AV_NOPTS_VALUE)
2500
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2501
            if(pkt.dts != AV_NOPTS_VALUE)
2502
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2503
        }
2504

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

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

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

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

    
2539
    discard_packet:
2540
        av_free_packet(&pkt);
2541

    
2542
        /* dump report by using the output first video and audio streams */
2543
        print_report(output_files, ost_table, nb_ostreams, 0);
2544
    }
2545

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

    
2554
    term_exit();
2555

    
2556
    /* write the trailer if needed and close file */
2557
    for(i=0;i<nb_output_files;i++) {
2558
        os = output_files[i];
2559
        av_write_trailer(os);
2560
    }
2561

    
2562
    /* dump report by using the first video and audio streams */
2563
    print_report(output_files, ost_table, nb_ostreams, 1);
2564

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

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

    
2588
    /* finished ! */
2589
    ret = 0;
2590

    
2591
 fail:
2592
    av_freep(&bit_buffer);
2593
    av_free(file_table);
2594

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

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

    
2640
    last_asked_format = arg;
2641
}
2642

    
2643
static void opt_video_rc_override_string(const char *arg)
2644
{
2645
    video_rc_override_string = arg;
2646
}
2647

    
2648
static int opt_me_threshold(const char *opt, const char *arg)
2649
{
2650
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2651
    return 0;
2652
}
2653

    
2654
static int opt_verbose(const char *opt, const char *arg)
2655
{
2656
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2657
    return 0;
2658
}
2659

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

    
2669
static int opt_bitrate(const char *opt, const char *arg)
2670
{
2671
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2672

    
2673
    opt_default(opt, arg);
2674

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

    
2678
    return 0;
2679
}
2680

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

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

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

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

    
2714
static void opt_frame_aspect_ratio(const char *arg)
2715
{
2716
    int x = 0, y = 0;
2717
    double ar = 0;
2718
    const char *p;
2719
    char *end;
2720

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

    
2731
    if (!ar) {
2732
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2733
        ffmpeg_exit(1);
2734
    }
2735
    frame_aspect_ratio = ar;
2736
}
2737

    
2738
static int opt_metadata(const char *opt, const char *arg)
2739
{
2740
    char *mid= strchr(arg, '=');
2741

    
2742
    if(!mid){
2743
        fprintf(stderr, "Missing =\n");
2744
        ffmpeg_exit(1);
2745
    }
2746
    *mid++= 0;
2747

    
2748
    av_metadata_set2(&metadata, arg, mid, 0);
2749

    
2750
    return 0;
2751
}
2752

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

    
2763
static void opt_top_field_first(const char *arg)
2764
{
2765
    top_field_first= atoi(arg);
2766
}
2767

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

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

    
2788
static int opt_audio_rate(const char *opt, const char *arg)
2789
{
2790
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2791
    return 0;
2792
}
2793

    
2794
static int opt_audio_channels(const char *opt, const char *arg)
2795
{
2796
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2797
    return 0;
2798
}
2799

    
2800
static void opt_video_channel(const char *arg)
2801
{
2802
    video_channel = strtol(arg, NULL, 0);
2803
}
2804

    
2805
static void opt_video_standard(const char *arg)
2806
{
2807
    video_standard = av_strdup(arg);
2808
}
2809

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

    
2821
static void opt_audio_codec(const char *arg)
2822
{
2823
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2824
}
2825

    
2826
static void opt_audio_tag(const char *arg)
2827
{
2828
    char *tail;
2829
    audio_codec_tag= strtol(arg, &tail, 0);
2830

    
2831
    if(!tail || *tail)
2832
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2833
}
2834

    
2835
static void opt_video_tag(const char *arg)
2836
{
2837
    char *tail;
2838
    video_codec_tag= strtol(arg, &tail, 0);
2839

    
2840
    if(!tail || *tail)
2841
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2842
}
2843

    
2844
static void opt_video_codec(const char *arg)
2845
{
2846
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2847
}
2848

    
2849
static void opt_subtitle_codec(const char *arg)
2850
{
2851
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2852
}
2853

    
2854
static void opt_subtitle_tag(const char *arg)
2855
{
2856
    char *tail;
2857
    subtitle_codec_tag= strtol(arg, &tail, 0);
2858

    
2859
    if(!tail || *tail)
2860
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2861
}
2862

    
2863
static void opt_map(const char *arg)
2864
{
2865
    AVStreamMap *m;
2866
    char *p;
2867

    
2868
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2869
    m = &stream_maps[nb_stream_maps-1];
2870

    
2871
    m->file_index = strtol(arg, &p, 0);
2872
    if (*p)
2873
        p++;
2874

    
2875
    m->stream_index = strtol(p, &p, 0);
2876
    if (*p) {
2877
        p++;
2878
        m->sync_file_index = strtol(p, &p, 0);
2879
        if (*p)
2880
            p++;
2881
        m->sync_stream_index = strtol(p, &p, 0);
2882
    } else {
2883
        m->sync_file_index = m->file_index;
2884
        m->sync_stream_index = m->stream_index;
2885
    }
2886
}
2887

    
2888
static void opt_map_meta_data(const char *arg)
2889
{
2890
    AVMetaDataMap *m;
2891
    char *p;
2892

    
2893
    m = &meta_data_maps[nb_meta_data_maps++];
2894

    
2895
    m->out_file = strtol(arg, &p, 0);
2896
    if (*p)
2897
        p++;
2898

    
2899
    m->in_file = strtol(p, &p, 0);
2900
}
2901

    
2902
static void opt_input_ts_scale(const char *arg)
2903
{
2904
    unsigned int stream;
2905
    double scale;
2906
    char *p;
2907

    
2908
    stream = strtol(arg, &p, 0);
2909
    if (*p)
2910
        p++;
2911
    scale= strtod(p, &p);
2912

    
2913
    if(stream >= MAX_STREAMS)
2914
        ffmpeg_exit(1);
2915

    
2916
    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);
2917
    input_files_ts_scale[nb_input_files][stream]= scale;
2918
}
2919

    
2920
static int opt_recording_time(const char *opt, const char *arg)
2921
{
2922
    recording_time = parse_time_or_die(opt, arg, 1);
2923
    return 0;
2924
}
2925

    
2926
static int opt_start_time(const char *opt, const char *arg)
2927
{
2928
    start_time = parse_time_or_die(opt, arg, 1);
2929
    return 0;
2930
}
2931

    
2932
static int opt_recording_timestamp(const char *opt, const char *arg)
2933
{
2934
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2935
    return 0;
2936
}
2937

    
2938
static int opt_input_ts_offset(const char *opt, const char *arg)
2939
{
2940
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2941
    return 0;
2942
}
2943

    
2944
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
2945
{
2946
    const char *codec_string = encoder ? "encoder" : "decoder";
2947
    AVCodec *codec;
2948

    
2949
    if(!name)
2950
        return CODEC_ID_NONE;
2951
    codec = encoder ?
2952
        avcodec_find_encoder_by_name(name) :
2953
        avcodec_find_decoder_by_name(name);
2954
    if(!codec) {
2955
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2956
        ffmpeg_exit(1);
2957
    }
2958
    if(codec->type != type) {
2959
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2960
        ffmpeg_exit(1);
2961
    }
2962
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
2963
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
2964
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
2965
                "results.\nAdd '-strict experimental' if you want to use it.\n",
2966
                codec_string, codec->name);
2967
        codec = encoder ?
2968
            avcodec_find_encoder(codec->id) :
2969
            avcodec_find_decoder(codec->id);
2970
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
2971
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
2972
                    codec_string, codec->name);
2973
        ffmpeg_exit(1);
2974
    }
2975
    return codec->id;
2976
}
2977

    
2978
static void opt_input_file(const char *filename)
2979
{
2980
    AVFormatContext *ic;
2981
    AVFormatParameters params, *ap = &params;
2982
    AVInputFormat *file_iformat = NULL;
2983
    int err, i, ret, rfps, rfps_base;
2984
    int64_t timestamp;
2985

    
2986
    if (last_asked_format) {
2987
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
2988
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2989
            ffmpeg_exit(1);
2990
        }
2991
        last_asked_format = NULL;
2992
    }
2993

    
2994
    if (!strcmp(filename, "-"))
2995
        filename = "pipe:";
2996

    
2997
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2998
                    !strcmp(filename, "/dev/stdin");
2999

    
3000
    /* get default parameters from command line */
3001
    ic = avformat_alloc_context();
3002
    if (!ic) {
3003
        print_error(filename, AVERROR(ENOMEM));
3004
        ffmpeg_exit(1);
3005
    }
3006

    
3007
    memset(ap, 0, sizeof(*ap));
3008
    ap->prealloced_context = 1;
3009
    ap->sample_rate = audio_sample_rate;
3010
    ap->channels = audio_channels;
3011
    ap->time_base.den = frame_rate.num;
3012
    ap->time_base.num = frame_rate.den;
3013
    ap->width = frame_width;
3014
    ap->height = frame_height;
3015
    ap->pix_fmt = frame_pix_fmt;
3016
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3017
    ap->channel = video_channel;
3018
    ap->standard = video_standard;
3019

    
3020
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3021

    
3022
    ic->video_codec_id   =
3023
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3024
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3025
    ic->audio_codec_id   =
3026
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3027
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3028
    ic->subtitle_codec_id=
3029
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3030
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3031
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3032

    
3033
    if(pgmyuv_compatibility_hack)
3034
        ic->video_codec_id= CODEC_ID_PGMYUV;
3035

    
3036
    /* open the input file with generic libav function */
3037
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3038
    if (err < 0) {
3039
        print_error(filename, err);
3040
        ffmpeg_exit(1);
3041
    }
3042
    if(opt_programid) {
3043
        int i, j;
3044
        int found=0;
3045
        for(i=0; i<ic->nb_streams; i++){
3046
            ic->streams[i]->discard= AVDISCARD_ALL;
3047
        }
3048
        for(i=0; i<ic->nb_programs; i++){
3049
            AVProgram *p= ic->programs[i];
3050
            if(p->id != opt_programid){
3051
                p->discard = AVDISCARD_ALL;
3052
            }else{
3053
                found=1;
3054
                for(j=0; j<p->nb_stream_indexes; j++){
3055
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3056
                }
3057
            }
3058
        }
3059
        if(!found){
3060
            fprintf(stderr, "Specified program id not found\n");
3061
            ffmpeg_exit(1);
3062
        }
3063
        opt_programid=0;
3064
    }
3065

    
3066
    ic->loop_input = loop_input;
3067

    
3068
    /* If not enough info to get the stream parameters, we decode the
3069
       first frames to get it. (used in mpeg case for example) */
3070
    ret = av_find_stream_info(ic);
3071
    if (ret < 0 && verbose >= 0) {
3072
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3073
        av_close_input_file(ic);
3074
        ffmpeg_exit(1);
3075
    }
3076

    
3077
    timestamp = start_time;
3078
    /* add the stream start time */
3079
    if (ic->start_time != AV_NOPTS_VALUE)
3080
        timestamp += ic->start_time;
3081

    
3082
    /* if seeking requested, we execute it */
3083
    if (start_time != 0) {
3084
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3085
        if (ret < 0) {
3086
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3087
                    filename, (double)timestamp / AV_TIME_BASE);
3088
        }
3089
        /* reset seek info */
3090
        start_time = 0;
3091
    }
3092

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

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

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

    
3143
                    (float)rfps / rfps_base, rfps, rfps_base);
3144
            }
3145
            /* update the current frame rate to match the stream frame rate */
3146
            frame_rate.num = rfps;
3147
            frame_rate.den = rfps_base;
3148

    
3149
            if(video_disable)
3150
                st->discard= AVDISCARD_ALL;
3151
            else if(video_discard)
3152
                st->discard= video_discard;
3153
            break;
3154
        case AVMEDIA_TYPE_DATA:
3155
            break;
3156
        case AVMEDIA_TYPE_SUBTITLE:
3157
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3158
            if(subtitle_disable)
3159
                st->discard = AVDISCARD_ALL;
3160
            break;
3161
        case AVMEDIA_TYPE_ATTACHMENT:
3162
        case AVMEDIA_TYPE_UNKNOWN:
3163
            break;
3164
        default:
3165
            abort();
3166
        }
3167
    }
3168

    
3169
    input_files[nb_input_files] = ic;
3170
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3171
    /* dump the file content */
3172
    if (verbose >= 0)
3173
        dump_format(ic, nb_input_files, filename, 0);
3174

    
3175
    nb_input_files++;
3176

    
3177
    video_channel = 0;
3178

    
3179
    av_freep(&video_codec_name);
3180
    av_freep(&audio_codec_name);
3181
    av_freep(&subtitle_codec_name);
3182
}
3183

    
3184
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3185
                                         int *has_subtitle_ptr)
3186
{
3187
    int has_video, has_audio, has_subtitle, i, j;
3188
    AVFormatContext *ic;
3189

    
3190
    has_video = 0;
3191
    has_audio = 0;
3192
    has_subtitle = 0;
3193
    for(j=0;j<nb_input_files;j++) {
3194
        ic = input_files[j];
3195
        for(i=0;i<ic->nb_streams;i++) {
3196
            AVCodecContext *enc = ic->streams[i]->codec;
3197
            switch(enc->codec_type) {
3198
            case AVMEDIA_TYPE_AUDIO:
3199
                has_audio = 1;
3200
                break;
3201
            case AVMEDIA_TYPE_VIDEO:
3202
                has_video = 1;
3203
                break;
3204
            case AVMEDIA_TYPE_SUBTITLE:
3205
                has_subtitle = 1;
3206
                break;
3207
            case AVMEDIA_TYPE_DATA:
3208
            case AVMEDIA_TYPE_ATTACHMENT:
3209
            case AVMEDIA_TYPE_UNKNOWN:
3210
                break;
3211
            default:
3212
                abort();
3213
            }
3214
        }
3215
    }
3216
    *has_video_ptr = has_video;
3217
    *has_audio_ptr = has_audio;
3218
    *has_subtitle_ptr = has_subtitle;
3219
}
3220

    
3221
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
3222
{
3223
    int idx = oc->nb_streams - 1;
3224
    AVOutputStream *ost;
3225

    
3226
    output_streams_for_file[file_idx] =
3227
        grow_array(output_streams_for_file[file_idx],
3228
                   sizeof(*output_streams_for_file[file_idx]),
3229
                   &nb_output_streams_for_file[file_idx],
3230
                   oc->nb_streams);
3231
    ost = output_streams_for_file[file_idx][idx] =
3232
        av_mallocz(sizeof(AVOutputStream));
3233
    if (!ost) {
3234
        fprintf(stderr, "Could not alloc output stream\n");
3235
        ffmpeg_exit(1);
3236
    }
3237
    ost->file_index = file_idx;
3238
    ost->index = idx;
3239
    return ost;
3240
}
3241

    
3242
static void new_video_stream(AVFormatContext *oc, int file_idx)
3243
{
3244
    AVStream *st;
3245
    AVOutputStream *ost;
3246
    AVCodecContext *video_enc;
3247
    enum CodecID codec_id;
3248
    AVCodec *codec= NULL;
3249

    
3250
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3251
    if (!st) {
3252
        fprintf(stderr, "Could not alloc stream\n");
3253
        ffmpeg_exit(1);
3254
    }
3255
    ost = new_output_stream(oc, file_idx);
3256

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

    
3270
    avcodec_get_context_defaults3(st->codec, codec);
3271
    ost->bitstream_filters = video_bitstream_filters;
3272
    video_bitstream_filters= NULL;
3273

    
3274
    avcodec_thread_init(st->codec, thread_count);
3275

    
3276
    video_enc = st->codec;
3277

    
3278
    if(video_codec_tag)
3279
        video_enc->codec_tag= video_codec_tag;
3280

    
3281
    if(   (video_global_header&1)
3282
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3283
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3284
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3285
    }
3286
    if(video_global_header&2){
3287
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3288
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3289
    }
3290

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

    
3301
        video_enc->codec_id = codec_id;
3302
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3303

    
3304
        if (codec && codec->supported_framerates && !force_fps)
3305
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3306
        video_enc->time_base.den = fps.num;
3307
        video_enc->time_base.num = fps.den;
3308

    
3309
        video_enc->width = frame_width;
3310
        video_enc->height = frame_height;
3311
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3312
        video_enc->pix_fmt = frame_pix_fmt;
3313
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3314

    
3315
        choose_pixel_fmt(st, codec);
3316

    
3317
        if (intra_only)
3318
            video_enc->gop_size = 0;
3319
        if (video_qscale || same_quality) {
3320
            video_enc->flags |= CODEC_FLAG_QSCALE;
3321
            video_enc->global_quality=
3322
                st->quality = FF_QP2LAMBDA * video_qscale;
3323
        }
3324

    
3325
        if(intra_matrix)
3326
            video_enc->intra_matrix = intra_matrix;
3327
        if(inter_matrix)
3328
            video_enc->inter_matrix = inter_matrix;
3329

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

    
3360
        if (do_psnr)
3361
            video_enc->flags|= CODEC_FLAG_PSNR;
3362

    
3363
        /* two pass mode */
3364
        if (do_pass) {
3365
            if (do_pass == 1) {
3366
                video_enc->flags |= CODEC_FLAG_PASS1;
3367
            } else {
3368
                video_enc->flags |= CODEC_FLAG_PASS2;
3369
            }
3370
        }
3371

    
3372
        if (forced_key_frames)
3373
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3374
    }
3375
    if (video_language) {
3376
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3377
        av_freep(&video_language);
3378
    }
3379

    
3380
    /* reset some key parameters */
3381
    video_disable = 0;
3382
    av_freep(&video_codec_name);
3383
    av_freep(&forced_key_frames);
3384
    video_stream_copy = 0;
3385
    frame_pix_fmt = PIX_FMT_NONE;
3386
}
3387

    
3388
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3389
{
3390
    AVStream *st;
3391
    AVOutputStream *ost;
3392
    AVCodec *codec= NULL;
3393
    AVCodecContext *audio_enc;
3394
    enum CodecID codec_id;
3395

    
3396
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3397
    if (!st) {
3398
        fprintf(stderr, "Could not alloc stream\n");
3399
        ffmpeg_exit(1);
3400
    }
3401
    ost = new_output_stream(oc, file_idx);
3402

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

    
3416
    avcodec_get_context_defaults3(st->codec, codec);
3417

    
3418
    ost->bitstream_filters = audio_bitstream_filters;
3419
    audio_bitstream_filters= NULL;
3420

    
3421
    avcodec_thread_init(st->codec, thread_count);
3422

    
3423
    audio_enc = st->codec;
3424
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3425

    
3426
    if(audio_codec_tag)
3427
        audio_enc->codec_tag= audio_codec_tag;
3428

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

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

    
3460
    /* reset some key parameters */
3461
    audio_disable = 0;
3462
    av_freep(&audio_codec_name);
3463
    audio_stream_copy = 0;
3464
}
3465

    
3466
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3467
{
3468
    AVStream *st;
3469
    AVOutputStream *ost;
3470
    AVCodec *codec=NULL;
3471
    AVCodecContext *subtitle_enc;
3472

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

    
3488
    ost->bitstream_filters = subtitle_bitstream_filters;
3489
    subtitle_bitstream_filters= NULL;
3490

    
3491
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3492

    
3493
    if(subtitle_codec_tag)
3494
        subtitle_enc->codec_tag= subtitle_codec_tag;
3495

    
3496
    if (subtitle_stream_copy) {
3497
        st->stream_copy = 1;
3498
    } else {
3499
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3500
    }
3501

    
3502
    if (subtitle_language) {
3503
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3504
        av_freep(&subtitle_language);
3505
    }
3506

    
3507
    subtitle_disable = 0;
3508
    av_freep(&subtitle_codec_name);
3509
    subtitle_stream_copy = 0;
3510
}
3511

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

    
3522
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3523
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3524
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3525
    else av_assert0(0);
3526
    return 0;
3527
}
3528

    
3529
/* arg format is "output-stream-index:streamid-value". */
3530
static int opt_streamid(const char *opt, const char *arg)
3531
{
3532
    int idx;
3533
    char *p;
3534
    char idx_str[16];
3535

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

    
3552
static void opt_output_file(const char *filename)
3553
{
3554
    AVFormatContext *oc;
3555
    int err, use_video, use_audio, use_subtitle;
3556
    int input_has_video, input_has_audio, input_has_subtitle;
3557
    AVFormatParameters params, *ap = &params;
3558
    AVOutputFormat *file_oformat;
3559
    AVMetadataTag *tag = NULL;
3560

    
3561
    if (!strcmp(filename, "-"))
3562
        filename = "pipe:";
3563

    
3564
    oc = avformat_alloc_context();
3565
    if (!oc) {
3566
        print_error(filename, AVERROR(ENOMEM));
3567
        ffmpeg_exit(1);
3568
    }
3569

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

    
3586
    oc->oformat = file_oformat;
3587
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3588

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

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

    
3616
        /* manual disable */
3617
        if (audio_disable)    use_audio    = 0;
3618
        if (video_disable)    use_video    = 0;
3619
        if (subtitle_disable) use_subtitle = 0;
3620

    
3621
        if (use_video)    new_video_stream(oc, nb_output_files);
3622
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3623
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3624

    
3625
        oc->timestamp = recording_timestamp;
3626

    
3627
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3628
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3629
        av_metadata_free(&metadata);
3630
    }
3631

    
3632
    output_files[nb_output_files++] = oc;
3633

    
3634
    /* check filename in case of an image number is expected */
3635
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3636
        if (!av_filename_number_test(oc->filename)) {
3637
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3638
            ffmpeg_exit(1);
3639
        }
3640
    }
3641

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

    
3664
        /* open the file */
3665
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3666
            print_error(filename, err);
3667
            ffmpeg_exit(1);
3668
        }
3669
    }
3670

    
3671
    memset(ap, 0, sizeof(*ap));
3672
    if (av_set_parameters(oc, ap) < 0) {
3673
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3674
                oc->filename);
3675
        ffmpeg_exit(1);
3676
    }
3677

    
3678
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3679
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3680
    oc->loop_output = loop_output;
3681
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3682

    
3683
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3684

    
3685
    nb_streamid_map = 0;
3686
    av_freep(&forced_key_frames);
3687
}
3688

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

    
3701
static int64_t getutime(void)
3702
{
3703
#if HAVE_GETRUSAGE
3704
    struct rusage rusage;
3705

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

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

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

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

    
3760
static void opt_intra_matrix(const char *arg)
3761
{
3762
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3763
    parse_matrix_coeffs(intra_matrix, arg);
3764
}
3765

    
3766
static void show_usage(void)
3767
{
3768
    printf("Hyper fast Audio and Video encoder\n");
3769
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3770
    printf("\n");
3771
}
3772

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

    
3808
static void opt_target(const char *arg)
3809
{
3810
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3811
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3812

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

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

    
3864
    if(!strcmp(arg, "vcd")) {
3865

    
3866
        opt_video_codec("mpeg1video");
3867
        opt_audio_codec("mp2");
3868
        opt_format("vcd");
3869

    
3870
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3871
        opt_frame_rate(NULL, frame_rates[norm]);
3872
        opt_default("g", norm == PAL ? "15" : "18");
3873

    
3874
        opt_default("b", "1150000");
3875
        opt_default("maxrate", "1150000");
3876
        opt_default("minrate", "1150000");
3877
        opt_default("bufsize", "327680"); // 40*1024*8;
3878

    
3879
        opt_default("ab", "224000");
3880
        audio_sample_rate = 44100;
3881
        audio_channels = 2;
3882

    
3883
        opt_default("packetsize", "2324");
3884
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3885

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

    
3894
        opt_video_codec("mpeg2video");
3895
        opt_audio_codec("mp2");
3896
        opt_format("svcd");
3897

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

    
3902
        opt_default("b", "2040000");
3903
        opt_default("maxrate", "2516000");
3904
        opt_default("minrate", "0"); //1145000;
3905
        opt_default("bufsize", "1835008"); //224*1024*8;
3906
        opt_default("flags", "+scan_offset");
3907

    
3908

    
3909
        opt_default("ab", "224000");
3910
        audio_sample_rate = 44100;
3911

    
3912
        opt_default("packetsize", "2324");
3913

    
3914
    } else if(!strcmp(arg, "dvd")) {
3915

    
3916
        opt_video_codec("mpeg2video");
3917
        opt_audio_codec("ac3");
3918
        opt_format("dvd");
3919

    
3920
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3921
        opt_frame_rate(NULL, frame_rates[norm]);
3922
        opt_default("g", norm == PAL ? "15" : "18");
3923

    
3924
        opt_default("b", "6000000");
3925
        opt_default("maxrate", "9000000");
3926
        opt_default("minrate", "0"); //1500000;
3927
        opt_default("bufsize", "1835008"); //224*1024*8;
3928

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

    
3932
        opt_default("ab", "448000");
3933
        audio_sample_rate = 48000;
3934

    
3935
    } else if(!strncmp(arg, "dv", 2)) {
3936

    
3937
        opt_format("dv");
3938

    
3939
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3940
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3941
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3942
        opt_frame_rate(NULL, frame_rates[norm]);
3943

    
3944
        audio_sample_rate = 48000;
3945
        audio_channels = 2;
3946

    
3947
    } else {
3948
        fprintf(stderr, "Unknown target: %s\n", arg);
3949
        ffmpeg_exit(1);
3950
    }
3951
}
3952

    
3953
static void opt_vstats_file (const char *arg)
3954
{
3955
    av_free (vstats_filename);
3956
    vstats_filename=av_strdup (arg);
3957
}
3958

    
3959
static void opt_vstats (void)
3960
{
3961
    char filename[40];
3962
    time_t today2 = time(NULL);
3963
    struct tm *today = localtime(&today2);
3964

    
3965
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3966
             today->tm_sec);
3967
    opt_vstats_file(filename);
3968
}
3969

    
3970
static int opt_bsf(const char *opt, const char *arg)
3971
{
3972
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3973
    AVBitStreamFilterContext **bsfp;
3974

    
3975
    if(!bsfc){
3976
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3977
        ffmpeg_exit(1);
3978
    }
3979

    
3980
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3981
          *opt == 'a' ? &audio_bitstream_filters :
3982
                        &subtitle_bitstream_filters;
3983
    while(*bsfp)
3984
        bsfp= &(*bsfp)->next;
3985

    
3986
    *bsfp= bsfc;
3987

    
3988
    return 0;
3989
}
3990

    
3991
static int opt_preset(const char *opt, const char *arg)
3992
{
3993
    FILE *f=NULL;
3994
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3995
    int i;
3996
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
3997
                           getenv("HOME"),
3998
                           FFMPEG_DATADIR,
3999
                         };
4000

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

    
4020
    if(!f){
4021
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4022
        ffmpeg_exit(1);
4023
    }
4024

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

    
4046
    fclose(f);
4047

    
4048
    return 0;
4049
}
4050

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

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

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

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

    
4160
    /* grab options */
4161
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4162
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4163
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4164

    
4165
    /* muxer options */
4166
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4167
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4168

    
4169
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4170
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4171
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4172

    
4173
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4174
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4175
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4176
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4177

    
4178
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4179
    { NULL, },
4180
};
4181

    
4182
int main(int argc, char **argv)
4183
{
4184
    int64_t ti;
4185

    
4186
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4187

    
4188
    avcodec_register_all();
4189
#if CONFIG_AVDEVICE
4190
    avdevice_register_all();
4191
#endif
4192
#if CONFIG_AVFILTER
4193
    avfilter_register_all();
4194
#endif
4195
    av_register_all();
4196

    
4197
#if HAVE_ISATTY
4198
    if(isatty(STDIN_FILENO))
4199
        url_set_interrupt_cb(decode_interrupt_cb);
4200
#endif
4201

    
4202
    init_opts();
4203

    
4204
    show_banner();
4205

    
4206
    /* parse options */
4207
    parse_options(argc, argv, options, opt_output_file);
4208

    
4209
    if(nb_output_files <= 0 && nb_input_files == 0) {
4210
        show_usage();
4211
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4212
        ffmpeg_exit(1);
4213
    }
4214

    
4215
    /* file converter / grab */
4216
    if (nb_output_files <= 0) {
4217
        fprintf(stderr, "At least one output file must be specified\n");
4218
        ffmpeg_exit(1);
4219
    }
4220

    
4221
    if (nb_input_files == 0) {
4222
        fprintf(stderr, "At least one input file must be specified\n");
4223
        ffmpeg_exit(1);
4224
    }
4225

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

    
4236
    return ffmpeg_exit(0);
4237
}