Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0f27e6b4

History | View | Annotate | Download (159 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/audioconvert.h"
40
#include "libavcore/parseutils.h"
41
#include "libavcore/samplefmt.h"
42
#include "libavutil/colorspace.h"
43
#include "libavutil/fifo.h"
44
#include "libavutil/intreadwrite.h"
45
#include "libavutil/pixdesc.h"
46
#include "libavutil/avstring.h"
47
#include "libavutil/libm.h"
48
#include "libavformat/os_support.h"
49

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

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

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

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

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

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

    
97
/**
98
 * select an input file for an output file
99
 */
100
typedef struct AVMetaDataMap {
101
    int  file;      //< file index
102
    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103
    int  index;     //< stream/chapter/program number
104
} AVMetaDataMap;
105

    
106
typedef struct AVChapterMap {
107
    int in_file;
108
    int out_file;
109
} AVChapterMap;
110

    
111
static const OptionDef options[];
112

    
113
#define MAX_FILES 100
114
#if !FF_API_MAX_STREAMS
115
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
116
#endif
117

    
118
static const char *last_asked_format = NULL;
119
static AVFormatContext *input_files[MAX_FILES];
120
static int64_t input_files_ts_offset[MAX_FILES];
121
static double *input_files_ts_scale[MAX_FILES] = {NULL};
122
static AVCodec **input_codecs = NULL;
123
static int nb_input_files = 0;
124
static int nb_input_codecs = 0;
125
static int nb_input_files_ts_scale[MAX_FILES] = {0};
126

    
127
static AVFormatContext *output_files[MAX_FILES];
128
static AVCodec **output_codecs = NULL;
129
static int nb_output_files = 0;
130
static int nb_output_codecs = 0;
131

    
132
static AVStreamMap *stream_maps = NULL;
133
static int nb_stream_maps;
134

    
135
/* first item specifies output metadata, second is input */
136
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137
static int nb_meta_data_maps;
138
static int metadata_global_autocopy   = 1;
139
static int metadata_streams_autocopy  = 1;
140
static int metadata_chapters_autocopy = 1;
141

    
142
static AVChapterMap *chapter_maps = NULL;
143
static int nb_chapter_maps;
144

    
145
/* indexed by output file stream index */
146
static int *streamid_map = NULL;
147
static int nb_streamid_map = 0;
148

    
149
static int frame_width  = 0;
150
static int frame_height = 0;
151
static float frame_aspect_ratio = 0;
152
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153
static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155
static AVRational frame_rate;
156
static float video_qscale = 0;
157
static uint16_t *intra_matrix = NULL;
158
static uint16_t *inter_matrix = NULL;
159
static const char *video_rc_override_string=NULL;
160
static int video_disable = 0;
161
static int video_discard = 0;
162
static char *video_codec_name = NULL;
163
static unsigned int video_codec_tag = 0;
164
static char *video_language = NULL;
165
static int same_quality = 0;
166
static int do_deinterlace = 0;
167
static int top_field_first = -1;
168
static int me_threshold = 0;
169
static int intra_dc_precision = 8;
170
static int loop_input = 0;
171
static int loop_output = AVFMT_NOOUTPUTLOOP;
172
static int qp_hist = 0;
173
#if CONFIG_AVFILTER
174
static char *vfilters = NULL;
175
AVFilterGraph *graph = NULL;
176
#endif
177

    
178
static int intra_only = 0;
179
static int audio_sample_rate = 44100;
180
static int64_t channel_layout = 0;
181
#define QSCALE_NONE -99999
182
static float audio_qscale = QSCALE_NONE;
183
static int audio_disable = 0;
184
static int audio_channels = 1;
185
static char  *audio_codec_name = NULL;
186
static unsigned int audio_codec_tag = 0;
187
static char *audio_language = NULL;
188

    
189
static int subtitle_disable = 0;
190
static char *subtitle_codec_name = NULL;
191
static char *subtitle_language = NULL;
192
static unsigned int subtitle_codec_tag = 0;
193

    
194
static float mux_preload= 0.5;
195
static float mux_max_delay= 0.7;
196

    
197
static int64_t recording_time = INT64_MAX;
198
static int64_t start_time = 0;
199
static int64_t recording_timestamp = 0;
200
static int64_t input_ts_offset = 0;
201
static int file_overwrite = 0;
202
static AVMetadata *metadata;
203
static int do_benchmark = 0;
204
static int do_hex_dump = 0;
205
static int do_pkt_dump = 0;
206
static int do_psnr = 0;
207
static int do_pass = 0;
208
static char *pass_logfilename_prefix = NULL;
209
static int audio_stream_copy = 0;
210
static int video_stream_copy = 0;
211
static int subtitle_stream_copy = 0;
212
static int video_sync_method= -1;
213
static int audio_sync_method= 0;
214
static float audio_drift_threshold= 0.1;
215
static int copy_ts= 0;
216
static int copy_tb;
217
static int opt_shortest = 0;
218
static int video_global_header = 0;
219
static char *vstats_filename;
220
static FILE *vstats_file;
221
static int opt_programid = 0;
222
static int copy_initial_nonkeyframes = 0;
223

    
224
static int rate_emu = 0;
225

    
226
static int  video_channel = 0;
227
static char *video_standard;
228

    
229
static int audio_volume = 256;
230

    
231
static int exit_on_error = 0;
232
static int using_stdin = 0;
233
static int verbose = 1;
234
static int thread_count= 1;
235
static int q_pressed = 0;
236
static int64_t video_size = 0;
237
static int64_t audio_size = 0;
238
static int64_t extra_size = 0;
239
static int nb_frames_dup = 0;
240
static int nb_frames_drop = 0;
241
static int input_sync;
242
static uint64_t limit_filesize = 0;
243
static int force_fps = 0;
244
static char *forced_key_frames = NULL;
245

    
246
static float dts_delta_threshold = 10;
247

    
248
static unsigned int sws_flags = SWS_BICUBIC;
249

    
250
static int64_t timer_start;
251

    
252
static uint8_t *audio_buf;
253
static uint8_t *audio_out;
254
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
255

    
256
static short *samples;
257

    
258
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
259
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
260
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
261

    
262
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263

    
264
struct AVInputStream;
265

    
266
typedef struct AVOutputStream {
267
    int file_index;          /* file index */
268
    int index;               /* stream index in the output file */
269
    int source_index;        /* AVInputStream index */
270
    AVStream *st;            /* stream in the output file */
271
    int encoding_needed;     /* true if encoding needed for this stream */
272
    int frame_number;
273
    /* input pts and corresponding output pts
274
       for A/V sync */
275
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
276
    struct AVInputStream *sync_ist; /* input stream to sync against */
277
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
278
    AVBitStreamFilterContext *bitstream_filters;
279
    /* video only */
280
    int video_resample;
281
    AVFrame pict_tmp;      /* temporary image for resampling */
282
    struct SwsContext *img_resample_ctx; /* for image resampling */
283
    int resample_height;
284
    int resample_width;
285
    int resample_pix_fmt;
286

    
287
    /* full frame size of first frame */
288
    int original_height;
289
    int original_width;
290

    
291
    /* forced key frames */
292
    int64_t *forced_kf_pts;
293
    int forced_kf_count;
294
    int forced_kf_index;
295

    
296
    /* audio only */
297
    int audio_resample;
298
    ReSampleContext *resample; /* for audio resampling */
299
    int resample_sample_fmt;
300
    int resample_channels;
301
    int resample_sample_rate;
302
    int reformat_pair;
303
    AVAudioConvert *reformat_ctx;
304
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
305
    FILE *logfile;
306
} AVOutputStream;
307

    
308
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
310

    
311
typedef struct AVInputStream {
312
    int file_index;
313
    int index;
314
    AVStream *st;
315
    int discard;             /* true if stream data should be discarded */
316
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
317
    int64_t sample_index;      /* current sample */
318

    
319
    int64_t       start;     /* time when read started */
320
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
321
                                is not defined */
322
    int64_t       pts;       /* current pts */
323
    PtsCorrectionContext pts_ctx;
324
    int is_start;            /* is 1 at the start and after a discontinuity */
325
    int showed_multi_packet_warning;
326
    int is_past_recording_time;
327
#if CONFIG_AVFILTER
328
    AVFilterContext *output_video_filter;
329
    AVFilterContext *input_video_filter;
330
    AVFrame *filter_frame;
331
    int has_filter_frame;
332
    AVFilterBufferRef *picref;
333
#endif
334
} AVInputStream;
335

    
336
typedef struct AVInputFile {
337
    int eof_reached;      /* true if eof reached */
338
    int ist_index;        /* index of first stream in ist_table */
339
    int buffer_size;      /* current total buffer size */
340
    int nb_streams;       /* nb streams we are aware of */
341
} AVInputFile;
342

    
343
#if HAVE_TERMIOS_H
344

    
345
/* init terminal so that we can grab keys */
346
static struct termios oldtty;
347
#endif
348

    
349
#if CONFIG_AVFILTER
350

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

    
361
    graph = avfilter_graph_alloc();
362

    
363
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
364
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
365
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
366
                                       "src", args, NULL, graph);
367
    if (ret < 0)
368
        return ret;
369
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
370
                                       "out", NULL, &ffsink_ctx, graph);
371
    if (ret < 0)
372
        return ret;
373
    last_filter = ist->input_video_filter;
374

    
375
    if (codec->width  != icodec->width || codec->height != icodec->height) {
376
        snprintf(args, 255, "%d:%d:flags=0x%X",
377
                 codec->width,
378
                 codec->height,
379
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
380
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
381
                                                NULL, args, NULL, graph)) < 0)
382
            return ret;
383
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
384
            return ret;
385
        last_filter = filter;
386
    }
387

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

    
391
    if (vfilters) {
392
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
394

    
395
        outputs->name    = av_strdup("in");
396
        outputs->filter_ctx = last_filter;
397
        outputs->pad_idx = 0;
398
        outputs->next    = NULL;
399

    
400
        inputs->name    = av_strdup("out");
401
        inputs->filter_ctx = ist->output_video_filter;
402
        inputs->pad_idx = 0;
403
        inputs->next    = NULL;
404

    
405
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
406
            return ret;
407
        av_freep(&vfilters);
408
    } else {
409
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
410
            return ret;
411
    }
412

    
413
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
414
        return ret;
415

    
416
    codec->width  = ist->output_video_filter->inputs[0]->w;
417
    codec->height = ist->output_video_filter->inputs[0]->h;
418

    
419
    return 0;
420
}
421
#endif /* CONFIG_AVFILTER */
422

    
423
static void term_exit(void)
424
{
425
    av_log(NULL, AV_LOG_QUIET, "");
426
#if HAVE_TERMIOS_H
427
    tcsetattr (0, TCSANOW, &oldtty);
428
#endif
429
}
430

    
431
static volatile int received_sigterm = 0;
432

    
433
static void
434
sigterm_handler(int sig)
435
{
436
    received_sigterm = sig;
437
    term_exit();
438
}
439

    
440
static void term_init(void)
441
{
442
#if HAVE_TERMIOS_H
443
    struct termios tty;
444

    
445
    tcgetattr (0, &tty);
446
    oldtty = tty;
447
    atexit(term_exit);
448

    
449
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
450
                          |INLCR|IGNCR|ICRNL|IXON);
451
    tty.c_oflag |= OPOST;
452
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
453
    tty.c_cflag &= ~(CSIZE|PARENB);
454
    tty.c_cflag |= CS8;
455
    tty.c_cc[VMIN] = 1;
456
    tty.c_cc[VTIME] = 0;
457

    
458
    tcsetattr (0, TCSANOW, &tty);
459
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
460
#endif
461

    
462
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
463
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
464
#ifdef SIGXCPU
465
    signal(SIGXCPU, sigterm_handler);
466
#endif
467
}
468

    
469
/* read a key without blocking */
470
static int read_key(void)
471
{
472
#if HAVE_TERMIOS_H
473
    int n = 1;
474
    unsigned char ch;
475
    struct timeval tv;
476
    fd_set rfds;
477

    
478
    FD_ZERO(&rfds);
479
    FD_SET(0, &rfds);
480
    tv.tv_sec = 0;
481
    tv.tv_usec = 0;
482
    n = select(1, &rfds, NULL, NULL, &tv);
483
    if (n > 0) {
484
        n = read(0, &ch, 1);
485
        if (n == 1)
486
            return ch;
487

    
488
        return n;
489
    }
490
#elif HAVE_CONIO_H
491
    if(kbhit())
492
        return(getch());
493
#endif
494
    return -1;
495
}
496

    
497
static int decode_interrupt_cb(void)
498
{
499
    return q_pressed || (q_pressed = read_key() == 'q');
500
}
501

    
502
static int ffmpeg_exit(int ret)
503
{
504
    int i;
505

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

    
534
    av_free(intra_matrix);
535
    av_free(inter_matrix);
536

    
537
    if (vstats_file)
538
        fclose(vstats_file);
539
    av_free(vstats_filename);
540

    
541
    av_free(opt_names);
542
    av_free(streamid_map);
543
    av_free(input_codecs);
544
    av_free(output_codecs);
545
    av_free(stream_maps);
546
    av_free(meta_data_maps);
547

    
548
    av_free(video_codec_name);
549
    av_free(audio_codec_name);
550
    av_free(subtitle_codec_name);
551

    
552
    av_free(video_standard);
553

    
554
    uninit_opts();
555
    av_free(audio_buf);
556
    av_free(audio_out);
557
    allocated_audio_buf_size= allocated_audio_out_size= 0;
558
    av_free(samples);
559

    
560
#if CONFIG_AVFILTER
561
    avfilter_uninit();
562
#endif
563

    
564
    if (received_sigterm) {
565
        fprintf(stderr,
566
            "Received signal %d: terminating.\n",
567
            (int) received_sigterm);
568
        exit (255);
569
    }
570

    
571
    exit(ret); /* not all OS-es handle main() return value */
572
    return ret;
573
}
574

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

    
595
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
596
{
597
    if(codec && codec->sample_fmts){
598
        const enum AVSampleFormat *p= codec->sample_fmts;
599
        for(; *p!=-1; p++){
600
            if(*p == st->codec->sample_fmt)
601
                break;
602
        }
603
        if(*p == -1)
604
            st->codec->sample_fmt = codec->sample_fmts[0];
605
    }
606
}
607

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

    
628
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
629
{
630
    if(codec && codec->pix_fmts){
631
        const enum PixelFormat *p= codec->pix_fmts;
632
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
633
            if(st->codec->codec_id==CODEC_ID_MJPEG){
634
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
635
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
636
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
637
            }
638
        }
639
        for(; *p!=-1; p++){
640
            if(*p == st->codec->pix_fmt)
641
                break;
642
        }
643
        if(*p == -1)
644
            st->codec->pix_fmt = codec->pix_fmts[0];
645
    }
646
}
647

    
648
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
649
{
650
    int idx = oc->nb_streams - 1;
651
    AVOutputStream *ost;
652

    
653
    output_streams_for_file[file_idx] =
654
        grow_array(output_streams_for_file[file_idx],
655
                   sizeof(*output_streams_for_file[file_idx]),
656
                   &nb_output_streams_for_file[file_idx],
657
                   oc->nb_streams);
658
    ost = output_streams_for_file[file_idx][idx] =
659
        av_mallocz(sizeof(AVOutputStream));
660
    if (!ost) {
661
        fprintf(stderr, "Could not alloc output stream\n");
662
        ffmpeg_exit(1);
663
    }
664
    ost->file_index = file_idx;
665
    ost->index = idx;
666
    return ost;
667
}
668

    
669
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
670
{
671
    int i, err;
672
    AVFormatContext *ic;
673
    int nopts = 0;
674

    
675
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
676
    if (err < 0)
677
        return err;
678
    /* copy stream format */
679
    s->nb_streams = 0;
680
    for(i=0;i<ic->nb_streams;i++) {
681
        AVStream *st;
682
        AVCodec *codec;
683

    
684
        s->nb_streams++;
685

    
686
        // FIXME: a more elegant solution is needed
687
        st = av_mallocz(sizeof(AVStream));
688
        memcpy(st, ic->streams[i], sizeof(AVStream));
689
        st->codec = avcodec_alloc_context();
690
        if (!st->codec) {
691
            print_error(filename, AVERROR(ENOMEM));
692
            ffmpeg_exit(1);
693
        }
694
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
695
        s->streams[i] = st;
696

    
697
        codec = avcodec_find_encoder(st->codec->codec_id);
698
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
699
            if (audio_stream_copy) {
700
                st->stream_copy = 1;
701
            } else
702
                choose_sample_fmt(st, codec);
703
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
704
            if (video_stream_copy) {
705
                st->stream_copy = 1;
706
            } else
707
                choose_pixel_fmt(st, codec);
708
        }
709

    
710
        if(!st->codec->thread_count)
711
            st->codec->thread_count = 1;
712
        if(st->codec->thread_count>1)
713
            avcodec_thread_init(st->codec, st->codec->thread_count);
714

    
715
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
716
            nopts = 1;
717

    
718
        new_output_stream(s, nb_output_files);
719
    }
720

    
721
    if (!nopts)
722
        s->timestamp = av_gettime();
723

    
724
    av_close_input_file(ic);
725
    return 0;
726
}
727

    
728
static double
729
get_sync_ipts(const AVOutputStream *ost)
730
{
731
    const AVInputStream *ist = ost->sync_ist;
732
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
733
}
734

    
735
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
736
    int ret;
737

    
738
    while(bsfc){
739
        AVPacket new_pkt= *pkt;
740
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
741
                                          &new_pkt.data, &new_pkt.size,
742
                                          pkt->data, pkt->size,
743
                                          pkt->flags & AV_PKT_FLAG_KEY);
744
        if(a>0){
745
            av_free_packet(pkt);
746
            new_pkt.destruct= av_destruct_packet;
747
        } else if(a<0){
748
            fprintf(stderr, "%s failed for stream %d, codec %s",
749
                    bsfc->filter->name, pkt->stream_index,
750
                    avctx->codec ? avctx->codec->name : "copy");
751
            print_error("", a);
752
            if (exit_on_error)
753
                ffmpeg_exit(1);
754
        }
755
        *pkt= new_pkt;
756

    
757
        bsfc= bsfc->next;
758
    }
759

    
760
    ret= av_interleaved_write_frame(s, pkt);
761
    if(ret < 0){
762
        print_error("av_interleaved_write_frame()", ret);
763
        ffmpeg_exit(1);
764
    }
765
}
766

    
767
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
768

    
769
static void do_audio_out(AVFormatContext *s,
770
                         AVOutputStream *ost,
771
                         AVInputStream *ist,
772
                         unsigned char *buf, int size)
773
{
774
    uint8_t *buftmp;
775
    int64_t audio_out_size, audio_buf_size;
776
    int64_t allocated_for_size= size;
777

    
778
    int size_out, frame_bytes, ret, resample_changed;
779
    AVCodecContext *enc= ost->st->codec;
780
    AVCodecContext *dec= ist->st->codec;
781
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
782
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
783
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
784

    
785
need_realloc:
786
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
787
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
788
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
789
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
790
    audio_buf_size*= osize*enc->channels;
791

    
792
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
793
    if(coded_bps > 8*osize)
794
        audio_out_size= audio_out_size * coded_bps / (8*osize);
795
    audio_out_size += FF_MIN_BUFFER_SIZE;
796

    
797
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
798
        fprintf(stderr, "Buffer sizes too large\n");
799
        ffmpeg_exit(1);
800
    }
801

    
802
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
803
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
804
    if (!audio_buf || !audio_out){
805
        fprintf(stderr, "Out of memory in do_audio_out\n");
806
        ffmpeg_exit(1);
807
    }
808

    
809
    if (enc->channels != dec->channels)
810
        ost->audio_resample = 1;
811

    
812
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
813
                       ost->resample_channels    != dec->channels   ||
814
                       ost->resample_sample_rate != dec->sample_rate;
815

    
816
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
817
        if (resample_changed) {
818
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
819
                   ist->file_index, ist->index,
820
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
821
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
822
            ost->resample_sample_fmt  = dec->sample_fmt;
823
            ost->resample_channels    = dec->channels;
824
            ost->resample_sample_rate = dec->sample_rate;
825
            if (ost->resample)
826
                audio_resample_close(ost->resample);
827
        }
828
        if (ost->resample_sample_fmt  == enc->sample_fmt &&
829
            ost->resample_channels    == enc->channels   &&
830
            ost->resample_sample_rate == enc->sample_rate) {
831
            ost->resample = NULL;
832
            ost->audio_resample = 0;
833
        } else {
834
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
835
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
836
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
837
                                                   enc->sample_rate, dec->sample_rate,
838
                                                   enc->sample_fmt,  dec->sample_fmt,
839
                                                   16, 10, 0, 0.8);
840
            if (!ost->resample) {
841
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
842
                        dec->channels, dec->sample_rate,
843
                        enc->channels, enc->sample_rate);
844
                ffmpeg_exit(1);
845
            }
846
        }
847
    }
848

    
849
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
850
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
851
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
852
        if (ost->reformat_ctx)
853
            av_audio_convert_free(ost->reformat_ctx);
854
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
855
                                                   dec->sample_fmt, 1, NULL, 0);
856
        if (!ost->reformat_ctx) {
857
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
858
                av_get_sample_fmt_name(dec->sample_fmt),
859
                av_get_sample_fmt_name(enc->sample_fmt));
860
            ffmpeg_exit(1);
861
        }
862
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
863
    }
864

    
865
    if(audio_sync_method){
866
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
867
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
868
        double idelta= delta*dec->sample_rate / enc->sample_rate;
869
        int byte_delta= ((int)idelta)*2*dec->channels;
870

    
871
        //FIXME resample delay
872
        if(fabs(delta) > 50){
873
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
874
                if(byte_delta < 0){
875
                    byte_delta= FFMAX(byte_delta, -size);
876
                    size += byte_delta;
877
                    buf  -= byte_delta;
878
                    if(verbose > 2)
879
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
880
                    if(!size)
881
                        return;
882
                    ist->is_start=0;
883
                }else{
884
                    static uint8_t *input_tmp= NULL;
885
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
886

    
887
                    if(byte_delta > allocated_for_size - size){
888
                        allocated_for_size= byte_delta + (int64_t)size;
889
                        goto need_realloc;
890
                    }
891
                    ist->is_start=0;
892

    
893
                    memset(input_tmp, 0, byte_delta);
894
                    memcpy(input_tmp + byte_delta, buf, size);
895
                    buf= input_tmp;
896
                    size += byte_delta;
897
                    if(verbose > 2)
898
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
899
                }
900
            }else if(audio_sync_method>1){
901
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
902
                av_assert0(ost->audio_resample);
903
                if(verbose > 2)
904
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
905
//                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));
906
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
907
            }
908
        }
909
    }else
910
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
911
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
912

    
913
    if (ost->audio_resample) {
914
        buftmp = audio_buf;
915
        size_out = audio_resample(ost->resample,
916
                                  (short *)buftmp, (short *)buf,
917
                                  size / (dec->channels * isize));
918
        size_out = size_out * enc->channels * osize;
919
    } else {
920
        buftmp = buf;
921
        size_out = size;
922
    }
923

    
924
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
925
        const void *ibuf[6]= {buftmp};
926
        void *obuf[6]= {audio_buf};
927
        int istride[6]= {isize};
928
        int ostride[6]= {osize};
929
        int len= size_out/istride[0];
930
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
931
            printf("av_audio_convert() failed\n");
932
            if (exit_on_error)
933
                ffmpeg_exit(1);
934
            return;
935
        }
936
        buftmp = audio_buf;
937
        size_out = len*osize;
938
    }
939

    
940
    /* now encode as many frames as possible */
941
    if (enc->frame_size > 1) {
942
        /* output resampled raw samples */
943
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
944
            fprintf(stderr, "av_fifo_realloc2() failed\n");
945
            ffmpeg_exit(1);
946
        }
947
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
948

    
949
        frame_bytes = enc->frame_size * osize * enc->channels;
950

    
951
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
952
            AVPacket pkt;
953
            av_init_packet(&pkt);
954

    
955
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
956

    
957
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
958

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

    
974
            ost->sync_opts += enc->frame_size;
975
        }
976
    } else {
977
        AVPacket pkt;
978
        av_init_packet(&pkt);
979

    
980
        ost->sync_opts += size_out / (osize * enc->channels);
981

    
982
        /* output a pcm frame */
983
        /* determine the size of the coded buffer */
984
        size_out /= osize;
985
        if (coded_bps)
986
            size_out = size_out*coded_bps/8;
987

    
988
        if(size_out > audio_out_size){
989
            fprintf(stderr, "Internal error, buffer size too small\n");
990
            ffmpeg_exit(1);
991
        }
992

    
993
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
994
        ret = avcodec_encode_audio(enc, audio_out, size_out,
995
                                   (short *)buftmp);
996
        if (ret < 0) {
997
            fprintf(stderr, "Audio encoding failed\n");
998
            ffmpeg_exit(1);
999
        }
1000
        audio_size += ret;
1001
        pkt.stream_index= ost->index;
1002
        pkt.data= audio_out;
1003
        pkt.size= ret;
1004
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1005
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1006
        pkt.flags |= AV_PKT_FLAG_KEY;
1007
        write_frame(s, &pkt, enc, ost->bitstream_filters);
1008
    }
1009
}
1010

    
1011
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1012
{
1013
    AVCodecContext *dec;
1014
    AVPicture *picture2;
1015
    AVPicture picture_tmp;
1016
    uint8_t *buf = 0;
1017

    
1018
    dec = ist->st->codec;
1019

    
1020
    /* deinterlace : must be done before any resize */
1021
    if (do_deinterlace) {
1022
        int size;
1023

    
1024
        /* create temporary picture */
1025
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1026
        buf = av_malloc(size);
1027
        if (!buf)
1028
            return;
1029

    
1030
        picture2 = &picture_tmp;
1031
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1032

    
1033
        if(avpicture_deinterlace(picture2, picture,
1034
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1035
            /* if error, do not deinterlace */
1036
            fprintf(stderr, "Deinterlacing failed\n");
1037
            av_free(buf);
1038
            buf = NULL;
1039
            picture2 = picture;
1040
        }
1041
    } else {
1042
        picture2 = picture;
1043
    }
1044

    
1045
    if (picture != picture2)
1046
        *picture = *picture2;
1047
    *bufp = buf;
1048
}
1049

    
1050
/* we begin to correct av delay at this threshold */
1051
#define AV_DELAY_MAX 0.100
1052

    
1053
static void do_subtitle_out(AVFormatContext *s,
1054
                            AVOutputStream *ost,
1055
                            AVInputStream *ist,
1056
                            AVSubtitle *sub,
1057
                            int64_t pts)
1058
{
1059
    static uint8_t *subtitle_out = NULL;
1060
    int subtitle_out_max_size = 1024 * 1024;
1061
    int subtitle_out_size, nb, i;
1062
    AVCodecContext *enc;
1063
    AVPacket pkt;
1064

    
1065
    if (pts == AV_NOPTS_VALUE) {
1066
        fprintf(stderr, "Subtitle packets must have a pts\n");
1067
        if (exit_on_error)
1068
            ffmpeg_exit(1);
1069
        return;
1070
    }
1071

    
1072
    enc = ost->st->codec;
1073

    
1074
    if (!subtitle_out) {
1075
        subtitle_out = av_malloc(subtitle_out_max_size);
1076
    }
1077

    
1078
    /* Note: DVB subtitle need one packet to draw them and one other
1079
       packet to clear them */
1080
    /* XXX: signal it in the codec context ? */
1081
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1082
        nb = 2;
1083
    else
1084
        nb = 1;
1085

    
1086
    for(i = 0; i < nb; i++) {
1087
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1088
        // start_display_time is required to be 0
1089
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1090
        sub->end_display_time -= sub->start_display_time;
1091
        sub->start_display_time = 0;
1092
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1093
                                                    subtitle_out_max_size, sub);
1094
        if (subtitle_out_size < 0) {
1095
            fprintf(stderr, "Subtitle encoding failed\n");
1096
            ffmpeg_exit(1);
1097
        }
1098

    
1099
        av_init_packet(&pkt);
1100
        pkt.stream_index = ost->index;
1101
        pkt.data = subtitle_out;
1102
        pkt.size = subtitle_out_size;
1103
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1104
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1105
            /* XXX: the pts correction is handled here. Maybe handling
1106
               it in the codec would be better */
1107
            if (i == 0)
1108
                pkt.pts += 90 * sub->start_display_time;
1109
            else
1110
                pkt.pts += 90 * sub->end_display_time;
1111
        }
1112
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1113
    }
1114
}
1115

    
1116
static int bit_buffer_size= 1024*256;
1117
static uint8_t *bit_buffer= NULL;
1118

    
1119
static void do_video_out(AVFormatContext *s,
1120
                         AVOutputStream *ost,
1121
                         AVInputStream *ist,
1122
                         AVFrame *in_picture,
1123
                         int *frame_size)
1124
{
1125
    int nb_frames, i, ret;
1126
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1127
    AVCodecContext *enc, *dec;
1128
    double sync_ipts;
1129

    
1130
    enc = ost->st->codec;
1131
    dec = ist->st->codec;
1132

    
1133
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1134

    
1135
    /* by default, we output a single frame */
1136
    nb_frames = 1;
1137

    
1138
    *frame_size = 0;
1139

    
1140
    if(video_sync_method){
1141
        double vdelta = sync_ipts - ost->sync_opts;
1142
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1143
        if (vdelta < -1.1)
1144
            nb_frames = 0;
1145
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1146
            if(vdelta<=-0.6){
1147
                nb_frames=0;
1148
            }else if(vdelta>0.6)
1149
                ost->sync_opts= lrintf(sync_ipts);
1150
        }else if (vdelta > 1.1)
1151
            nb_frames = lrintf(vdelta);
1152
//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);
1153
        if (nb_frames == 0){
1154
            ++nb_frames_drop;
1155
            if (verbose>2)
1156
                fprintf(stderr, "*** drop!\n");
1157
        }else if (nb_frames > 1) {
1158
            nb_frames_dup += nb_frames - 1;
1159
            if (verbose>2)
1160
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1161
        }
1162
    }else
1163
        ost->sync_opts= lrintf(sync_ipts);
1164

    
1165
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1166
    if (nb_frames <= 0)
1167
        return;
1168

    
1169
    formatted_picture = in_picture;
1170
    final_picture = formatted_picture;
1171
    padding_src = formatted_picture;
1172
    resampling_dst = &ost->pict_tmp;
1173

    
1174
    if (   ost->resample_height != ist->st->codec->height
1175
        || ost->resample_width  != ist->st->codec->width
1176
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1177

    
1178
        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));
1179
        if(!ost->video_resample)
1180
            ffmpeg_exit(1);
1181
    }
1182

    
1183
#if !CONFIG_AVFILTER
1184
    if (ost->video_resample) {
1185
        padding_src = NULL;
1186
        final_picture = &ost->pict_tmp;
1187
        if(  ost->resample_height != ist->st->codec->height
1188
          || ost->resample_width  != ist->st->codec->width
1189
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1190

    
1191
            /* initialize a new scaler context */
1192
            sws_freeContext(ost->img_resample_ctx);
1193
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1194
            ost->img_resample_ctx = sws_getContext(
1195
                ist->st->codec->width,
1196
                ist->st->codec->height,
1197
                ist->st->codec->pix_fmt,
1198
                ost->st->codec->width,
1199
                ost->st->codec->height,
1200
                ost->st->codec->pix_fmt,
1201
                sws_flags, NULL, NULL, NULL);
1202
            if (ost->img_resample_ctx == NULL) {
1203
                fprintf(stderr, "Cannot get resampling context\n");
1204
                ffmpeg_exit(1);
1205
            }
1206
        }
1207
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1208
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1209
    }
1210
#endif
1211

    
1212
    /* duplicates frame if needed */
1213
    for(i=0;i<nb_frames;i++) {
1214
        AVPacket pkt;
1215
        av_init_packet(&pkt);
1216
        pkt.stream_index= ost->index;
1217

    
1218
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1219
            /* raw pictures are written as AVPicture structure to
1220
               avoid any copies. We support temorarily the older
1221
               method. */
1222
            AVFrame* old_frame = enc->coded_frame;
1223
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1224
            pkt.data= (uint8_t *)final_picture;
1225
            pkt.size=  sizeof(AVPicture);
1226
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1227
            pkt.flags |= AV_PKT_FLAG_KEY;
1228

    
1229
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1230
            enc->coded_frame = old_frame;
1231
        } else {
1232
            AVFrame big_picture;
1233

    
1234
            big_picture= *final_picture;
1235
            /* better than nothing: use input picture interlaced
1236
               settings */
1237
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1238
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1239
                if(top_field_first == -1)
1240
                    big_picture.top_field_first = in_picture->top_field_first;
1241
                else
1242
                    big_picture.top_field_first = top_field_first;
1243
            }
1244

    
1245
            /* handles sameq here. This is not correct because it may
1246
               not be a global option */
1247
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1248
            if(!me_threshold)
1249
                big_picture.pict_type = 0;
1250
//            big_picture.pts = AV_NOPTS_VALUE;
1251
            big_picture.pts= ost->sync_opts;
1252
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1253
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1254
            if (ost->forced_kf_index < ost->forced_kf_count &&
1255
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1256
                big_picture.pict_type = FF_I_TYPE;
1257
                ost->forced_kf_index++;
1258
            }
1259
            ret = avcodec_encode_video(enc,
1260
                                       bit_buffer, bit_buffer_size,
1261
                                       &big_picture);
1262
            if (ret < 0) {
1263
                fprintf(stderr, "Video encoding failed\n");
1264
                ffmpeg_exit(1);
1265
            }
1266

    
1267
            if(ret>0){
1268
                pkt.data= bit_buffer;
1269
                pkt.size= ret;
1270
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1271
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1272
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1273
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1274
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1275

    
1276
                if(enc->coded_frame->key_frame)
1277
                    pkt.flags |= AV_PKT_FLAG_KEY;
1278
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1279
                *frame_size = ret;
1280
                video_size += ret;
1281
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1282
                //        enc->frame_number-1, ret, enc->pict_type);
1283
                /* if two pass, output log */
1284
                if (ost->logfile && enc->stats_out) {
1285
                    fprintf(ost->logfile, "%s", enc->stats_out);
1286
                }
1287
            }
1288
        }
1289
        ost->sync_opts++;
1290
        ost->frame_number++;
1291
    }
1292
}
1293

    
1294
static double psnr(double d){
1295
    return -10.0*log(d)/log(10.0);
1296
}
1297

    
1298
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1299
                           int frame_size)
1300
{
1301
    AVCodecContext *enc;
1302
    int frame_number;
1303
    double ti1, bitrate, avg_bitrate;
1304

    
1305
    /* this is executed just the first time do_video_stats is called */
1306
    if (!vstats_file) {
1307
        vstats_file = fopen(vstats_filename, "w");
1308
        if (!vstats_file) {
1309
            perror("fopen");
1310
            ffmpeg_exit(1);
1311
        }
1312
    }
1313

    
1314
    enc = ost->st->codec;
1315
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1316
        frame_number = ost->frame_number;
1317
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1318
        if (enc->flags&CODEC_FLAG_PSNR)
1319
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1320

    
1321
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1322
        /* compute pts value */
1323
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1324
        if (ti1 < 0.01)
1325
            ti1 = 0.01;
1326

    
1327
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1328
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1329
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1330
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1331
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1332
    }
1333
}
1334

    
1335
static void print_report(AVFormatContext **output_files,
1336
                         AVOutputStream **ost_table, int nb_ostreams,
1337
                         int is_last_report)
1338
{
1339
    char buf[1024];
1340
    AVOutputStream *ost;
1341
    AVFormatContext *oc;
1342
    int64_t total_size;
1343
    AVCodecContext *enc;
1344
    int frame_number, vid, i;
1345
    double bitrate, ti1, pts;
1346
    static int64_t last_time = -1;
1347
    static int qp_histogram[52];
1348

    
1349
    if (!is_last_report) {
1350
        int64_t cur_time;
1351
        /* display the report every 0.5 seconds */
1352
        cur_time = av_gettime();
1353
        if (last_time == -1) {
1354
            last_time = cur_time;
1355
            return;
1356
        }
1357
        if ((cur_time - last_time) < 500000)
1358
            return;
1359
        last_time = cur_time;
1360
    }
1361

    
1362

    
1363
    oc = output_files[0];
1364

    
1365
    total_size = url_fsize(oc->pb);
1366
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1367
        total_size= url_ftell(oc->pb);
1368

    
1369
    buf[0] = '\0';
1370
    ti1 = 1e10;
1371
    vid = 0;
1372
    for(i=0;i<nb_ostreams;i++) {
1373
        ost = ost_table[i];
1374
        enc = ost->st->codec;
1375
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1376
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1377
                     !ost->st->stream_copy ?
1378
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1379
        }
1380
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1381
            float t = (av_gettime()-timer_start) / 1000000.0;
1382

    
1383
            frame_number = ost->frame_number;
1384
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1385
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1386
                     !ost->st->stream_copy ?
1387
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1388
            if(is_last_report)
1389
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1390
            if(qp_hist){
1391
                int j;
1392
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1393
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1394
                    qp_histogram[qp]++;
1395
                for(j=0; j<32; j++)
1396
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1397
            }
1398
            if (enc->flags&CODEC_FLAG_PSNR){
1399
                int j;
1400
                double error, error_sum=0;
1401
                double scale, scale_sum=0;
1402
                char type[3]= {'Y','U','V'};
1403
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1404
                for(j=0; j<3; j++){
1405
                    if(is_last_report){
1406
                        error= enc->error[j];
1407
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1408
                    }else{
1409
                        error= enc->coded_frame->error[j];
1410
                        scale= enc->width*enc->height*255.0*255.0;
1411
                    }
1412
                    if(j) scale/=4;
1413
                    error_sum += error;
1414
                    scale_sum += scale;
1415
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1416
                }
1417
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1418
            }
1419
            vid = 1;
1420
        }
1421
        /* compute min output value */
1422
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1423
        if ((pts < ti1) && (pts > 0))
1424
            ti1 = pts;
1425
    }
1426
    if (ti1 < 0.01)
1427
        ti1 = 0.01;
1428

    
1429
    if (verbose || is_last_report) {
1430
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1431

    
1432
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1433
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1434
            (double)total_size / 1024, ti1, bitrate);
1435

    
1436
        if (nb_frames_dup || nb_frames_drop)
1437
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1438
                  nb_frames_dup, nb_frames_drop);
1439

    
1440
        if (verbose >= 0)
1441
            fprintf(stderr, "%s    \r", buf);
1442

    
1443
        fflush(stderr);
1444
    }
1445

    
1446
    if (is_last_report && verbose >= 0){
1447
        int64_t raw= audio_size + video_size + extra_size;
1448
        fprintf(stderr, "\n");
1449
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1450
                video_size/1024.0,
1451
                audio_size/1024.0,
1452
                extra_size/1024.0,
1453
                100.0*(total_size - raw)/raw
1454
        );
1455
    }
1456
}
1457

    
1458
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1459
static int output_packet(AVInputStream *ist, int ist_index,
1460
                         AVOutputStream **ost_table, int nb_ostreams,
1461
                         const AVPacket *pkt)
1462
{
1463
    AVFormatContext *os;
1464
    AVOutputStream *ost;
1465
    int ret, i;
1466
    int got_picture;
1467
    AVFrame picture;
1468
    void *buffer_to_free;
1469
    static unsigned int samples_size= 0;
1470
    AVSubtitle subtitle, *subtitle_to_free;
1471
    int64_t pkt_pts = AV_NOPTS_VALUE;
1472
#if CONFIG_AVFILTER
1473
    int frame_available;
1474
#endif
1475

    
1476
    AVPacket avpkt;
1477
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1478

    
1479
    if(ist->next_pts == AV_NOPTS_VALUE)
1480
        ist->next_pts= ist->pts;
1481

    
1482
    if (pkt == NULL) {
1483
        /* EOF handling */
1484
        av_init_packet(&avpkt);
1485
        avpkt.data = NULL;
1486
        avpkt.size = 0;
1487
        goto handle_eof;
1488
    } else {
1489
        avpkt = *pkt;
1490
    }
1491

    
1492
    if(pkt->dts != AV_NOPTS_VALUE)
1493
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1494
    if(pkt->pts != AV_NOPTS_VALUE)
1495
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1496

    
1497
    //while we have more to decode or while the decoder did output something on EOF
1498
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1499
        uint8_t *data_buf, *decoded_data_buf;
1500
        int data_size, decoded_data_size;
1501
    handle_eof:
1502
        ist->pts= ist->next_pts;
1503

    
1504
        if(avpkt.size && avpkt.size != pkt->size &&
1505
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1506
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1507
            ist->showed_multi_packet_warning=1;
1508
        }
1509

    
1510
        /* decode the packet if needed */
1511
        decoded_data_buf = NULL; /* fail safe */
1512
        decoded_data_size= 0;
1513
        data_buf  = avpkt.data;
1514
        data_size = avpkt.size;
1515
        subtitle_to_free = NULL;
1516
        if (ist->decoding_needed) {
1517
            switch(ist->st->codec->codec_type) {
1518
            case AVMEDIA_TYPE_AUDIO:{
1519
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1520
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1521
                    av_free(samples);
1522
                    samples= av_malloc(samples_size);
1523
                }
1524
                decoded_data_size= samples_size;
1525
                    /* XXX: could avoid copy if PCM 16 bits with same
1526
                       endianness as CPU */
1527
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1528
                                            &avpkt);
1529
                if (ret < 0)
1530
                    goto fail_decode;
1531
                avpkt.data += ret;
1532
                avpkt.size -= ret;
1533
                data_size   = ret;
1534
                /* Some bug in mpeg audio decoder gives */
1535
                /* decoded_data_size < 0, it seems they are overflows */
1536
                if (decoded_data_size <= 0) {
1537
                    /* no audio frame */
1538
                    continue;
1539
                }
1540
                decoded_data_buf = (uint8_t *)samples;
1541
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1542
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1543
                break;}
1544
            case AVMEDIA_TYPE_VIDEO:
1545
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1546
                    /* XXX: allocate picture correctly */
1547
                    avcodec_get_frame_defaults(&picture);
1548
                    ist->st->codec->reordered_opaque = pkt_pts;
1549
                    pkt_pts = AV_NOPTS_VALUE;
1550

    
1551
                    ret = avcodec_decode_video2(ist->st->codec,
1552
                                                &picture, &got_picture, &avpkt);
1553
                    ist->st->quality= picture.quality;
1554
                    if (ret < 0)
1555
                        goto fail_decode;
1556
                    if (!got_picture) {
1557
                        /* no picture yet */
1558
                        goto discard_packet;
1559
                    }
1560
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1561
                    if (ist->st->codec->time_base.num != 0) {
1562
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1563
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1564
                                          ist->st->codec->time_base.num * ticks) /
1565
                            ist->st->codec->time_base.den;
1566
                    }
1567
                    avpkt.size = 0;
1568
                    break;
1569
            case AVMEDIA_TYPE_SUBTITLE:
1570
                ret = avcodec_decode_subtitle2(ist->st->codec,
1571
                                               &subtitle, &got_picture, &avpkt);
1572
                if (ret < 0)
1573
                    goto fail_decode;
1574
                if (!got_picture) {
1575
                    goto discard_packet;
1576
                }
1577
                subtitle_to_free = &subtitle;
1578
                avpkt.size = 0;
1579
                break;
1580
            default:
1581
                goto fail_decode;
1582
            }
1583
        } else {
1584
            switch(ist->st->codec->codec_type) {
1585
            case AVMEDIA_TYPE_AUDIO:
1586
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1587
                    ist->st->codec->sample_rate;
1588
                break;
1589
            case AVMEDIA_TYPE_VIDEO:
1590
                if (ist->st->codec->time_base.num != 0) {
1591
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1592
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1593
                                      ist->st->codec->time_base.num * ticks) /
1594
                        ist->st->codec->time_base.den;
1595
                }
1596
                break;
1597
            }
1598
            ret = avpkt.size;
1599
            avpkt.size = 0;
1600
        }
1601

    
1602
        buffer_to_free = NULL;
1603
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1604
            pre_process_video_frame(ist, (AVPicture *)&picture,
1605
                                    &buffer_to_free);
1606
        }
1607

    
1608
#if CONFIG_AVFILTER
1609
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1610
            // add it to be filtered
1611
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1612
                                     ist->pts,
1613
                                     ist->st->codec->sample_aspect_ratio);
1614
        }
1615
#endif
1616

    
1617
        // preprocess audio (volume)
1618
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1619
            if (audio_volume != 256) {
1620
                short *volp;
1621
                volp = samples;
1622
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1623
                    int v = ((*volp) * audio_volume + 128) >> 8;
1624
                    if (v < -32768) v = -32768;
1625
                    if (v >  32767) v = 32767;
1626
                    *volp++ = v;
1627
                }
1628
            }
1629
        }
1630

    
1631
        /* frame rate emulation */
1632
        if (rate_emu) {
1633
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1634
            int64_t now = av_gettime() - ist->start;
1635
            if (pts > now)
1636
                usleep(pts - now);
1637
        }
1638
#if CONFIG_AVFILTER
1639
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1640
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1641
#endif
1642
        /* if output time reached then transcode raw format,
1643
           encode packets and output them */
1644
        if (start_time == 0 || ist->pts >= start_time)
1645
#if CONFIG_AVFILTER
1646
        while (frame_available) {
1647
            AVRational ist_pts_tb;
1648
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1649
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1650
            if (ist->picref)
1651
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1652
#endif
1653
            for(i=0;i<nb_ostreams;i++) {
1654
                int frame_size;
1655

    
1656
                ost = ost_table[i];
1657
                if (ost->source_index == ist_index) {
1658
                    os = output_files[ost->file_index];
1659

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

    
1663
                    if (ost->encoding_needed) {
1664
                        av_assert0(ist->decoding_needed);
1665
                        switch(ost->st->codec->codec_type) {
1666
                        case AVMEDIA_TYPE_AUDIO:
1667
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1668
                            break;
1669
                        case AVMEDIA_TYPE_VIDEO:
1670
#if CONFIG_AVFILTER
1671
                            if (ist->picref->video)
1672
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1673
#endif
1674
                            do_video_out(os, ost, ist, &picture, &frame_size);
1675
                            if (vstats_filename && frame_size)
1676
                                do_video_stats(os, ost, frame_size);
1677
                            break;
1678
                        case AVMEDIA_TYPE_SUBTITLE:
1679
                            do_subtitle_out(os, ost, ist, &subtitle,
1680
                                            pkt->pts);
1681
                            break;
1682
                        default:
1683
                            abort();
1684
                        }
1685
                    } else {
1686
                        AVFrame avframe; //FIXME/XXX remove this
1687
                        AVPacket opkt;
1688
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1689

    
1690
                        av_init_packet(&opkt);
1691

    
1692
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1693
                            continue;
1694

    
1695
                        /* no reencoding needed : output the packet directly */
1696
                        /* force the input stream PTS */
1697

    
1698
                        avcodec_get_frame_defaults(&avframe);
1699
                        ost->st->codec->coded_frame= &avframe;
1700
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1701

    
1702
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1703
                            audio_size += data_size;
1704
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1705
                            video_size += data_size;
1706
                            ost->sync_opts++;
1707
                        }
1708

    
1709
                        opkt.stream_index= ost->index;
1710
                        if(pkt->pts != AV_NOPTS_VALUE)
1711
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1712
                        else
1713
                            opkt.pts= AV_NOPTS_VALUE;
1714

    
1715
                        if (pkt->dts == AV_NOPTS_VALUE)
1716
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1717
                        else
1718
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1719
                        opkt.dts -= ost_tb_start_time;
1720

    
1721
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1722
                        opkt.flags= pkt->flags;
1723

    
1724
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1725
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1726
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1727
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1728
                           ) {
1729
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1730
                                opkt.destruct= av_destruct_packet;
1731
                        } else {
1732
                            opkt.data = data_buf;
1733
                            opkt.size = data_size;
1734
                        }
1735

    
1736
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1737
                        ost->st->codec->frame_number++;
1738
                        ost->frame_number++;
1739
                        av_free_packet(&opkt);
1740
                    }
1741
                }
1742
            }
1743

    
1744
#if CONFIG_AVFILTER
1745
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1746
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1747
            if(ist->picref)
1748
                avfilter_unref_buffer(ist->picref);
1749
        }
1750
#endif
1751
        av_free(buffer_to_free);
1752
        /* XXX: allocate the subtitles in the codec ? */
1753
        if (subtitle_to_free) {
1754
            avsubtitle_free(subtitle_to_free);
1755
            subtitle_to_free = NULL;
1756
        }
1757
    }
1758
 discard_packet:
1759
    if (pkt == NULL) {
1760
        /* EOF handling */
1761

    
1762
        for(i=0;i<nb_ostreams;i++) {
1763
            ost = ost_table[i];
1764
            if (ost->source_index == ist_index) {
1765
                AVCodecContext *enc= ost->st->codec;
1766
                os = output_files[ost->file_index];
1767

    
1768
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1769
                    continue;
1770
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1771
                    continue;
1772

    
1773
                if (ost->encoding_needed) {
1774
                    for(;;) {
1775
                        AVPacket pkt;
1776
                        int fifo_bytes;
1777
                        av_init_packet(&pkt);
1778
                        pkt.stream_index= ost->index;
1779

    
1780
                        switch(ost->st->codec->codec_type) {
1781
                        case AVMEDIA_TYPE_AUDIO:
1782
                            fifo_bytes = av_fifo_size(ost->fifo);
1783
                            ret = 0;
1784
                            /* encode any samples remaining in fifo */
1785
                            if (fifo_bytes > 0) {
1786
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1787
                                int fs_tmp = enc->frame_size;
1788

    
1789
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1790
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1791
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1792
                                } else { /* pad */
1793
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1794
                                    if (allocated_audio_buf_size < frame_bytes)
1795
                                        ffmpeg_exit(1);
1796
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1797
                                }
1798

    
1799
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1800
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1801
                                                          ost->st->time_base.num, enc->sample_rate);
1802
                                enc->frame_size = fs_tmp;
1803
                            }
1804
                            if(ret <= 0) {
1805
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1806
                            }
1807
                            if (ret < 0) {
1808
                                fprintf(stderr, "Audio encoding failed\n");
1809
                                ffmpeg_exit(1);
1810
                            }
1811
                            audio_size += ret;
1812
                            pkt.flags |= AV_PKT_FLAG_KEY;
1813
                            break;
1814
                        case AVMEDIA_TYPE_VIDEO:
1815
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1816
                            if (ret < 0) {
1817
                                fprintf(stderr, "Video encoding failed\n");
1818
                                ffmpeg_exit(1);
1819
                            }
1820
                            video_size += ret;
1821
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1822
                                pkt.flags |= AV_PKT_FLAG_KEY;
1823
                            if (ost->logfile && enc->stats_out) {
1824
                                fprintf(ost->logfile, "%s", enc->stats_out);
1825
                            }
1826
                            break;
1827
                        default:
1828
                            ret=-1;
1829
                        }
1830

    
1831
                        if(ret<=0)
1832
                            break;
1833
                        pkt.data= bit_buffer;
1834
                        pkt.size= ret;
1835
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1836
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1837
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1838
                    }
1839
                }
1840
            }
1841
        }
1842
    }
1843

    
1844
    return 0;
1845
 fail_decode:
1846
    return -1;
1847
}
1848

    
1849
static void print_sdp(AVFormatContext **avc, int n)
1850
{
1851
    char sdp[2048];
1852

    
1853
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1854
    printf("SDP:\n%s\n", sdp);
1855
    fflush(stdout);
1856
}
1857

    
1858
static int copy_chapters(int infile, int outfile)
1859
{
1860
    AVFormatContext *is = input_files[infile];
1861
    AVFormatContext *os = output_files[outfile];
1862
    int i;
1863

    
1864
    for (i = 0; i < is->nb_chapters; i++) {
1865
        AVChapter *in_ch = is->chapters[i], *out_ch;
1866
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1867
                                      AV_TIME_BASE_Q, in_ch->time_base);
1868
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1869
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1870

    
1871

    
1872
        if (in_ch->end < ts_off)
1873
            continue;
1874
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1875
            break;
1876

    
1877
        out_ch = av_mallocz(sizeof(AVChapter));
1878
        if (!out_ch)
1879
            return AVERROR(ENOMEM);
1880

    
1881
        out_ch->id        = in_ch->id;
1882
        out_ch->time_base = in_ch->time_base;
1883
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1884
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1885

    
1886
        if (metadata_chapters_autocopy)
1887
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1888

    
1889
        os->nb_chapters++;
1890
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1891
        if (!os->chapters)
1892
            return AVERROR(ENOMEM);
1893
        os->chapters[os->nb_chapters - 1] = out_ch;
1894
    }
1895
    return 0;
1896
}
1897

    
1898
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1899
                                    AVCodecContext *avctx)
1900
{
1901
    char *p;
1902
    int n = 1, i;
1903
    int64_t t;
1904

    
1905
    for (p = kf; *p; p++)
1906
        if (*p == ',')
1907
            n++;
1908
    ost->forced_kf_count = n;
1909
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1910
    if (!ost->forced_kf_pts) {
1911
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1912
        ffmpeg_exit(1);
1913
    }
1914
    for (i = 0; i < n; i++) {
1915
        p = i ? strchr(p, ',') + 1 : kf;
1916
        t = parse_time_or_die("force_key_frames", p, 1);
1917
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1918
    }
1919
}
1920

    
1921
/*
1922
 * The following code is the main loop of the file converter
1923
 */
1924
static int transcode(AVFormatContext **output_files,
1925
                     int nb_output_files,
1926
                     AVFormatContext **input_files,
1927
                     int nb_input_files,
1928
                     AVStreamMap *stream_maps, int nb_stream_maps)
1929
{
1930
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1931
    AVFormatContext *is, *os;
1932
    AVCodecContext *codec, *icodec;
1933
    AVOutputStream *ost, **ost_table = NULL;
1934
    AVInputStream *ist, **ist_table = NULL;
1935
    AVInputFile *file_table;
1936
    char error[1024];
1937
    int key;
1938
    int want_sdp = 1;
1939
    uint8_t no_packet[MAX_FILES]={0};
1940
    int no_packet_count=0;
1941

    
1942
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1943
    if (!file_table)
1944
        goto fail;
1945

    
1946
    /* input stream init */
1947
    j = 0;
1948
    for(i=0;i<nb_input_files;i++) {
1949
        is = input_files[i];
1950
        file_table[i].ist_index = j;
1951
        file_table[i].nb_streams = is->nb_streams;
1952
        j += is->nb_streams;
1953
    }
1954
    nb_istreams = j;
1955

    
1956
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1957
    if (!ist_table)
1958
        goto fail;
1959

    
1960
    for(i=0;i<nb_istreams;i++) {
1961
        ist = av_mallocz(sizeof(AVInputStream));
1962
        if (!ist)
1963
            goto fail;
1964
        ist_table[i] = ist;
1965
    }
1966
    j = 0;
1967
    for(i=0;i<nb_input_files;i++) {
1968
        is = input_files[i];
1969
        for(k=0;k<is->nb_streams;k++) {
1970
            ist = ist_table[j++];
1971
            ist->st = is->streams[k];
1972
            ist->file_index = i;
1973
            ist->index = k;
1974
            ist->discard = 1; /* the stream is discarded by default
1975
                                 (changed later) */
1976

    
1977
            if (rate_emu) {
1978
                ist->start = av_gettime();
1979
            }
1980
        }
1981
    }
1982

    
1983
    /* output stream init */
1984
    nb_ostreams = 0;
1985
    for(i=0;i<nb_output_files;i++) {
1986
        os = output_files[i];
1987
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1988
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1989
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1990
            ret = AVERROR(EINVAL);
1991
            goto fail;
1992
        }
1993
        nb_ostreams += os->nb_streams;
1994
    }
1995
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1996
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1997
        ret = AVERROR(EINVAL);
1998
        goto fail;
1999
    }
2000

    
2001
    /* Sanity check the mapping args -- do the input files & streams exist? */
2002
    for(i=0;i<nb_stream_maps;i++) {
2003
        int fi = stream_maps[i].file_index;
2004
        int si = stream_maps[i].stream_index;
2005

    
2006
        if (fi < 0 || fi > nb_input_files - 1 ||
2007
            si < 0 || si > file_table[fi].nb_streams - 1) {
2008
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2009
            ret = AVERROR(EINVAL);
2010
            goto fail;
2011
        }
2012
        fi = stream_maps[i].sync_file_index;
2013
        si = stream_maps[i].sync_stream_index;
2014
        if (fi < 0 || fi > nb_input_files - 1 ||
2015
            si < 0 || si > file_table[fi].nb_streams - 1) {
2016
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2017
            ret = AVERROR(EINVAL);
2018
            goto fail;
2019
        }
2020
    }
2021

    
2022
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2023
    if (!ost_table)
2024
        goto fail;
2025
    n = 0;
2026
    for(k=0;k<nb_output_files;k++) {
2027
        os = output_files[k];
2028
        for(i=0;i<os->nb_streams;i++,n++) {
2029
            int found;
2030
            ost = ost_table[n] = output_streams_for_file[k][i];
2031
            ost->st = os->streams[i];
2032
            if (nb_stream_maps > 0) {
2033
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2034
                    stream_maps[n].stream_index;
2035

    
2036
                /* Sanity check that the stream types match */
2037
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2038
                    int i= ost->file_index;
2039
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2040
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2041
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2042
                        ost->file_index, ost->index);
2043
                    ffmpeg_exit(1);
2044
                }
2045

    
2046
            } else {
2047
                int best_nb_frames=-1;
2048
                /* get corresponding input stream index : we select the first one with the right type */
2049
                found = 0;
2050
                for(j=0;j<nb_istreams;j++) {
2051
                    int skip=0;
2052
                    ist = ist_table[j];
2053
                    if(opt_programid){
2054
                        int pi,si;
2055
                        AVFormatContext *f= input_files[ ist->file_index ];
2056
                        skip=1;
2057
                        for(pi=0; pi<f->nb_programs; pi++){
2058
                            AVProgram *p= f->programs[pi];
2059
                            if(p->id == opt_programid)
2060
                                for(si=0; si<p->nb_stream_indexes; si++){
2061
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2062
                                        skip=0;
2063
                                }
2064
                        }
2065
                    }
2066
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2067
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2068
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2069
                            best_nb_frames= ist->st->codec_info_nb_frames;
2070
                            ost->source_index = j;
2071
                            found = 1;
2072
                        }
2073
                    }
2074
                }
2075

    
2076
                if (!found) {
2077
                    if(! opt_programid) {
2078
                        /* try again and reuse existing stream */
2079
                        for(j=0;j<nb_istreams;j++) {
2080
                            ist = ist_table[j];
2081
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2082
                                && ist->st->discard != AVDISCARD_ALL) {
2083
                                ost->source_index = j;
2084
                                found = 1;
2085
                            }
2086
                        }
2087
                    }
2088
                    if (!found) {
2089
                        int i= ost->file_index;
2090
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2091
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2092
                                ost->file_index, ost->index);
2093
                        ffmpeg_exit(1);
2094
                    }
2095
                }
2096
            }
2097
            ist = ist_table[ost->source_index];
2098
            ist->discard = 0;
2099
            ost->sync_ist = (nb_stream_maps > 0) ?
2100
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2101
                         stream_maps[n].sync_stream_index] : ist;
2102
        }
2103
    }
2104

    
2105
    /* for each output stream, we compute the right encoding parameters */
2106
    for(i=0;i<nb_ostreams;i++) {
2107
        ost = ost_table[i];
2108
        os = output_files[ost->file_index];
2109
        ist = ist_table[ost->source_index];
2110

    
2111
        codec = ost->st->codec;
2112
        icodec = ist->st->codec;
2113

    
2114
        if (metadata_streams_autocopy)
2115
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2116
                             AV_METADATA_DONT_OVERWRITE);
2117

    
2118
        ost->st->disposition = ist->st->disposition;
2119
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2120
        codec->chroma_sample_location = icodec->chroma_sample_location;
2121

    
2122
        if (ost->st->stream_copy) {
2123
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2124

    
2125
            if (extra_size > INT_MAX)
2126
                goto fail;
2127

    
2128
            /* if stream_copy is selected, no need to decode or encode */
2129
            codec->codec_id = icodec->codec_id;
2130
            codec->codec_type = icodec->codec_type;
2131

    
2132
            if(!codec->codec_tag){
2133
                if(   !os->oformat->codec_tag
2134
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2135
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2136
                    codec->codec_tag = icodec->codec_tag;
2137
            }
2138

    
2139
            codec->bit_rate = icodec->bit_rate;
2140
            codec->rc_max_rate    = icodec->rc_max_rate;
2141
            codec->rc_buffer_size = icodec->rc_buffer_size;
2142
            codec->extradata= av_mallocz(extra_size);
2143
            if (!codec->extradata)
2144
                goto fail;
2145
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2146
            codec->extradata_size= icodec->extradata_size;
2147
            if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2148
                codec->time_base = icodec->time_base;
2149
                codec->time_base.num *= icodec->ticks_per_frame;
2150
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2151
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2152
            }else
2153
                codec->time_base = ist->st->time_base;
2154
            switch(codec->codec_type) {
2155
            case AVMEDIA_TYPE_AUDIO:
2156
                if(audio_volume != 256) {
2157
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2158
                    ffmpeg_exit(1);
2159
                }
2160
                codec->channel_layout = icodec->channel_layout;
2161
                codec->sample_rate = icodec->sample_rate;
2162
                codec->channels = icodec->channels;
2163
                codec->frame_size = icodec->frame_size;
2164
                codec->block_align= icodec->block_align;
2165
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2166
                    codec->block_align= 0;
2167
                if(codec->codec_id == CODEC_ID_AC3)
2168
                    codec->block_align= 0;
2169
                break;
2170
            case AVMEDIA_TYPE_VIDEO:
2171
                codec->pix_fmt = icodec->pix_fmt;
2172
                codec->width = icodec->width;
2173
                codec->height = icodec->height;
2174
                codec->has_b_frames = icodec->has_b_frames;
2175
                break;
2176
            case AVMEDIA_TYPE_SUBTITLE:
2177
                codec->width = icodec->width;
2178
                codec->height = icodec->height;
2179
                break;
2180
            default:
2181
                abort();
2182
            }
2183
        } else {
2184
            switch(codec->codec_type) {
2185
            case AVMEDIA_TYPE_AUDIO:
2186
                ost->fifo= av_fifo_alloc(1024);
2187
                if(!ost->fifo)
2188
                    goto fail;
2189
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2190
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2191
                icodec->request_channels = codec->channels;
2192
                ist->decoding_needed = 1;
2193
                ost->encoding_needed = 1;
2194
                ost->resample_sample_fmt  = icodec->sample_fmt;
2195
                ost->resample_sample_rate = icodec->sample_rate;
2196
                ost->resample_channels    = icodec->channels;
2197
                break;
2198
            case AVMEDIA_TYPE_VIDEO:
2199
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2200
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2201
                    ffmpeg_exit(1);
2202
                }
2203
                ost->video_resample = (codec->width != icodec->width   ||
2204
                                       codec->height != icodec->height ||
2205
                        (codec->pix_fmt != icodec->pix_fmt));
2206
                if (ost->video_resample) {
2207
#if !CONFIG_AVFILTER
2208
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2209
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2210
                                         codec->width, codec->height)) {
2211
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2212
                        ffmpeg_exit(1);
2213
                    }
2214
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2215
                    ost->img_resample_ctx = sws_getContext(
2216
                        icodec->width,
2217
                        icodec->height,
2218
                            icodec->pix_fmt,
2219
                            codec->width,
2220
                            codec->height,
2221
                            codec->pix_fmt,
2222
                            sws_flags, NULL, NULL, NULL);
2223
                    if (ost->img_resample_ctx == NULL) {
2224
                        fprintf(stderr, "Cannot get resampling context\n");
2225
                        ffmpeg_exit(1);
2226
                    }
2227

    
2228
                    ost->original_height = icodec->height;
2229
                    ost->original_width  = icodec->width;
2230
#endif
2231
                    codec->bits_per_raw_sample= 0;
2232
                }
2233
                ost->resample_height = icodec->height;
2234
                ost->resample_width  = icodec->width;
2235
                ost->resample_pix_fmt= icodec->pix_fmt;
2236
                ost->encoding_needed = 1;
2237
                ist->decoding_needed = 1;
2238

    
2239
#if CONFIG_AVFILTER
2240
                if (configure_filters(ist, ost)) {
2241
                    fprintf(stderr, "Error opening filters!\n");
2242
                    exit(1);
2243
                }
2244
#endif
2245
                break;
2246
            case AVMEDIA_TYPE_SUBTITLE:
2247
                ost->encoding_needed = 1;
2248
                ist->decoding_needed = 1;
2249
                break;
2250
            default:
2251
                abort();
2252
                break;
2253
            }
2254
            /* two pass mode */
2255
            if (ost->encoding_needed &&
2256
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2257
                char logfilename[1024];
2258
                FILE *f;
2259

    
2260
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2261
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2262
                         i);
2263
                if (codec->flags & CODEC_FLAG_PASS1) {
2264
                    f = fopen(logfilename, "wb");
2265
                    if (!f) {
2266
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2267
                        ffmpeg_exit(1);
2268
                    }
2269
                    ost->logfile = f;
2270
                } else {
2271
                    char  *logbuffer;
2272
                    size_t logbuffer_size;
2273
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2274
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2275
                        ffmpeg_exit(1);
2276
                    }
2277
                    codec->stats_in = logbuffer;
2278
                }
2279
            }
2280
        }
2281
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2282
            int size= codec->width * codec->height;
2283
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2284
        }
2285
    }
2286

    
2287
    if (!bit_buffer)
2288
        bit_buffer = av_malloc(bit_buffer_size);
2289
    if (!bit_buffer) {
2290
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2291
                bit_buffer_size);
2292
        ret = AVERROR(ENOMEM);
2293
        goto fail;
2294
    }
2295

    
2296
    /* open each encoder */
2297
    for(i=0;i<nb_ostreams;i++) {
2298
        ost = ost_table[i];
2299
        if (ost->encoding_needed) {
2300
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2301
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2302
            if (!codec)
2303
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2304
            if (!codec) {
2305
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2306
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2307
                ret = AVERROR(EINVAL);
2308
                goto dump_format;
2309
            }
2310
            if (dec->subtitle_header) {
2311
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2312
                if (!ost->st->codec->subtitle_header) {
2313
                    ret = AVERROR(ENOMEM);
2314
                    goto dump_format;
2315
                }
2316
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2317
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2318
            }
2319
            if (avcodec_open(ost->st->codec, codec) < 0) {
2320
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2321
                        ost->file_index, ost->index);
2322
                ret = AVERROR(EINVAL);
2323
                goto dump_format;
2324
            }
2325
            extra_size += ost->st->codec->extradata_size;
2326
        }
2327
    }
2328

    
2329
    /* open each decoder */
2330
    for(i=0;i<nb_istreams;i++) {
2331
        ist = ist_table[i];
2332
        if (ist->decoding_needed) {
2333
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2334
            if (!codec)
2335
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2336
            if (!codec) {
2337
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2338
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2339
                ret = AVERROR(EINVAL);
2340
                goto dump_format;
2341
            }
2342
            if (avcodec_open(ist->st->codec, codec) < 0) {
2343
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2344
                        ist->file_index, ist->index);
2345
                ret = AVERROR(EINVAL);
2346
                goto dump_format;
2347
            }
2348
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2349
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2350
        }
2351
    }
2352

    
2353
    /* init pts */
2354
    for(i=0;i<nb_istreams;i++) {
2355
        AVStream *st;
2356
        ist = ist_table[i];
2357
        st= ist->st;
2358
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2359
        ist->next_pts = AV_NOPTS_VALUE;
2360
        init_pts_correction(&ist->pts_ctx);
2361
        ist->is_start = 1;
2362
    }
2363

    
2364
    /* set meta data information from input file if required */
2365
    for (i=0;i<nb_meta_data_maps;i++) {
2366
        AVFormatContext *files[2];
2367
        AVMetadata      **meta[2];
2368
        int j;
2369

    
2370
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2371
        if ((index) < 0 || (index) >= (nb_elems)) {\
2372
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2373
                     (desc), (index));\
2374
            ret = AVERROR(EINVAL);\
2375
            goto dump_format;\
2376
        }
2377

    
2378
        int out_file_index = meta_data_maps[i][0].file;
2379
        int in_file_index = meta_data_maps[i][1].file;
2380
        if (in_file_index < 0 || out_file_index < 0)
2381
            continue;
2382
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2383
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2384

    
2385
        files[0] = output_files[out_file_index];
2386
        files[1] = input_files[in_file_index];
2387

    
2388
        for (j = 0; j < 2; j++) {
2389
            AVMetaDataMap *map = &meta_data_maps[i][j];
2390

    
2391
            switch (map->type) {
2392
            case 'g':
2393
                meta[j] = &files[j]->metadata;
2394
                break;
2395
            case 's':
2396
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2397
                meta[j] = &files[j]->streams[map->index]->metadata;
2398
                break;
2399
            case 'c':
2400
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2401
                meta[j] = &files[j]->chapters[map->index]->metadata;
2402
                break;
2403
            case 'p':
2404
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2405
                meta[j] = &files[j]->programs[map->index]->metadata;
2406
                break;
2407
            }
2408
        }
2409

    
2410
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2411
    }
2412

    
2413
    /* copy global metadata by default */
2414
    if (metadata_global_autocopy) {
2415

    
2416
        for (i = 0; i < nb_output_files; i++)
2417
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2418
                             AV_METADATA_DONT_OVERWRITE);
2419
    }
2420

    
2421
    /* copy chapters according to chapter maps */
2422
    for (i = 0; i < nb_chapter_maps; i++) {
2423
        int infile  = chapter_maps[i].in_file;
2424
        int outfile = chapter_maps[i].out_file;
2425

    
2426
        if (infile < 0 || outfile < 0)
2427
            continue;
2428
        if (infile >= nb_input_files) {
2429
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2430
            ret = AVERROR(EINVAL);
2431
            goto dump_format;
2432
        }
2433
        if (outfile >= nb_output_files) {
2434
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2435
            ret = AVERROR(EINVAL);
2436
            goto dump_format;
2437
        }
2438
        copy_chapters(infile, outfile);
2439
    }
2440

    
2441
    /* copy chapters from the first input file that has them*/
2442
    if (!nb_chapter_maps)
2443
        for (i = 0; i < nb_input_files; i++) {
2444
            if (!input_files[i]->nb_chapters)
2445
                continue;
2446

    
2447
            for (j = 0; j < nb_output_files; j++)
2448
                if ((ret = copy_chapters(i, j)) < 0)
2449
                    goto dump_format;
2450
            break;
2451
        }
2452

    
2453
    /* open files and write file headers */
2454
    for(i=0;i<nb_output_files;i++) {
2455
        os = output_files[i];
2456
        if (av_write_header(os) < 0) {
2457
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2458
            ret = AVERROR(EINVAL);
2459
            goto dump_format;
2460
        }
2461
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2462
            want_sdp = 0;
2463
        }
2464
    }
2465

    
2466
 dump_format:
2467
    /* dump the file output parameters - cannot be done before in case
2468
       of stream copy */
2469
    for(i=0;i<nb_output_files;i++) {
2470
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2471
    }
2472

    
2473
    /* dump the stream mapping */
2474
    if (verbose >= 0) {
2475
        fprintf(stderr, "Stream mapping:\n");
2476
        for(i=0;i<nb_ostreams;i++) {
2477
            ost = ost_table[i];
2478
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2479
                    ist_table[ost->source_index]->file_index,
2480
                    ist_table[ost->source_index]->index,
2481
                    ost->file_index,
2482
                    ost->index);
2483
            if (ost->sync_ist != ist_table[ost->source_index])
2484
                fprintf(stderr, " [sync #%d.%d]",
2485
                        ost->sync_ist->file_index,
2486
                        ost->sync_ist->index);
2487
            fprintf(stderr, "\n");
2488
        }
2489
    }
2490

    
2491
    if (ret) {
2492
        fprintf(stderr, "%s\n", error);
2493
        goto fail;
2494
    }
2495

    
2496
    if (want_sdp) {
2497
        print_sdp(output_files, nb_output_files);
2498
    }
2499

    
2500
    if (!using_stdin && verbose >= 0) {
2501
        fprintf(stderr, "Press [q] to stop encoding\n");
2502
        url_set_interrupt_cb(decode_interrupt_cb);
2503
    }
2504
    term_init();
2505

    
2506
    timer_start = av_gettime();
2507

    
2508
    for(; received_sigterm == 0;) {
2509
        int file_index, ist_index;
2510
        AVPacket pkt;
2511
        double ipts_min;
2512
        double opts_min;
2513

    
2514
    redo:
2515
        ipts_min= 1e100;
2516
        opts_min= 1e100;
2517
        /* if 'q' pressed, exits */
2518
        if (!using_stdin) {
2519
            if (q_pressed)
2520
                break;
2521
            /* read_key() returns 0 on EOF */
2522
            key = read_key();
2523
            if (key == 'q')
2524
                break;
2525
        }
2526

    
2527
        /* select the stream that we must read now by looking at the
2528
           smallest output pts */
2529
        file_index = -1;
2530
        for(i=0;i<nb_ostreams;i++) {
2531
            double ipts, opts;
2532
            ost = ost_table[i];
2533
            os = output_files[ost->file_index];
2534
            ist = ist_table[ost->source_index];
2535
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2536
                continue;
2537
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2538
            ipts = (double)ist->pts;
2539
            if (!file_table[ist->file_index].eof_reached){
2540
                if(ipts < ipts_min) {
2541
                    ipts_min = ipts;
2542
                    if(input_sync ) file_index = ist->file_index;
2543
                }
2544
                if(opts < opts_min) {
2545
                    opts_min = opts;
2546
                    if(!input_sync) file_index = ist->file_index;
2547
                }
2548
            }
2549
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2550
                file_index= -1;
2551
                break;
2552
            }
2553
        }
2554
        /* if none, if is finished */
2555
        if (file_index < 0) {
2556
            if(no_packet_count){
2557
                no_packet_count=0;
2558
                memset(no_packet, 0, sizeof(no_packet));
2559
                usleep(10000);
2560
                continue;
2561
            }
2562
            break;
2563
        }
2564

    
2565
        /* finish if limit size exhausted */
2566
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2567
            break;
2568

    
2569
        /* read a frame from it and output it in the fifo */
2570
        is = input_files[file_index];
2571
        ret= av_read_frame(is, &pkt);
2572
        if(ret == AVERROR(EAGAIN)){
2573
            no_packet[file_index]=1;
2574
            no_packet_count++;
2575
            continue;
2576
        }
2577
        if (ret < 0) {
2578
            file_table[file_index].eof_reached = 1;
2579
            if (opt_shortest)
2580
                break;
2581
            else
2582
                continue;
2583
        }
2584

    
2585
        no_packet_count=0;
2586
        memset(no_packet, 0, sizeof(no_packet));
2587

    
2588
        if (do_pkt_dump) {
2589
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2590
        }
2591
        /* the following test is needed in case new streams appear
2592
           dynamically in stream : we ignore them */
2593
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2594
            goto discard_packet;
2595
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2596
        ist = ist_table[ist_index];
2597
        if (ist->discard)
2598
            goto discard_packet;
2599

    
2600
        if (pkt.dts != AV_NOPTS_VALUE)
2601
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2602
        if (pkt.pts != AV_NOPTS_VALUE)
2603
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2604

    
2605
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2606
            && input_files_ts_scale[file_index][pkt.stream_index]){
2607
            if(pkt.pts != AV_NOPTS_VALUE)
2608
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2609
            if(pkt.dts != AV_NOPTS_VALUE)
2610
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2611
        }
2612

    
2613
//        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);
2614
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2615
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2616
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2617
            int64_t delta= pkt_dts - ist->next_pts;
2618
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2619
                input_files_ts_offset[ist->file_index]-= delta;
2620
                if (verbose > 2)
2621
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2622
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2623
                if(pkt.pts != AV_NOPTS_VALUE)
2624
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2625
            }
2626
        }
2627

    
2628
        /* finish if recording time exhausted */
2629
        if (recording_time != INT64_MAX &&
2630
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2631
            ist->is_past_recording_time = 1;
2632
            goto discard_packet;
2633
        }
2634

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

    
2638
            if (verbose >= 0)
2639
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2640
                        ist->file_index, ist->index);
2641
            if (exit_on_error)
2642
                ffmpeg_exit(1);
2643
            av_free_packet(&pkt);
2644
            goto redo;
2645
        }
2646

    
2647
    discard_packet:
2648
        av_free_packet(&pkt);
2649

    
2650
        /* dump report by using the output first video and audio streams */
2651
        print_report(output_files, ost_table, nb_ostreams, 0);
2652
    }
2653

    
2654
    /* at the end of stream, we must flush the decoder buffers */
2655
    for(i=0;i<nb_istreams;i++) {
2656
        ist = ist_table[i];
2657
        if (ist->decoding_needed) {
2658
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2659
        }
2660
    }
2661

    
2662
    term_exit();
2663

    
2664
    /* write the trailer if needed and close file */
2665
    for(i=0;i<nb_output_files;i++) {
2666
        os = output_files[i];
2667
        av_write_trailer(os);
2668
    }
2669

    
2670
    /* dump report by using the first video and audio streams */
2671
    print_report(output_files, ost_table, nb_ostreams, 1);
2672

    
2673
    /* close each encoder */
2674
    for(i=0;i<nb_ostreams;i++) {
2675
        ost = ost_table[i];
2676
        if (ost->encoding_needed) {
2677
            av_freep(&ost->st->codec->stats_in);
2678
            avcodec_close(ost->st->codec);
2679
        }
2680
    }
2681

    
2682
    /* close each decoder */
2683
    for(i=0;i<nb_istreams;i++) {
2684
        ist = ist_table[i];
2685
        if (ist->decoding_needed) {
2686
            avcodec_close(ist->st->codec);
2687
        }
2688
    }
2689
#if CONFIG_AVFILTER
2690
    if (graph) {
2691
        avfilter_graph_free(graph);
2692
        av_freep(&graph);
2693
    }
2694
#endif
2695

    
2696
    /* finished ! */
2697
    ret = 0;
2698

    
2699
 fail:
2700
    av_freep(&bit_buffer);
2701
    av_free(file_table);
2702

    
2703
    if (ist_table) {
2704
        for(i=0;i<nb_istreams;i++) {
2705
            ist = ist_table[i];
2706
            av_free(ist);
2707
        }
2708
        av_free(ist_table);
2709
    }
2710
    if (ost_table) {
2711
        for(i=0;i<nb_ostreams;i++) {
2712
            ost = ost_table[i];
2713
            if (ost) {
2714
                if (ost->st->stream_copy)
2715
                    av_freep(&ost->st->codec->extradata);
2716
                if (ost->logfile) {
2717
                    fclose(ost->logfile);
2718
                    ost->logfile = NULL;
2719
                }
2720
                av_fifo_free(ost->fifo); /* works even if fifo is not
2721
                                             initialized but set to zero */
2722
                av_freep(&ost->st->codec->subtitle_header);
2723
                av_free(ost->pict_tmp.data[0]);
2724
                av_free(ost->forced_kf_pts);
2725
                if (ost->video_resample)
2726
                    sws_freeContext(ost->img_resample_ctx);
2727
                if (ost->resample)
2728
                    audio_resample_close(ost->resample);
2729
                if (ost->reformat_ctx)
2730
                    av_audio_convert_free(ost->reformat_ctx);
2731
                av_free(ost);
2732
            }
2733
        }
2734
        av_free(ost_table);
2735
    }
2736
    return ret;
2737
}
2738

    
2739
static void opt_format(const char *arg)
2740
{
2741
    last_asked_format = arg;
2742
}
2743

    
2744
static void opt_video_rc_override_string(const char *arg)
2745
{
2746
    video_rc_override_string = arg;
2747
}
2748

    
2749
static int opt_me_threshold(const char *opt, const char *arg)
2750
{
2751
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2752
    return 0;
2753
}
2754

    
2755
static int opt_verbose(const char *opt, const char *arg)
2756
{
2757
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2758
    return 0;
2759
}
2760

    
2761
static int opt_frame_rate(const char *opt, const char *arg)
2762
{
2763
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2764
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2765
        ffmpeg_exit(1);
2766
    }
2767
    return 0;
2768
}
2769

    
2770
static int opt_bitrate(const char *opt, const char *arg)
2771
{
2772
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2773

    
2774
    opt_default(opt, arg);
2775

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

    
2779
    return 0;
2780
}
2781

    
2782
static int opt_frame_crop(const char *opt, const char *arg)
2783
{
2784
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2785
    return AVERROR(EINVAL);
2786
}
2787

    
2788
static void opt_frame_size(const char *arg)
2789
{
2790
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2791
        fprintf(stderr, "Incorrect frame size\n");
2792
        ffmpeg_exit(1);
2793
    }
2794
}
2795

    
2796
static int opt_pad(const char *opt, const char *arg) {
2797
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2798
    return -1;
2799
}
2800

    
2801
static void opt_frame_pix_fmt(const char *arg)
2802
{
2803
    if (strcmp(arg, "list")) {
2804
        frame_pix_fmt = av_get_pix_fmt(arg);
2805
        if (frame_pix_fmt == PIX_FMT_NONE) {
2806
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2807
            ffmpeg_exit(1);
2808
        }
2809
    } else {
2810
        show_pix_fmts();
2811
        ffmpeg_exit(0);
2812
    }
2813
}
2814

    
2815
static void opt_frame_aspect_ratio(const char *arg)
2816
{
2817
    int x = 0, y = 0;
2818
    double ar = 0;
2819
    const char *p;
2820
    char *end;
2821

    
2822
    p = strchr(arg, ':');
2823
    if (p) {
2824
        x = strtol(arg, &end, 10);
2825
        if (end == p)
2826
            y = strtol(end+1, &end, 10);
2827
        if (x > 0 && y > 0)
2828
            ar = (double)x / (double)y;
2829
    } else
2830
        ar = strtod(arg, NULL);
2831

    
2832
    if (!ar) {
2833
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2834
        ffmpeg_exit(1);
2835
    }
2836
    frame_aspect_ratio = ar;
2837
}
2838

    
2839
static int opt_metadata(const char *opt, const char *arg)
2840
{
2841
    char *mid= strchr(arg, '=');
2842

    
2843
    if(!mid){
2844
        fprintf(stderr, "Missing =\n");
2845
        ffmpeg_exit(1);
2846
    }
2847
    *mid++= 0;
2848

    
2849
    av_metadata_set2(&metadata, arg, mid, 0);
2850

    
2851
    return 0;
2852
}
2853

    
2854
static void opt_qscale(const char *arg)
2855
{
2856
    video_qscale = atof(arg);
2857
    if (video_qscale <= 0 ||
2858
        video_qscale > 255) {
2859
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2860
        ffmpeg_exit(1);
2861
    }
2862
}
2863

    
2864
static void opt_top_field_first(const char *arg)
2865
{
2866
    top_field_first= atoi(arg);
2867
}
2868

    
2869
static int opt_thread_count(const char *opt, const char *arg)
2870
{
2871
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2872
#if !HAVE_THREADS
2873
    if (verbose >= 0)
2874
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2875
#endif
2876
    return 0;
2877
}
2878

    
2879
static void opt_audio_sample_fmt(const char *arg)
2880
{
2881
    if (strcmp(arg, "list")) {
2882
        audio_sample_fmt = av_get_sample_fmt(arg);
2883
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2884
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2885
            ffmpeg_exit(1);
2886
        }
2887
    } else {
2888
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2889
        ffmpeg_exit(0);
2890
    }
2891
}
2892

    
2893
static int opt_audio_rate(const char *opt, const char *arg)
2894
{
2895
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2896
    return 0;
2897
}
2898

    
2899
static int opt_audio_channels(const char *opt, const char *arg)
2900
{
2901
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2902
    return 0;
2903
}
2904

    
2905
static void opt_video_channel(const char *arg)
2906
{
2907
    video_channel = strtol(arg, NULL, 0);
2908
}
2909

    
2910
static void opt_video_standard(const char *arg)
2911
{
2912
    video_standard = av_strdup(arg);
2913
}
2914

    
2915
static void opt_codec(int *pstream_copy, char **pcodec_name,
2916
                      int codec_type, const char *arg)
2917
{
2918
    av_freep(pcodec_name);
2919
    if (!strcmp(arg, "copy")) {
2920
        *pstream_copy = 1;
2921
    } else {
2922
        *pcodec_name = av_strdup(arg);
2923
    }
2924
}
2925

    
2926
static void opt_audio_codec(const char *arg)
2927
{
2928
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2929
}
2930

    
2931
static void opt_video_codec(const char *arg)
2932
{
2933
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2934
}
2935

    
2936
static void opt_subtitle_codec(const char *arg)
2937
{
2938
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2939
}
2940

    
2941
static int opt_codec_tag(const char *opt, const char *arg)
2942
{
2943
    char *tail;
2944
    uint32_t *codec_tag;
2945

    
2946
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2947
                !strcmp(opt, "vtag") ? &video_codec_tag :
2948
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2949
    if (!codec_tag)
2950
        return -1;
2951

    
2952
    *codec_tag = strtol(arg, &tail, 0);
2953
    if (!tail || *tail)
2954
        *codec_tag = AV_RL32(arg);
2955

    
2956
    return 0;
2957
}
2958

    
2959
static void opt_map(const char *arg)
2960
{
2961
    AVStreamMap *m;
2962
    char *p;
2963

    
2964
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2965
    m = &stream_maps[nb_stream_maps-1];
2966

    
2967
    m->file_index = strtol(arg, &p, 0);
2968
    if (*p)
2969
        p++;
2970

    
2971
    m->stream_index = strtol(p, &p, 0);
2972
    if (*p) {
2973
        p++;
2974
        m->sync_file_index = strtol(p, &p, 0);
2975
        if (*p)
2976
            p++;
2977
        m->sync_stream_index = strtol(p, &p, 0);
2978
    } else {
2979
        m->sync_file_index = m->file_index;
2980
        m->sync_stream_index = m->stream_index;
2981
    }
2982
}
2983

    
2984
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2985
{
2986
    *endptr = arg;
2987
    if (*arg == ',') {
2988
        *type = *(++arg);
2989
        switch (*arg) {
2990
        case 'g':
2991
            break;
2992
        case 's':
2993
        case 'c':
2994
        case 'p':
2995
            *index = strtol(++arg, endptr, 0);
2996
            break;
2997
        default:
2998
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2999
            ffmpeg_exit(1);
3000
        }
3001
    } else
3002
        *type = 'g';
3003
}
3004

    
3005
static void opt_map_meta_data(const char *arg)
3006
{
3007
    AVMetaDataMap *m, *m1;
3008
    char *p;
3009

    
3010
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3011
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3012

    
3013
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3014
    m->file = strtol(arg, &p, 0);
3015
    parse_meta_type(p, &m->type, &m->index, &p);
3016
    if (*p)
3017
        p++;
3018

    
3019
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3020
    m1->file = strtol(p, &p, 0);
3021
    parse_meta_type(p, &m1->type, &m1->index, &p);
3022

    
3023
    if (m->type == 'g' || m1->type == 'g')
3024
        metadata_global_autocopy = 0;
3025
    if (m->type == 's' || m1->type == 's')
3026
        metadata_streams_autocopy = 0;
3027
    if (m->type == 'c' || m1->type == 'c')
3028
        metadata_chapters_autocopy = 0;
3029
}
3030

    
3031
static void opt_map_chapters(const char *arg)
3032
{
3033
    AVChapterMap *c;
3034
    char *p;
3035

    
3036
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3037
                              nb_chapter_maps + 1);
3038
    c = &chapter_maps[nb_chapter_maps - 1];
3039
    c->out_file = strtol(arg, &p, 0);
3040
    if (*p)
3041
        p++;
3042

    
3043
    c->in_file = strtol(p, &p, 0);
3044
}
3045

    
3046
static void opt_input_ts_scale(const char *arg)
3047
{
3048
    unsigned int stream;
3049
    double scale;
3050
    char *p;
3051

    
3052
    stream = strtol(arg, &p, 0);
3053
    if (*p)
3054
        p++;
3055
    scale= strtod(p, &p);
3056

    
3057
    if(stream >= MAX_STREAMS)
3058
        ffmpeg_exit(1);
3059

    
3060
    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);
3061
    input_files_ts_scale[nb_input_files][stream]= scale;
3062
}
3063

    
3064
static int opt_recording_time(const char *opt, const char *arg)
3065
{
3066
    recording_time = parse_time_or_die(opt, arg, 1);
3067
    return 0;
3068
}
3069

    
3070
static int opt_start_time(const char *opt, const char *arg)
3071
{
3072
    start_time = parse_time_or_die(opt, arg, 1);
3073
    return 0;
3074
}
3075

    
3076
static int opt_recording_timestamp(const char *opt, const char *arg)
3077
{
3078
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3079
    return 0;
3080
}
3081

    
3082
static int opt_input_ts_offset(const char *opt, const char *arg)
3083
{
3084
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3085
    return 0;
3086
}
3087

    
3088
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3089
{
3090
    const char *codec_string = encoder ? "encoder" : "decoder";
3091
    AVCodec *codec;
3092

    
3093
    if(!name)
3094
        return CODEC_ID_NONE;
3095
    codec = encoder ?
3096
        avcodec_find_encoder_by_name(name) :
3097
        avcodec_find_decoder_by_name(name);
3098
    if(!codec) {
3099
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3100
        ffmpeg_exit(1);
3101
    }
3102
    if(codec->type != type) {
3103
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3104
        ffmpeg_exit(1);
3105
    }
3106
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3107
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3108
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3109
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3110
                codec_string, codec->name);
3111
        codec = encoder ?
3112
            avcodec_find_encoder(codec->id) :
3113
            avcodec_find_decoder(codec->id);
3114
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3115
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3116
                    codec_string, codec->name);
3117
        ffmpeg_exit(1);
3118
    }
3119
    return codec->id;
3120
}
3121

    
3122
static void opt_input_file(const char *filename)
3123
{
3124
    AVFormatContext *ic;
3125
    AVFormatParameters params, *ap = &params;
3126
    AVInputFormat *file_iformat = NULL;
3127
    int err, i, ret, rfps, rfps_base;
3128
    int64_t timestamp;
3129

    
3130
    if (last_asked_format) {
3131
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3132
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3133
            ffmpeg_exit(1);
3134
        }
3135
        last_asked_format = NULL;
3136
    }
3137

    
3138
    if (!strcmp(filename, "-"))
3139
        filename = "pipe:";
3140

    
3141
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3142
                    !strcmp(filename, "/dev/stdin");
3143

    
3144
    /* get default parameters from command line */
3145
    ic = avformat_alloc_context();
3146
    if (!ic) {
3147
        print_error(filename, AVERROR(ENOMEM));
3148
        ffmpeg_exit(1);
3149
    }
3150

    
3151
    memset(ap, 0, sizeof(*ap));
3152
    ap->prealloced_context = 1;
3153
    ap->sample_rate = audio_sample_rate;
3154
    ap->channels = audio_channels;
3155
    ap->time_base.den = frame_rate.num;
3156
    ap->time_base.num = frame_rate.den;
3157
    ap->width = frame_width;
3158
    ap->height = frame_height;
3159
    ap->pix_fmt = frame_pix_fmt;
3160
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3161
    ap->channel = video_channel;
3162
    ap->standard = video_standard;
3163

    
3164
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3165

    
3166
    ic->video_codec_id   =
3167
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3168
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3169
    ic->audio_codec_id   =
3170
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3171
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3172
    ic->subtitle_codec_id=
3173
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3174
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3175
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3176

    
3177
    /* open the input file with generic libav function */
3178
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3179
    if (err < 0) {
3180
        print_error(filename, err);
3181
        ffmpeg_exit(1);
3182
    }
3183
    if(opt_programid) {
3184
        int i, j;
3185
        int found=0;
3186
        for(i=0; i<ic->nb_streams; i++){
3187
            ic->streams[i]->discard= AVDISCARD_ALL;
3188
        }
3189
        for(i=0; i<ic->nb_programs; i++){
3190
            AVProgram *p= ic->programs[i];
3191
            if(p->id != opt_programid){
3192
                p->discard = AVDISCARD_ALL;
3193
            }else{
3194
                found=1;
3195
                for(j=0; j<p->nb_stream_indexes; j++){
3196
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3197
                }
3198
            }
3199
        }
3200
        if(!found){
3201
            fprintf(stderr, "Specified program id not found\n");
3202
            ffmpeg_exit(1);
3203
        }
3204
        opt_programid=0;
3205
    }
3206

    
3207
    ic->loop_input = loop_input;
3208

    
3209
    /* If not enough info to get the stream parameters, we decode the
3210
       first frames to get it. (used in mpeg case for example) */
3211
    ret = av_find_stream_info(ic);
3212
    if (ret < 0 && verbose >= 0) {
3213
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3214
        av_close_input_file(ic);
3215
        ffmpeg_exit(1);
3216
    }
3217

    
3218
    timestamp = start_time;
3219
    /* add the stream start time */
3220
    if (ic->start_time != AV_NOPTS_VALUE)
3221
        timestamp += ic->start_time;
3222

    
3223
    /* if seeking requested, we execute it */
3224
    if (start_time != 0) {
3225
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3226
        if (ret < 0) {
3227
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3228
                    filename, (double)timestamp / AV_TIME_BASE);
3229
        }
3230
        /* reset seek info */
3231
        start_time = 0;
3232
    }
3233

    
3234
    /* update the current parameters so that they match the one of the input stream */
3235
    for(i=0;i<ic->nb_streams;i++) {
3236
        AVStream *st = ic->streams[i];
3237
        AVCodecContext *dec = st->codec;
3238
        avcodec_thread_init(dec, thread_count);
3239
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3240
        switch (dec->codec_type) {
3241
        case AVMEDIA_TYPE_AUDIO:
3242
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3243
            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]);
3244
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3245
            channel_layout    = dec->channel_layout;
3246
            audio_channels    = dec->channels;
3247
            audio_sample_rate = dec->sample_rate;
3248
            audio_sample_fmt  = dec->sample_fmt;
3249
            if(audio_disable)
3250
                st->discard= AVDISCARD_ALL;
3251
            /* Note that av_find_stream_info can add more streams, and we
3252
             * currently have no chance of setting up lowres decoding
3253
             * early enough for them. */
3254
            if (dec->lowres)
3255
                audio_sample_rate >>= dec->lowres;
3256
            break;
3257
        case AVMEDIA_TYPE_VIDEO:
3258
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3259
            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]);
3260
            frame_height = dec->height;
3261
            frame_width  = dec->width;
3262
            if(ic->streams[i]->sample_aspect_ratio.num)
3263
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3264
            else
3265
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3266
            frame_aspect_ratio *= (float) dec->width / dec->height;
3267
            frame_pix_fmt = dec->pix_fmt;
3268
            rfps      = ic->streams[i]->r_frame_rate.num;
3269
            rfps_base = ic->streams[i]->r_frame_rate.den;
3270
            if (dec->lowres) {
3271
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3272
                frame_height >>= dec->lowres;
3273
                frame_width  >>= dec->lowres;
3274
                dec->height = frame_height;
3275
                dec->width  = frame_width;
3276
            }
3277
            if(me_threshold)
3278
                dec->debug |= FF_DEBUG_MV;
3279

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

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

    
3286
                    (float)rfps / rfps_base, rfps, rfps_base);
3287
            }
3288
            /* update the current frame rate to match the stream frame rate */
3289
            frame_rate.num = rfps;
3290
            frame_rate.den = rfps_base;
3291

    
3292
            if(video_disable)
3293
                st->discard= AVDISCARD_ALL;
3294
            else if(video_discard)
3295
                st->discard= video_discard;
3296
            break;
3297
        case AVMEDIA_TYPE_DATA:
3298
            break;
3299
        case AVMEDIA_TYPE_SUBTITLE:
3300
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3301
            if(subtitle_disable)
3302
                st->discard = AVDISCARD_ALL;
3303
            break;
3304
        case AVMEDIA_TYPE_ATTACHMENT:
3305
        case AVMEDIA_TYPE_UNKNOWN:
3306
            break;
3307
        default:
3308
            abort();
3309
        }
3310
    }
3311

    
3312
    input_files[nb_input_files] = ic;
3313
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3314
    /* dump the file content */
3315
    if (verbose >= 0)
3316
        dump_format(ic, nb_input_files, filename, 0);
3317

    
3318
    nb_input_files++;
3319

    
3320
    video_channel = 0;
3321

    
3322
    av_freep(&video_codec_name);
3323
    av_freep(&audio_codec_name);
3324
    av_freep(&subtitle_codec_name);
3325
}
3326

    
3327
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3328
                                         int *has_subtitle_ptr)
3329
{
3330
    int has_video, has_audio, has_subtitle, i, j;
3331
    AVFormatContext *ic;
3332

    
3333
    has_video = 0;
3334
    has_audio = 0;
3335
    has_subtitle = 0;
3336
    for(j=0;j<nb_input_files;j++) {
3337
        ic = input_files[j];
3338
        for(i=0;i<ic->nb_streams;i++) {
3339
            AVCodecContext *enc = ic->streams[i]->codec;
3340
            switch(enc->codec_type) {
3341
            case AVMEDIA_TYPE_AUDIO:
3342
                has_audio = 1;
3343
                break;
3344
            case AVMEDIA_TYPE_VIDEO:
3345
                has_video = 1;
3346
                break;
3347
            case AVMEDIA_TYPE_SUBTITLE:
3348
                has_subtitle = 1;
3349
                break;
3350
            case AVMEDIA_TYPE_DATA:
3351
            case AVMEDIA_TYPE_ATTACHMENT:
3352
            case AVMEDIA_TYPE_UNKNOWN:
3353
                break;
3354
            default:
3355
                abort();
3356
            }
3357
        }
3358
    }
3359
    *has_video_ptr = has_video;
3360
    *has_audio_ptr = has_audio;
3361
    *has_subtitle_ptr = has_subtitle;
3362
}
3363

    
3364
static void new_video_stream(AVFormatContext *oc, int file_idx)
3365
{
3366
    AVStream *st;
3367
    AVOutputStream *ost;
3368
    AVCodecContext *video_enc;
3369
    enum CodecID codec_id = CODEC_ID_NONE;
3370
    AVCodec *codec= NULL;
3371

    
3372
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3373
    if (!st) {
3374
        fprintf(stderr, "Could not alloc stream\n");
3375
        ffmpeg_exit(1);
3376
    }
3377
    ost = new_output_stream(oc, file_idx);
3378

    
3379
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3380
    if(!video_stream_copy){
3381
        if (video_codec_name) {
3382
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3383
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3384
            codec = avcodec_find_encoder_by_name(video_codec_name);
3385
            output_codecs[nb_output_codecs-1] = codec;
3386
        } else {
3387
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3388
            codec = avcodec_find_encoder(codec_id);
3389
        }
3390
    }
3391

    
3392
    avcodec_get_context_defaults3(st->codec, codec);
3393
    ost->bitstream_filters = video_bitstream_filters;
3394
    video_bitstream_filters= NULL;
3395

    
3396
    avcodec_thread_init(st->codec, thread_count);
3397

    
3398
    video_enc = st->codec;
3399

    
3400
    if(video_codec_tag)
3401
        video_enc->codec_tag= video_codec_tag;
3402

    
3403
    if(   (video_global_header&1)
3404
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3405
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3406
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3407
    }
3408
    if(video_global_header&2){
3409
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3410
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3411
    }
3412

    
3413
    if (video_stream_copy) {
3414
        st->stream_copy = 1;
3415
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3416
        video_enc->sample_aspect_ratio =
3417
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3418
    } else {
3419
        const char *p;
3420
        int i;
3421
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3422

    
3423
        video_enc->codec_id = codec_id;
3424
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3425

    
3426
        if (codec && codec->supported_framerates && !force_fps)
3427
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3428
        video_enc->time_base.den = fps.num;
3429
        video_enc->time_base.num = fps.den;
3430

    
3431
        video_enc->width = frame_width;
3432
        video_enc->height = frame_height;
3433
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3434
        video_enc->pix_fmt = frame_pix_fmt;
3435
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3436

    
3437
        choose_pixel_fmt(st, codec);
3438

    
3439
        if (intra_only)
3440
            video_enc->gop_size = 0;
3441
        if (video_qscale || same_quality) {
3442
            video_enc->flags |= CODEC_FLAG_QSCALE;
3443
            video_enc->global_quality=
3444
                st->quality = FF_QP2LAMBDA * video_qscale;
3445
        }
3446

    
3447
        if(intra_matrix)
3448
            video_enc->intra_matrix = intra_matrix;
3449
        if(inter_matrix)
3450
            video_enc->inter_matrix = inter_matrix;
3451

    
3452
        p= video_rc_override_string;
3453
        for(i=0; p; i++){
3454
            int start, end, q;
3455
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3456
            if(e!=3){
3457
                fprintf(stderr, "error parsing rc_override\n");
3458
                ffmpeg_exit(1);
3459
            }
3460
            video_enc->rc_override=
3461
                av_realloc(video_enc->rc_override,
3462
                           sizeof(RcOverride)*(i+1));
3463
            video_enc->rc_override[i].start_frame= start;
3464
            video_enc->rc_override[i].end_frame  = end;
3465
            if(q>0){
3466
                video_enc->rc_override[i].qscale= q;
3467
                video_enc->rc_override[i].quality_factor= 1.0;
3468
            }
3469
            else{
3470
                video_enc->rc_override[i].qscale= 0;
3471
                video_enc->rc_override[i].quality_factor= -q/100.0;
3472
            }
3473
            p= strchr(p, '/');
3474
            if(p) p++;
3475
        }
3476
        video_enc->rc_override_count=i;
3477
        if (!video_enc->rc_initial_buffer_occupancy)
3478
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3479
        video_enc->me_threshold= me_threshold;
3480
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3481

    
3482
        if (do_psnr)
3483
            video_enc->flags|= CODEC_FLAG_PSNR;
3484

    
3485
        /* two pass mode */
3486
        if (do_pass) {
3487
            if (do_pass == 1) {
3488
                video_enc->flags |= CODEC_FLAG_PASS1;
3489
            } else {
3490
                video_enc->flags |= CODEC_FLAG_PASS2;
3491
            }
3492
        }
3493

    
3494
        if (forced_key_frames)
3495
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3496
    }
3497
    if (video_language) {
3498
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3499
        av_freep(&video_language);
3500
    }
3501

    
3502
    /* reset some key parameters */
3503
    video_disable = 0;
3504
    av_freep(&video_codec_name);
3505
    av_freep(&forced_key_frames);
3506
    video_stream_copy = 0;
3507
    frame_pix_fmt = PIX_FMT_NONE;
3508
}
3509

    
3510
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3511
{
3512
    AVStream *st;
3513
    AVOutputStream *ost;
3514
    AVCodec *codec= NULL;
3515
    AVCodecContext *audio_enc;
3516
    enum CodecID codec_id = CODEC_ID_NONE;
3517

    
3518
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3519
    if (!st) {
3520
        fprintf(stderr, "Could not alloc stream\n");
3521
        ffmpeg_exit(1);
3522
    }
3523
    ost = new_output_stream(oc, file_idx);
3524

    
3525
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3526
    if(!audio_stream_copy){
3527
        if (audio_codec_name) {
3528
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3529
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3530
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3531
            output_codecs[nb_output_codecs-1] = codec;
3532
        } else {
3533
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3534
            codec = avcodec_find_encoder(codec_id);
3535
        }
3536
    }
3537

    
3538
    avcodec_get_context_defaults3(st->codec, codec);
3539

    
3540
    ost->bitstream_filters = audio_bitstream_filters;
3541
    audio_bitstream_filters= NULL;
3542

    
3543
    avcodec_thread_init(st->codec, thread_count);
3544

    
3545
    audio_enc = st->codec;
3546
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3547

    
3548
    if(audio_codec_tag)
3549
        audio_enc->codec_tag= audio_codec_tag;
3550

    
3551
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3552
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3553
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3554
    }
3555
    if (audio_stream_copy) {
3556
        st->stream_copy = 1;
3557
        audio_enc->channels = audio_channels;
3558
        audio_enc->sample_rate = audio_sample_rate;
3559
    } else {
3560
        audio_enc->codec_id = codec_id;
3561
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3562

    
3563
        if (audio_qscale > QSCALE_NONE) {
3564
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3565
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3566
        }
3567
        audio_enc->channels = audio_channels;
3568
        audio_enc->sample_fmt = audio_sample_fmt;
3569
        audio_enc->sample_rate = audio_sample_rate;
3570
        audio_enc->channel_layout = channel_layout;
3571
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3572
            audio_enc->channel_layout = 0;
3573
        choose_sample_fmt(st, codec);
3574
        choose_sample_rate(st, codec);
3575
    }
3576
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3577
    if (audio_language) {
3578
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3579
        av_freep(&audio_language);
3580
    }
3581

    
3582
    /* reset some key parameters */
3583
    audio_disable = 0;
3584
    av_freep(&audio_codec_name);
3585
    audio_stream_copy = 0;
3586
}
3587

    
3588
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3589
{
3590
    AVStream *st;
3591
    AVOutputStream *ost;
3592
    AVCodec *codec=NULL;
3593
    AVCodecContext *subtitle_enc;
3594
    enum CodecID codec_id = CODEC_ID_NONE;
3595

    
3596
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3597
    if (!st) {
3598
        fprintf(stderr, "Could not alloc stream\n");
3599
        ffmpeg_exit(1);
3600
    }
3601
    ost = new_output_stream(oc, file_idx);
3602
    subtitle_enc = st->codec;
3603
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3604
    if(!subtitle_stream_copy){
3605
        if (subtitle_codec_name) {
3606
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3607
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3608
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3609
        } else {
3610
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3611
            codec = avcodec_find_encoder(codec_id);
3612
        }
3613
    }
3614
    avcodec_get_context_defaults3(st->codec, codec);
3615

    
3616
    ost->bitstream_filters = subtitle_bitstream_filters;
3617
    subtitle_bitstream_filters= NULL;
3618

    
3619
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3620

    
3621
    if(subtitle_codec_tag)
3622
        subtitle_enc->codec_tag= subtitle_codec_tag;
3623

    
3624
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3625
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3626
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3627
    }
3628
    if (subtitle_stream_copy) {
3629
        st->stream_copy = 1;
3630
    } else {
3631
        subtitle_enc->codec_id = codec_id;
3632
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3633
    }
3634

    
3635
    if (subtitle_language) {
3636
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3637
        av_freep(&subtitle_language);
3638
    }
3639

    
3640
    subtitle_disable = 0;
3641
    av_freep(&subtitle_codec_name);
3642
    subtitle_stream_copy = 0;
3643
}
3644

    
3645
static int opt_new_stream(const char *opt, const char *arg)
3646
{
3647
    AVFormatContext *oc;
3648
    int file_idx = nb_output_files - 1;
3649
    if (nb_output_files <= 0) {
3650
        fprintf(stderr, "At least one output file must be specified\n");
3651
        ffmpeg_exit(1);
3652
    }
3653
    oc = output_files[file_idx];
3654

    
3655
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3656
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3657
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3658
    else av_assert0(0);
3659
    return 0;
3660
}
3661

    
3662
/* arg format is "output-stream-index:streamid-value". */
3663
static int opt_streamid(const char *opt, const char *arg)
3664
{
3665
    int idx;
3666
    char *p;
3667
    char idx_str[16];
3668

    
3669
    strncpy(idx_str, arg, sizeof(idx_str));
3670
    idx_str[sizeof(idx_str)-1] = '\0';
3671
    p = strchr(idx_str, ':');
3672
    if (!p) {
3673
        fprintf(stderr,
3674
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3675
                arg, opt);
3676
        ffmpeg_exit(1);
3677
    }
3678
    *p++ = '\0';
3679
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3680
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3681
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3682
    return 0;
3683
}
3684

    
3685
static void opt_output_file(const char *filename)
3686
{
3687
    AVFormatContext *oc;
3688
    int err, use_video, use_audio, use_subtitle;
3689
    int input_has_video, input_has_audio, input_has_subtitle;
3690
    AVFormatParameters params, *ap = &params;
3691
    AVOutputFormat *file_oformat;
3692

    
3693
    if (!strcmp(filename, "-"))
3694
        filename = "pipe:";
3695

    
3696
    oc = avformat_alloc_context();
3697
    if (!oc) {
3698
        print_error(filename, AVERROR(ENOMEM));
3699
        ffmpeg_exit(1);
3700
    }
3701

    
3702
    if (last_asked_format) {
3703
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3704
        if (!file_oformat) {
3705
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3706
            ffmpeg_exit(1);
3707
        }
3708
        last_asked_format = NULL;
3709
    } else {
3710
        file_oformat = av_guess_format(NULL, filename, NULL);
3711
        if (!file_oformat) {
3712
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3713
                    filename);
3714
            ffmpeg_exit(1);
3715
        }
3716
    }
3717

    
3718
    oc->oformat = file_oformat;
3719
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3720

    
3721
    if (!strcmp(file_oformat->name, "ffm") &&
3722
        av_strstart(filename, "http:", NULL)) {
3723
        /* special case for files sent to ffserver: we get the stream
3724
           parameters from ffserver */
3725
        int err = read_ffserver_streams(oc, filename);
3726
        if (err < 0) {
3727
            print_error(filename, err);
3728
            ffmpeg_exit(1);
3729
        }
3730
    } else {
3731
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3732
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3733
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3734

    
3735
        /* disable if no corresponding type found and at least one
3736
           input file */
3737
        if (nb_input_files > 0) {
3738
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3739
                                         &input_has_subtitle);
3740
            if (!input_has_video)
3741
                use_video = 0;
3742
            if (!input_has_audio)
3743
                use_audio = 0;
3744
            if (!input_has_subtitle)
3745
                use_subtitle = 0;
3746
        }
3747

    
3748
        /* manual disable */
3749
        if (audio_disable)    use_audio    = 0;
3750
        if (video_disable)    use_video    = 0;
3751
        if (subtitle_disable) use_subtitle = 0;
3752

    
3753
        if (use_video)    new_video_stream(oc, nb_output_files);
3754
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3755
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3756

    
3757
        oc->timestamp = recording_timestamp;
3758

    
3759
        av_metadata_copy(&oc->metadata, metadata, 0);
3760
        av_metadata_free(&metadata);
3761
    }
3762

    
3763
    output_files[nb_output_files++] = oc;
3764

    
3765
    /* check filename in case of an image number is expected */
3766
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3767
        if (!av_filename_number_test(oc->filename)) {
3768
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3769
            ffmpeg_exit(1);
3770
        }
3771
    }
3772

    
3773
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3774
        /* test if it already exists to avoid loosing precious files */
3775
        if (!file_overwrite &&
3776
            (strchr(filename, ':') == NULL ||
3777
             filename[1] == ':' ||
3778
             av_strstart(filename, "file:", NULL))) {
3779
            if (url_exist(filename)) {
3780
                if (!using_stdin) {
3781
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3782
                    fflush(stderr);
3783
                    if (!read_yesno()) {
3784
                        fprintf(stderr, "Not overwriting - exiting\n");
3785
                        ffmpeg_exit(1);
3786
                    }
3787
                }
3788
                else {
3789
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3790
                    ffmpeg_exit(1);
3791
                }
3792
            }
3793
        }
3794

    
3795
        /* open the file */
3796
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3797
            print_error(filename, err);
3798
            ffmpeg_exit(1);
3799
        }
3800
    }
3801

    
3802
    memset(ap, 0, sizeof(*ap));
3803
    if (av_set_parameters(oc, ap) < 0) {
3804
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3805
                oc->filename);
3806
        ffmpeg_exit(1);
3807
    }
3808

    
3809
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3810
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3811
    oc->loop_output = loop_output;
3812
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3813

    
3814
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3815

    
3816
    nb_streamid_map = 0;
3817
    av_freep(&forced_key_frames);
3818
}
3819

    
3820
/* same option as mencoder */
3821
static void opt_pass(const char *pass_str)
3822
{
3823
    int pass;
3824
    pass = atoi(pass_str);
3825
    if (pass != 1 && pass != 2) {
3826
        fprintf(stderr, "pass number can be only 1 or 2\n");
3827
        ffmpeg_exit(1);
3828
    }
3829
    do_pass = pass;
3830
}
3831

    
3832
static int64_t getutime(void)
3833
{
3834
#if HAVE_GETRUSAGE
3835
    struct rusage rusage;
3836

    
3837
    getrusage(RUSAGE_SELF, &rusage);
3838
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3839
#elif HAVE_GETPROCESSTIMES
3840
    HANDLE proc;
3841
    FILETIME c, e, k, u;
3842
    proc = GetCurrentProcess();
3843
    GetProcessTimes(proc, &c, &e, &k, &u);
3844
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3845
#else
3846
    return av_gettime();
3847
#endif
3848
}
3849

    
3850
static int64_t getmaxrss(void)
3851
{
3852
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3853
    struct rusage rusage;
3854
    getrusage(RUSAGE_SELF, &rusage);
3855
    return (int64_t)rusage.ru_maxrss * 1024;
3856
#elif HAVE_GETPROCESSMEMORYINFO
3857
    HANDLE proc;
3858
    PROCESS_MEMORY_COUNTERS memcounters;
3859
    proc = GetCurrentProcess();
3860
    memcounters.cb = sizeof(memcounters);
3861
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3862
    return memcounters.PeakPagefileUsage;
3863
#else
3864
    return 0;
3865
#endif
3866
}
3867

    
3868
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3869
{
3870
    int i;
3871
    const char *p = str;
3872
    for(i = 0;; i++) {
3873
        dest[i] = atoi(p);
3874
        if(i == 63)
3875
            break;
3876
        p = strchr(p, ',');
3877
        if(!p) {
3878
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3879
            ffmpeg_exit(1);
3880
        }
3881
        p++;
3882
    }
3883
}
3884

    
3885
static void opt_inter_matrix(const char *arg)
3886
{
3887
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3888
    parse_matrix_coeffs(inter_matrix, arg);
3889
}
3890

    
3891
static void opt_intra_matrix(const char *arg)
3892
{
3893
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3894
    parse_matrix_coeffs(intra_matrix, arg);
3895
}
3896

    
3897
static void show_usage(void)
3898
{
3899
    printf("Hyper fast Audio and Video encoder\n");
3900
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3901
    printf("\n");
3902
}
3903

    
3904
static void show_help(void)
3905
{
3906
    AVCodec *c;
3907
    AVOutputFormat *oformat = NULL;
3908

    
3909
    av_log_set_callback(log_callback_help);
3910
    show_usage();
3911
    show_help_options(options, "Main options:\n",
3912
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3913
    show_help_options(options, "\nAdvanced options:\n",
3914
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3915
                      OPT_EXPERT);
3916
    show_help_options(options, "\nVideo options:\n",
3917
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3918
                      OPT_VIDEO);
3919
    show_help_options(options, "\nAdvanced Video options:\n",
3920
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3921
                      OPT_VIDEO | OPT_EXPERT);
3922
    show_help_options(options, "\nAudio options:\n",
3923
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3924
                      OPT_AUDIO);
3925
    show_help_options(options, "\nAdvanced Audio options:\n",
3926
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3927
                      OPT_AUDIO | OPT_EXPERT);
3928
    show_help_options(options, "\nSubtitle options:\n",
3929
                      OPT_SUBTITLE | OPT_GRAB,
3930
                      OPT_SUBTITLE);
3931
    show_help_options(options, "\nAudio/Video grab options:\n",
3932
                      OPT_GRAB,
3933
                      OPT_GRAB);
3934
    printf("\n");
3935
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3936
    printf("\n");
3937

    
3938
    /* individual codec options */
3939
    c = NULL;
3940
    while ((c = av_codec_next(c))) {
3941
        if (c->priv_class) {
3942
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3943
            printf("\n");
3944
        }
3945
    }
3946

    
3947
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3948
    printf("\n");
3949

    
3950
    /* individual muxer options */
3951
    while ((oformat = av_oformat_next(oformat))) {
3952
        if (oformat->priv_class) {
3953
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3954
            printf("\n");
3955
        }
3956
    }
3957

    
3958
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3959
}
3960

    
3961
static void opt_target(const char *arg)
3962
{
3963
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3964
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3965

    
3966
    if(!strncmp(arg, "pal-", 4)) {
3967
        norm = PAL;
3968
        arg += 4;
3969
    } else if(!strncmp(arg, "ntsc-", 5)) {
3970
        norm = NTSC;
3971
        arg += 5;
3972
    } else if(!strncmp(arg, "film-", 5)) {
3973
        norm = FILM;
3974
        arg += 5;
3975
    } else {
3976
        int fr;
3977
        /* Calculate FR via float to avoid int overflow */
3978
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3979
        if(fr == 25000) {
3980
            norm = PAL;
3981
        } else if((fr == 29970) || (fr == 23976)) {
3982
            norm = NTSC;
3983
        } else {
3984
            /* Try to determine PAL/NTSC by peeking in the input files */
3985
            if(nb_input_files) {
3986
                int i, j;
3987
                for(j = 0; j < nb_input_files; j++) {
3988
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3989
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3990
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3991
                            continue;
3992
                        fr = c->time_base.den * 1000 / c->time_base.num;
3993
                        if(fr == 25000) {
3994
                            norm = PAL;
3995
                            break;
3996
                        } else if((fr == 29970) || (fr == 23976)) {
3997
                            norm = NTSC;
3998
                            break;
3999
                        }
4000
                    }
4001
                    if(norm != UNKNOWN)
4002
                        break;
4003
                }
4004
            }
4005
        }
4006
        if(verbose && norm != UNKNOWN)
4007
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4008
    }
4009

    
4010
    if(norm == UNKNOWN) {
4011
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4012
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4013
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4014
        ffmpeg_exit(1);
4015
    }
4016

    
4017
    if(!strcmp(arg, "vcd")) {
4018

    
4019
        opt_video_codec("mpeg1video");
4020
        opt_audio_codec("mp2");
4021
        opt_format("vcd");
4022

    
4023
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4024
        opt_frame_rate(NULL, frame_rates[norm]);
4025
        opt_default("g", norm == PAL ? "15" : "18");
4026

    
4027
        opt_default("b", "1150000");
4028
        opt_default("maxrate", "1150000");
4029
        opt_default("minrate", "1150000");
4030
        opt_default("bufsize", "327680"); // 40*1024*8;
4031

    
4032
        opt_default("ab", "224000");
4033
        audio_sample_rate = 44100;
4034
        audio_channels = 2;
4035

    
4036
        opt_default("packetsize", "2324");
4037
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4038

    
4039
        /* We have to offset the PTS, so that it is consistent with the SCR.
4040
           SCR starts at 36000, but the first two packs contain only padding
4041
           and the first pack from the other stream, respectively, may also have
4042
           been written before.
4043
           So the real data starts at SCR 36000+3*1200. */
4044
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4045
    } else if(!strcmp(arg, "svcd")) {
4046

    
4047
        opt_video_codec("mpeg2video");
4048
        opt_audio_codec("mp2");
4049
        opt_format("svcd");
4050

    
4051
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4052
        opt_frame_rate(NULL, frame_rates[norm]);
4053
        opt_default("g", norm == PAL ? "15" : "18");
4054

    
4055
        opt_default("b", "2040000");
4056
        opt_default("maxrate", "2516000");
4057
        opt_default("minrate", "0"); //1145000;
4058
        opt_default("bufsize", "1835008"); //224*1024*8;
4059
        opt_default("flags", "+scan_offset");
4060

    
4061

    
4062
        opt_default("ab", "224000");
4063
        audio_sample_rate = 44100;
4064

    
4065
        opt_default("packetsize", "2324");
4066

    
4067
    } else if(!strcmp(arg, "dvd")) {
4068

    
4069
        opt_video_codec("mpeg2video");
4070
        opt_audio_codec("ac3");
4071
        opt_format("dvd");
4072

    
4073
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4074
        opt_frame_rate(NULL, frame_rates[norm]);
4075
        opt_default("g", norm == PAL ? "15" : "18");
4076

    
4077
        opt_default("b", "6000000");
4078
        opt_default("maxrate", "9000000");
4079
        opt_default("minrate", "0"); //1500000;
4080
        opt_default("bufsize", "1835008"); //224*1024*8;
4081

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

    
4085
        opt_default("ab", "448000");
4086
        audio_sample_rate = 48000;
4087

    
4088
    } else if(!strncmp(arg, "dv", 2)) {
4089

    
4090
        opt_format("dv");
4091

    
4092
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4093
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4094
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4095
        opt_frame_rate(NULL, frame_rates[norm]);
4096

    
4097
        audio_sample_rate = 48000;
4098
        audio_channels = 2;
4099

    
4100
    } else {
4101
        fprintf(stderr, "Unknown target: %s\n", arg);
4102
        ffmpeg_exit(1);
4103
    }
4104
}
4105

    
4106
static void opt_vstats_file (const char *arg)
4107
{
4108
    av_free (vstats_filename);
4109
    vstats_filename=av_strdup (arg);
4110
}
4111

    
4112
static void opt_vstats (void)
4113
{
4114
    char filename[40];
4115
    time_t today2 = time(NULL);
4116
    struct tm *today = localtime(&today2);
4117

    
4118
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4119
             today->tm_sec);
4120
    opt_vstats_file(filename);
4121
}
4122

    
4123
static int opt_bsf(const char *opt, const char *arg)
4124
{
4125
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4126
    AVBitStreamFilterContext **bsfp;
4127

    
4128
    if(!bsfc){
4129
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4130
        ffmpeg_exit(1);
4131
    }
4132

    
4133
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4134
          *opt == 'a' ? &audio_bitstream_filters :
4135
                        &subtitle_bitstream_filters;
4136
    while(*bsfp)
4137
        bsfp= &(*bsfp)->next;
4138

    
4139
    *bsfp= bsfc;
4140

    
4141
    return 0;
4142
}
4143

    
4144
static int opt_preset(const char *opt, const char *arg)
4145
{
4146
    FILE *f=NULL;
4147
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4148
    char *codec_name = *opt == 'v' ? video_codec_name :
4149
                       *opt == 'a' ? audio_codec_name :
4150
                                     subtitle_codec_name;
4151

    
4152
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4153
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4154
        ffmpeg_exit(1);
4155
    }
4156

    
4157
    while(!feof(f)){
4158
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4159
        if(line[0] == '#' && !e)
4160
            continue;
4161
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4162
        if(e){
4163
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4164
            ffmpeg_exit(1);
4165
        }
4166
        if(!strcmp(tmp, "acodec")){
4167
            opt_audio_codec(tmp2);
4168
        }else if(!strcmp(tmp, "vcodec")){
4169
            opt_video_codec(tmp2);
4170
        }else if(!strcmp(tmp, "scodec")){
4171
            opt_subtitle_codec(tmp2);
4172
        }else if(opt_default(tmp, tmp2) < 0){
4173
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4174
            ffmpeg_exit(1);
4175
        }
4176
    }
4177

    
4178
    fclose(f);
4179

    
4180
    return 0;
4181
}
4182

    
4183
static const OptionDef options[] = {
4184
    /* main options */
4185
#include "cmdutils_common_opts.h"
4186
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4187
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4188
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4189
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4190
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4191
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4192
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4193
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4194
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4195
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4196
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4197
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4198
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4199
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4200
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4201
      "add timings for benchmarking" },
4202
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4203
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4204
      "dump each input packet" },
4205
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4206
      "when dumping packets, also dump the payload" },
4207
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4208
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4209
    { "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)", "" },
4210
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4211
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4212
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4213
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4214
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4215
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4216
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4217
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4218
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4219
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4220
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4221
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4222
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4223
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4224

    
4225
    /* video options */
4226
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4227
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4228
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4229
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4230
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4231
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4232
    { "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" },
4233
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4234
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4235
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4236
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4237
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4238
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4239
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4240
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4241
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4242
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4243
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4244
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4245
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4246
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4247
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4248
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4249
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4250
      "use same video quality as source (implies VBR)" },
4251
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4252
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4253
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4254
      "deinterlace pictures" },
4255
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4256
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4257
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4258
#if CONFIG_AVFILTER
4259
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4260
#endif
4261
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4262
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4263
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4264
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4265
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4266
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4267
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4268
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4269
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4270
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4271
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4272

    
4273
    /* audio options */
4274
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4275
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4276
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4277
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4278
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4279
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4280
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4281
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4282
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4283
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4284
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4285
    { "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" },
4286

    
4287
    /* subtitle options */
4288
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4289
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4290
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4291
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4292
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4293

    
4294
    /* grab options */
4295
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4296
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4297
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4298

    
4299
    /* muxer options */
4300
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4301
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4302

    
4303
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4304
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4305
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4306

    
4307
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4308
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4309
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4310
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4311

    
4312
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4313
    { NULL, },
4314
};
4315

    
4316
int main(int argc, char **argv)
4317
{
4318
    int64_t ti;
4319

    
4320
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4321

    
4322
    avcodec_register_all();
4323
#if CONFIG_AVDEVICE
4324
    avdevice_register_all();
4325
#endif
4326
#if CONFIG_AVFILTER
4327
    avfilter_register_all();
4328
#endif
4329
    av_register_all();
4330

    
4331
#if HAVE_ISATTY
4332
    if(isatty(STDIN_FILENO))
4333
        url_set_interrupt_cb(decode_interrupt_cb);
4334
#endif
4335

    
4336
    init_opts();
4337

    
4338
    show_banner();
4339

    
4340
    /* parse options */
4341
    parse_options(argc, argv, options, opt_output_file);
4342

    
4343
    if(nb_output_files <= 0 && nb_input_files == 0) {
4344
        show_usage();
4345
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4346
        ffmpeg_exit(1);
4347
    }
4348

    
4349
    /* file converter / grab */
4350
    if (nb_output_files <= 0) {
4351
        fprintf(stderr, "At least one output file must be specified\n");
4352
        ffmpeg_exit(1);
4353
    }
4354

    
4355
    if (nb_input_files == 0) {
4356
        fprintf(stderr, "At least one input file must be specified\n");
4357
        ffmpeg_exit(1);
4358
    }
4359

    
4360
    ti = getutime();
4361
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4362
                  stream_maps, nb_stream_maps) < 0)
4363
        ffmpeg_exit(1);
4364
    ti = getutime() - ti;
4365
    if (do_benchmark) {
4366
        int maxrss = getmaxrss() / 1024;
4367
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4368
    }
4369

    
4370
    return ffmpeg_exit(0);
4371
}