Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ fd0ae17a

History | View | Annotate | Download (160 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
static 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
static 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
    AVRational sample_aspect_ratio;
359
    char args[255];
360
    int ret;
361

    
362
    graph = avfilter_graph_alloc();
363

    
364
    if (ist->st->sample_aspect_ratio.num){
365
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
366
    }else
367
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
368

    
369
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
370
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
371
             sample_aspect_ratio.num, sample_aspect_ratio.den);
372

    
373
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
374
                                       "src", args, NULL, graph);
375
    if (ret < 0)
376
        return ret;
377
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
378
                                       "out", NULL, &ffsink_ctx, graph);
379
    if (ret < 0)
380
        return ret;
381
    last_filter = ist->input_video_filter;
382

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

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

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

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

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

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

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

    
424
    codec->width  = ist->output_video_filter->inputs[0]->w;
425
    codec->height = ist->output_video_filter->inputs[0]->h;
426
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
427
        ist->output_video_filter->inputs[0]->sample_aspect_ratio;
428

    
429
    return 0;
430
}
431
#endif /* CONFIG_AVFILTER */
432

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

    
441
static volatile int received_sigterm = 0;
442

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

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

    
455
    tcgetattr (0, &tty);
456
    oldtty = tty;
457
    atexit(term_exit);
458

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

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

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

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

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

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

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

    
512
static int ffmpeg_exit(int ret)
513
{
514
    int i;
515

    
516
    /* close files */
517
    for(i=0;i<nb_output_files;i++) {
518
        AVFormatContext *s = output_files[i];
519
        int j;
520
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
521
            url_fclose(s->pb);
522
        avformat_free_context(s);
523
        av_free(output_streams_for_file[i]);
524
    }
525
    for(i=0;i<nb_input_files;i++) {
526
        av_close_input_file(input_files[i]);
527
        av_free(input_files_ts_scale[i]);
528
    }
529

    
530
    av_free(intra_matrix);
531
    av_free(inter_matrix);
532

    
533
    if (vstats_file)
534
        fclose(vstats_file);
535
    av_free(vstats_filename);
536

    
537
    av_free(opt_names);
538
    av_free(streamid_map);
539
    av_free(input_codecs);
540
    av_free(output_codecs);
541
    av_free(stream_maps);
542
    av_free(meta_data_maps);
543

    
544
    av_free(video_codec_name);
545
    av_free(audio_codec_name);
546
    av_free(subtitle_codec_name);
547

    
548
    av_free(video_standard);
549

    
550
    uninit_opts();
551
    av_free(audio_buf);
552
    av_free(audio_out);
553
    allocated_audio_buf_size= allocated_audio_out_size= 0;
554
    av_free(samples);
555

    
556
#if CONFIG_AVFILTER
557
    avfilter_uninit();
558
#endif
559

    
560
    if (received_sigterm) {
561
        fprintf(stderr,
562
            "Received signal %d: terminating.\n",
563
            (int) received_sigterm);
564
        exit (255);
565
    }
566

    
567
    exit(ret); /* not all OS-es handle main() return value */
568
    return ret;
569
}
570

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

    
591
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
592
{
593
    if(codec && codec->sample_fmts){
594
        const enum AVSampleFormat *p= codec->sample_fmts;
595
        for(; *p!=-1; p++){
596
            if(*p == st->codec->sample_fmt)
597
                break;
598
        }
599
        if (*p == -1) {
600
            av_log(NULL, AV_LOG_WARNING,
601
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
602
                   av_get_sample_fmt_name(st->codec->sample_fmt),
603
                   codec->name,
604
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
605
            st->codec->sample_fmt = codec->sample_fmts[0];
606
        }
607
    }
608
}
609

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

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

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

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

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

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

    
686
        s->nb_streams++;
687

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

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

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

    
717
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
718
            nopts = 1;
719

    
720
        new_output_stream(s, nb_output_files);
721
    }
722

    
723
    if (!nopts)
724
        s->timestamp = av_gettime();
725

    
726
    av_close_input_file(ic);
727
    return 0;
728
}
729

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

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

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

    
759
        bsfc= bsfc->next;
760
    }
761

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

    
769
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
770

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

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

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

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

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

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

    
811
    if (enc->channels != dec->channels)
812
        ost->audio_resample = 1;
813

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

    
818
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
819
        if (resample_changed) {
820
            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",
821
                   ist->file_index, ist->index,
822
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
823
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
824
            ost->resample_sample_fmt  = dec->sample_fmt;
825
            ost->resample_channels    = dec->channels;
826
            ost->resample_sample_rate = dec->sample_rate;
827
            if (ost->resample)
828
                audio_resample_close(ost->resample);
829
        }
830
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
831
        if (audio_sync_method <= 1 &&
832
            ost->resample_sample_fmt  == enc->sample_fmt &&
833
            ost->resample_channels    == enc->channels   &&
834
            ost->resample_sample_rate == enc->sample_rate) {
835
            ost->resample = NULL;
836
            ost->audio_resample = 0;
837
        } else {
838
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
839
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
840
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
841
                                                   enc->sample_rate, dec->sample_rate,
842
                                                   enc->sample_fmt,  dec->sample_fmt,
843
                                                   16, 10, 0, 0.8);
844
            if (!ost->resample) {
845
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
846
                        dec->channels, dec->sample_rate,
847
                        enc->channels, enc->sample_rate);
848
                ffmpeg_exit(1);
849
            }
850
        }
851
    }
852

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

    
869
    if(audio_sync_method){
870
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
871
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
872
        double idelta= delta*dec->sample_rate / enc->sample_rate;
873
        int byte_delta= ((int)idelta)*2*dec->channels;
874

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

    
891
                    if(byte_delta > allocated_for_size - size){
892
                        allocated_for_size= byte_delta + (int64_t)size;
893
                        goto need_realloc;
894
                    }
895
                    ist->is_start=0;
896

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

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

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

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

    
953
        frame_bytes = enc->frame_size * osize * enc->channels;
954

    
955
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
956
            AVPacket pkt;
957
            av_init_packet(&pkt);
958

    
959
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
960

    
961
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
962

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

    
978
            ost->sync_opts += enc->frame_size;
979
        }
980
    } else {
981
        AVPacket pkt;
982
        av_init_packet(&pkt);
983

    
984
        ost->sync_opts += size_out / (osize * enc->channels);
985

    
986
        /* output a pcm frame */
987
        /* determine the size of the coded buffer */
988
        size_out /= osize;
989
        if (coded_bps)
990
            size_out = size_out*coded_bps/8;
991

    
992
        if(size_out > audio_out_size){
993
            fprintf(stderr, "Internal error, buffer size too small\n");
994
            ffmpeg_exit(1);
995
        }
996

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

    
1015
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1016
{
1017
    AVCodecContext *dec;
1018
    AVPicture *picture2;
1019
    AVPicture picture_tmp;
1020
    uint8_t *buf = 0;
1021

    
1022
    dec = ist->st->codec;
1023

    
1024
    /* deinterlace : must be done before any resize */
1025
    if (do_deinterlace) {
1026
        int size;
1027

    
1028
        /* create temporary picture */
1029
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1030
        buf = av_malloc(size);
1031
        if (!buf)
1032
            return;
1033

    
1034
        picture2 = &picture_tmp;
1035
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1036

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

    
1049
    if (picture != picture2)
1050
        *picture = *picture2;
1051
    *bufp = buf;
1052
}
1053

    
1054
/* we begin to correct av delay at this threshold */
1055
#define AV_DELAY_MAX 0.100
1056

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

    
1069
    if (pts == AV_NOPTS_VALUE) {
1070
        fprintf(stderr, "Subtitle packets must have a pts\n");
1071
        if (exit_on_error)
1072
            ffmpeg_exit(1);
1073
        return;
1074
    }
1075

    
1076
    enc = ost->st->codec;
1077

    
1078
    if (!subtitle_out) {
1079
        subtitle_out = av_malloc(subtitle_out_max_size);
1080
    }
1081

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

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

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

    
1120
static int bit_buffer_size= 1024*256;
1121
static uint8_t *bit_buffer= NULL;
1122

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

    
1134
    enc = ost->st->codec;
1135
    dec = ist->st->codec;
1136

    
1137
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1138

    
1139
    /* by default, we output a single frame */
1140
    nb_frames = 1;
1141

    
1142
    *frame_size = 0;
1143

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

    
1169
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1170
    if (nb_frames <= 0)
1171
        return;
1172

    
1173
    formatted_picture = in_picture;
1174
    final_picture = formatted_picture;
1175
    padding_src = formatted_picture;
1176
    resampling_dst = &ost->pict_tmp;
1177

    
1178
    if (   ost->resample_height != ist->st->codec->height
1179
        || ost->resample_width  != ist->st->codec->width
1180
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1181

    
1182
        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));
1183
        if(!ost->video_resample)
1184
            ffmpeg_exit(1);
1185
    }
1186

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

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

    
1216
    /* duplicates frame if needed */
1217
    for(i=0;i<nb_frames;i++) {
1218
        AVPacket pkt;
1219
        av_init_packet(&pkt);
1220
        pkt.stream_index= ost->index;
1221

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

    
1233
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1234
            enc->coded_frame = old_frame;
1235
        } else {
1236
            AVFrame big_picture;
1237

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

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

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

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

    
1298
static double psnr(double d){
1299
    return -10.0*log(d)/log(10.0);
1300
}
1301

    
1302
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1303
                           int frame_size)
1304
{
1305
    AVCodecContext *enc;
1306
    int frame_number;
1307
    double ti1, bitrate, avg_bitrate;
1308

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

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

    
1325
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1326
        /* compute pts value */
1327
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1328
        if (ti1 < 0.01)
1329
            ti1 = 0.01;
1330

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

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

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

    
1366

    
1367
    oc = output_files[0];
1368

    
1369
    total_size = url_fsize(oc->pb);
1370
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1371
        total_size= url_ftell(oc->pb);
1372

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

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

    
1433
    if (verbose || is_last_report) {
1434
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1435

    
1436
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1437
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1438
            (double)total_size / 1024, ti1, bitrate);
1439

    
1440
        if (nb_frames_dup || nb_frames_drop)
1441
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1442
                  nb_frames_dup, nb_frames_drop);
1443

    
1444
        if (verbose >= 0)
1445
            fprintf(stderr, "%s    \r", buf);
1446

    
1447
        fflush(stderr);
1448
    }
1449

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

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

    
1480
    AVPacket avpkt;
1481
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1482

    
1483
    if(ist->next_pts == AV_NOPTS_VALUE)
1484
        ist->next_pts= ist->pts;
1485

    
1486
    if (pkt == NULL) {
1487
        /* EOF handling */
1488
        av_init_packet(&avpkt);
1489
        avpkt.data = NULL;
1490
        avpkt.size = 0;
1491
        goto handle_eof;
1492
    } else {
1493
        avpkt = *pkt;
1494
    }
1495

    
1496
    if(pkt->dts != AV_NOPTS_VALUE)
1497
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1498
    if(pkt->pts != AV_NOPTS_VALUE)
1499
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1500

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

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

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

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

    
1607
        buffer_to_free = NULL;
1608
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1609
            pre_process_video_frame(ist, (AVPicture *)&picture,
1610
                                    &buffer_to_free);
1611
        }
1612

    
1613
#if CONFIG_AVFILTER
1614
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1615
            AVRational sar;
1616
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1617
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1618
            // add it to be filtered
1619
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1620
                                     ist->pts,
1621
                                     sar);
1622
        }
1623
#endif
1624

    
1625
        // preprocess audio (volume)
1626
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1627
            if (audio_volume != 256) {
1628
                short *volp;
1629
                volp = samples;
1630
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1631
                    int v = ((*volp) * audio_volume + 128) >> 8;
1632
                    if (v < -32768) v = -32768;
1633
                    if (v >  32767) v = 32767;
1634
                    *volp++ = v;
1635
                }
1636
            }
1637
        }
1638

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

    
1664
                ost = ost_table[i];
1665
                if (ost->source_index == ist_index) {
1666
                    os = output_files[ost->file_index];
1667

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

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

    
1698
                        av_init_packet(&opkt);
1699

    
1700
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1701
                            continue;
1702

    
1703
                        /* no reencoding needed : output the packet directly */
1704
                        /* force the input stream PTS */
1705

    
1706
                        avcodec_get_frame_defaults(&avframe);
1707
                        ost->st->codec->coded_frame= &avframe;
1708
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1709

    
1710
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1711
                            audio_size += data_size;
1712
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1713
                            video_size += data_size;
1714
                            ost->sync_opts++;
1715
                        }
1716

    
1717
                        opkt.stream_index= ost->index;
1718
                        if(pkt->pts != AV_NOPTS_VALUE)
1719
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1720
                        else
1721
                            opkt.pts= AV_NOPTS_VALUE;
1722

    
1723
                        if (pkt->dts == AV_NOPTS_VALUE)
1724
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1725
                        else
1726
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1727
                        opkt.dts -= ost_tb_start_time;
1728

    
1729
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1730
                        opkt.flags= pkt->flags;
1731

    
1732
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1733
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1734
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1735
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1736
                           ) {
1737
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1738
                                opkt.destruct= av_destruct_packet;
1739
                        } else {
1740
                            opkt.data = data_buf;
1741
                            opkt.size = data_size;
1742
                        }
1743

    
1744
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1745
                        ost->st->codec->frame_number++;
1746
                        ost->frame_number++;
1747
                        av_free_packet(&opkt);
1748
                    }
1749
                }
1750
            }
1751

    
1752
#if CONFIG_AVFILTER
1753
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1754
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1755
            if(ist->picref)
1756
                avfilter_unref_buffer(ist->picref);
1757
        }
1758
#endif
1759
        av_free(buffer_to_free);
1760
        /* XXX: allocate the subtitles in the codec ? */
1761
        if (subtitle_to_free) {
1762
            avsubtitle_free(subtitle_to_free);
1763
            subtitle_to_free = NULL;
1764
        }
1765
    }
1766
 discard_packet:
1767
    if (pkt == NULL) {
1768
        /* EOF handling */
1769

    
1770
        for(i=0;i<nb_ostreams;i++) {
1771
            ost = ost_table[i];
1772
            if (ost->source_index == ist_index) {
1773
                AVCodecContext *enc= ost->st->codec;
1774
                os = output_files[ost->file_index];
1775

    
1776
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1777
                    continue;
1778
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1779
                    continue;
1780

    
1781
                if (ost->encoding_needed) {
1782
                    for(;;) {
1783
                        AVPacket pkt;
1784
                        int fifo_bytes;
1785
                        av_init_packet(&pkt);
1786
                        pkt.stream_index= ost->index;
1787

    
1788
                        switch(ost->st->codec->codec_type) {
1789
                        case AVMEDIA_TYPE_AUDIO:
1790
                            fifo_bytes = av_fifo_size(ost->fifo);
1791
                            ret = 0;
1792
                            /* encode any samples remaining in fifo */
1793
                            if (fifo_bytes > 0) {
1794
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1795
                                int fs_tmp = enc->frame_size;
1796

    
1797
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1798
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1799
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1800
                                } else { /* pad */
1801
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1802
                                    if (allocated_audio_buf_size < frame_bytes)
1803
                                        ffmpeg_exit(1);
1804
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1805
                                }
1806

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

    
1839
                        if(ret<=0)
1840
                            break;
1841
                        pkt.data= bit_buffer;
1842
                        pkt.size= ret;
1843
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1844
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1845
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1846
                    }
1847
                }
1848
            }
1849
        }
1850
    }
1851

    
1852
    return 0;
1853
 fail_decode:
1854
    return -1;
1855
}
1856

    
1857
static void print_sdp(AVFormatContext **avc, int n)
1858
{
1859
    char sdp[2048];
1860

    
1861
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1862
    printf("SDP:\n%s\n", sdp);
1863
    fflush(stdout);
1864
}
1865

    
1866
static int copy_chapters(int infile, int outfile)
1867
{
1868
    AVFormatContext *is = input_files[infile];
1869
    AVFormatContext *os = output_files[outfile];
1870
    int i;
1871

    
1872
    for (i = 0; i < is->nb_chapters; i++) {
1873
        AVChapter *in_ch = is->chapters[i], *out_ch;
1874
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1875
                                      AV_TIME_BASE_Q, in_ch->time_base);
1876
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1877
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1878

    
1879

    
1880
        if (in_ch->end < ts_off)
1881
            continue;
1882
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1883
            break;
1884

    
1885
        out_ch = av_mallocz(sizeof(AVChapter));
1886
        if (!out_ch)
1887
            return AVERROR(ENOMEM);
1888

    
1889
        out_ch->id        = in_ch->id;
1890
        out_ch->time_base = in_ch->time_base;
1891
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1892
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1893

    
1894
        if (metadata_chapters_autocopy)
1895
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1896

    
1897
        os->nb_chapters++;
1898
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1899
        if (!os->chapters)
1900
            return AVERROR(ENOMEM);
1901
        os->chapters[os->nb_chapters - 1] = out_ch;
1902
    }
1903
    return 0;
1904
}
1905

    
1906
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1907
                                    AVCodecContext *avctx)
1908
{
1909
    char *p;
1910
    int n = 1, i;
1911
    int64_t t;
1912

    
1913
    for (p = kf; *p; p++)
1914
        if (*p == ',')
1915
            n++;
1916
    ost->forced_kf_count = n;
1917
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1918
    if (!ost->forced_kf_pts) {
1919
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1920
        ffmpeg_exit(1);
1921
    }
1922
    for (i = 0; i < n; i++) {
1923
        p = i ? strchr(p, ',') + 1 : kf;
1924
        t = parse_time_or_die("force_key_frames", p, 1);
1925
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1926
    }
1927
}
1928

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

    
1950
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1951
    if (!file_table)
1952
        goto fail;
1953

    
1954
    /* input stream init */
1955
    j = 0;
1956
    for(i=0;i<nb_input_files;i++) {
1957
        is = input_files[i];
1958
        file_table[i].ist_index = j;
1959
        file_table[i].nb_streams = is->nb_streams;
1960
        j += is->nb_streams;
1961
    }
1962
    nb_istreams = j;
1963

    
1964
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1965
    if (!ist_table)
1966
        goto fail;
1967

    
1968
    for(i=0;i<nb_istreams;i++) {
1969
        ist = av_mallocz(sizeof(AVInputStream));
1970
        if (!ist)
1971
            goto fail;
1972
        ist_table[i] = ist;
1973
    }
1974
    j = 0;
1975
    for(i=0;i<nb_input_files;i++) {
1976
        is = input_files[i];
1977
        for(k=0;k<is->nb_streams;k++) {
1978
            ist = ist_table[j++];
1979
            ist->st = is->streams[k];
1980
            ist->file_index = i;
1981
            ist->index = k;
1982
            ist->discard = 1; /* the stream is discarded by default
1983
                                 (changed later) */
1984

    
1985
            if (rate_emu) {
1986
                ist->start = av_gettime();
1987
            }
1988
        }
1989
    }
1990

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

    
2009
    /* Sanity check the mapping args -- do the input files & streams exist? */
2010
    for(i=0;i<nb_stream_maps;i++) {
2011
        int fi = stream_maps[i].file_index;
2012
        int si = stream_maps[i].stream_index;
2013

    
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 input stream #%d.%d\n", fi, si);
2017
            ret = AVERROR(EINVAL);
2018
            goto fail;
2019
        }
2020
        fi = stream_maps[i].sync_file_index;
2021
        si = stream_maps[i].sync_stream_index;
2022
        if (fi < 0 || fi > nb_input_files - 1 ||
2023
            si < 0 || si > file_table[fi].nb_streams - 1) {
2024
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2025
            ret = AVERROR(EINVAL);
2026
            goto fail;
2027
        }
2028
    }
2029

    
2030
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2031
    if (!ost_table)
2032
        goto fail;
2033
    n = 0;
2034
    for(k=0;k<nb_output_files;k++) {
2035
        os = output_files[k];
2036
        for(i=0;i<os->nb_streams;i++,n++) {
2037
            int found;
2038
            ost = ost_table[n] = output_streams_for_file[k][i];
2039
            ost->st = os->streams[i];
2040
            if (nb_stream_maps > 0) {
2041
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2042
                    stream_maps[n].stream_index;
2043

    
2044
                /* Sanity check that the stream types match */
2045
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2046
                    int i= ost->file_index;
2047
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2048
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2049
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2050
                        ost->file_index, ost->index);
2051
                    ffmpeg_exit(1);
2052
                }
2053

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

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

    
2113
    /* for each output stream, we compute the right encoding parameters */
2114
    for(i=0;i<nb_ostreams;i++) {
2115
        ost = ost_table[i];
2116
        os = output_files[ost->file_index];
2117
        ist = ist_table[ost->source_index];
2118

    
2119
        codec = ost->st->codec;
2120
        icodec = ist->st->codec;
2121

    
2122
        if (metadata_streams_autocopy)
2123
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2124
                             AV_METADATA_DONT_OVERWRITE);
2125

    
2126
        ost->st->disposition = ist->st->disposition;
2127
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2128
        codec->chroma_sample_location = icodec->chroma_sample_location;
2129

    
2130
        if (ost->st->stream_copy) {
2131
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2132

    
2133
            if (extra_size > INT_MAX)
2134
                goto fail;
2135

    
2136
            /* if stream_copy is selected, no need to decode or encode */
2137
            codec->codec_id = icodec->codec_id;
2138
            codec->codec_type = icodec->codec_type;
2139

    
2140
            if(!codec->codec_tag){
2141
                if(   !os->oformat->codec_tag
2142
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2143
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2144
                    codec->codec_tag = icodec->codec_tag;
2145
            }
2146

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

    
2236
                    ost->original_height = icodec->height;
2237
                    ost->original_width  = icodec->width;
2238
#endif
2239
                    codec->bits_per_raw_sample= 0;
2240
                }
2241
                ost->resample_height = icodec->height;
2242
                ost->resample_width  = icodec->width;
2243
                ost->resample_pix_fmt= icodec->pix_fmt;
2244
                ost->encoding_needed = 1;
2245
                ist->decoding_needed = 1;
2246

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

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

    
2295
    if (!bit_buffer)
2296
        bit_buffer = av_malloc(bit_buffer_size);
2297
    if (!bit_buffer) {
2298
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2299
                bit_buffer_size);
2300
        ret = AVERROR(ENOMEM);
2301
        goto fail;
2302
    }
2303

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

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

    
2361
    /* init pts */
2362
    for(i=0;i<nb_istreams;i++) {
2363
        AVStream *st;
2364
        ist = ist_table[i];
2365
        st= ist->st;
2366
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2367
        ist->next_pts = AV_NOPTS_VALUE;
2368
        init_pts_correction(&ist->pts_ctx);
2369
        ist->is_start = 1;
2370
    }
2371

    
2372
    /* set meta data information from input file if required */
2373
    for (i=0;i<nb_meta_data_maps;i++) {
2374
        AVFormatContext *files[2];
2375
        AVMetadata      **meta[2];
2376
        int j;
2377

    
2378
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2379
        if ((index) < 0 || (index) >= (nb_elems)) {\
2380
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2381
                     (desc), (index));\
2382
            ret = AVERROR(EINVAL);\
2383
            goto dump_format;\
2384
        }
2385

    
2386
        int out_file_index = meta_data_maps[i][0].file;
2387
        int in_file_index = meta_data_maps[i][1].file;
2388
        if (in_file_index < 0 || out_file_index < 0)
2389
            continue;
2390
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2391
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2392

    
2393
        files[0] = output_files[out_file_index];
2394
        files[1] = input_files[in_file_index];
2395

    
2396
        for (j = 0; j < 2; j++) {
2397
            AVMetaDataMap *map = &meta_data_maps[i][j];
2398

    
2399
            switch (map->type) {
2400
            case 'g':
2401
                meta[j] = &files[j]->metadata;
2402
                break;
2403
            case 's':
2404
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2405
                meta[j] = &files[j]->streams[map->index]->metadata;
2406
                break;
2407
            case 'c':
2408
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2409
                meta[j] = &files[j]->chapters[map->index]->metadata;
2410
                break;
2411
            case 'p':
2412
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2413
                meta[j] = &files[j]->programs[map->index]->metadata;
2414
                break;
2415
            }
2416
        }
2417

    
2418
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2419
    }
2420

    
2421
    /* copy global metadata by default */
2422
    if (metadata_global_autocopy) {
2423

    
2424
        for (i = 0; i < nb_output_files; i++)
2425
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2426
                             AV_METADATA_DONT_OVERWRITE);
2427
    }
2428

    
2429
    /* copy chapters according to chapter maps */
2430
    for (i = 0; i < nb_chapter_maps; i++) {
2431
        int infile  = chapter_maps[i].in_file;
2432
        int outfile = chapter_maps[i].out_file;
2433

    
2434
        if (infile < 0 || outfile < 0)
2435
            continue;
2436
        if (infile >= nb_input_files) {
2437
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2438
            ret = AVERROR(EINVAL);
2439
            goto dump_format;
2440
        }
2441
        if (outfile >= nb_output_files) {
2442
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2443
            ret = AVERROR(EINVAL);
2444
            goto dump_format;
2445
        }
2446
        copy_chapters(infile, outfile);
2447
    }
2448

    
2449
    /* copy chapters from the first input file that has them*/
2450
    if (!nb_chapter_maps)
2451
        for (i = 0; i < nb_input_files; i++) {
2452
            if (!input_files[i]->nb_chapters)
2453
                continue;
2454

    
2455
            for (j = 0; j < nb_output_files; j++)
2456
                if ((ret = copy_chapters(i, j)) < 0)
2457
                    goto dump_format;
2458
            break;
2459
        }
2460

    
2461
    /* open files and write file headers */
2462
    for(i=0;i<nb_output_files;i++) {
2463
        os = output_files[i];
2464
        if (av_write_header(os) < 0) {
2465
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2466
            ret = AVERROR(EINVAL);
2467
            goto dump_format;
2468
        }
2469
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2470
            want_sdp = 0;
2471
        }
2472
    }
2473

    
2474
 dump_format:
2475
    /* dump the file output parameters - cannot be done before in case
2476
       of stream copy */
2477
    for(i=0;i<nb_output_files;i++) {
2478
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2479
    }
2480

    
2481
    /* dump the stream mapping */
2482
    if (verbose >= 0) {
2483
        fprintf(stderr, "Stream mapping:\n");
2484
        for(i=0;i<nb_ostreams;i++) {
2485
            ost = ost_table[i];
2486
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2487
                    ist_table[ost->source_index]->file_index,
2488
                    ist_table[ost->source_index]->index,
2489
                    ost->file_index,
2490
                    ost->index);
2491
            if (ost->sync_ist != ist_table[ost->source_index])
2492
                fprintf(stderr, " [sync #%d.%d]",
2493
                        ost->sync_ist->file_index,
2494
                        ost->sync_ist->index);
2495
            fprintf(stderr, "\n");
2496
        }
2497
    }
2498

    
2499
    if (ret) {
2500
        fprintf(stderr, "%s\n", error);
2501
        goto fail;
2502
    }
2503

    
2504
    if (want_sdp) {
2505
        print_sdp(output_files, nb_output_files);
2506
    }
2507

    
2508
    if (!using_stdin && verbose >= 0) {
2509
        fprintf(stderr, "Press [q] to stop encoding\n");
2510
        url_set_interrupt_cb(decode_interrupt_cb);
2511
    }
2512
    term_init();
2513

    
2514
    timer_start = av_gettime();
2515

    
2516
    for(; received_sigterm == 0;) {
2517
        int file_index, ist_index;
2518
        AVPacket pkt;
2519
        double ipts_min;
2520
        double opts_min;
2521

    
2522
    redo:
2523
        ipts_min= 1e100;
2524
        opts_min= 1e100;
2525
        /* if 'q' pressed, exits */
2526
        if (!using_stdin) {
2527
            if (q_pressed)
2528
                break;
2529
            /* read_key() returns 0 on EOF */
2530
            key = read_key();
2531
            if (key == 'q')
2532
                break;
2533
        }
2534

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

    
2573
        /* finish if limit size exhausted */
2574
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2575
            break;
2576

    
2577
        /* read a frame from it and output it in the fifo */
2578
        is = input_files[file_index];
2579
        ret= av_read_frame(is, &pkt);
2580
        if(ret == AVERROR(EAGAIN)){
2581
            no_packet[file_index]=1;
2582
            no_packet_count++;
2583
            continue;
2584
        }
2585
        if (ret < 0) {
2586
            file_table[file_index].eof_reached = 1;
2587
            if (opt_shortest)
2588
                break;
2589
            else
2590
                continue;
2591
        }
2592

    
2593
        no_packet_count=0;
2594
        memset(no_packet, 0, sizeof(no_packet));
2595

    
2596
        if (do_pkt_dump) {
2597
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2598
        }
2599
        /* the following test is needed in case new streams appear
2600
           dynamically in stream : we ignore them */
2601
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2602
            goto discard_packet;
2603
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2604
        ist = ist_table[ist_index];
2605
        if (ist->discard)
2606
            goto discard_packet;
2607

    
2608
        if (pkt.dts != AV_NOPTS_VALUE)
2609
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2610
        if (pkt.pts != AV_NOPTS_VALUE)
2611
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2612

    
2613
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2614
            && input_files_ts_scale[file_index][pkt.stream_index]){
2615
            if(pkt.pts != AV_NOPTS_VALUE)
2616
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2617
            if(pkt.dts != AV_NOPTS_VALUE)
2618
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2619
        }
2620

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

    
2636
        /* finish if recording time exhausted */
2637
        if (recording_time != INT64_MAX &&
2638
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2639
            ist->is_past_recording_time = 1;
2640
            goto discard_packet;
2641
        }
2642

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

    
2646
            if (verbose >= 0)
2647
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2648
                        ist->file_index, ist->index);
2649
            if (exit_on_error)
2650
                ffmpeg_exit(1);
2651
            av_free_packet(&pkt);
2652
            goto redo;
2653
        }
2654

    
2655
    discard_packet:
2656
        av_free_packet(&pkt);
2657

    
2658
        /* dump report by using the output first video and audio streams */
2659
        print_report(output_files, ost_table, nb_ostreams, 0);
2660
    }
2661

    
2662
    /* at the end of stream, we must flush the decoder buffers */
2663
    for(i=0;i<nb_istreams;i++) {
2664
        ist = ist_table[i];
2665
        if (ist->decoding_needed) {
2666
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2667
        }
2668
    }
2669

    
2670
    term_exit();
2671

    
2672
    /* write the trailer if needed and close file */
2673
    for(i=0;i<nb_output_files;i++) {
2674
        os = output_files[i];
2675
        av_write_trailer(os);
2676
    }
2677

    
2678
    /* dump report by using the first video and audio streams */
2679
    print_report(output_files, ost_table, nb_ostreams, 1);
2680

    
2681
    /* close each encoder */
2682
    for(i=0;i<nb_ostreams;i++) {
2683
        ost = ost_table[i];
2684
        if (ost->encoding_needed) {
2685
            av_freep(&ost->st->codec->stats_in);
2686
            avcodec_close(ost->st->codec);
2687
        }
2688
    }
2689

    
2690
    /* close each decoder */
2691
    for(i=0;i<nb_istreams;i++) {
2692
        ist = ist_table[i];
2693
        if (ist->decoding_needed) {
2694
            avcodec_close(ist->st->codec);
2695
        }
2696
    }
2697
#if CONFIG_AVFILTER
2698
    avfilter_graph_free(&graph);
2699
#endif
2700

    
2701
    /* finished ! */
2702
    ret = 0;
2703

    
2704
 fail:
2705
    av_freep(&bit_buffer);
2706
    av_free(file_table);
2707

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

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

    
2749
static void opt_video_rc_override_string(const char *arg)
2750
{
2751
    video_rc_override_string = arg;
2752
}
2753

    
2754
static int opt_me_threshold(const char *opt, const char *arg)
2755
{
2756
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2757
    return 0;
2758
}
2759

    
2760
static int opt_verbose(const char *opt, const char *arg)
2761
{
2762
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2763
    return 0;
2764
}
2765

    
2766
static int opt_frame_rate(const char *opt, const char *arg)
2767
{
2768
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2769
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2770
        ffmpeg_exit(1);
2771
    }
2772
    return 0;
2773
}
2774

    
2775
static int opt_bitrate(const char *opt, const char *arg)
2776
{
2777
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2778

    
2779
    opt_default(opt, arg);
2780

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

    
2784
    return 0;
2785
}
2786

    
2787
static int opt_frame_crop(const char *opt, const char *arg)
2788
{
2789
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2790
    return AVERROR(EINVAL);
2791
}
2792

    
2793
static void opt_frame_size(const char *arg)
2794
{
2795
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2796
        fprintf(stderr, "Incorrect frame size\n");
2797
        ffmpeg_exit(1);
2798
    }
2799
}
2800

    
2801
static int opt_pad(const char *opt, const char *arg) {
2802
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2803
    return -1;
2804
}
2805

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

    
2820
static void opt_frame_aspect_ratio(const char *arg)
2821
{
2822
    int x = 0, y = 0;
2823
    double ar = 0;
2824
    const char *p;
2825
    char *end;
2826

    
2827
    p = strchr(arg, ':');
2828
    if (p) {
2829
        x = strtol(arg, &end, 10);
2830
        if (end == p)
2831
            y = strtol(end+1, &end, 10);
2832
        if (x > 0 && y > 0)
2833
            ar = (double)x / (double)y;
2834
    } else
2835
        ar = strtod(arg, NULL);
2836

    
2837
    if (!ar) {
2838
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2839
        ffmpeg_exit(1);
2840
    }
2841
    frame_aspect_ratio = ar;
2842

    
2843
    x = vfilters ? strlen(vfilters) : 0;
2844
    vfilters = av_realloc(vfilters, x+100);
2845
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2846
}
2847

    
2848
static int opt_metadata(const char *opt, const char *arg)
2849
{
2850
    char *mid= strchr(arg, '=');
2851

    
2852
    if(!mid){
2853
        fprintf(stderr, "Missing =\n");
2854
        ffmpeg_exit(1);
2855
    }
2856
    *mid++= 0;
2857

    
2858
    av_metadata_set2(&metadata, arg, mid, 0);
2859

    
2860
    return 0;
2861
}
2862

    
2863
static void opt_qscale(const char *arg)
2864
{
2865
    video_qscale = atof(arg);
2866
    if (video_qscale <= 0 ||
2867
        video_qscale > 255) {
2868
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2869
        ffmpeg_exit(1);
2870
    }
2871
}
2872

    
2873
static void opt_top_field_first(const char *arg)
2874
{
2875
    top_field_first= atoi(arg);
2876
}
2877

    
2878
static int opt_thread_count(const char *opt, const char *arg)
2879
{
2880
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2881
#if !HAVE_THREADS
2882
    if (verbose >= 0)
2883
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2884
#endif
2885
    return 0;
2886
}
2887

    
2888
static void opt_audio_sample_fmt(const char *arg)
2889
{
2890
    if (strcmp(arg, "list")) {
2891
        audio_sample_fmt = av_get_sample_fmt(arg);
2892
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2893
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2894
            ffmpeg_exit(1);
2895
        }
2896
    } else {
2897
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2898
        ffmpeg_exit(0);
2899
    }
2900
}
2901

    
2902
static int opt_audio_rate(const char *opt, const char *arg)
2903
{
2904
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2905
    return 0;
2906
}
2907

    
2908
static int opt_audio_channels(const char *opt, const char *arg)
2909
{
2910
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2911
    return 0;
2912
}
2913

    
2914
static void opt_video_channel(const char *arg)
2915
{
2916
    video_channel = strtol(arg, NULL, 0);
2917
}
2918

    
2919
static void opt_video_standard(const char *arg)
2920
{
2921
    video_standard = av_strdup(arg);
2922
}
2923

    
2924
static void opt_codec(int *pstream_copy, char **pcodec_name,
2925
                      int codec_type, const char *arg)
2926
{
2927
    av_freep(pcodec_name);
2928
    if (!strcmp(arg, "copy")) {
2929
        *pstream_copy = 1;
2930
    } else {
2931
        *pcodec_name = av_strdup(arg);
2932
    }
2933
}
2934

    
2935
static void opt_audio_codec(const char *arg)
2936
{
2937
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2938
}
2939

    
2940
static void opt_video_codec(const char *arg)
2941
{
2942
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2943
}
2944

    
2945
static void opt_subtitle_codec(const char *arg)
2946
{
2947
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2948
}
2949

    
2950
static int opt_codec_tag(const char *opt, const char *arg)
2951
{
2952
    char *tail;
2953
    uint32_t *codec_tag;
2954

    
2955
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2956
                !strcmp(opt, "vtag") ? &video_codec_tag :
2957
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2958
    if (!codec_tag)
2959
        return -1;
2960

    
2961
    *codec_tag = strtol(arg, &tail, 0);
2962
    if (!tail || *tail)
2963
        *codec_tag = AV_RL32(arg);
2964

    
2965
    return 0;
2966
}
2967

    
2968
static void opt_map(const char *arg)
2969
{
2970
    AVStreamMap *m;
2971
    char *p;
2972

    
2973
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2974
    m = &stream_maps[nb_stream_maps-1];
2975

    
2976
    m->file_index = strtol(arg, &p, 0);
2977
    if (*p)
2978
        p++;
2979

    
2980
    m->stream_index = strtol(p, &p, 0);
2981
    if (*p) {
2982
        p++;
2983
        m->sync_file_index = strtol(p, &p, 0);
2984
        if (*p)
2985
            p++;
2986
        m->sync_stream_index = strtol(p, &p, 0);
2987
    } else {
2988
        m->sync_file_index = m->file_index;
2989
        m->sync_stream_index = m->stream_index;
2990
    }
2991
}
2992

    
2993
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2994
{
2995
    *endptr = arg;
2996
    if (*arg == ',') {
2997
        *type = *(++arg);
2998
        switch (*arg) {
2999
        case 'g':
3000
            break;
3001
        case 's':
3002
        case 'c':
3003
        case 'p':
3004
            *index = strtol(++arg, endptr, 0);
3005
            break;
3006
        default:
3007
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3008
            ffmpeg_exit(1);
3009
        }
3010
    } else
3011
        *type = 'g';
3012
}
3013

    
3014
static void opt_map_metadata(const char *arg)
3015
{
3016
    AVMetaDataMap *m, *m1;
3017
    char *p;
3018

    
3019
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3020
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3021

    
3022
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3023
    m->file = strtol(arg, &p, 0);
3024
    parse_meta_type(p, &m->type, &m->index, &p);
3025
    if (*p)
3026
        p++;
3027

    
3028
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3029
    m1->file = strtol(p, &p, 0);
3030
    parse_meta_type(p, &m1->type, &m1->index, &p);
3031

    
3032
    if (m->type == 'g' || m1->type == 'g')
3033
        metadata_global_autocopy = 0;
3034
    if (m->type == 's' || m1->type == 's')
3035
        metadata_streams_autocopy = 0;
3036
    if (m->type == 'c' || m1->type == 'c')
3037
        metadata_chapters_autocopy = 0;
3038
}
3039

    
3040
static void opt_map_meta_data(const char *arg)
3041
{
3042
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3043
                    "Use -map_metadata instead.\n");
3044
    opt_map_metadata(arg);
3045
}
3046

    
3047
static void opt_map_chapters(const char *arg)
3048
{
3049
    AVChapterMap *c;
3050
    char *p;
3051

    
3052
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3053
                              nb_chapter_maps + 1);
3054
    c = &chapter_maps[nb_chapter_maps - 1];
3055
    c->out_file = strtol(arg, &p, 0);
3056
    if (*p)
3057
        p++;
3058

    
3059
    c->in_file = strtol(p, &p, 0);
3060
}
3061

    
3062
static void opt_input_ts_scale(const char *arg)
3063
{
3064
    unsigned int stream;
3065
    double scale;
3066
    char *p;
3067

    
3068
    stream = strtol(arg, &p, 0);
3069
    if (*p)
3070
        p++;
3071
    scale= strtod(p, &p);
3072

    
3073
    if(stream >= MAX_STREAMS)
3074
        ffmpeg_exit(1);
3075

    
3076
    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);
3077
    input_files_ts_scale[nb_input_files][stream]= scale;
3078
}
3079

    
3080
static int opt_recording_time(const char *opt, const char *arg)
3081
{
3082
    recording_time = parse_time_or_die(opt, arg, 1);
3083
    return 0;
3084
}
3085

    
3086
static int opt_start_time(const char *opt, const char *arg)
3087
{
3088
    start_time = parse_time_or_die(opt, arg, 1);
3089
    return 0;
3090
}
3091

    
3092
static int opt_recording_timestamp(const char *opt, const char *arg)
3093
{
3094
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3095
    return 0;
3096
}
3097

    
3098
static int opt_input_ts_offset(const char *opt, const char *arg)
3099
{
3100
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3101
    return 0;
3102
}
3103

    
3104
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3105
{
3106
    const char *codec_string = encoder ? "encoder" : "decoder";
3107
    AVCodec *codec;
3108

    
3109
    if(!name)
3110
        return CODEC_ID_NONE;
3111
    codec = encoder ?
3112
        avcodec_find_encoder_by_name(name) :
3113
        avcodec_find_decoder_by_name(name);
3114
    if(!codec) {
3115
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3116
        ffmpeg_exit(1);
3117
    }
3118
    if(codec->type != type) {
3119
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3120
        ffmpeg_exit(1);
3121
    }
3122
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3123
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3124
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3125
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3126
                codec_string, codec->name);
3127
        codec = encoder ?
3128
            avcodec_find_encoder(codec->id) :
3129
            avcodec_find_decoder(codec->id);
3130
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3131
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3132
                    codec_string, codec->name);
3133
        ffmpeg_exit(1);
3134
    }
3135
    return codec->id;
3136
}
3137

    
3138
static void opt_input_file(const char *filename)
3139
{
3140
    AVFormatContext *ic;
3141
    AVFormatParameters params, *ap = &params;
3142
    AVInputFormat *file_iformat = NULL;
3143
    int err, i, ret, rfps, rfps_base;
3144
    int64_t timestamp;
3145

    
3146
    if (last_asked_format) {
3147
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3148
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3149
            ffmpeg_exit(1);
3150
        }
3151
        last_asked_format = NULL;
3152
    }
3153

    
3154
    if (!strcmp(filename, "-"))
3155
        filename = "pipe:";
3156

    
3157
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3158
                    !strcmp(filename, "/dev/stdin");
3159

    
3160
    /* get default parameters from command line */
3161
    ic = avformat_alloc_context();
3162
    if (!ic) {
3163
        print_error(filename, AVERROR(ENOMEM));
3164
        ffmpeg_exit(1);
3165
    }
3166

    
3167
    memset(ap, 0, sizeof(*ap));
3168
    ap->prealloced_context = 1;
3169
    ap->sample_rate = audio_sample_rate;
3170
    ap->channels = audio_channels;
3171
    ap->time_base.den = frame_rate.num;
3172
    ap->time_base.num = frame_rate.den;
3173
    ap->width = frame_width;
3174
    ap->height = frame_height;
3175
    ap->pix_fmt = frame_pix_fmt;
3176
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3177
    ap->channel = video_channel;
3178
    ap->standard = video_standard;
3179

    
3180
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3181

    
3182
    ic->video_codec_id   =
3183
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3184
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3185
    ic->audio_codec_id   =
3186
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3187
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3188
    ic->subtitle_codec_id=
3189
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3190
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3191
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3192

    
3193
    /* open the input file with generic libav function */
3194
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3195
    if (err < 0) {
3196
        print_error(filename, err);
3197
        ffmpeg_exit(1);
3198
    }
3199
    if(opt_programid) {
3200
        int i, j;
3201
        int found=0;
3202
        for(i=0; i<ic->nb_streams; i++){
3203
            ic->streams[i]->discard= AVDISCARD_ALL;
3204
        }
3205
        for(i=0; i<ic->nb_programs; i++){
3206
            AVProgram *p= ic->programs[i];
3207
            if(p->id != opt_programid){
3208
                p->discard = AVDISCARD_ALL;
3209
            }else{
3210
                found=1;
3211
                for(j=0; j<p->nb_stream_indexes; j++){
3212
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3213
                }
3214
            }
3215
        }
3216
        if(!found){
3217
            fprintf(stderr, "Specified program id not found\n");
3218
            ffmpeg_exit(1);
3219
        }
3220
        opt_programid=0;
3221
    }
3222

    
3223
    ic->loop_input = loop_input;
3224

    
3225
    /* If not enough info to get the stream parameters, we decode the
3226
       first frames to get it. (used in mpeg case for example) */
3227
    ret = av_find_stream_info(ic);
3228
    if (ret < 0 && verbose >= 0) {
3229
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3230
        av_close_input_file(ic);
3231
        ffmpeg_exit(1);
3232
    }
3233

    
3234
    timestamp = start_time;
3235
    /* add the stream start time */
3236
    if (ic->start_time != AV_NOPTS_VALUE)
3237
        timestamp += ic->start_time;
3238

    
3239
    /* if seeking requested, we execute it */
3240
    if (start_time != 0) {
3241
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3242
        if (ret < 0) {
3243
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3244
                    filename, (double)timestamp / AV_TIME_BASE);
3245
        }
3246
        /* reset seek info */
3247
        start_time = 0;
3248
    }
3249

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

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

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

    
3302
                    (float)rfps / rfps_base, rfps, rfps_base);
3303
            }
3304
            /* update the current frame rate to match the stream frame rate */
3305
            frame_rate.num = rfps;
3306
            frame_rate.den = rfps_base;
3307

    
3308
            if(video_disable)
3309
                st->discard= AVDISCARD_ALL;
3310
            else if(video_discard)
3311
                st->discard= video_discard;
3312
            break;
3313
        case AVMEDIA_TYPE_DATA:
3314
            break;
3315
        case AVMEDIA_TYPE_SUBTITLE:
3316
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3317
            if(subtitle_disable)
3318
                st->discard = AVDISCARD_ALL;
3319
            break;
3320
        case AVMEDIA_TYPE_ATTACHMENT:
3321
        case AVMEDIA_TYPE_UNKNOWN:
3322
            break;
3323
        default:
3324
            abort();
3325
        }
3326
    }
3327

    
3328
    input_files[nb_input_files] = ic;
3329
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3330
    /* dump the file content */
3331
    if (verbose >= 0)
3332
        dump_format(ic, nb_input_files, filename, 0);
3333

    
3334
    nb_input_files++;
3335

    
3336
    video_channel = 0;
3337

    
3338
    av_freep(&video_codec_name);
3339
    av_freep(&audio_codec_name);
3340
    av_freep(&subtitle_codec_name);
3341
}
3342

    
3343
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3344
                                         int *has_subtitle_ptr)
3345
{
3346
    int has_video, has_audio, has_subtitle, i, j;
3347
    AVFormatContext *ic;
3348

    
3349
    has_video = 0;
3350
    has_audio = 0;
3351
    has_subtitle = 0;
3352
    for(j=0;j<nb_input_files;j++) {
3353
        ic = input_files[j];
3354
        for(i=0;i<ic->nb_streams;i++) {
3355
            AVCodecContext *enc = ic->streams[i]->codec;
3356
            switch(enc->codec_type) {
3357
            case AVMEDIA_TYPE_AUDIO:
3358
                has_audio = 1;
3359
                break;
3360
            case AVMEDIA_TYPE_VIDEO:
3361
                has_video = 1;
3362
                break;
3363
            case AVMEDIA_TYPE_SUBTITLE:
3364
                has_subtitle = 1;
3365
                break;
3366
            case AVMEDIA_TYPE_DATA:
3367
            case AVMEDIA_TYPE_ATTACHMENT:
3368
            case AVMEDIA_TYPE_UNKNOWN:
3369
                break;
3370
            default:
3371
                abort();
3372
            }
3373
        }
3374
    }
3375
    *has_video_ptr = has_video;
3376
    *has_audio_ptr = has_audio;
3377
    *has_subtitle_ptr = has_subtitle;
3378
}
3379

    
3380
static void new_video_stream(AVFormatContext *oc, int file_idx)
3381
{
3382
    AVStream *st;
3383
    AVOutputStream *ost;
3384
    AVCodecContext *video_enc;
3385
    enum CodecID codec_id = CODEC_ID_NONE;
3386
    AVCodec *codec= NULL;
3387

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

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

    
3408
    avcodec_get_context_defaults3(st->codec, codec);
3409
    ost->bitstream_filters = video_bitstream_filters;
3410
    video_bitstream_filters= NULL;
3411

    
3412
    avcodec_thread_init(st->codec, thread_count);
3413

    
3414
    video_enc = st->codec;
3415

    
3416
    if(video_codec_tag)
3417
        video_enc->codec_tag= video_codec_tag;
3418

    
3419
    if(   (video_global_header&1)
3420
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3421
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3422
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3423
    }
3424
    if(video_global_header&2){
3425
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3426
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3427
    }
3428

    
3429
    if (video_stream_copy) {
3430
        st->stream_copy = 1;
3431
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3432
        video_enc->sample_aspect_ratio =
3433
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3434
    } else {
3435
        const char *p;
3436
        int i;
3437
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3438

    
3439
        video_enc->codec_id = codec_id;
3440
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3441

    
3442
        if (codec && codec->supported_framerates && !force_fps)
3443
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3444
        video_enc->time_base.den = fps.num;
3445
        video_enc->time_base.num = fps.den;
3446

    
3447
        video_enc->width = frame_width;
3448
        video_enc->height = frame_height;
3449
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3450
        video_enc->pix_fmt = frame_pix_fmt;
3451
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3452

    
3453
        choose_pixel_fmt(st, codec);
3454

    
3455
        if (intra_only)
3456
            video_enc->gop_size = 0;
3457
        if (video_qscale || same_quality) {
3458
            video_enc->flags |= CODEC_FLAG_QSCALE;
3459
            video_enc->global_quality=
3460
                st->quality = FF_QP2LAMBDA * video_qscale;
3461
        }
3462

    
3463
        if(intra_matrix)
3464
            video_enc->intra_matrix = intra_matrix;
3465
        if(inter_matrix)
3466
            video_enc->inter_matrix = inter_matrix;
3467

    
3468
        p= video_rc_override_string;
3469
        for(i=0; p; i++){
3470
            int start, end, q;
3471
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3472
            if(e!=3){
3473
                fprintf(stderr, "error parsing rc_override\n");
3474
                ffmpeg_exit(1);
3475
            }
3476
            video_enc->rc_override=
3477
                av_realloc(video_enc->rc_override,
3478
                           sizeof(RcOverride)*(i+1));
3479
            video_enc->rc_override[i].start_frame= start;
3480
            video_enc->rc_override[i].end_frame  = end;
3481
            if(q>0){
3482
                video_enc->rc_override[i].qscale= q;
3483
                video_enc->rc_override[i].quality_factor= 1.0;
3484
            }
3485
            else{
3486
                video_enc->rc_override[i].qscale= 0;
3487
                video_enc->rc_override[i].quality_factor= -q/100.0;
3488
            }
3489
            p= strchr(p, '/');
3490
            if(p) p++;
3491
        }
3492
        video_enc->rc_override_count=i;
3493
        if (!video_enc->rc_initial_buffer_occupancy)
3494
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3495
        video_enc->me_threshold= me_threshold;
3496
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3497

    
3498
        if (do_psnr)
3499
            video_enc->flags|= CODEC_FLAG_PSNR;
3500

    
3501
        /* two pass mode */
3502
        if (do_pass) {
3503
            if (do_pass == 1) {
3504
                video_enc->flags |= CODEC_FLAG_PASS1;
3505
            } else {
3506
                video_enc->flags |= CODEC_FLAG_PASS2;
3507
            }
3508
        }
3509

    
3510
        if (forced_key_frames)
3511
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3512
    }
3513
    if (video_language) {
3514
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3515
        av_freep(&video_language);
3516
    }
3517

    
3518
    /* reset some key parameters */
3519
    video_disable = 0;
3520
    av_freep(&video_codec_name);
3521
    av_freep(&forced_key_frames);
3522
    video_stream_copy = 0;
3523
    frame_pix_fmt = PIX_FMT_NONE;
3524
}
3525

    
3526
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3527
{
3528
    AVStream *st;
3529
    AVOutputStream *ost;
3530
    AVCodec *codec= NULL;
3531
    AVCodecContext *audio_enc;
3532
    enum CodecID codec_id = CODEC_ID_NONE;
3533

    
3534
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3535
    if (!st) {
3536
        fprintf(stderr, "Could not alloc stream\n");
3537
        ffmpeg_exit(1);
3538
    }
3539
    ost = new_output_stream(oc, file_idx);
3540

    
3541
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3542
    if(!audio_stream_copy){
3543
        if (audio_codec_name) {
3544
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3545
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3546
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3547
            output_codecs[nb_output_codecs-1] = codec;
3548
        } else {
3549
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3550
            codec = avcodec_find_encoder(codec_id);
3551
        }
3552
    }
3553

    
3554
    avcodec_get_context_defaults3(st->codec, codec);
3555

    
3556
    ost->bitstream_filters = audio_bitstream_filters;
3557
    audio_bitstream_filters= NULL;
3558

    
3559
    avcodec_thread_init(st->codec, thread_count);
3560

    
3561
    audio_enc = st->codec;
3562
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3563

    
3564
    if(audio_codec_tag)
3565
        audio_enc->codec_tag= audio_codec_tag;
3566

    
3567
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3568
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3569
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3570
    }
3571
    if (audio_stream_copy) {
3572
        st->stream_copy = 1;
3573
        audio_enc->channels = audio_channels;
3574
        audio_enc->sample_rate = audio_sample_rate;
3575
    } else {
3576
        audio_enc->codec_id = codec_id;
3577
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3578

    
3579
        if (audio_qscale > QSCALE_NONE) {
3580
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3581
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3582
        }
3583
        audio_enc->channels = audio_channels;
3584
        audio_enc->sample_fmt = audio_sample_fmt;
3585
        audio_enc->sample_rate = audio_sample_rate;
3586
        audio_enc->channel_layout = channel_layout;
3587
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3588
            audio_enc->channel_layout = 0;
3589
        choose_sample_fmt(st, codec);
3590
        choose_sample_rate(st, codec);
3591
    }
3592
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3593
    if (audio_language) {
3594
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3595
        av_freep(&audio_language);
3596
    }
3597

    
3598
    /* reset some key parameters */
3599
    audio_disable = 0;
3600
    av_freep(&audio_codec_name);
3601
    audio_stream_copy = 0;
3602
}
3603

    
3604
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3605
{
3606
    AVStream *st;
3607
    AVOutputStream *ost;
3608
    AVCodec *codec=NULL;
3609
    AVCodecContext *subtitle_enc;
3610
    enum CodecID codec_id = CODEC_ID_NONE;
3611

    
3612
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3613
    if (!st) {
3614
        fprintf(stderr, "Could not alloc stream\n");
3615
        ffmpeg_exit(1);
3616
    }
3617
    ost = new_output_stream(oc, file_idx);
3618
    subtitle_enc = st->codec;
3619
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3620
    if(!subtitle_stream_copy){
3621
        if (subtitle_codec_name) {
3622
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3623
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3624
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3625
        } else {
3626
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3627
            codec = avcodec_find_encoder(codec_id);
3628
        }
3629
    }
3630
    avcodec_get_context_defaults3(st->codec, codec);
3631

    
3632
    ost->bitstream_filters = subtitle_bitstream_filters;
3633
    subtitle_bitstream_filters= NULL;
3634

    
3635
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3636

    
3637
    if(subtitle_codec_tag)
3638
        subtitle_enc->codec_tag= subtitle_codec_tag;
3639

    
3640
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3641
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3642
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3643
    }
3644
    if (subtitle_stream_copy) {
3645
        st->stream_copy = 1;
3646
    } else {
3647
        subtitle_enc->codec_id = codec_id;
3648
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3649
    }
3650

    
3651
    if (subtitle_language) {
3652
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3653
        av_freep(&subtitle_language);
3654
    }
3655

    
3656
    subtitle_disable = 0;
3657
    av_freep(&subtitle_codec_name);
3658
    subtitle_stream_copy = 0;
3659
}
3660

    
3661
static int opt_new_stream(const char *opt, const char *arg)
3662
{
3663
    AVFormatContext *oc;
3664
    int file_idx = nb_output_files - 1;
3665
    if (nb_output_files <= 0) {
3666
        fprintf(stderr, "At least one output file must be specified\n");
3667
        ffmpeg_exit(1);
3668
    }
3669
    oc = output_files[file_idx];
3670

    
3671
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3672
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3673
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3674
    else av_assert0(0);
3675
    return 0;
3676
}
3677

    
3678
/* arg format is "output-stream-index:streamid-value". */
3679
static int opt_streamid(const char *opt, const char *arg)
3680
{
3681
    int idx;
3682
    char *p;
3683
    char idx_str[16];
3684

    
3685
    strncpy(idx_str, arg, sizeof(idx_str));
3686
    idx_str[sizeof(idx_str)-1] = '\0';
3687
    p = strchr(idx_str, ':');
3688
    if (!p) {
3689
        fprintf(stderr,
3690
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3691
                arg, opt);
3692
        ffmpeg_exit(1);
3693
    }
3694
    *p++ = '\0';
3695
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3696
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3697
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3698
    return 0;
3699
}
3700

    
3701
static void opt_output_file(const char *filename)
3702
{
3703
    AVFormatContext *oc;
3704
    int err, use_video, use_audio, use_subtitle;
3705
    int input_has_video, input_has_audio, input_has_subtitle;
3706
    AVFormatParameters params, *ap = &params;
3707
    AVOutputFormat *file_oformat;
3708

    
3709
    if (!strcmp(filename, "-"))
3710
        filename = "pipe:";
3711

    
3712
    oc = avformat_alloc_context();
3713
    if (!oc) {
3714
        print_error(filename, AVERROR(ENOMEM));
3715
        ffmpeg_exit(1);
3716
    }
3717

    
3718
    if (last_asked_format) {
3719
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3720
        if (!file_oformat) {
3721
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3722
            ffmpeg_exit(1);
3723
        }
3724
        last_asked_format = NULL;
3725
    } else {
3726
        file_oformat = av_guess_format(NULL, filename, NULL);
3727
        if (!file_oformat) {
3728
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3729
                    filename);
3730
            ffmpeg_exit(1);
3731
        }
3732
    }
3733

    
3734
    oc->oformat = file_oformat;
3735
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3736

    
3737
    if (!strcmp(file_oformat->name, "ffm") &&
3738
        av_strstart(filename, "http:", NULL)) {
3739
        /* special case for files sent to ffserver: we get the stream
3740
           parameters from ffserver */
3741
        int err = read_ffserver_streams(oc, filename);
3742
        if (err < 0) {
3743
            print_error(filename, err);
3744
            ffmpeg_exit(1);
3745
        }
3746
    } else {
3747
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3748
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3749
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3750

    
3751
        /* disable if no corresponding type found and at least one
3752
           input file */
3753
        if (nb_input_files > 0) {
3754
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3755
                                         &input_has_subtitle);
3756
            if (!input_has_video)
3757
                use_video = 0;
3758
            if (!input_has_audio)
3759
                use_audio = 0;
3760
            if (!input_has_subtitle)
3761
                use_subtitle = 0;
3762
        }
3763

    
3764
        /* manual disable */
3765
        if (audio_disable)    use_audio    = 0;
3766
        if (video_disable)    use_video    = 0;
3767
        if (subtitle_disable) use_subtitle = 0;
3768

    
3769
        if (use_video)    new_video_stream(oc, nb_output_files);
3770
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3771
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3772

    
3773
        oc->timestamp = recording_timestamp;
3774

    
3775
        av_metadata_copy(&oc->metadata, metadata, 0);
3776
        av_metadata_free(&metadata);
3777
    }
3778

    
3779
    output_files[nb_output_files++] = oc;
3780

    
3781
    /* check filename in case of an image number is expected */
3782
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3783
        if (!av_filename_number_test(oc->filename)) {
3784
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3785
            ffmpeg_exit(1);
3786
        }
3787
    }
3788

    
3789
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3790
        /* test if it already exists to avoid loosing precious files */
3791
        if (!file_overwrite &&
3792
            (strchr(filename, ':') == NULL ||
3793
             filename[1] == ':' ||
3794
             av_strstart(filename, "file:", NULL))) {
3795
            if (url_exist(filename)) {
3796
                if (!using_stdin) {
3797
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3798
                    fflush(stderr);
3799
                    if (!read_yesno()) {
3800
                        fprintf(stderr, "Not overwriting - exiting\n");
3801
                        ffmpeg_exit(1);
3802
                    }
3803
                }
3804
                else {
3805
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3806
                    ffmpeg_exit(1);
3807
                }
3808
            }
3809
        }
3810

    
3811
        /* open the file */
3812
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3813
            print_error(filename, err);
3814
            ffmpeg_exit(1);
3815
        }
3816
    }
3817

    
3818
    memset(ap, 0, sizeof(*ap));
3819
    if (av_set_parameters(oc, ap) < 0) {
3820
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3821
                oc->filename);
3822
        ffmpeg_exit(1);
3823
    }
3824

    
3825
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3826
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3827
    oc->loop_output = loop_output;
3828
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3829

    
3830
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3831

    
3832
    av_freep(&forced_key_frames);
3833
}
3834

    
3835
/* same option as mencoder */
3836
static void opt_pass(const char *pass_str)
3837
{
3838
    int pass;
3839
    pass = atoi(pass_str);
3840
    if (pass != 1 && pass != 2) {
3841
        fprintf(stderr, "pass number can be only 1 or 2\n");
3842
        ffmpeg_exit(1);
3843
    }
3844
    do_pass = pass;
3845
}
3846

    
3847
static int64_t getutime(void)
3848
{
3849
#if HAVE_GETRUSAGE
3850
    struct rusage rusage;
3851

    
3852
    getrusage(RUSAGE_SELF, &rusage);
3853
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3854
#elif HAVE_GETPROCESSTIMES
3855
    HANDLE proc;
3856
    FILETIME c, e, k, u;
3857
    proc = GetCurrentProcess();
3858
    GetProcessTimes(proc, &c, &e, &k, &u);
3859
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3860
#else
3861
    return av_gettime();
3862
#endif
3863
}
3864

    
3865
static int64_t getmaxrss(void)
3866
{
3867
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3868
    struct rusage rusage;
3869
    getrusage(RUSAGE_SELF, &rusage);
3870
    return (int64_t)rusage.ru_maxrss * 1024;
3871
#elif HAVE_GETPROCESSMEMORYINFO
3872
    HANDLE proc;
3873
    PROCESS_MEMORY_COUNTERS memcounters;
3874
    proc = GetCurrentProcess();
3875
    memcounters.cb = sizeof(memcounters);
3876
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3877
    return memcounters.PeakPagefileUsage;
3878
#else
3879
    return 0;
3880
#endif
3881
}
3882

    
3883
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3884
{
3885
    int i;
3886
    const char *p = str;
3887
    for(i = 0;; i++) {
3888
        dest[i] = atoi(p);
3889
        if(i == 63)
3890
            break;
3891
        p = strchr(p, ',');
3892
        if(!p) {
3893
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3894
            ffmpeg_exit(1);
3895
        }
3896
        p++;
3897
    }
3898
}
3899

    
3900
static void opt_inter_matrix(const char *arg)
3901
{
3902
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3903
    parse_matrix_coeffs(inter_matrix, arg);
3904
}
3905

    
3906
static void opt_intra_matrix(const char *arg)
3907
{
3908
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3909
    parse_matrix_coeffs(intra_matrix, arg);
3910
}
3911

    
3912
static void show_usage(void)
3913
{
3914
    printf("Hyper fast Audio and Video encoder\n");
3915
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3916
    printf("\n");
3917
}
3918

    
3919
static void show_help(void)
3920
{
3921
    AVCodec *c;
3922
    AVOutputFormat *oformat = NULL;
3923

    
3924
    av_log_set_callback(log_callback_help);
3925
    show_usage();
3926
    show_help_options(options, "Main options:\n",
3927
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3928
    show_help_options(options, "\nAdvanced options:\n",
3929
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3930
                      OPT_EXPERT);
3931
    show_help_options(options, "\nVideo options:\n",
3932
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3933
                      OPT_VIDEO);
3934
    show_help_options(options, "\nAdvanced Video options:\n",
3935
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3936
                      OPT_VIDEO | OPT_EXPERT);
3937
    show_help_options(options, "\nAudio options:\n",
3938
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3939
                      OPT_AUDIO);
3940
    show_help_options(options, "\nAdvanced Audio options:\n",
3941
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3942
                      OPT_AUDIO | OPT_EXPERT);
3943
    show_help_options(options, "\nSubtitle options:\n",
3944
                      OPT_SUBTITLE | OPT_GRAB,
3945
                      OPT_SUBTITLE);
3946
    show_help_options(options, "\nAudio/Video grab options:\n",
3947
                      OPT_GRAB,
3948
                      OPT_GRAB);
3949
    printf("\n");
3950
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3951
    printf("\n");
3952

    
3953
    /* individual codec options */
3954
    c = NULL;
3955
    while ((c = av_codec_next(c))) {
3956
        if (c->priv_class) {
3957
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3958
            printf("\n");
3959
        }
3960
    }
3961

    
3962
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3963
    printf("\n");
3964

    
3965
    /* individual muxer options */
3966
    while ((oformat = av_oformat_next(oformat))) {
3967
        if (oformat->priv_class) {
3968
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3969
            printf("\n");
3970
        }
3971
    }
3972

    
3973
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3974
}
3975

    
3976
static void opt_target(const char *arg)
3977
{
3978
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3979
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3980

    
3981
    if(!strncmp(arg, "pal-", 4)) {
3982
        norm = PAL;
3983
        arg += 4;
3984
    } else if(!strncmp(arg, "ntsc-", 5)) {
3985
        norm = NTSC;
3986
        arg += 5;
3987
    } else if(!strncmp(arg, "film-", 5)) {
3988
        norm = FILM;
3989
        arg += 5;
3990
    } else {
3991
        int fr;
3992
        /* Calculate FR via float to avoid int overflow */
3993
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3994
        if(fr == 25000) {
3995
            norm = PAL;
3996
        } else if((fr == 29970) || (fr == 23976)) {
3997
            norm = NTSC;
3998
        } else {
3999
            /* Try to determine PAL/NTSC by peeking in the input files */
4000
            if(nb_input_files) {
4001
                int i, j;
4002
                for(j = 0; j < nb_input_files; j++) {
4003
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4004
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4005
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4006
                            continue;
4007
                        fr = c->time_base.den * 1000 / c->time_base.num;
4008
                        if(fr == 25000) {
4009
                            norm = PAL;
4010
                            break;
4011
                        } else if((fr == 29970) || (fr == 23976)) {
4012
                            norm = NTSC;
4013
                            break;
4014
                        }
4015
                    }
4016
                    if(norm != UNKNOWN)
4017
                        break;
4018
                }
4019
            }
4020
        }
4021
        if(verbose && norm != UNKNOWN)
4022
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4023
    }
4024

    
4025
    if(norm == UNKNOWN) {
4026
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4027
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4028
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4029
        ffmpeg_exit(1);
4030
    }
4031

    
4032
    if(!strcmp(arg, "vcd")) {
4033

    
4034
        opt_video_codec("mpeg1video");
4035
        opt_audio_codec("mp2");
4036
        opt_format("vcd");
4037

    
4038
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4039
        opt_frame_rate(NULL, frame_rates[norm]);
4040
        opt_default("g", norm == PAL ? "15" : "18");
4041

    
4042
        opt_default("b", "1150000");
4043
        opt_default("maxrate", "1150000");
4044
        opt_default("minrate", "1150000");
4045
        opt_default("bufsize", "327680"); // 40*1024*8;
4046

    
4047
        opt_default("ab", "224000");
4048
        audio_sample_rate = 44100;
4049
        audio_channels = 2;
4050

    
4051
        opt_default("packetsize", "2324");
4052
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4053

    
4054
        /* We have to offset the PTS, so that it is consistent with the SCR.
4055
           SCR starts at 36000, but the first two packs contain only padding
4056
           and the first pack from the other stream, respectively, may also have
4057
           been written before.
4058
           So the real data starts at SCR 36000+3*1200. */
4059
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4060
    } else if(!strcmp(arg, "svcd")) {
4061

    
4062
        opt_video_codec("mpeg2video");
4063
        opt_audio_codec("mp2");
4064
        opt_format("svcd");
4065

    
4066
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4067
        opt_frame_rate(NULL, frame_rates[norm]);
4068
        opt_default("g", norm == PAL ? "15" : "18");
4069

    
4070
        opt_default("b", "2040000");
4071
        opt_default("maxrate", "2516000");
4072
        opt_default("minrate", "0"); //1145000;
4073
        opt_default("bufsize", "1835008"); //224*1024*8;
4074
        opt_default("flags", "+scan_offset");
4075

    
4076

    
4077
        opt_default("ab", "224000");
4078
        audio_sample_rate = 44100;
4079

    
4080
        opt_default("packetsize", "2324");
4081

    
4082
    } else if(!strcmp(arg, "dvd")) {
4083

    
4084
        opt_video_codec("mpeg2video");
4085
        opt_audio_codec("ac3");
4086
        opt_format("dvd");
4087

    
4088
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4089
        opt_frame_rate(NULL, frame_rates[norm]);
4090
        opt_default("g", norm == PAL ? "15" : "18");
4091

    
4092
        opt_default("b", "6000000");
4093
        opt_default("maxrate", "9000000");
4094
        opt_default("minrate", "0"); //1500000;
4095
        opt_default("bufsize", "1835008"); //224*1024*8;
4096

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

    
4100
        opt_default("ab", "448000");
4101
        audio_sample_rate = 48000;
4102

    
4103
    } else if(!strncmp(arg, "dv", 2)) {
4104

    
4105
        opt_format("dv");
4106

    
4107
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4108
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4109
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4110
        opt_frame_rate(NULL, frame_rates[norm]);
4111

    
4112
        audio_sample_rate = 48000;
4113
        audio_channels = 2;
4114

    
4115
    } else {
4116
        fprintf(stderr, "Unknown target: %s\n", arg);
4117
        ffmpeg_exit(1);
4118
    }
4119
}
4120

    
4121
static void opt_vstats_file (const char *arg)
4122
{
4123
    av_free (vstats_filename);
4124
    vstats_filename=av_strdup (arg);
4125
}
4126

    
4127
static void opt_vstats (void)
4128
{
4129
    char filename[40];
4130
    time_t today2 = time(NULL);
4131
    struct tm *today = localtime(&today2);
4132

    
4133
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4134
             today->tm_sec);
4135
    opt_vstats_file(filename);
4136
}
4137

    
4138
static int opt_bsf(const char *opt, const char *arg)
4139
{
4140
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4141
    AVBitStreamFilterContext **bsfp;
4142

    
4143
    if(!bsfc){
4144
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4145
        ffmpeg_exit(1);
4146
    }
4147

    
4148
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4149
          *opt == 'a' ? &audio_bitstream_filters :
4150
                        &subtitle_bitstream_filters;
4151
    while(*bsfp)
4152
        bsfp= &(*bsfp)->next;
4153

    
4154
    *bsfp= bsfc;
4155

    
4156
    return 0;
4157
}
4158

    
4159
static int opt_preset(const char *opt, const char *arg)
4160
{
4161
    FILE *f=NULL;
4162
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4163
    char *codec_name = *opt == 'v' ? video_codec_name :
4164
                       *opt == 'a' ? audio_codec_name :
4165
                                     subtitle_codec_name;
4166

    
4167
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4168
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4169
        ffmpeg_exit(1);
4170
    }
4171

    
4172
    while(!feof(f)){
4173
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4174
        if(line[0] == '#' && !e)
4175
            continue;
4176
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4177
        if(e){
4178
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4179
            ffmpeg_exit(1);
4180
        }
4181
        if(!strcmp(tmp, "acodec")){
4182
            opt_audio_codec(tmp2);
4183
        }else if(!strcmp(tmp, "vcodec")){
4184
            opt_video_codec(tmp2);
4185
        }else if(!strcmp(tmp, "scodec")){
4186
            opt_subtitle_codec(tmp2);
4187
        }else if(opt_default(tmp, tmp2) < 0){
4188
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4189
            ffmpeg_exit(1);
4190
        }
4191
    }
4192

    
4193
    fclose(f);
4194

    
4195
    return 0;
4196
}
4197

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

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

    
4291
    /* audio options */
4292
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4293
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4294
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4295
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4296
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4297
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4298
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4299
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4300
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4301
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4302
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4303
    { "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" },
4304

    
4305
    /* subtitle options */
4306
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4307
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4308
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4309
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4310
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4311

    
4312
    /* grab options */
4313
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4314
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4315
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4316

    
4317
    /* muxer options */
4318
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4319
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4320

    
4321
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4322
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4323
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4324

    
4325
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4326
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4327
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4328
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4329

    
4330
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4331
    { NULL, },
4332
};
4333

    
4334
int main(int argc, char **argv)
4335
{
4336
    int64_t ti;
4337

    
4338
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4339

    
4340
    avcodec_register_all();
4341
#if CONFIG_AVDEVICE
4342
    avdevice_register_all();
4343
#endif
4344
#if CONFIG_AVFILTER
4345
    avfilter_register_all();
4346
#endif
4347
    av_register_all();
4348

    
4349
#if HAVE_ISATTY
4350
    if(isatty(STDIN_FILENO))
4351
        url_set_interrupt_cb(decode_interrupt_cb);
4352
#endif
4353

    
4354
    init_opts();
4355

    
4356
    show_banner();
4357

    
4358
    /* parse options */
4359
    parse_options(argc, argv, options, opt_output_file);
4360

    
4361
    if(nb_output_files <= 0 && nb_input_files == 0) {
4362
        show_usage();
4363
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4364
        ffmpeg_exit(1);
4365
    }
4366

    
4367
    /* file converter / grab */
4368
    if (nb_output_files <= 0) {
4369
        fprintf(stderr, "At least one output file must be specified\n");
4370
        ffmpeg_exit(1);
4371
    }
4372

    
4373
    if (nb_input_files == 0) {
4374
        fprintf(stderr, "At least one input file must be specified\n");
4375
        ffmpeg_exit(1);
4376
    }
4377

    
4378
    ti = getutime();
4379
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4380
                  stream_maps, nb_stream_maps) < 0)
4381
        ffmpeg_exit(1);
4382
    ti = getutime() - ti;
4383
    if (do_benchmark) {
4384
        int maxrss = getmaxrss() / 1024;
4385
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4386
    }
4387

    
4388
    return ffmpeg_exit(0);
4389
}