Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 90da2b50

History | View | Annotate | Download (140 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 "libavutil/fifo.h"
40
#include "libavutil/avstring.h"
41
#include "libavformat/os_support.h"
42

    
43
#if HAVE_SYS_RESOURCE_H
44
#include <sys/types.h>
45
#include <sys/resource.h>
46
#elif HAVE_GETPROCESSTIMES
47
#include <windows.h>
48
#endif
49

    
50
#if HAVE_SYS_SELECT_H
51
#include <sys/select.h>
52
#endif
53

    
54
#if HAVE_TERMIOS_H
55
#include <fcntl.h>
56
#include <sys/ioctl.h>
57
#include <sys/time.h>
58
#include <termios.h>
59
#elif HAVE_CONIO_H
60
#include <conio.h>
61
#endif
62
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
63
#include <time.h>
64

    
65
#include "cmdutils.h"
66

    
67
#undef NDEBUG
68
#include <assert.h>
69

    
70
#undef exit
71

    
72
const char program_name[] = "FFmpeg";
73
const int program_birth_year = 2000;
74

    
75
/* select an input stream for an output stream */
76
typedef struct AVStreamMap {
77
    int file_index;
78
    int stream_index;
79
    int sync_file_index;
80
    int sync_stream_index;
81
} AVStreamMap;
82

    
83
/** select an input file for an output file */
84
typedef struct AVMetaDataMap {
85
    int out_file;
86
    int in_file;
87
} AVMetaDataMap;
88

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

    
93
static AVFormatContext *input_files[MAX_FILES];
94
static int64_t input_files_ts_offset[MAX_FILES];
95
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
96
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
97
static int nb_input_files = 0;
98
static int nb_icodecs;
99

    
100
static AVFormatContext *output_files[MAX_FILES];
101
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
102
static int nb_output_files = 0;
103
static int nb_ocodecs;
104

    
105
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
106
static int nb_stream_maps;
107

    
108
static AVMetaDataMap meta_data_maps[MAX_FILES];
109
static int nb_meta_data_maps;
110

    
111
static AVInputFormat *file_iformat;
112
static AVOutputFormat *file_oformat;
113
static int frame_width  = 0;
114
static int frame_height = 0;
115
static float frame_aspect_ratio = 0;
116
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
117
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
118
static int frame_padtop  = 0;
119
static int frame_padbottom = 0;
120
static int frame_padleft  = 0;
121
static int frame_padright = 0;
122
static int padcolor[3] = {16,128,128}; /* default to black */
123
static int frame_topBand  = 0;
124
static int frame_bottomBand = 0;
125
static int frame_leftBand  = 0;
126
static int frame_rightBand = 0;
127
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
128
static AVRational frame_rate;
129
static float video_qscale = 0;
130
static uint16_t *intra_matrix = NULL;
131
static uint16_t *inter_matrix = NULL;
132
#if 0 //experimental, (can be removed)
133
static float video_rc_qsquish=1.0;
134
static float video_rc_qmod_amp=0;
135
static int video_rc_qmod_freq=0;
136
#endif
137
static const char *video_rc_override_string=NULL;
138
static int video_disable = 0;
139
static int video_discard = 0;
140
static char *video_codec_name = NULL;
141
static int video_codec_tag = 0;
142
static int same_quality = 0;
143
static int do_deinterlace = 0;
144
static int top_field_first = -1;
145
static int me_threshold = 0;
146
static int intra_dc_precision = 8;
147
static int loop_input = 0;
148
static int loop_output = AVFMT_NOOUTPUTLOOP;
149
static int qp_hist = 0;
150

    
151
static int intra_only = 0;
152
static int audio_sample_rate = 44100;
153
static int64_t channel_layout = 0;
154
#define QSCALE_NONE -99999
155
static float audio_qscale = QSCALE_NONE;
156
static int audio_disable = 0;
157
static int audio_channels = 1;
158
static char  *audio_codec_name = NULL;
159
static int audio_codec_tag = 0;
160
static char *audio_language = NULL;
161

    
162
static int subtitle_disable = 0;
163
static char *subtitle_codec_name = NULL;
164
static char *subtitle_language = NULL;
165
static int subtitle_codec_tag = 0;
166

    
167
static float mux_preload= 0.5;
168
static float mux_max_delay= 0.7;
169

    
170
static int64_t recording_time = INT64_MAX;
171
static int64_t start_time = 0;
172
static int64_t rec_timestamp = 0;
173
static int64_t input_ts_offset = 0;
174
static int file_overwrite = 0;
175
static int metadata_count;
176
static AVMetadataTag *metadata;
177
static int do_benchmark = 0;
178
static int do_hex_dump = 0;
179
static int do_pkt_dump = 0;
180
static int do_psnr = 0;
181
static int do_pass = 0;
182
static char *pass_logfilename_prefix = NULL;
183
static int audio_stream_copy = 0;
184
static int video_stream_copy = 0;
185
static int subtitle_stream_copy = 0;
186
static int video_sync_method= -1;
187
static int audio_sync_method= 0;
188
static float audio_drift_threshold= 0.1;
189
static int copy_ts= 0;
190
static int opt_shortest = 0;
191
static int video_global_header = 0;
192
static char *vstats_filename;
193
static FILE *vstats_file;
194
static int opt_programid = 0;
195
static int copy_initial_nonkeyframes = 0;
196

    
197
static int rate_emu = 0;
198

    
199
static int  video_channel = 0;
200
static char *video_standard;
201

    
202
static int audio_volume = 256;
203

    
204
static int exit_on_error = 0;
205
static int using_stdin = 0;
206
static int verbose = 1;
207
static int thread_count= 1;
208
static int q_pressed = 0;
209
static int64_t video_size = 0;
210
static int64_t audio_size = 0;
211
static int64_t extra_size = 0;
212
static int nb_frames_dup = 0;
213
static int nb_frames_drop = 0;
214
static int input_sync;
215
static uint64_t limit_filesize = 0;
216
static int force_fps = 0;
217

    
218
static int pgmyuv_compatibility_hack=0;
219
static float dts_delta_threshold = 10;
220

    
221
static unsigned int sws_flags = SWS_BICUBIC;
222

    
223
static int64_t timer_start;
224

    
225
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
226
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
227
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
228
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
229

    
230
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
231

    
232
struct AVInputStream;
233

    
234
typedef struct AVOutputStream {
235
    int file_index;          /* file index */
236
    int index;               /* stream index in the output file */
237
    int source_index;        /* AVInputStream index */
238
    AVStream *st;            /* stream in the output file */
239
    int encoding_needed;     /* true if encoding needed for this stream */
240
    int frame_number;
241
    /* input pts and corresponding output pts
242
       for A/V sync */
243
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
244
    struct AVInputStream *sync_ist; /* input stream to sync against */
245
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
246
    /* video only */
247
    int video_resample;
248
    AVFrame pict_tmp;      /* temporary image for resampling */
249
    struct SwsContext *img_resample_ctx; /* for image resampling */
250
    int resample_height;
251

    
252
    int video_crop;
253
    int topBand;             /* cropping area sizes */
254
    int leftBand;
255

    
256
    int video_pad;
257
    int padtop;              /* padding area sizes */
258
    int padbottom;
259
    int padleft;
260
    int padright;
261

    
262
    /* audio only */
263
    int audio_resample;
264
    ReSampleContext *resample; /* for audio resampling */
265
    int reformat_pair;
266
    AVAudioConvert *reformat_ctx;
267
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
268
    FILE *logfile;
269
} AVOutputStream;
270

    
271
typedef struct AVInputStream {
272
    int file_index;
273
    int index;
274
    AVStream *st;
275
    int discard;             /* true if stream data should be discarded */
276
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
277
    int64_t sample_index;      /* current sample */
278

    
279
    int64_t       start;     /* time when read started */
280
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
281
                                is not defined */
282
    int64_t       pts;       /* current pts */
283
    int is_start;            /* is 1 at the start and after a discontinuity */
284
} AVInputStream;
285

    
286
typedef struct AVInputFile {
287
    int eof_reached;      /* true if eof reached */
288
    int ist_index;        /* index of first stream in ist_table */
289
    int buffer_size;      /* current total buffer size */
290
    int nb_streams;       /* nb streams we are aware of */
291
} AVInputFile;
292

    
293
#if HAVE_TERMIOS_H
294

    
295
/* init terminal so that we can grab keys */
296
static struct termios oldtty;
297
#endif
298

    
299
static void term_exit(void)
300
{
301
#if HAVE_TERMIOS_H
302
    tcsetattr (0, TCSANOW, &oldtty);
303
#endif
304
}
305

    
306
static volatile sig_atomic_t received_sigterm = 0;
307

    
308
static void
309
sigterm_handler(int sig)
310
{
311
    received_sigterm = sig;
312
    term_exit();
313
}
314

    
315
static void term_init(void)
316
{
317
#if HAVE_TERMIOS_H
318
    struct termios tty;
319

    
320
    tcgetattr (0, &tty);
321
    oldtty = tty;
322

    
323
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
324
                          |INLCR|IGNCR|ICRNL|IXON);
325
    tty.c_oflag |= OPOST;
326
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
327
    tty.c_cflag &= ~(CSIZE|PARENB);
328
    tty.c_cflag |= CS8;
329
    tty.c_cc[VMIN] = 1;
330
    tty.c_cc[VTIME] = 0;
331

    
332
    tcsetattr (0, TCSANOW, &tty);
333
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
334
#endif
335

    
336
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
337
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
338
    /*
339
    register a function to be called at normal program termination
340
    */
341
    atexit(term_exit);
342
#if CONFIG_BEOS_NETSERVER
343
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
344
#endif
345
}
346

    
347
/* read a key without blocking */
348
static int read_key(void)
349
{
350
#if HAVE_TERMIOS_H
351
    int n = 1;
352
    unsigned char ch;
353
#if !CONFIG_BEOS_NETSERVER
354
    struct timeval tv;
355
    fd_set rfds;
356

    
357
    FD_ZERO(&rfds);
358
    FD_SET(0, &rfds);
359
    tv.tv_sec = 0;
360
    tv.tv_usec = 0;
361
    n = select(1, &rfds, NULL, NULL, &tv);
362
#endif
363
    if (n > 0) {
364
        n = read(0, &ch, 1);
365
        if (n == 1)
366
            return ch;
367

    
368
        return n;
369
    }
370
#elif HAVE_CONIO_H
371
    if(kbhit())
372
        return(getch());
373
#endif
374
    return -1;
375
}
376

    
377
static int decode_interrupt_cb(void)
378
{
379
    return q_pressed || (q_pressed = read_key() == 'q');
380
}
381

    
382
static int av_exit(int ret)
383
{
384
    int i;
385

    
386
    /* close files */
387
    for(i=0;i<nb_output_files;i++) {
388
        /* maybe av_close_output_file ??? */
389
        AVFormatContext *s = output_files[i];
390
        int j;
391
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
392
            url_fclose(s->pb);
393
        for(j=0;j<s->nb_streams;j++) {
394
            av_metadata_free(&s->streams[j]->metadata);
395
            av_free(s->streams[j]->codec);
396
            av_free(s->streams[j]);
397
        }
398
        for(j=0;j<s->nb_programs;j++) {
399
            av_metadata_free(&s->programs[j]->metadata);
400
        }
401
        for(j=0;j<s->nb_chapters;j++) {
402
            av_metadata_free(&s->chapters[j]->metadata);
403
        }
404
        av_metadata_free(&s->metadata);
405
        av_free(s);
406
    }
407
    for(i=0;i<nb_input_files;i++)
408
        av_close_input_file(input_files[i]);
409

    
410
    av_free(intra_matrix);
411
    av_free(inter_matrix);
412

    
413
    if (vstats_file)
414
        fclose(vstats_file);
415
    av_free(vstats_filename);
416

    
417
    av_free(opt_names);
418

    
419
    av_free(video_codec_name);
420
    av_free(audio_codec_name);
421
    av_free(subtitle_codec_name);
422

    
423
    av_free(video_standard);
424

    
425
#if CONFIG_POWERPC_PERF
426
    void powerpc_display_perf_report(void);
427
    powerpc_display_perf_report();
428
#endif /* CONFIG_POWERPC_PERF */
429

    
430
    if (received_sigterm) {
431
        fprintf(stderr,
432
            "Received signal %d: terminating.\n",
433
            (int) received_sigterm);
434
        exit (255);
435
    }
436

    
437
    exit(ret); /* not all OS-es handle main() return value */
438
    return ret;
439
}
440

    
441
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
442
{
443
    int i, err;
444
    AVFormatContext *ic;
445
    int nopts = 0;
446

    
447
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
448
    if (err < 0)
449
        return err;
450
    /* copy stream format */
451
    s->nb_streams = ic->nb_streams;
452
    for(i=0;i<ic->nb_streams;i++) {
453
        AVStream *st;
454

    
455
        // FIXME: a more elegant solution is needed
456
        st = av_mallocz(sizeof(AVStream));
457
        memcpy(st, ic->streams[i], sizeof(AVStream));
458
        st->codec = avcodec_alloc_context();
459
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
460
        s->streams[i] = st;
461

    
462
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
463
            st->stream_copy = 1;
464
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
465
            st->stream_copy = 1;
466

    
467
        if(!st->codec->thread_count)
468
            st->codec->thread_count = 1;
469
        if(st->codec->thread_count>1)
470
            avcodec_thread_init(st->codec, st->codec->thread_count);
471

    
472
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
473
            nopts = 1;
474
    }
475

    
476
    if (!nopts)
477
        s->timestamp = av_gettime();
478

    
479
    av_close_input_file(ic);
480
    return 0;
481
}
482

    
483
static double
484
get_sync_ipts(const AVOutputStream *ost)
485
{
486
    const AVInputStream *ist = ost->sync_ist;
487
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
488
}
489

    
490
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
491
    int ret;
492

    
493
    while(bsfc){
494
        AVPacket new_pkt= *pkt;
495
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
496
                                          &new_pkt.data, &new_pkt.size,
497
                                          pkt->data, pkt->size,
498
                                          pkt->flags & PKT_FLAG_KEY);
499
        if(a>0){
500
            av_free_packet(pkt);
501
            new_pkt.destruct= av_destruct_packet;
502
        } else if(a<0){
503
            fprintf(stderr, "%s failed for stream %d, codec %s",
504
                    bsfc->filter->name, pkt->stream_index,
505
                    avctx->codec ? avctx->codec->name : "copy");
506
            print_error("", a);
507
            if (exit_on_error)
508
                av_exit(1);
509
        }
510
        *pkt= new_pkt;
511

    
512
        bsfc= bsfc->next;
513
    }
514

    
515
    ret= av_interleaved_write_frame(s, pkt);
516
    if(ret < 0){
517
        print_error("av_interleaved_write_frame()", ret);
518
        av_exit(1);
519
    }
520
}
521

    
522
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
523

    
524
static void do_audio_out(AVFormatContext *s,
525
                         AVOutputStream *ost,
526
                         AVInputStream *ist,
527
                         unsigned char *buf, int size)
528
{
529
    uint8_t *buftmp;
530
    static uint8_t *audio_buf = NULL;
531
    static uint8_t *audio_out = NULL;
532
    static uint8_t *audio_out2 = NULL;
533
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
534

    
535
    int size_out, frame_bytes, ret;
536
    AVCodecContext *enc= ost->st->codec;
537
    AVCodecContext *dec= ist->st->codec;
538
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
539
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
540

    
541
    /* SC: dynamic allocation of buffers */
542
    if (!audio_buf)
543
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
544
    if (!audio_out)
545
        audio_out = av_malloc(audio_out_size);
546
    if (!audio_buf || !audio_out)
547
        return;               /* Should signal an error ! */
548

    
549
    if (enc->channels != dec->channels)
550
        ost->audio_resample = 1;
551

    
552
    if (ost->audio_resample && !ost->resample) {
553
        if (dec->sample_fmt != SAMPLE_FMT_S16)
554
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
555
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
556
                                               enc->sample_rate, dec->sample_rate,
557
                                               enc->sample_fmt,  dec->sample_fmt,
558
                                               16, 10, 0, 0.8);
559
        if (!ost->resample) {
560
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
561
                    dec->channels, dec->sample_rate,
562
                    enc->channels, enc->sample_rate);
563
            av_exit(1);
564
        }
565
    }
566

    
567
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
568
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
569
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
570
        if (!audio_out2)
571
            audio_out2 = av_malloc(audio_out_size);
572
        if (!audio_out2)
573
            av_exit(1);
574
        if (ost->reformat_ctx)
575
            av_audio_convert_free(ost->reformat_ctx);
576
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
577
                                                   dec->sample_fmt, 1, NULL, 0);
578
        if (!ost->reformat_ctx) {
579
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
580
                avcodec_get_sample_fmt_name(dec->sample_fmt),
581
                avcodec_get_sample_fmt_name(enc->sample_fmt));
582
            av_exit(1);
583
        }
584
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
585
    }
586

    
587
    if(audio_sync_method){
588
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
589
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
590
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
591
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
592

    
593
        //FIXME resample delay
594
        if(fabs(delta) > 50){
595
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
596
                if(byte_delta < 0){
597
                    byte_delta= FFMAX(byte_delta, -size);
598
                    size += byte_delta;
599
                    buf  -= byte_delta;
600
                    if(verbose > 2)
601
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
602
                    if(!size)
603
                        return;
604
                    ist->is_start=0;
605
                }else{
606
                    static uint8_t *input_tmp= NULL;
607
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
608

    
609
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
610
                        ist->is_start=0;
611
                    else
612
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
613

    
614
                    memset(input_tmp, 0, byte_delta);
615
                    memcpy(input_tmp + byte_delta, buf, size);
616
                    buf= input_tmp;
617
                    size += byte_delta;
618
                    if(verbose > 2)
619
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
620
                }
621
            }else if(audio_sync_method>1){
622
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
623
                assert(ost->audio_resample);
624
                if(verbose > 2)
625
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
626
//                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));
627
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
628
            }
629
        }
630
    }else
631
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
632
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
633

    
634
    if (ost->audio_resample) {
635
        buftmp = audio_buf;
636
        size_out = audio_resample(ost->resample,
637
                                  (short *)buftmp, (short *)buf,
638
                                  size / (ist->st->codec->channels * isize));
639
        size_out = size_out * enc->channels * osize;
640
    } else {
641
        buftmp = buf;
642
        size_out = size;
643
    }
644

    
645
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
646
        const void *ibuf[6]= {buftmp};
647
        void *obuf[6]= {audio_out2};
648
        int istride[6]= {isize};
649
        int ostride[6]= {osize};
650
        int len= size_out/istride[0];
651
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
652
            printf("av_audio_convert() failed\n");
653
            if (exit_on_error)
654
                av_exit(1);
655
            return;
656
        }
657
        buftmp = audio_out2;
658
        size_out = len*osize;
659
    }
660

    
661
    /* now encode as many frames as possible */
662
    if (enc->frame_size > 1) {
663
        /* output resampled raw samples */
664
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
665
            fprintf(stderr, "av_fifo_realloc2() failed\n");
666
            av_exit(1);
667
        }
668
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
669

    
670
        frame_bytes = enc->frame_size * osize * enc->channels;
671

    
672
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
673
            AVPacket pkt;
674
            av_init_packet(&pkt);
675

    
676
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
677

    
678
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
679

    
680
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
681
                                       (short *)audio_buf);
682
            if (ret < 0) {
683
                fprintf(stderr, "Audio encoding failed\n");
684
                av_exit(1);
685
            }
686
            audio_size += ret;
687
            pkt.stream_index= ost->index;
688
            pkt.data= audio_out;
689
            pkt.size= ret;
690
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
691
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
692
            pkt.flags |= PKT_FLAG_KEY;
693
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
694

    
695
            ost->sync_opts += enc->frame_size;
696
        }
697
    } else {
698
        AVPacket pkt;
699
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
700
        av_init_packet(&pkt);
701

    
702
        ost->sync_opts += size_out / (osize * enc->channels);
703

    
704
        /* output a pcm frame */
705
        /* determine the size of the coded buffer */
706
        size_out /= osize;
707
        if (coded_bps)
708
            size_out *= coded_bps;
709

    
710
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
711
        ret = avcodec_encode_audio(enc, audio_out, size_out,
712
                                   (short *)buftmp);
713
        if (ret < 0) {
714
            fprintf(stderr, "Audio encoding failed\n");
715
            av_exit(1);
716
        }
717
        audio_size += ret;
718
        pkt.stream_index= ost->index;
719
        pkt.data= audio_out;
720
        pkt.size= ret;
721
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
722
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
723
        pkt.flags |= PKT_FLAG_KEY;
724
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
725
    }
726
}
727

    
728
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
729
{
730
    AVCodecContext *dec;
731
    AVPicture *picture2;
732
    AVPicture picture_tmp;
733
    uint8_t *buf = 0;
734

    
735
    dec = ist->st->codec;
736

    
737
    /* deinterlace : must be done before any resize */
738
    if (do_deinterlace) {
739
        int size;
740

    
741
        /* create temporary picture */
742
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
743
        buf = av_malloc(size);
744
        if (!buf)
745
            return;
746

    
747
        picture2 = &picture_tmp;
748
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
749

    
750
        if (do_deinterlace){
751
            if(avpicture_deinterlace(picture2, picture,
752
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
753
                /* if error, do not deinterlace */
754
                fprintf(stderr, "Deinterlacing failed\n");
755
                av_free(buf);
756
                buf = NULL;
757
                picture2 = picture;
758
            }
759
        } else {
760
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
761
        }
762
    } else {
763
        picture2 = picture;
764
    }
765

    
766
    if (picture != picture2)
767
        *picture = *picture2;
768
    *bufp = buf;
769
}
770

    
771
/* we begin to correct av delay at this threshold */
772
#define AV_DELAY_MAX 0.100
773

    
774
static void do_subtitle_out(AVFormatContext *s,
775
                            AVOutputStream *ost,
776
                            AVInputStream *ist,
777
                            AVSubtitle *sub,
778
                            int64_t pts)
779
{
780
    static uint8_t *subtitle_out = NULL;
781
    int subtitle_out_max_size = 65536;
782
    int subtitle_out_size, nb, i;
783
    AVCodecContext *enc;
784
    AVPacket pkt;
785

    
786
    if (pts == AV_NOPTS_VALUE) {
787
        fprintf(stderr, "Subtitle packets must have a pts\n");
788
        if (exit_on_error)
789
            av_exit(1);
790
        return;
791
    }
792

    
793
    enc = ost->st->codec;
794

    
795
    if (!subtitle_out) {
796
        subtitle_out = av_malloc(subtitle_out_max_size);
797
    }
798

    
799
    /* Note: DVB subtitle need one packet to draw them and one other
800
       packet to clear them */
801
    /* XXX: signal it in the codec context ? */
802
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
803
        nb = 2;
804
    else
805
        nb = 1;
806

    
807
    for(i = 0; i < nb; i++) {
808
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
809
                                                    subtitle_out_max_size, sub);
810

    
811
        av_init_packet(&pkt);
812
        pkt.stream_index = ost->index;
813
        pkt.data = subtitle_out;
814
        pkt.size = subtitle_out_size;
815
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
816
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
817
            /* XXX: the pts correction is handled here. Maybe handling
818
               it in the codec would be better */
819
            if (i == 0)
820
                pkt.pts += 90 * sub->start_display_time;
821
            else
822
                pkt.pts += 90 * sub->end_display_time;
823
        }
824
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
825
    }
826
}
827

    
828
static int bit_buffer_size= 1024*256;
829
static uint8_t *bit_buffer= NULL;
830

    
831
static void do_video_out(AVFormatContext *s,
832
                         AVOutputStream *ost,
833
                         AVInputStream *ist,
834
                         AVFrame *in_picture,
835
                         int *frame_size)
836
{
837
    int nb_frames, i, ret;
838
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
839
    AVFrame picture_crop_temp, picture_pad_temp;
840
    AVCodecContext *enc, *dec;
841

    
842
    avcodec_get_frame_defaults(&picture_crop_temp);
843
    avcodec_get_frame_defaults(&picture_pad_temp);
844

    
845
    enc = ost->st->codec;
846
    dec = ist->st->codec;
847

    
848
    /* by default, we output a single frame */
849
    nb_frames = 1;
850

    
851
    *frame_size = 0;
852

    
853
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
854
        double vdelta;
855
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
856
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
857
        if (vdelta < -1.1)
858
            nb_frames = 0;
859
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
860
            if(vdelta<=-0.6){
861
                nb_frames=0;
862
            }else if(vdelta>0.6)
863
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
864
        }else if (vdelta > 1.1)
865
            nb_frames = lrintf(vdelta);
866
//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);
867
        if (nb_frames == 0){
868
            ++nb_frames_drop;
869
            if (verbose>2)
870
                fprintf(stderr, "*** drop!\n");
871
        }else if (nb_frames > 1) {
872
            nb_frames_dup += nb_frames;
873
            if (verbose>2)
874
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
875
        }
876
    }else
877
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
878

    
879
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
880
    if (nb_frames <= 0)
881
        return;
882

    
883
    if (ost->video_crop) {
884
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
885
            fprintf(stderr, "error cropping picture\n");
886
            if (exit_on_error)
887
                av_exit(1);
888
            return;
889
        }
890
        formatted_picture = &picture_crop_temp;
891
    } else {
892
        formatted_picture = in_picture;
893
    }
894

    
895
    final_picture = formatted_picture;
896
    padding_src = formatted_picture;
897
    resampling_dst = &ost->pict_tmp;
898
    if (ost->video_pad) {
899
        final_picture = &ost->pict_tmp;
900
        if (ost->video_resample) {
901
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
902
                fprintf(stderr, "error padding picture\n");
903
                if (exit_on_error)
904
                    av_exit(1);
905
                return;
906
            }
907
            resampling_dst = &picture_pad_temp;
908
        }
909
    }
910

    
911
    if (ost->video_resample) {
912
        padding_src = NULL;
913
        final_picture = &ost->pict_tmp;
914
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
915
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
916
    }
917

    
918
    if (ost->video_pad) {
919
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
920
                enc->height, enc->width, enc->pix_fmt,
921
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
922
    }
923

    
924
    /* duplicates frame if needed */
925
    for(i=0;i<nb_frames;i++) {
926
        AVPacket pkt;
927
        av_init_packet(&pkt);
928
        pkt.stream_index= ost->index;
929

    
930
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
931
            /* raw pictures are written as AVPicture structure to
932
               avoid any copies. We support temorarily the older
933
               method. */
934
            AVFrame* old_frame = enc->coded_frame;
935
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
936
            pkt.data= (uint8_t *)final_picture;
937
            pkt.size=  sizeof(AVPicture);
938
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
939
            pkt.flags |= PKT_FLAG_KEY;
940

    
941
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
942
            enc->coded_frame = old_frame;
943
        } else {
944
            AVFrame big_picture;
945

    
946
            big_picture= *final_picture;
947
            /* better than nothing: use input picture interlaced
948
               settings */
949
            big_picture.interlaced_frame = in_picture->interlaced_frame;
950
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
951
                if(top_field_first == -1)
952
                    big_picture.top_field_first = in_picture->top_field_first;
953
                else
954
                    big_picture.top_field_first = top_field_first;
955
            }
956

    
957
            /* handles sameq here. This is not correct because it may
958
               not be a global option */
959
            if (same_quality) {
960
                big_picture.quality = ist->st->quality;
961
            }else
962
                big_picture.quality = ost->st->quality;
963
            if(!me_threshold)
964
                big_picture.pict_type = 0;
965
//            big_picture.pts = AV_NOPTS_VALUE;
966
            big_picture.pts= ost->sync_opts;
967
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
968
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
969
            ret = avcodec_encode_video(enc,
970
                                       bit_buffer, bit_buffer_size,
971
                                       &big_picture);
972
            if (ret < 0) {
973
                fprintf(stderr, "Video encoding failed\n");
974
                av_exit(1);
975
            }
976
            //enc->frame_number = enc->real_pict_num;
977
            if(ret>0){
978
                pkt.data= bit_buffer;
979
                pkt.size= ret;
980
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
981
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
982
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
983
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
984
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
985

    
986
                if(enc->coded_frame->key_frame)
987
                    pkt.flags |= PKT_FLAG_KEY;
988
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
989
                *frame_size = ret;
990
                video_size += ret;
991
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
992
                //        enc->frame_number-1, enc->real_pict_num, ret,
993
                //        enc->pict_type);
994
                /* if two pass, output log */
995
                if (ost->logfile && enc->stats_out) {
996
                    fprintf(ost->logfile, "%s", enc->stats_out);
997
                }
998
            }
999
        }
1000
        ost->sync_opts++;
1001
        ost->frame_number++;
1002
    }
1003
}
1004

    
1005
static double psnr(double d){
1006
    return -10.0*log(d)/log(10.0);
1007
}
1008

    
1009
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1010
                           int frame_size)
1011
{
1012
    AVCodecContext *enc;
1013
    int frame_number;
1014
    double ti1, bitrate, avg_bitrate;
1015

    
1016
    /* this is executed just the first time do_video_stats is called */
1017
    if (!vstats_file) {
1018
        vstats_file = fopen(vstats_filename, "w");
1019
        if (!vstats_file) {
1020
            perror("fopen");
1021
            av_exit(1);
1022
        }
1023
    }
1024

    
1025
    enc = ost->st->codec;
1026
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1027
        frame_number = ost->frame_number;
1028
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1029
        if (enc->flags&CODEC_FLAG_PSNR)
1030
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1031

    
1032
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1033
        /* compute pts value */
1034
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1035
        if (ti1 < 0.01)
1036
            ti1 = 0.01;
1037

    
1038
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1039
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1040
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1041
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1042
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1043
    }
1044
}
1045

    
1046
static void print_report(AVFormatContext **output_files,
1047
                         AVOutputStream **ost_table, int nb_ostreams,
1048
                         int is_last_report)
1049
{
1050
    char buf[1024];
1051
    AVOutputStream *ost;
1052
    AVFormatContext *oc, *os;
1053
    int64_t total_size;
1054
    AVCodecContext *enc;
1055
    int frame_number, vid, i;
1056
    double bitrate, ti1, pts;
1057
    static int64_t last_time = -1;
1058
    static int qp_histogram[52];
1059

    
1060
    if (!is_last_report) {
1061
        int64_t cur_time;
1062
        /* display the report every 0.5 seconds */
1063
        cur_time = av_gettime();
1064
        if (last_time == -1) {
1065
            last_time = cur_time;
1066
            return;
1067
        }
1068
        if ((cur_time - last_time) < 500000)
1069
            return;
1070
        last_time = cur_time;
1071
    }
1072

    
1073

    
1074
    oc = output_files[0];
1075

    
1076
    total_size = url_fsize(oc->pb);
1077
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1078
        total_size= url_ftell(oc->pb);
1079

    
1080
    buf[0] = '\0';
1081
    ti1 = 1e10;
1082
    vid = 0;
1083
    for(i=0;i<nb_ostreams;i++) {
1084
        ost = ost_table[i];
1085
        os = output_files[ost->file_index];
1086
        enc = ost->st->codec;
1087
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1088
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1089
                     !ost->st->stream_copy ?
1090
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1091
        }
1092
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1093
            float t = (av_gettime()-timer_start) / 1000000.0;
1094

    
1095
            frame_number = ost->frame_number;
1096
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1097
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1098
                     !ost->st->stream_copy ?
1099
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1100
            if(is_last_report)
1101
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1102
            if(qp_hist){
1103
                int j;
1104
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1105
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1106
                    qp_histogram[qp]++;
1107
                for(j=0; j<32; j++)
1108
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1109
            }
1110
            if (enc->flags&CODEC_FLAG_PSNR){
1111
                int j;
1112
                double error, error_sum=0;
1113
                double scale, scale_sum=0;
1114
                char type[3]= {'Y','U','V'};
1115
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1116
                for(j=0; j<3; j++){
1117
                    if(is_last_report){
1118
                        error= enc->error[j];
1119
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1120
                    }else{
1121
                        error= enc->coded_frame->error[j];
1122
                        scale= enc->width*enc->height*255.0*255.0;
1123
                    }
1124
                    if(j) scale/=4;
1125
                    error_sum += error;
1126
                    scale_sum += scale;
1127
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1128
                }
1129
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1130
            }
1131
            vid = 1;
1132
        }
1133
        /* compute min output value */
1134
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1135
        if ((pts < ti1) && (pts > 0))
1136
            ti1 = pts;
1137
    }
1138
    if (ti1 < 0.01)
1139
        ti1 = 0.01;
1140

    
1141
    if (verbose || is_last_report) {
1142
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1143

    
1144
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1145
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1146
            (double)total_size / 1024, ti1, bitrate);
1147

    
1148
        if (verbose > 1)
1149
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1150
                  nb_frames_dup, nb_frames_drop);
1151

    
1152
        if (verbose >= 0)
1153
            fprintf(stderr, "%s    \r", buf);
1154

    
1155
        fflush(stderr);
1156
    }
1157

    
1158
    if (is_last_report && verbose >= 0){
1159
        int64_t raw= audio_size + video_size + extra_size;
1160
        fprintf(stderr, "\n");
1161
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1162
                video_size/1024.0,
1163
                audio_size/1024.0,
1164
                extra_size/1024.0,
1165
                100.0*(total_size - raw)/raw
1166
        );
1167
    }
1168
}
1169

    
1170
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1171
static int output_packet(AVInputStream *ist, int ist_index,
1172
                         AVOutputStream **ost_table, int nb_ostreams,
1173
                         const AVPacket *pkt)
1174
{
1175
    AVFormatContext *os;
1176
    AVOutputStream *ost;
1177
    uint8_t *ptr;
1178
    int len, ret, i;
1179
    uint8_t *data_buf;
1180
    int data_size, got_picture;
1181
    AVFrame picture;
1182
    void *buffer_to_free;
1183
    static unsigned int samples_size= 0;
1184
    static short *samples= NULL;
1185
    AVSubtitle subtitle, *subtitle_to_free;
1186
    int got_subtitle;
1187

    
1188
    if(ist->next_pts == AV_NOPTS_VALUE)
1189
        ist->next_pts= ist->pts;
1190

    
1191
    if (pkt == NULL) {
1192
        /* EOF handling */
1193
        ptr = NULL;
1194
        len = 0;
1195
        goto handle_eof;
1196
    }
1197

    
1198
    if(pkt->dts != AV_NOPTS_VALUE)
1199
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1200

    
1201
    len = pkt->size;
1202
    ptr = pkt->data;
1203

    
1204
    //while we have more to decode or while the decoder did output something on EOF
1205
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1206
    handle_eof:
1207
        ist->pts= ist->next_pts;
1208

    
1209
        if(len && len != pkt->size && verbose>0)
1210
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1211

    
1212
        /* decode the packet if needed */
1213
        data_buf = NULL; /* fail safe */
1214
        data_size = 0;
1215
        subtitle_to_free = NULL;
1216
        if (ist->decoding_needed) {
1217
            switch(ist->st->codec->codec_type) {
1218
            case CODEC_TYPE_AUDIO:{
1219
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1220
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1221
                    av_free(samples);
1222
                    samples= av_malloc(samples_size);
1223
                }
1224
                data_size= samples_size;
1225
                    /* XXX: could avoid copy if PCM 16 bits with same
1226
                       endianness as CPU */
1227
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1228
                                           ptr, len);
1229
                if (ret < 0)
1230
                    goto fail_decode;
1231
                ptr += ret;
1232
                len -= ret;
1233
                /* Some bug in mpeg audio decoder gives */
1234
                /* data_size < 0, it seems they are overflows */
1235
                if (data_size <= 0) {
1236
                    /* no audio frame */
1237
                    continue;
1238
                }
1239
                data_buf = (uint8_t *)samples;
1240
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1241
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1242
                break;}
1243
            case CODEC_TYPE_VIDEO:
1244
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1245
                    /* XXX: allocate picture correctly */
1246
                    avcodec_get_frame_defaults(&picture);
1247

    
1248
                    ret = avcodec_decode_video(ist->st->codec,
1249
                                               &picture, &got_picture, ptr, len);
1250
                    ist->st->quality= picture.quality;
1251
                    if (ret < 0)
1252
                        goto fail_decode;
1253
                    if (!got_picture) {
1254
                        /* no picture yet */
1255
                        goto discard_packet;
1256
                    }
1257
                    if (ist->st->codec->time_base.num != 0) {
1258
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1259
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1260
                                          ist->st->codec->time_base.num * ticks) /
1261
                            ist->st->codec->time_base.den;
1262
                    }
1263
                    len = 0;
1264
                    break;
1265
            case CODEC_TYPE_SUBTITLE:
1266
                ret = avcodec_decode_subtitle(ist->st->codec,
1267
                                              &subtitle, &got_subtitle, ptr, len);
1268
                if (ret < 0)
1269
                    goto fail_decode;
1270
                if (!got_subtitle) {
1271
                    goto discard_packet;
1272
                }
1273
                subtitle_to_free = &subtitle;
1274
                len = 0;
1275
                break;
1276
            default:
1277
                goto fail_decode;
1278
            }
1279
        } else {
1280
            switch(ist->st->codec->codec_type) {
1281
            case CODEC_TYPE_AUDIO:
1282
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1283
                    ist->st->codec->sample_rate;
1284
                break;
1285
            case CODEC_TYPE_VIDEO:
1286
                if (ist->st->codec->time_base.num != 0) {
1287
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1288
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1289
                                      ist->st->codec->time_base.num * ticks) /
1290
                        ist->st->codec->time_base.den;
1291
                }
1292
                break;
1293
            }
1294
            data_buf = ptr;
1295
            data_size = len;
1296
            ret = len;
1297
            len = 0;
1298
        }
1299

    
1300
        buffer_to_free = NULL;
1301
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1302
            pre_process_video_frame(ist, (AVPicture *)&picture,
1303
                                    &buffer_to_free);
1304
        }
1305

    
1306
        // preprocess audio (volume)
1307
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1308
            if (audio_volume != 256) {
1309
                short *volp;
1310
                volp = samples;
1311
                for(i=0;i<(data_size / sizeof(short));i++) {
1312
                    int v = ((*volp) * audio_volume + 128) >> 8;
1313
                    if (v < -32768) v = -32768;
1314
                    if (v >  32767) v = 32767;
1315
                    *volp++ = v;
1316
                }
1317
            }
1318
        }
1319

    
1320
        /* frame rate emulation */
1321
        if (rate_emu) {
1322
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1323
            int64_t now = av_gettime() - ist->start;
1324
            if (pts > now)
1325
                usleep(pts - now);
1326
        }
1327

    
1328
        /* if output time reached then transcode raw format,
1329
           encode packets and output them */
1330
        if (start_time == 0 || ist->pts >= start_time)
1331
            for(i=0;i<nb_ostreams;i++) {
1332
                int frame_size;
1333

    
1334
                ost = ost_table[i];
1335
                if (ost->source_index == ist_index) {
1336
                    os = output_files[ost->file_index];
1337

    
1338
#if 0
1339
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1340
                           (double)pkt->pts / AV_TIME_BASE,
1341
                           ((double)ist->pts / AV_TIME_BASE) -
1342
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1343
#endif
1344
                    /* set the input output pts pairs */
1345
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1346

    
1347
                    if (ost->encoding_needed) {
1348
                        switch(ost->st->codec->codec_type) {
1349
                        case CODEC_TYPE_AUDIO:
1350
                            do_audio_out(os, ost, ist, data_buf, data_size);
1351
                            break;
1352
                        case CODEC_TYPE_VIDEO:
1353
                            do_video_out(os, ost, ist, &picture, &frame_size);
1354
                            if (vstats_filename && frame_size)
1355
                                do_video_stats(os, ost, frame_size);
1356
                            break;
1357
                        case CODEC_TYPE_SUBTITLE:
1358
                            do_subtitle_out(os, ost, ist, &subtitle,
1359
                                            pkt->pts);
1360
                            break;
1361
                        default:
1362
                            abort();
1363
                        }
1364
                    } else {
1365
                        AVFrame avframe; //FIXME/XXX remove this
1366
                        AVPacket opkt;
1367
                        av_init_packet(&opkt);
1368

    
1369
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1370
                            continue;
1371

    
1372
                        /* no reencoding needed : output the packet directly */
1373
                        /* force the input stream PTS */
1374

    
1375
                        avcodec_get_frame_defaults(&avframe);
1376
                        ost->st->codec->coded_frame= &avframe;
1377
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1378

    
1379
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1380
                            audio_size += data_size;
1381
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1382
                            video_size += data_size;
1383
                            ost->sync_opts++;
1384
                        }
1385

    
1386
                        opkt.stream_index= ost->index;
1387
                        if(pkt->pts != AV_NOPTS_VALUE)
1388
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1389
                        else
1390
                            opkt.pts= AV_NOPTS_VALUE;
1391

    
1392
                        if (pkt->dts == AV_NOPTS_VALUE)
1393
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1394
                        else
1395
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1396

    
1397
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1398
                        opkt.flags= pkt->flags;
1399

    
1400
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1401
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1402
                            opkt.destruct= av_destruct_packet;
1403

    
1404
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1405
                        ost->st->codec->frame_number++;
1406
                        ost->frame_number++;
1407
                        av_free_packet(&opkt);
1408
                    }
1409
                }
1410
            }
1411
        av_free(buffer_to_free);
1412
        /* XXX: allocate the subtitles in the codec ? */
1413
        if (subtitle_to_free) {
1414
            if (subtitle_to_free->rects != NULL) {
1415
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1416
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1417
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1418
                    av_freep(&subtitle_to_free->rects[i]);
1419
                }
1420
                av_freep(&subtitle_to_free->rects);
1421
            }
1422
            subtitle_to_free->num_rects = 0;
1423
            subtitle_to_free = NULL;
1424
        }
1425
    }
1426
 discard_packet:
1427
    if (pkt == NULL) {
1428
        /* EOF handling */
1429

    
1430
        for(i=0;i<nb_ostreams;i++) {
1431
            ost = ost_table[i];
1432
            if (ost->source_index == ist_index) {
1433
                AVCodecContext *enc= ost->st->codec;
1434
                os = output_files[ost->file_index];
1435

    
1436
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1437
                    continue;
1438
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1439
                    continue;
1440

    
1441
                if (ost->encoding_needed) {
1442
                    for(;;) {
1443
                        AVPacket pkt;
1444
                        int fifo_bytes;
1445
                        av_init_packet(&pkt);
1446
                        pkt.stream_index= ost->index;
1447

    
1448
                        switch(ost->st->codec->codec_type) {
1449
                        case CODEC_TYPE_AUDIO:
1450
                            fifo_bytes = av_fifo_size(ost->fifo);
1451
                            ret = 0;
1452
                            /* encode any samples remaining in fifo */
1453
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1454
                                int fs_tmp = enc->frame_size;
1455
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1456
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1457
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1458
                                enc->frame_size = fs_tmp;
1459
                            }
1460
                            if(ret <= 0) {
1461
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1462
                            }
1463
                            if (ret < 0) {
1464
                                fprintf(stderr, "Audio encoding failed\n");
1465
                                av_exit(1);
1466
                            }
1467
                            audio_size += ret;
1468
                            pkt.flags |= PKT_FLAG_KEY;
1469
                            break;
1470
                        case CODEC_TYPE_VIDEO:
1471
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1472
                            if (ret < 0) {
1473
                                fprintf(stderr, "Video encoding failed\n");
1474
                                av_exit(1);
1475
                            }
1476
                            video_size += ret;
1477
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1478
                                pkt.flags |= PKT_FLAG_KEY;
1479
                            if (ost->logfile && enc->stats_out) {
1480
                                fprintf(ost->logfile, "%s", enc->stats_out);
1481
                            }
1482
                            break;
1483
                        default:
1484
                            ret=-1;
1485
                        }
1486

    
1487
                        if(ret<=0)
1488
                            break;
1489
                        pkt.data= bit_buffer;
1490
                        pkt.size= ret;
1491
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1492
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1493
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1494
                    }
1495
                }
1496
            }
1497
        }
1498
    }
1499

    
1500
    return 0;
1501
 fail_decode:
1502
    return -1;
1503
}
1504

    
1505
static void print_sdp(AVFormatContext **avc, int n)
1506
{
1507
    char sdp[2048];
1508

    
1509
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1510
    printf("SDP:\n%s\n", sdp);
1511
    fflush(stdout);
1512
}
1513

    
1514
static int stream_index_from_inputs(AVFormatContext **input_files,
1515
                                    int nb_input_files,
1516
                                    AVInputFile *file_table,
1517
                                    AVInputStream **ist_table,
1518
                                    enum CodecType type,
1519
                                    int programid)
1520
{
1521
    int p, q, z;
1522
    for(z=0; z<nb_input_files; z++) {
1523
        AVFormatContext *ic = input_files[z];
1524
        for(p=0; p<ic->nb_programs; p++) {
1525
            AVProgram *program = ic->programs[p];
1526
            if(program->id != programid)
1527
                continue;
1528
            for(q=0; q<program->nb_stream_indexes; q++) {
1529
                int sidx = program->stream_index[q];
1530
                int ris = file_table[z].ist_index + sidx;
1531
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1532
                    return ris;
1533
            }
1534
        }
1535
    }
1536

    
1537
    return -1;
1538
}
1539

    
1540
/*
1541
 * The following code is the main loop of the file converter
1542
 */
1543
static int av_encode(AVFormatContext **output_files,
1544
                     int nb_output_files,
1545
                     AVFormatContext **input_files,
1546
                     int nb_input_files,
1547
                     AVStreamMap *stream_maps, int nb_stream_maps)
1548
{
1549
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1550
    AVFormatContext *is, *os;
1551
    AVCodecContext *codec, *icodec;
1552
    AVOutputStream *ost, **ost_table = NULL;
1553
    AVInputStream *ist, **ist_table = NULL;
1554
    AVInputFile *file_table;
1555
    char error[1024];
1556
    int key;
1557
    int want_sdp = 1;
1558
    uint8_t no_packet[MAX_FILES]={0};
1559
    int no_packet_count=0;
1560

    
1561
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1562
    if (!file_table)
1563
        goto fail;
1564

    
1565
    /* input stream init */
1566
    j = 0;
1567
    for(i=0;i<nb_input_files;i++) {
1568
        is = input_files[i];
1569
        file_table[i].ist_index = j;
1570
        file_table[i].nb_streams = is->nb_streams;
1571
        j += is->nb_streams;
1572
    }
1573
    nb_istreams = j;
1574

    
1575
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1576
    if (!ist_table)
1577
        goto fail;
1578

    
1579
    for(i=0;i<nb_istreams;i++) {
1580
        ist = av_mallocz(sizeof(AVInputStream));
1581
        if (!ist)
1582
            goto fail;
1583
        ist_table[i] = ist;
1584
    }
1585
    j = 0;
1586
    for(i=0;i<nb_input_files;i++) {
1587
        is = input_files[i];
1588
        for(k=0;k<is->nb_streams;k++) {
1589
            ist = ist_table[j++];
1590
            ist->st = is->streams[k];
1591
            ist->file_index = i;
1592
            ist->index = k;
1593
            ist->discard = 1; /* the stream is discarded by default
1594
                                 (changed later) */
1595

    
1596
            if (rate_emu) {
1597
                ist->start = av_gettime();
1598
            }
1599
        }
1600
    }
1601

    
1602
    /* output stream init */
1603
    nb_ostreams = 0;
1604
    for(i=0;i<nb_output_files;i++) {
1605
        os = output_files[i];
1606
        if (!os->nb_streams) {
1607
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1608
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1609
            av_exit(1);
1610
        }
1611
        nb_ostreams += os->nb_streams;
1612
    }
1613
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1614
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1615
        av_exit(1);
1616
    }
1617

    
1618
    /* Sanity check the mapping args -- do the input files & streams exist? */
1619
    for(i=0;i<nb_stream_maps;i++) {
1620
        int fi = stream_maps[i].file_index;
1621
        int si = stream_maps[i].stream_index;
1622

    
1623
        if (fi < 0 || fi > nb_input_files - 1 ||
1624
            si < 0 || si > file_table[fi].nb_streams - 1) {
1625
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1626
            av_exit(1);
1627
        }
1628
        fi = stream_maps[i].sync_file_index;
1629
        si = stream_maps[i].sync_stream_index;
1630
        if (fi < 0 || fi > nb_input_files - 1 ||
1631
            si < 0 || si > file_table[fi].nb_streams - 1) {
1632
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1633
            av_exit(1);
1634
        }
1635
    }
1636

    
1637
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1638
    if (!ost_table)
1639
        goto fail;
1640
    for(i=0;i<nb_ostreams;i++) {
1641
        ost = av_mallocz(sizeof(AVOutputStream));
1642
        if (!ost)
1643
            goto fail;
1644
        ost_table[i] = ost;
1645
    }
1646

    
1647
    n = 0;
1648
    for(k=0;k<nb_output_files;k++) {
1649
        os = output_files[k];
1650
        for(i=0;i<os->nb_streams;i++,n++) {
1651
            int found;
1652
            ost = ost_table[n];
1653
            ost->file_index = k;
1654
            ost->index = i;
1655
            ost->st = os->streams[i];
1656
            if (nb_stream_maps > 0) {
1657
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1658
                    stream_maps[n].stream_index;
1659

    
1660
                /* Sanity check that the stream types match */
1661
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1662
                    int i= ost->file_index;
1663
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1664
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1665
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1666
                        ost->file_index, ost->index);
1667
                    av_exit(1);
1668
                }
1669

    
1670
            } else {
1671
                if(opt_programid) {
1672
                    found = 0;
1673
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1674
                    if(j != -1) {
1675
                        ost->source_index = j;
1676
                        found = 1;
1677
                    }
1678
                } else {
1679
                    /* get corresponding input stream index : we select the first one with the right type */
1680
                    found = 0;
1681
                    for(j=0;j<nb_istreams;j++) {
1682
                        ist = ist_table[j];
1683
                        if (ist->discard &&
1684
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1685
                            ost->source_index = j;
1686
                            found = 1;
1687
                            break;
1688
                        }
1689
                    }
1690
                }
1691

    
1692
                if (!found) {
1693
                    if(! opt_programid) {
1694
                        /* try again and reuse existing stream */
1695
                        for(j=0;j<nb_istreams;j++) {
1696
                            ist = ist_table[j];
1697
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1698
                                ost->source_index = j;
1699
                                found = 1;
1700
                            }
1701
                        }
1702
                    }
1703
                    if (!found) {
1704
                        int i= ost->file_index;
1705
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1706
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1707
                                ost->file_index, ost->index);
1708
                        av_exit(1);
1709
                    }
1710
                }
1711
            }
1712
            ist = ist_table[ost->source_index];
1713
            ist->discard = 0;
1714
            ost->sync_ist = (nb_stream_maps > 0) ?
1715
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1716
                         stream_maps[n].sync_stream_index] : ist;
1717
        }
1718
    }
1719

    
1720
    /* for each output stream, we compute the right encoding parameters */
1721
    for(i=0;i<nb_ostreams;i++) {
1722
        AVMetadataTag *lang;
1723
        ost = ost_table[i];
1724
        os = output_files[ost->file_index];
1725
        ist = ist_table[ost->source_index];
1726

    
1727
        codec = ost->st->codec;
1728
        icodec = ist->st->codec;
1729

    
1730
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1731
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1732
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1733

    
1734
        ost->st->disposition = ist->st->disposition;
1735

    
1736
        if (ost->st->stream_copy) {
1737
            /* if stream_copy is selected, no need to decode or encode */
1738
            codec->codec_id = icodec->codec_id;
1739
            codec->codec_type = icodec->codec_type;
1740

    
1741
            if(!codec->codec_tag){
1742
                if(   !os->oformat->codec_tag
1743
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1744
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1745
                    codec->codec_tag = icodec->codec_tag;
1746
            }
1747

    
1748
            codec->bit_rate = icodec->bit_rate;
1749
            codec->extradata= icodec->extradata;
1750
            codec->extradata_size= icodec->extradata_size;
1751
            if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1752
                codec->time_base = icodec->time_base;
1753
                codec->time_base.num *= icodec->ticks_per_frame;
1754
            }else
1755
                codec->time_base = ist->st->time_base;
1756
            switch(codec->codec_type) {
1757
            case CODEC_TYPE_AUDIO:
1758
                if(audio_volume != 256) {
1759
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1760
                    av_exit(1);
1761
                }
1762
                codec->channel_layout = icodec->channel_layout;
1763
                codec->sample_rate = icodec->sample_rate;
1764
                codec->channels = icodec->channels;
1765
                codec->frame_size = icodec->frame_size;
1766
                codec->block_align= icodec->block_align;
1767
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1768
                    codec->block_align= 0;
1769
                if(codec->codec_id == CODEC_ID_AC3)
1770
                    codec->block_align= 0;
1771
                break;
1772
            case CODEC_TYPE_VIDEO:
1773
                codec->pix_fmt = icodec->pix_fmt;
1774
                codec->width = icodec->width;
1775
                codec->height = icodec->height;
1776
                codec->has_b_frames = icodec->has_b_frames;
1777
                break;
1778
            case CODEC_TYPE_SUBTITLE:
1779
                codec->width = icodec->width;
1780
                codec->height = icodec->height;
1781
                break;
1782
            default:
1783
                abort();
1784
            }
1785
        } else {
1786
            switch(codec->codec_type) {
1787
            case CODEC_TYPE_AUDIO:
1788
                ost->fifo= av_fifo_alloc(1024);
1789
                if(!ost->fifo)
1790
                    goto fail;
1791
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1792
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1793
                icodec->request_channels = codec->channels;
1794
                ist->decoding_needed = 1;
1795
                ost->encoding_needed = 1;
1796
                break;
1797
            case CODEC_TYPE_VIDEO:
1798
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1799
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1800
                ost->video_resample = ((codec->width != icodec->width -
1801
                                (frame_leftBand + frame_rightBand) +
1802
                                (frame_padleft + frame_padright)) ||
1803
                        (codec->height != icodec->height -
1804
                                (frame_topBand  + frame_bottomBand) +
1805
                                (frame_padtop + frame_padbottom)) ||
1806
                        (codec->pix_fmt != icodec->pix_fmt));
1807
                if (ost->video_crop) {
1808
                    ost->topBand = frame_topBand;
1809
                    ost->leftBand = frame_leftBand;
1810
                }
1811
                if (ost->video_pad) {
1812
                    ost->padtop = frame_padtop;
1813
                    ost->padleft = frame_padleft;
1814
                    ost->padbottom = frame_padbottom;
1815
                    ost->padright = frame_padright;
1816
                    if (!ost->video_resample) {
1817
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1818
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1819
                                         codec->width, codec->height))
1820
                            goto fail;
1821
                    }
1822
                }
1823
                if (ost->video_resample) {
1824
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1825
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1826
                                         codec->width, codec->height)) {
1827
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1828
                        av_exit(1);
1829
                    }
1830
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1831
                    ost->img_resample_ctx = sws_getContext(
1832
                            icodec->width - (frame_leftBand + frame_rightBand),
1833
                            icodec->height - (frame_topBand + frame_bottomBand),
1834
                            icodec->pix_fmt,
1835
                            codec->width - (frame_padleft + frame_padright),
1836
                            codec->height - (frame_padtop + frame_padbottom),
1837
                            codec->pix_fmt,
1838
                            sws_flags, NULL, NULL, NULL);
1839
                    if (ost->img_resample_ctx == NULL) {
1840
                        fprintf(stderr, "Cannot get resampling context\n");
1841
                        av_exit(1);
1842
                    }
1843
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1844
                }
1845
                ost->encoding_needed = 1;
1846
                ist->decoding_needed = 1;
1847
                break;
1848
            case CODEC_TYPE_SUBTITLE:
1849
                ost->encoding_needed = 1;
1850
                ist->decoding_needed = 1;
1851
                break;
1852
            default:
1853
                abort();
1854
                break;
1855
            }
1856
            /* two pass mode */
1857
            if (ost->encoding_needed &&
1858
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1859
                char logfilename[1024];
1860
                FILE *f;
1861
                int size;
1862
                char *logbuffer;
1863

    
1864
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1865
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1866
                         i);
1867
                if (codec->flags & CODEC_FLAG_PASS1) {
1868
                    f = fopen(logfilename, "w");
1869
                    if (!f) {
1870
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1871
                        av_exit(1);
1872
                    }
1873
                    ost->logfile = f;
1874
                } else {
1875
                    /* read the log file */
1876
                    f = fopen(logfilename, "r");
1877
                    if (!f) {
1878
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1879
                        av_exit(1);
1880
                    }
1881
                    fseek(f, 0, SEEK_END);
1882
                    size = ftell(f);
1883
                    fseek(f, 0, SEEK_SET);
1884
                    logbuffer = av_malloc(size + 1);
1885
                    if (!logbuffer) {
1886
                        fprintf(stderr, "Could not allocate log buffer\n");
1887
                        av_exit(1);
1888
                    }
1889
                    size = fread(logbuffer, 1, size, f);
1890
                    fclose(f);
1891
                    logbuffer[size] = '\0';
1892
                    codec->stats_in = logbuffer;
1893
                }
1894
            }
1895
        }
1896
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1897
            int size= codec->width * codec->height;
1898
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1899
        }
1900
    }
1901

    
1902
    if (!bit_buffer)
1903
        bit_buffer = av_malloc(bit_buffer_size);
1904
    if (!bit_buffer) {
1905
        ret = AVERROR(ENOMEM);
1906
        goto fail;
1907
    }
1908

    
1909
    /* open each encoder */
1910
    for(i=0;i<nb_ostreams;i++) {
1911
        ost = ost_table[i];
1912
        if (ost->encoding_needed) {
1913
            AVCodec *codec = output_codecs[i];
1914
            if (!codec)
1915
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1916
            if (!codec) {
1917
                snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1918
                        ost->file_index, ost->index);
1919
                ret = AVERROR(EINVAL);
1920
                goto dump_format;
1921
            }
1922
            if (avcodec_open(ost->st->codec, codec) < 0) {
1923
                snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1924
                        ost->file_index, ost->index);
1925
                ret = AVERROR(EINVAL);
1926
                goto dump_format;
1927
            }
1928
            extra_size += ost->st->codec->extradata_size;
1929
        }
1930
    }
1931

    
1932
    /* open each decoder */
1933
    for(i=0;i<nb_istreams;i++) {
1934
        ist = ist_table[i];
1935
        if (ist->decoding_needed) {
1936
            AVCodec *codec = input_codecs[i];
1937
            if (!codec)
1938
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1939
            if (!codec) {
1940
                snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1941
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1942
                ret = AVERROR(EINVAL);
1943
                goto dump_format;
1944
            }
1945
            if (avcodec_open(ist->st->codec, codec) < 0) {
1946
                snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1947
                        ist->file_index, ist->index);
1948
                ret = AVERROR(EINVAL);
1949
                goto dump_format;
1950
            }
1951
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1952
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1953
        }
1954
    }
1955

    
1956
    /* init pts */
1957
    for(i=0;i<nb_istreams;i++) {
1958
        ist = ist_table[i];
1959
        is = input_files[ist->file_index];
1960
        ist->pts = 0;
1961
        ist->next_pts = AV_NOPTS_VALUE;
1962
        ist->is_start = 1;
1963
    }
1964

    
1965
    /* set meta data information from input file if required */
1966
    for (i=0;i<nb_meta_data_maps;i++) {
1967
        AVFormatContext *out_file;
1968
        AVFormatContext *in_file;
1969
        AVMetadataTag *mtag;
1970

    
1971
        int out_file_index = meta_data_maps[i].out_file;
1972
        int in_file_index = meta_data_maps[i].in_file;
1973
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1974
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1975
                     out_file_index, out_file_index, in_file_index);
1976
            ret = AVERROR(EINVAL);
1977
            goto dump_format;
1978
        }
1979
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1980
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1981
                     in_file_index, out_file_index, in_file_index);
1982
            ret = AVERROR(EINVAL);
1983
            goto dump_format;
1984
        }
1985

    
1986
        out_file = output_files[out_file_index];
1987
        in_file = input_files[in_file_index];
1988

    
1989

    
1990
        mtag=NULL;
1991
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
1992
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
1993
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
1994
                                    in_file->iformat->metadata_conv);
1995
    }
1996

    
1997
    /* open files and write file headers */
1998
    for(i=0;i<nb_output_files;i++) {
1999
        os = output_files[i];
2000
        if (av_write_header(os) < 0) {
2001
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2002
            ret = AVERROR(EINVAL);
2003
            goto dump_format;
2004
        }
2005
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2006
            want_sdp = 0;
2007
        }
2008
    }
2009

    
2010
 dump_format:
2011
    /* dump the file output parameters - cannot be done before in case
2012
       of stream copy */
2013
    for(i=0;i<nb_output_files;i++) {
2014
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2015
    }
2016

    
2017
    /* dump the stream mapping */
2018
    if (verbose >= 0) {
2019
        fprintf(stderr, "Stream mapping:\n");
2020
        for(i=0;i<nb_ostreams;i++) {
2021
            ost = ost_table[i];
2022
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2023
                    ist_table[ost->source_index]->file_index,
2024
                    ist_table[ost->source_index]->index,
2025
                    ost->file_index,
2026
                    ost->index);
2027
            if (ost->sync_ist != ist_table[ost->source_index])
2028
                fprintf(stderr, " [sync #%d.%d]",
2029
                        ost->sync_ist->file_index,
2030
                        ost->sync_ist->index);
2031
            fprintf(stderr, "\n");
2032
        }
2033
    }
2034

    
2035
    if (ret) {
2036
        fprintf(stderr, "%s\n", error);
2037
        goto fail;
2038
    }
2039

    
2040
    if (want_sdp) {
2041
        print_sdp(output_files, nb_output_files);
2042
    }
2043

    
2044
    if (!using_stdin && verbose >= 0) {
2045
        fprintf(stderr, "Press [q] to stop encoding\n");
2046
        url_set_interrupt_cb(decode_interrupt_cb);
2047
    }
2048
    term_init();
2049

    
2050
    key = -1;
2051
    timer_start = av_gettime();
2052

    
2053
    for(; received_sigterm == 0;) {
2054
        int file_index, ist_index;
2055
        AVPacket pkt;
2056
        double ipts_min;
2057
        double opts_min;
2058

    
2059
    redo:
2060
        ipts_min= 1e100;
2061
        opts_min= 1e100;
2062
        /* if 'q' pressed, exits */
2063
        if (!using_stdin) {
2064
            if (q_pressed)
2065
                break;
2066
            /* read_key() returns 0 on EOF */
2067
            key = read_key();
2068
            if (key == 'q')
2069
                break;
2070
        }
2071

    
2072
        /* select the stream that we must read now by looking at the
2073
           smallest output pts */
2074
        file_index = -1;
2075
        for(i=0;i<nb_ostreams;i++) {
2076
            double ipts, opts;
2077
            ost = ost_table[i];
2078
            os = output_files[ost->file_index];
2079
            ist = ist_table[ost->source_index];
2080
            if(no_packet[ist->file_index])
2081
                continue;
2082
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2083
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2084
            else
2085
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2086
            ipts = (double)ist->pts;
2087
            if (!file_table[ist->file_index].eof_reached){
2088
                if(ipts < ipts_min) {
2089
                    ipts_min = ipts;
2090
                    if(input_sync ) file_index = ist->file_index;
2091
                }
2092
                if(opts < opts_min) {
2093
                    opts_min = opts;
2094
                    if(!input_sync) file_index = ist->file_index;
2095
                }
2096
            }
2097
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2098
                file_index= -1;
2099
                break;
2100
            }
2101
        }
2102
        /* if none, if is finished */
2103
        if (file_index < 0) {
2104
            if(no_packet_count){
2105
                no_packet_count=0;
2106
                memset(no_packet, 0, sizeof(no_packet));
2107
                usleep(10000);
2108
                continue;
2109
            }
2110
            break;
2111
        }
2112

    
2113
        /* finish if recording time exhausted */
2114
        if (opts_min >= (recording_time / 1000000.0))
2115
            break;
2116

    
2117
        /* finish if limit size exhausted */
2118
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2119
            break;
2120

    
2121
        /* read a frame from it and output it in the fifo */
2122
        is = input_files[file_index];
2123
        ret= av_read_frame(is, &pkt);
2124
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm")){
2125
            no_packet[file_index]=1;
2126
            no_packet_count++;
2127
            continue;
2128
        }
2129
        if (ret < 0) {
2130
            file_table[file_index].eof_reached = 1;
2131
            if (opt_shortest)
2132
                break;
2133
            else
2134
                continue;
2135
        }
2136

    
2137
        no_packet_count=0;
2138
        memset(no_packet, 0, sizeof(no_packet));
2139

    
2140
        if (do_pkt_dump) {
2141
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2142
        }
2143
        /* the following test is needed in case new streams appear
2144
           dynamically in stream : we ignore them */
2145
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2146
            goto discard_packet;
2147
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2148
        ist = ist_table[ist_index];
2149
        if (ist->discard)
2150
            goto discard_packet;
2151

    
2152
        if (pkt.dts != AV_NOPTS_VALUE)
2153
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2154
        if (pkt.pts != AV_NOPTS_VALUE)
2155
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2156

    
2157
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2158
            if(pkt.pts != AV_NOPTS_VALUE)
2159
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2160
            if(pkt.dts != AV_NOPTS_VALUE)
2161
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2162
        }
2163

    
2164
//        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);
2165
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2166
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2167
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2168
            int64_t delta= pkt_dts - ist->next_pts;
2169
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2170
                input_files_ts_offset[ist->file_index]-= delta;
2171
                if (verbose > 2)
2172
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2173
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2174
                if(pkt.pts != AV_NOPTS_VALUE)
2175
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2176
            }
2177
        }
2178

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

    
2182
            if (verbose >= 0)
2183
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2184
                        ist->file_index, ist->index);
2185
            if (exit_on_error)
2186
                av_exit(1);
2187
            av_free_packet(&pkt);
2188
            goto redo;
2189
        }
2190

    
2191
    discard_packet:
2192
        av_free_packet(&pkt);
2193

    
2194
        /* dump report by using the output first video and audio streams */
2195
        print_report(output_files, ost_table, nb_ostreams, 0);
2196
    }
2197

    
2198
    /* at the end of stream, we must flush the decoder buffers */
2199
    for(i=0;i<nb_istreams;i++) {
2200
        ist = ist_table[i];
2201
        if (ist->decoding_needed) {
2202
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2203
        }
2204
    }
2205

    
2206
    term_exit();
2207

    
2208
    /* write the trailer if needed and close file */
2209
    for(i=0;i<nb_output_files;i++) {
2210
        os = output_files[i];
2211
        av_write_trailer(os);
2212
    }
2213

    
2214
    /* dump report by using the first video and audio streams */
2215
    print_report(output_files, ost_table, nb_ostreams, 1);
2216

    
2217
    /* close each encoder */
2218
    for(i=0;i<nb_ostreams;i++) {
2219
        ost = ost_table[i];
2220
        if (ost->encoding_needed) {
2221
            av_freep(&ost->st->codec->stats_in);
2222
            avcodec_close(ost->st->codec);
2223
        }
2224
    }
2225

    
2226
    /* close each decoder */
2227
    for(i=0;i<nb_istreams;i++) {
2228
        ist = ist_table[i];
2229
        if (ist->decoding_needed) {
2230
            avcodec_close(ist->st->codec);
2231
        }
2232
    }
2233

    
2234
    /* finished ! */
2235
    ret = 0;
2236

    
2237
 fail:
2238
    av_freep(&bit_buffer);
2239
    av_free(file_table);
2240

    
2241
    if (ist_table) {
2242
        for(i=0;i<nb_istreams;i++) {
2243
            ist = ist_table[i];
2244
            av_free(ist);
2245
        }
2246
        av_free(ist_table);
2247
    }
2248
    if (ost_table) {
2249
        for(i=0;i<nb_ostreams;i++) {
2250
            ost = ost_table[i];
2251
            if (ost) {
2252
                if (ost->logfile) {
2253
                    fclose(ost->logfile);
2254
                    ost->logfile = NULL;
2255
                }
2256
                av_fifo_free(ost->fifo); /* works even if fifo is not
2257
                                             initialized but set to zero */
2258
                av_free(ost->pict_tmp.data[0]);
2259
                if (ost->video_resample)
2260
                    sws_freeContext(ost->img_resample_ctx);
2261
                if (ost->resample)
2262
                    audio_resample_close(ost->resample);
2263
                if (ost->reformat_ctx)
2264
                    av_audio_convert_free(ost->reformat_ctx);
2265
                av_free(ost);
2266
            }
2267
        }
2268
        av_free(ost_table);
2269
    }
2270
    return ret;
2271
}
2272

    
2273
#if 0
2274
int file_read(const char *filename)
2275
{
2276
    URLContext *h;
2277
    unsigned char buffer[1024];
2278
    int len, i;
2279

2280
    if (url_open(&h, filename, O_RDONLY) < 0) {
2281
        printf("could not open '%s'\n", filename);
2282
        return -1;
2283
    }
2284
    for(;;) {
2285
        len = url_read(h, buffer, sizeof(buffer));
2286
        if (len <= 0)
2287
            break;
2288
        for(i=0;i<len;i++) putchar(buffer[i]);
2289
    }
2290
    url_close(h);
2291
    return 0;
2292
}
2293
#endif
2294

    
2295
static void opt_format(const char *arg)
2296
{
2297
    /* compatibility stuff for pgmyuv */
2298
    if (!strcmp(arg, "pgmyuv")) {
2299
        pgmyuv_compatibility_hack=1;
2300
//        opt_image_format(arg);
2301
        arg = "image2";
2302
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2303
    }
2304

    
2305
    file_iformat = av_find_input_format(arg);
2306
    file_oformat = guess_format(arg, NULL, NULL);
2307
    if (!file_iformat && !file_oformat) {
2308
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2309
        av_exit(1);
2310
    }
2311
}
2312

    
2313
static void opt_video_rc_override_string(const char *arg)
2314
{
2315
    video_rc_override_string = arg;
2316
}
2317

    
2318
static int opt_me_threshold(const char *opt, const char *arg)
2319
{
2320
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2321
    return 0;
2322
}
2323

    
2324
static void opt_loglevel(const char *opt, const char *arg)
2325
{
2326
    int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2327
    av_log_set_level(level);
2328
}
2329

    
2330
static int opt_verbose(const char *opt, const char *arg)
2331
{
2332
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2333
    return 0;
2334
}
2335

    
2336
static int opt_frame_rate(const char *opt, const char *arg)
2337
{
2338
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2339
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2340
        av_exit(1);
2341
    }
2342
    return 0;
2343
}
2344

    
2345
static int opt_bitrate(const char *opt, const char *arg)
2346
{
2347
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2348

    
2349
    opt_default(opt, arg);
2350

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

    
2354
    return 0;
2355
}
2356

    
2357
static void opt_frame_crop_top(const char *arg)
2358
{
2359
    frame_topBand = atoi(arg);
2360
    if (frame_topBand < 0) {
2361
        fprintf(stderr, "Incorrect top crop size\n");
2362
        av_exit(1);
2363
    }
2364
    if ((frame_topBand % 2) != 0) {
2365
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2366
        av_exit(1);
2367
    }
2368
    if ((frame_topBand) >= frame_height){
2369
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2370
        av_exit(1);
2371
    }
2372
    frame_height -= frame_topBand;
2373
}
2374

    
2375
static void opt_frame_crop_bottom(const char *arg)
2376
{
2377
    frame_bottomBand = atoi(arg);
2378
    if (frame_bottomBand < 0) {
2379
        fprintf(stderr, "Incorrect bottom crop size\n");
2380
        av_exit(1);
2381
    }
2382
    if ((frame_bottomBand % 2) != 0) {
2383
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2384
        av_exit(1);
2385
    }
2386
    if ((frame_bottomBand) >= frame_height){
2387
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2388
        av_exit(1);
2389
    }
2390
    frame_height -= frame_bottomBand;
2391
}
2392

    
2393
static void opt_frame_crop_left(const char *arg)
2394
{
2395
    frame_leftBand = atoi(arg);
2396
    if (frame_leftBand < 0) {
2397
        fprintf(stderr, "Incorrect left crop size\n");
2398
        av_exit(1);
2399
    }
2400
    if ((frame_leftBand % 2) != 0) {
2401
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2402
        av_exit(1);
2403
    }
2404
    if ((frame_leftBand) >= frame_width){
2405
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2406
        av_exit(1);
2407
    }
2408
    frame_width -= frame_leftBand;
2409
}
2410

    
2411
static void opt_frame_crop_right(const char *arg)
2412
{
2413
    frame_rightBand = atoi(arg);
2414
    if (frame_rightBand < 0) {
2415
        fprintf(stderr, "Incorrect right crop size\n");
2416
        av_exit(1);
2417
    }
2418
    if ((frame_rightBand % 2) != 0) {
2419
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2420
        av_exit(1);
2421
    }
2422
    if ((frame_rightBand) >= frame_width){
2423
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2424
        av_exit(1);
2425
    }
2426
    frame_width -= frame_rightBand;
2427
}
2428

    
2429
static void opt_frame_size(const char *arg)
2430
{
2431
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2432
        fprintf(stderr, "Incorrect frame size\n");
2433
        av_exit(1);
2434
    }
2435
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2436
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2437
        av_exit(1);
2438
    }
2439
}
2440

    
2441

    
2442
#define SCALEBITS 10
2443
#define ONE_HALF  (1 << (SCALEBITS - 1))
2444
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2445

    
2446
#define RGB_TO_Y(r, g, b) \
2447
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2448
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2449

    
2450
#define RGB_TO_U(r1, g1, b1, shift)\
2451
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2452
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2453

    
2454
#define RGB_TO_V(r1, g1, b1, shift)\
2455
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2456
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2457

    
2458
static void opt_pad_color(const char *arg) {
2459
    /* Input is expected to be six hex digits similar to
2460
       how colors are expressed in html tags (but without the #) */
2461
    int rgb = strtol(arg, NULL, 16);
2462
    int r,g,b;
2463

    
2464
    r = (rgb >> 16);
2465
    g = ((rgb >> 8) & 255);
2466
    b = (rgb & 255);
2467

    
2468
    padcolor[0] = RGB_TO_Y(r,g,b);
2469
    padcolor[1] = RGB_TO_U(r,g,b,0);
2470
    padcolor[2] = RGB_TO_V(r,g,b,0);
2471
}
2472

    
2473
static void opt_frame_pad_top(const char *arg)
2474
{
2475
    frame_padtop = atoi(arg);
2476
    if (frame_padtop < 0) {
2477
        fprintf(stderr, "Incorrect top pad size\n");
2478
        av_exit(1);
2479
    }
2480
    if ((frame_padtop % 2) != 0) {
2481
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2482
        av_exit(1);
2483
    }
2484
}
2485

    
2486
static void opt_frame_pad_bottom(const char *arg)
2487
{
2488
    frame_padbottom = atoi(arg);
2489
    if (frame_padbottom < 0) {
2490
        fprintf(stderr, "Incorrect bottom pad size\n");
2491
        av_exit(1);
2492
    }
2493
    if ((frame_padbottom % 2) != 0) {
2494
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2495
        av_exit(1);
2496
    }
2497
}
2498

    
2499

    
2500
static void opt_frame_pad_left(const char *arg)
2501
{
2502
    frame_padleft = atoi(arg);
2503
    if (frame_padleft < 0) {
2504
        fprintf(stderr, "Incorrect left pad size\n");
2505
        av_exit(1);
2506
    }
2507
    if ((frame_padleft % 2) != 0) {
2508
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2509
        av_exit(1);
2510
    }
2511
}
2512

    
2513

    
2514
static void opt_frame_pad_right(const char *arg)
2515
{
2516
    frame_padright = atoi(arg);
2517
    if (frame_padright < 0) {
2518
        fprintf(stderr, "Incorrect right pad size\n");
2519
        av_exit(1);
2520
    }
2521
    if ((frame_padright % 2) != 0) {
2522
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2523
        av_exit(1);
2524
    }
2525
}
2526

    
2527
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2528
{
2529
    int i;
2530
    char fmt_str[128];
2531
    for (i=-1; i < nb_fmts; i++) {
2532
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2533
        fprintf(stdout, "%s\n", fmt_str);
2534
    }
2535
}
2536

    
2537
static void opt_frame_pix_fmt(const char *arg)
2538
{
2539
    if (strcmp(arg, "list")) {
2540
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2541
        if (frame_pix_fmt == PIX_FMT_NONE) {
2542
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2543
            av_exit(1);
2544
        }
2545
    } else {
2546
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2547
        av_exit(0);
2548
    }
2549
}
2550

    
2551
static void opt_frame_aspect_ratio(const char *arg)
2552
{
2553
    int x = 0, y = 0;
2554
    double ar = 0;
2555
    const char *p;
2556
    char *end;
2557

    
2558
    p = strchr(arg, ':');
2559
    if (p) {
2560
        x = strtol(arg, &end, 10);
2561
        if (end == p)
2562
            y = strtol(end+1, &end, 10);
2563
        if (x > 0 && y > 0)
2564
            ar = (double)x / (double)y;
2565
    } else
2566
        ar = strtod(arg, NULL);
2567

    
2568
    if (!ar) {
2569
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2570
        av_exit(1);
2571
    }
2572
    frame_aspect_ratio = ar;
2573
}
2574

    
2575
static int opt_metadata(const char *opt, const char *arg)
2576
{
2577
    char *mid= strchr(arg, '=');
2578

    
2579
    if(!mid){
2580
        fprintf(stderr, "Missing =\n");
2581
        av_exit(1);
2582
    }
2583
    *mid++= 0;
2584

    
2585
    metadata_count++;
2586
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2587
    metadata[metadata_count-1].key  = av_strdup(arg);
2588
    metadata[metadata_count-1].value= av_strdup(mid);
2589

    
2590
    return 0;
2591
}
2592

    
2593
static void opt_qscale(const char *arg)
2594
{
2595
    video_qscale = atof(arg);
2596
    if (video_qscale <= 0 ||
2597
        video_qscale > 255) {
2598
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2599
        av_exit(1);
2600
    }
2601
}
2602

    
2603
static void opt_top_field_first(const char *arg)
2604
{
2605
    top_field_first= atoi(arg);
2606
}
2607

    
2608
static int opt_thread_count(const char *opt, const char *arg)
2609
{
2610
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2611
#if !HAVE_THREADS
2612
    if (verbose >= 0)
2613
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2614
#endif
2615
    return 0;
2616
}
2617

    
2618
static void opt_audio_sample_fmt(const char *arg)
2619
{
2620
    if (strcmp(arg, "list"))
2621
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2622
    else {
2623
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2624
        av_exit(0);
2625
    }
2626
}
2627

    
2628
static int opt_audio_rate(const char *opt, const char *arg)
2629
{
2630
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2631
    return 0;
2632
}
2633

    
2634
static int opt_audio_channels(const char *opt, const char *arg)
2635
{
2636
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2637
    return 0;
2638
}
2639

    
2640
static void opt_video_channel(const char *arg)
2641
{
2642
    video_channel = strtol(arg, NULL, 0);
2643
}
2644

    
2645
static void opt_video_standard(const char *arg)
2646
{
2647
    video_standard = av_strdup(arg);
2648
}
2649

    
2650
static void opt_codec(int *pstream_copy, char **pcodec_name,
2651
                      int codec_type, const char *arg)
2652
{
2653
    av_freep(pcodec_name);
2654
    if (!strcmp(arg, "copy")) {
2655
        *pstream_copy = 1;
2656
    } else {
2657
        *pcodec_name = av_strdup(arg);
2658
    }
2659
}
2660

    
2661
static void opt_audio_codec(const char *arg)
2662
{
2663
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2664
}
2665

    
2666
static void opt_audio_tag(const char *arg)
2667
{
2668
    char *tail;
2669
    audio_codec_tag= strtol(arg, &tail, 0);
2670

    
2671
    if(!tail || *tail)
2672
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2673
}
2674

    
2675
static void opt_video_tag(const char *arg)
2676
{
2677
    char *tail;
2678
    video_codec_tag= strtol(arg, &tail, 0);
2679

    
2680
    if(!tail || *tail)
2681
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2682
}
2683

    
2684
static void opt_video_codec(const char *arg)
2685
{
2686
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2687
}
2688

    
2689
static void opt_subtitle_codec(const char *arg)
2690
{
2691
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2692
}
2693

    
2694
static void opt_subtitle_tag(const char *arg)
2695
{
2696
    char *tail;
2697
    subtitle_codec_tag= strtol(arg, &tail, 0);
2698

    
2699
    if(!tail || *tail)
2700
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2701
}
2702

    
2703
static void opt_map(const char *arg)
2704
{
2705
    AVStreamMap *m;
2706
    char *p;
2707

    
2708
    m = &stream_maps[nb_stream_maps++];
2709

    
2710
    m->file_index = strtol(arg, &p, 0);
2711
    if (*p)
2712
        p++;
2713

    
2714
    m->stream_index = strtol(p, &p, 0);
2715
    if (*p) {
2716
        p++;
2717
        m->sync_file_index = strtol(p, &p, 0);
2718
        if (*p)
2719
            p++;
2720
        m->sync_stream_index = strtol(p, &p, 0);
2721
    } else {
2722
        m->sync_file_index = m->file_index;
2723
        m->sync_stream_index = m->stream_index;
2724
    }
2725
}
2726

    
2727
static void opt_map_meta_data(const char *arg)
2728
{
2729
    AVMetaDataMap *m;
2730
    char *p;
2731

    
2732
    m = &meta_data_maps[nb_meta_data_maps++];
2733

    
2734
    m->out_file = strtol(arg, &p, 0);
2735
    if (*p)
2736
        p++;
2737

    
2738
    m->in_file = strtol(p, &p, 0);
2739
}
2740

    
2741
static void opt_input_ts_scale(const char *arg)
2742
{
2743
    unsigned int stream;
2744
    double scale;
2745
    char *p;
2746

    
2747
    stream = strtol(arg, &p, 0);
2748
    if (*p)
2749
        p++;
2750
    scale= strtod(p, &p);
2751

    
2752
    if(stream >= MAX_STREAMS)
2753
        av_exit(1);
2754

    
2755
    input_files_ts_scale[nb_input_files][stream]= scale;
2756
}
2757

    
2758
static int opt_recording_time(const char *opt, const char *arg)
2759
{
2760
    recording_time = parse_time_or_die(opt, arg, 1);
2761
    return 0;
2762
}
2763

    
2764
static int opt_start_time(const char *opt, const char *arg)
2765
{
2766
    start_time = parse_time_or_die(opt, arg, 1);
2767
    return 0;
2768
}
2769

    
2770
static int opt_rec_timestamp(const char *opt, const char *arg)
2771
{
2772
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2773
    return 0;
2774
}
2775

    
2776
static int opt_input_ts_offset(const char *opt, const char *arg)
2777
{
2778
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2779
    return 0;
2780
}
2781

    
2782
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2783
{
2784
    const char *codec_string = encoder ? "encoder" : "decoder";
2785
    AVCodec *codec;
2786

    
2787
    if(!name)
2788
        return CODEC_ID_NONE;
2789
    codec = encoder ?
2790
        avcodec_find_encoder_by_name(name) :
2791
        avcodec_find_decoder_by_name(name);
2792
    if(!codec) {
2793
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2794
        av_exit(1);
2795
    }
2796
    if(codec->type != type) {
2797
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2798
        av_exit(1);
2799
    }
2800
    return codec->id;
2801
}
2802

    
2803
static void opt_input_file(const char *filename)
2804
{
2805
    AVFormatContext *ic;
2806
    AVFormatParameters params, *ap = &params;
2807
    int err, i, ret, rfps, rfps_base;
2808
    int64_t timestamp;
2809

    
2810
    if (!strcmp(filename, "-"))
2811
        filename = "pipe:";
2812

    
2813
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2814
                    !strcmp(filename, "/dev/stdin");
2815

    
2816
    /* get default parameters from command line */
2817
    ic = avformat_alloc_context();
2818

    
2819
    memset(ap, 0, sizeof(*ap));
2820
    ap->prealloced_context = 1;
2821
    ap->sample_rate = audio_sample_rate;
2822
    ap->channels = audio_channels;
2823
    ap->time_base.den = frame_rate.num;
2824
    ap->time_base.num = frame_rate.den;
2825
    ap->width = frame_width + frame_padleft + frame_padright;
2826
    ap->height = frame_height + frame_padtop + frame_padbottom;
2827
    ap->pix_fmt = frame_pix_fmt;
2828
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2829
    ap->channel = video_channel;
2830
    ap->standard = video_standard;
2831
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2832
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2833
    if(pgmyuv_compatibility_hack)
2834
        ap->video_codec_id= CODEC_ID_PGMYUV;
2835

    
2836
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2837

    
2838
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2839
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2840
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2841
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2842

    
2843
    /* open the input file with generic libav function */
2844
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2845
    if (err < 0) {
2846
        print_error(filename, err);
2847
        av_exit(1);
2848
    }
2849
    if(opt_programid) {
2850
        int i;
2851
        for(i=0; i<ic->nb_programs; i++)
2852
            if(ic->programs[i]->id != opt_programid)
2853
                ic->programs[i]->discard = AVDISCARD_ALL;
2854
    }
2855

    
2856
    ic->loop_input = loop_input;
2857

    
2858
    /* If not enough info to get the stream parameters, we decode the
2859
       first frames to get it. (used in mpeg case for example) */
2860
    ret = av_find_stream_info(ic);
2861
    if (ret < 0 && verbose >= 0) {
2862
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2863
        av_exit(1);
2864
    }
2865

    
2866
    timestamp = start_time;
2867
    /* add the stream start time */
2868
    if (ic->start_time != AV_NOPTS_VALUE)
2869
        timestamp += ic->start_time;
2870

    
2871
    /* if seeking requested, we execute it */
2872
    if (start_time != 0) {
2873
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2874
        if (ret < 0) {
2875
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2876
                    filename, (double)timestamp / AV_TIME_BASE);
2877
        }
2878
        /* reset seek info */
2879
        start_time = 0;
2880
    }
2881

    
2882
    /* update the current parameters so that they match the one of the input stream */
2883
    for(i=0;i<ic->nb_streams;i++) {
2884
        AVCodecContext *enc = ic->streams[i]->codec;
2885
        if(thread_count>1)
2886
            avcodec_thread_init(enc, thread_count);
2887
        enc->thread_count= thread_count;
2888
        switch(enc->codec_type) {
2889
        case CODEC_TYPE_AUDIO:
2890
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2891
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2892
            channel_layout = enc->channel_layout;
2893
            audio_channels = enc->channels;
2894
            audio_sample_rate = enc->sample_rate;
2895
            audio_sample_fmt = enc->sample_fmt;
2896
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2897
            if(audio_disable)
2898
                ic->streams[i]->discard= AVDISCARD_ALL;
2899
            break;
2900
        case CODEC_TYPE_VIDEO:
2901
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2902
            frame_height = enc->height;
2903
            frame_width = enc->width;
2904
            if(ic->streams[i]->sample_aspect_ratio.num)
2905
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2906
            else
2907
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2908
            frame_aspect_ratio *= (float) enc->width / enc->height;
2909
            frame_pix_fmt = enc->pix_fmt;
2910
            rfps      = ic->streams[i]->r_frame_rate.num;
2911
            rfps_base = ic->streams[i]->r_frame_rate.den;
2912
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2913
            if(me_threshold)
2914
                enc->debug |= FF_DEBUG_MV;
2915

    
2916
            if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2917

    
2918
                if (verbose >= 0)
2919
                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2920
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2921

    
2922
                    (float)rfps / rfps_base, rfps, rfps_base);
2923
            }
2924
            /* update the current frame rate to match the stream frame rate */
2925
            frame_rate.num = rfps;
2926
            frame_rate.den = rfps_base;
2927

    
2928
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2929
            if(video_disable)
2930
                ic->streams[i]->discard= AVDISCARD_ALL;
2931
            else if(video_discard)
2932
                ic->streams[i]->discard= video_discard;
2933
            break;
2934
        case CODEC_TYPE_DATA:
2935
            break;
2936
        case CODEC_TYPE_SUBTITLE:
2937
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2938
            if(subtitle_disable)
2939
                ic->streams[i]->discard = AVDISCARD_ALL;
2940
            break;
2941
        case CODEC_TYPE_ATTACHMENT:
2942
        case CODEC_TYPE_UNKNOWN:
2943
            nb_icodecs++;
2944
            break;
2945
        default:
2946
            abort();
2947
        }
2948
    }
2949

    
2950
    input_files[nb_input_files] = ic;
2951
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2952
    /* dump the file content */
2953
    if (verbose >= 0)
2954
        dump_format(ic, nb_input_files, filename, 0);
2955

    
2956
    nb_input_files++;
2957
    file_iformat = NULL;
2958
    file_oformat = NULL;
2959

    
2960
    video_channel = 0;
2961

    
2962
    av_freep(&video_codec_name);
2963
    av_freep(&audio_codec_name);
2964
    av_freep(&subtitle_codec_name);
2965
}
2966

    
2967
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2968
                                         int *has_subtitle_ptr)
2969
{
2970
    int has_video, has_audio, has_subtitle, i, j;
2971
    AVFormatContext *ic;
2972

    
2973
    has_video = 0;
2974
    has_audio = 0;
2975
    has_subtitle = 0;
2976
    for(j=0;j<nb_input_files;j++) {
2977
        ic = input_files[j];
2978
        for(i=0;i<ic->nb_streams;i++) {
2979
            AVCodecContext *enc = ic->streams[i]->codec;
2980
            switch(enc->codec_type) {
2981
            case CODEC_TYPE_AUDIO:
2982
                has_audio = 1;
2983
                break;
2984
            case CODEC_TYPE_VIDEO:
2985
                has_video = 1;
2986
                break;
2987
            case CODEC_TYPE_SUBTITLE:
2988
                has_subtitle = 1;
2989
                break;
2990
            case CODEC_TYPE_DATA:
2991
            case CODEC_TYPE_ATTACHMENT:
2992
            case CODEC_TYPE_UNKNOWN:
2993
                break;
2994
            default:
2995
                abort();
2996
            }
2997
        }
2998
    }
2999
    *has_video_ptr = has_video;
3000
    *has_audio_ptr = has_audio;
3001
    *has_subtitle_ptr = has_subtitle;
3002
}
3003

    
3004
static void new_video_stream(AVFormatContext *oc)
3005
{
3006
    AVStream *st;
3007
    AVCodecContext *video_enc;
3008
    int codec_id;
3009

    
3010
    st = av_new_stream(oc, oc->nb_streams);
3011
    if (!st) {
3012
        fprintf(stderr, "Could not alloc stream\n");
3013
        av_exit(1);
3014
    }
3015
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3016
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3017
    video_bitstream_filters= NULL;
3018

    
3019
    if(thread_count>1)
3020
        avcodec_thread_init(st->codec, thread_count);
3021

    
3022
    video_enc = st->codec;
3023

    
3024
    if(video_codec_tag)
3025
        video_enc->codec_tag= video_codec_tag;
3026

    
3027
    if(   (video_global_header&1)
3028
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3029
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3030
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3031
    }
3032
    if(video_global_header&2){
3033
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3034
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3035
    }
3036

    
3037
    if (video_stream_copy) {
3038
        st->stream_copy = 1;
3039
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3040
        video_enc->sample_aspect_ratio =
3041
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3042
    } else {
3043
        const char *p;
3044
        int i;
3045
        AVCodec *codec;
3046
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3047

    
3048
        if (video_codec_name) {
3049
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3050
            codec = avcodec_find_encoder_by_name(video_codec_name);
3051
            output_codecs[nb_ocodecs] = codec;
3052
        } else {
3053
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3054
            codec = avcodec_find_encoder(codec_id);
3055
        }
3056

    
3057
        video_enc->codec_id = codec_id;
3058

    
3059
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3060

    
3061
        if (codec && codec->supported_framerates && !force_fps)
3062
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3063
        video_enc->time_base.den = fps.num;
3064
        video_enc->time_base.num = fps.den;
3065

    
3066
        video_enc->width = frame_width + frame_padright + frame_padleft;
3067
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3068
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3069
        video_enc->pix_fmt = frame_pix_fmt;
3070
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3071

    
3072
        if(codec && codec->pix_fmts){
3073
            const enum PixelFormat *p= codec->pix_fmts;
3074
            for(; *p!=-1; p++){
3075
                if(*p == video_enc->pix_fmt)
3076
                    break;
3077
            }
3078
            if(*p == -1)
3079
                video_enc->pix_fmt = codec->pix_fmts[0];
3080
        }
3081

    
3082
        if (intra_only)
3083
            video_enc->gop_size = 0;
3084
        if (video_qscale || same_quality) {
3085
            video_enc->flags |= CODEC_FLAG_QSCALE;
3086
            video_enc->global_quality=
3087
                st->quality = FF_QP2LAMBDA * video_qscale;
3088
        }
3089

    
3090
        if(intra_matrix)
3091
            video_enc->intra_matrix = intra_matrix;
3092
        if(inter_matrix)
3093
            video_enc->inter_matrix = inter_matrix;
3094

    
3095
        video_enc->thread_count = thread_count;
3096
        p= video_rc_override_string;
3097
        for(i=0; p; i++){
3098
            int start, end, q;
3099
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3100
            if(e!=3){
3101
                fprintf(stderr, "error parsing rc_override\n");
3102
                av_exit(1);
3103
            }
3104
            video_enc->rc_override=
3105
                av_realloc(video_enc->rc_override,
3106
                           sizeof(RcOverride)*(i+1));
3107
            video_enc->rc_override[i].start_frame= start;
3108
            video_enc->rc_override[i].end_frame  = end;
3109
            if(q>0){
3110
                video_enc->rc_override[i].qscale= q;
3111
                video_enc->rc_override[i].quality_factor= 1.0;
3112
            }
3113
            else{
3114
                video_enc->rc_override[i].qscale= 0;
3115
                video_enc->rc_override[i].quality_factor= -q/100.0;
3116
            }
3117
            p= strchr(p, '/');
3118
            if(p) p++;
3119
        }
3120
        video_enc->rc_override_count=i;
3121
        if (!video_enc->rc_initial_buffer_occupancy)
3122
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3123
        video_enc->me_threshold= me_threshold;
3124
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3125

    
3126
        if (do_psnr)
3127
            video_enc->flags|= CODEC_FLAG_PSNR;
3128

    
3129
        /* two pass mode */
3130
        if (do_pass) {
3131
            if (do_pass == 1) {
3132
                video_enc->flags |= CODEC_FLAG_PASS1;
3133
            } else {
3134
                video_enc->flags |= CODEC_FLAG_PASS2;
3135
            }
3136
        }
3137
    }
3138
    nb_ocodecs++;
3139

    
3140
    /* reset some key parameters */
3141
    video_disable = 0;
3142
    av_freep(&video_codec_name);
3143
    video_stream_copy = 0;
3144
}
3145

    
3146
static void new_audio_stream(AVFormatContext *oc)
3147
{
3148
    AVStream *st;
3149
    AVCodecContext *audio_enc;
3150
    int codec_id;
3151

    
3152
    st = av_new_stream(oc, oc->nb_streams);
3153
    if (!st) {
3154
        fprintf(stderr, "Could not alloc stream\n");
3155
        av_exit(1);
3156
    }
3157
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3158

    
3159
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3160
    audio_bitstream_filters= NULL;
3161

    
3162
    if(thread_count>1)
3163
        avcodec_thread_init(st->codec, thread_count);
3164

    
3165
    audio_enc = st->codec;
3166
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3167

    
3168
    if(audio_codec_tag)
3169
        audio_enc->codec_tag= audio_codec_tag;
3170

    
3171
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3172
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3173
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3174
    }
3175
    if (audio_stream_copy) {
3176
        st->stream_copy = 1;
3177
        audio_enc->channels = audio_channels;
3178
    } else {
3179
        AVCodec *codec;
3180

    
3181
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3182

    
3183
        if (audio_codec_name) {
3184
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3185
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3186
            output_codecs[nb_ocodecs] = codec;
3187
        } else {
3188
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3189
            codec = avcodec_find_encoder(codec_id);
3190
        }
3191
        audio_enc->codec_id = codec_id;
3192

    
3193
        if (audio_qscale > QSCALE_NONE) {
3194
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3195
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3196
        }
3197
        audio_enc->thread_count = thread_count;
3198
        audio_enc->channels = audio_channels;
3199
        audio_enc->sample_fmt = audio_sample_fmt;
3200
        audio_enc->channel_layout = channel_layout;
3201

    
3202
        if(codec && codec->sample_fmts){
3203
            const enum SampleFormat *p= codec->sample_fmts;
3204
            for(; *p!=-1; p++){
3205
                if(*p == audio_enc->sample_fmt)
3206
                    break;
3207
            }
3208
            if(*p == -1)
3209
                audio_enc->sample_fmt = codec->sample_fmts[0];
3210
        }
3211
    }
3212
    nb_ocodecs++;
3213
    audio_enc->sample_rate = audio_sample_rate;
3214
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3215
    if (audio_language) {
3216
        av_metadata_set(&st->metadata, "language", audio_language);
3217
        av_free(audio_language);
3218
        audio_language = NULL;
3219
    }
3220

    
3221
    /* reset some key parameters */
3222
    audio_disable = 0;
3223
    av_freep(&audio_codec_name);
3224
    audio_stream_copy = 0;
3225
}
3226

    
3227
static void new_subtitle_stream(AVFormatContext *oc)
3228
{
3229
    AVStream *st;
3230
    AVCodecContext *subtitle_enc;
3231

    
3232
    st = av_new_stream(oc, oc->nb_streams);
3233
    if (!st) {
3234
        fprintf(stderr, "Could not alloc stream\n");
3235
        av_exit(1);
3236
    }
3237
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3238

    
3239
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3240
    subtitle_bitstream_filters= NULL;
3241

    
3242
    subtitle_enc = st->codec;
3243
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3244

    
3245
    if(subtitle_codec_tag)
3246
        subtitle_enc->codec_tag= subtitle_codec_tag;
3247

    
3248
    if (subtitle_stream_copy) {
3249
        st->stream_copy = 1;
3250
    } else {
3251
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3252
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3253
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3254
    }
3255
    nb_ocodecs++;
3256

    
3257
    if (subtitle_language) {
3258
        av_metadata_set(&st->metadata, "language", subtitle_language);
3259
        av_free(subtitle_language);
3260
        subtitle_language = NULL;
3261
    }
3262

    
3263
    subtitle_disable = 0;
3264
    av_freep(&subtitle_codec_name);
3265
    subtitle_stream_copy = 0;
3266
}
3267

    
3268
static void opt_new_audio_stream(void)
3269
{
3270
    AVFormatContext *oc;
3271
    if (nb_output_files <= 0) {
3272
        fprintf(stderr, "At least one output file must be specified\n");
3273
        av_exit(1);
3274
    }
3275
    oc = output_files[nb_output_files - 1];
3276
    new_audio_stream(oc);
3277
}
3278

    
3279
static void opt_new_video_stream(void)
3280
{
3281
    AVFormatContext *oc;
3282
    if (nb_output_files <= 0) {
3283
        fprintf(stderr, "At least one output file must be specified\n");
3284
        av_exit(1);
3285
    }
3286
    oc = output_files[nb_output_files - 1];
3287
    new_video_stream(oc);
3288
}
3289

    
3290
static void opt_new_subtitle_stream(void)
3291
{
3292
    AVFormatContext *oc;
3293
    if (nb_output_files <= 0) {
3294
        fprintf(stderr, "At least one output file must be specified\n");
3295
        av_exit(1);
3296
    }
3297
    oc = output_files[nb_output_files - 1];
3298
    new_subtitle_stream(oc);
3299
}
3300

    
3301
static void opt_output_file(const char *filename)
3302
{
3303
    AVFormatContext *oc;
3304
    int use_video, use_audio, use_subtitle;
3305
    int input_has_video, input_has_audio, input_has_subtitle;
3306
    AVFormatParameters params, *ap = &params;
3307

    
3308
    if (!strcmp(filename, "-"))
3309
        filename = "pipe:";
3310

    
3311
    oc = avformat_alloc_context();
3312

    
3313
    if (!file_oformat) {
3314
        file_oformat = guess_format(NULL, filename, NULL);
3315
        if (!file_oformat) {
3316
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3317
                    filename);
3318
            av_exit(1);
3319
        }
3320
    }
3321

    
3322
    oc->oformat = file_oformat;
3323
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3324

    
3325
    if (!strcmp(file_oformat->name, "ffm") &&
3326
        av_strstart(filename, "http:", NULL)) {
3327
        /* special case for files sent to ffserver: we get the stream
3328
           parameters from ffserver */
3329
        int err = read_ffserver_streams(oc, filename);
3330
        if (err < 0) {
3331
            print_error(filename, err);
3332
            av_exit(1);
3333
        }
3334
    } else {
3335
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3336
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3337
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3338

    
3339
        /* disable if no corresponding type found and at least one
3340
           input file */
3341
        if (nb_input_files > 0) {
3342
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3343
                                         &input_has_subtitle);
3344
            if (!input_has_video)
3345
                use_video = 0;
3346
            if (!input_has_audio)
3347
                use_audio = 0;
3348
            if (!input_has_subtitle)
3349
                use_subtitle = 0;
3350
        }
3351

    
3352
        /* manual disable */
3353
        if (audio_disable) {
3354
            use_audio = 0;
3355
        }
3356
        if (video_disable) {
3357
            use_video = 0;
3358
        }
3359
        if (subtitle_disable) {
3360
            use_subtitle = 0;
3361
        }
3362

    
3363
        if (use_video) {
3364
            new_video_stream(oc);
3365
        }
3366

    
3367
        if (use_audio) {
3368
            new_audio_stream(oc);
3369
        }
3370

    
3371
        if (use_subtitle) {
3372
            new_subtitle_stream(oc);
3373
        }
3374

    
3375
        oc->timestamp = rec_timestamp;
3376

    
3377
        for(; metadata_count>0; metadata_count--){
3378
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3379
                                           metadata[metadata_count-1].value);
3380
        }
3381
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3382
    }
3383

    
3384
    output_files[nb_output_files++] = oc;
3385

    
3386
    /* check filename in case of an image number is expected */
3387
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3388
        if (!av_filename_number_test(oc->filename)) {
3389
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3390
            av_exit(1);
3391
        }
3392
    }
3393

    
3394
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3395
        /* test if it already exists to avoid loosing precious files */
3396
        if (!file_overwrite &&
3397
            (strchr(filename, ':') == NULL ||
3398
             filename[1] == ':' ||
3399
             av_strstart(filename, "file:", NULL))) {
3400
            if (url_exist(filename)) {
3401
                if (!using_stdin) {
3402
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3403
                    fflush(stderr);
3404
                    if (!read_yesno()) {
3405
                        fprintf(stderr, "Not overwriting - exiting\n");
3406
                        av_exit(1);
3407
                    }
3408
                }
3409
                else {
3410
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3411
                    av_exit(1);
3412
                }
3413
            }
3414
        }
3415

    
3416
        /* open the file */
3417
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3418
            fprintf(stderr, "Could not open '%s'\n", filename);
3419
            av_exit(1);
3420
        }
3421
    }
3422

    
3423
    memset(ap, 0, sizeof(*ap));
3424
    if (av_set_parameters(oc, ap) < 0) {
3425
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3426
                oc->filename);
3427
        av_exit(1);
3428
    }
3429

    
3430
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3431
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3432
    oc->loop_output = loop_output;
3433
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3434

    
3435
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3436

    
3437
    /* reset some options */
3438
    file_oformat = NULL;
3439
    file_iformat = NULL;
3440
}
3441

    
3442
/* same option as mencoder */
3443
static void opt_pass(const char *pass_str)
3444
{
3445
    int pass;
3446
    pass = atoi(pass_str);
3447
    if (pass != 1 && pass != 2) {
3448
        fprintf(stderr, "pass number can be only 1 or 2\n");
3449
        av_exit(1);
3450
    }
3451
    do_pass = pass;
3452
}
3453

    
3454
static int64_t getutime(void)
3455
{
3456
#if HAVE_GETRUSAGE
3457
    struct rusage rusage;
3458

    
3459
    getrusage(RUSAGE_SELF, &rusage);
3460
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3461
#elif HAVE_GETPROCESSTIMES
3462
    HANDLE proc;
3463
    FILETIME c, e, k, u;
3464
    proc = GetCurrentProcess();
3465
    GetProcessTimes(proc, &c, &e, &k, &u);
3466
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3467
#else
3468
    return av_gettime();
3469
#endif
3470
}
3471

    
3472
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3473
{
3474
    int i;
3475
    const char *p = str;
3476
    for(i = 0;; i++) {
3477
        dest[i] = atoi(p);
3478
        if(i == 63)
3479
            break;
3480
        p = strchr(p, ',');
3481
        if(!p) {
3482
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3483
            av_exit(1);
3484
        }
3485
        p++;
3486
    }
3487
}
3488

    
3489
static void opt_inter_matrix(const char *arg)
3490
{
3491
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3492
    parse_matrix_coeffs(inter_matrix, arg);
3493
}
3494

    
3495
static void opt_intra_matrix(const char *arg)
3496
{
3497
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3498
    parse_matrix_coeffs(intra_matrix, arg);
3499
}
3500

    
3501
/**
3502
 * Trivial log callback.
3503
 * Only suitable for show_help and similar since it lacks prefix handling.
3504
 */
3505
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3506
{
3507
    vfprintf(stdout, fmt, vl);
3508
}
3509

    
3510
static void show_help(void)
3511
{
3512
    av_log_set_callback(log_callback_help);
3513
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3514
           "Hyper fast Audio and Video encoder\n");
3515
    printf("\n");
3516
    show_help_options(options, "Main options:\n",
3517
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3518
    show_help_options(options, "\nAdvanced options:\n",
3519
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3520
                      OPT_EXPERT);
3521
    show_help_options(options, "\nVideo options:\n",
3522
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3523
                      OPT_VIDEO);
3524
    show_help_options(options, "\nAdvanced Video options:\n",
3525
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3526
                      OPT_VIDEO | OPT_EXPERT);
3527
    show_help_options(options, "\nAudio options:\n",
3528
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3529
                      OPT_AUDIO);
3530
    show_help_options(options, "\nAdvanced Audio options:\n",
3531
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3532
                      OPT_AUDIO | OPT_EXPERT);
3533
    show_help_options(options, "\nSubtitle options:\n",
3534
                      OPT_SUBTITLE | OPT_GRAB,
3535
                      OPT_SUBTITLE);
3536
    show_help_options(options, "\nAudio/Video grab options:\n",
3537
                      OPT_GRAB,
3538
                      OPT_GRAB);
3539
    printf("\n");
3540
    av_opt_show(avcodec_opts[0], NULL);
3541
    printf("\n");
3542
    av_opt_show(avformat_opts, NULL);
3543
    printf("\n");
3544
    av_opt_show(sws_opts, NULL);
3545
}
3546

    
3547
static void opt_target(const char *arg)
3548
{
3549
    int norm = -1;
3550
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3551

    
3552
    if(!strncmp(arg, "pal-", 4)) {
3553
        norm = 0;
3554
        arg += 4;
3555
    } else if(!strncmp(arg, "ntsc-", 5)) {
3556
        norm = 1;
3557
        arg += 5;
3558
    } else if(!strncmp(arg, "film-", 5)) {
3559
        norm = 2;
3560
        arg += 5;
3561
    } else {
3562
        int fr;
3563
        /* Calculate FR via float to avoid int overflow */
3564
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3565
        if(fr == 25000) {
3566
            norm = 0;
3567
        } else if((fr == 29970) || (fr == 23976)) {
3568
            norm = 1;
3569
        } else {
3570
            /* Try to determine PAL/NTSC by peeking in the input files */
3571
            if(nb_input_files) {
3572
                int i, j;
3573
                for(j = 0; j < nb_input_files; j++) {
3574
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3575
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3576
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3577
                            continue;
3578
                        fr = c->time_base.den * 1000 / c->time_base.num;
3579
                        if(fr == 25000) {
3580
                            norm = 0;
3581
                            break;
3582
                        } else if((fr == 29970) || (fr == 23976)) {
3583
                            norm = 1;
3584
                            break;
3585
                        }
3586
                    }
3587
                    if(norm >= 0)
3588
                        break;
3589
                }
3590
            }
3591
        }
3592
        if(verbose && norm >= 0)
3593
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3594
    }
3595

    
3596
    if(norm < 0) {
3597
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3598
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3599
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3600
        av_exit(1);
3601
    }
3602

    
3603
    if(!strcmp(arg, "vcd")) {
3604

    
3605
        opt_video_codec("mpeg1video");
3606
        opt_audio_codec("mp2");
3607
        opt_format("vcd");
3608

    
3609
        opt_frame_size(norm ? "352x240" : "352x288");
3610
        opt_frame_rate(NULL, frame_rates[norm]);
3611
        opt_default("gop", norm ? "18" : "15");
3612

    
3613
        opt_default("b", "1150000");
3614
        opt_default("maxrate", "1150000");
3615
        opt_default("minrate", "1150000");
3616
        opt_default("bufsize", "327680"); // 40*1024*8;
3617

    
3618
        opt_default("ab", "224000");
3619
        audio_sample_rate = 44100;
3620
        audio_channels = 2;
3621

    
3622
        opt_default("packetsize", "2324");
3623
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3624

    
3625
        /* We have to offset the PTS, so that it is consistent with the SCR.
3626
           SCR starts at 36000, but the first two packs contain only padding
3627
           and the first pack from the other stream, respectively, may also have
3628
           been written before.
3629
           So the real data starts at SCR 36000+3*1200. */
3630
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3631
    } else if(!strcmp(arg, "svcd")) {
3632

    
3633
        opt_video_codec("mpeg2video");
3634
        opt_audio_codec("mp2");
3635
        opt_format("svcd");
3636

    
3637
        opt_frame_size(norm ? "480x480" : "480x576");
3638
        opt_frame_rate(NULL, frame_rates[norm]);
3639
        opt_default("gop", norm ? "18" : "15");
3640

    
3641
        opt_default("b", "2040000");
3642
        opt_default("maxrate", "2516000");
3643
        opt_default("minrate", "0"); //1145000;
3644
        opt_default("bufsize", "1835008"); //224*1024*8;
3645
        opt_default("flags", "+scan_offset");
3646

    
3647

    
3648
        opt_default("ab", "224000");
3649
        audio_sample_rate = 44100;
3650

    
3651
        opt_default("packetsize", "2324");
3652

    
3653
    } else if(!strcmp(arg, "dvd")) {
3654

    
3655
        opt_video_codec("mpeg2video");
3656
        opt_audio_codec("ac3");
3657
        opt_format("dvd");
3658

    
3659
        opt_frame_size(norm ? "720x480" : "720x576");
3660
        opt_frame_rate(NULL, frame_rates[norm]);
3661
        opt_default("gop", norm ? "18" : "15");
3662

    
3663
        opt_default("b", "6000000");
3664
        opt_default("maxrate", "9000000");
3665
        opt_default("minrate", "0"); //1500000;
3666
        opt_default("bufsize", "1835008"); //224*1024*8;
3667

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

    
3671
        opt_default("ab", "448000");
3672
        audio_sample_rate = 48000;
3673

    
3674
    } else if(!strncmp(arg, "dv", 2)) {
3675

    
3676
        opt_format("dv");
3677

    
3678
        opt_frame_size(norm ? "720x480" : "720x576");
3679
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3680
                                             (norm ? "yuv411p" : "yuv420p"));
3681
        opt_frame_rate(NULL, frame_rates[norm]);
3682

    
3683
        audio_sample_rate = 48000;
3684
        audio_channels = 2;
3685

    
3686
    } else {
3687
        fprintf(stderr, "Unknown target: %s\n", arg);
3688
        av_exit(1);
3689
    }
3690
}
3691

    
3692
static void opt_vstats_file (const char *arg)
3693
{
3694
    av_free (vstats_filename);
3695
    vstats_filename=av_strdup (arg);
3696
}
3697

    
3698
static void opt_vstats (void)
3699
{
3700
    char filename[40];
3701
    time_t today2 = time(NULL);
3702
    struct tm *today = localtime(&today2);
3703

    
3704
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3705
             today->tm_sec);
3706
    opt_vstats_file(filename);
3707
}
3708

    
3709
static int opt_bsf(const char *opt, const char *arg)
3710
{
3711
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3712
    AVBitStreamFilterContext **bsfp;
3713

    
3714
    if(!bsfc){
3715
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3716
        av_exit(1);
3717
    }
3718

    
3719
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3720
          *opt == 'a' ? &audio_bitstream_filters :
3721
                        &subtitle_bitstream_filters;
3722
    while(*bsfp)
3723
        bsfp= &(*bsfp)->next;
3724

    
3725
    *bsfp= bsfc;
3726

    
3727
    return 0;
3728
}
3729

    
3730
static int opt_preset(const char *opt, const char *arg)
3731
{
3732
    FILE *f=NULL;
3733
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3734
    int i;
3735
    const char *base[2]= { getenv("HOME"),
3736
                           FFMPEG_DATADIR,
3737
                         };
3738

    
3739
    for(i=!base[0]; i<2 && !f; i++){
3740
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3741
        f= fopen(filename, "r");
3742
        if(!f){
3743
            char *codec_name= *opt == 'v' ? video_codec_name :
3744
                              *opt == 'a' ? audio_codec_name :
3745
                                            subtitle_codec_name;
3746
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3747
            f= fopen(filename, "r");
3748
        }
3749
    }
3750
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3751
              is_dos_path(arg))){
3752
        av_strlcpy(filename, arg, sizeof(filename));
3753
        f= fopen(filename, "r");
3754
    }
3755

    
3756
    if(!f){
3757
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3758
        av_exit(1);
3759
    }
3760

    
3761
    while(!feof(f)){
3762
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3763
        if(line[0] == '#' && !e)
3764
            continue;
3765
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3766
        if(e){
3767
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3768
            av_exit(1);
3769
        }
3770
        if(!strcmp(tmp, "acodec")){
3771
            opt_audio_codec(tmp2);
3772
        }else if(!strcmp(tmp, "vcodec")){
3773
            opt_video_codec(tmp2);
3774
        }else if(!strcmp(tmp, "scodec")){
3775
            opt_subtitle_codec(tmp2);
3776
        }else if(opt_default(tmp, tmp2) < 0){
3777
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3778
            av_exit(1);
3779
        }
3780
    }
3781

    
3782
    fclose(f);
3783

    
3784
    return 0;
3785
}
3786

    
3787
static const OptionDef options[] = {
3788
    /* main options */
3789
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3790
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3791
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3792
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3793
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3794
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3795
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3796
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3797
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3798
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3799
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3800
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3801
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3802
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3803
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3804
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3805
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3806
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3807
      "add timings for benchmarking" },
3808
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3809
      "dump each input packet" },
3810
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3811
      "when dumping packets, also dump the payload" },
3812
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3813
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3814
    { "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)", "" },
3815
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3816
    { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3817
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3818
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3819
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3820
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3821
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3822
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3823
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3824
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3825
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3826
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3827
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3828
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3829

    
3830
    /* video options */
3831
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3832
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3833
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3834
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3835
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3836
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3837
    { "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" },
3838
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3839
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3840
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3841
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3842
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3843
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3844
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3845
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3846
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3847
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3848
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3849
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3850
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3851
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3852
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3853
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3854
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3855
      "use same video quality as source (implies VBR)" },
3856
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3857
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3858
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3859
      "deinterlace pictures" },
3860
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3861
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3862
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3863
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3864
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3865
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3866
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3867
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3868
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3869
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3870
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3871

    
3872
    /* audio options */
3873
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3874
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3875
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3876
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3877
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3878
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3879
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3880
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3881
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3882
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3883
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3884
    { "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" },
3885

    
3886
    /* subtitle options */
3887
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3888
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3889
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3890
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3891
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3892

    
3893
    /* grab options */
3894
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3895
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3896
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3897

    
3898
    /* muxer options */
3899
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3900
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3901

    
3902
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3903
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3904
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3905

    
3906
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3907
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3908
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3909

    
3910
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3911
    { NULL, },
3912
};
3913

    
3914
int main(int argc, char **argv)
3915
{
3916
    int i;
3917
    int64_t ti;
3918

    
3919
    avcodec_register_all();
3920
    avdevice_register_all();
3921
    av_register_all();
3922

    
3923
    if(isatty(STDIN_FILENO))
3924
        url_set_interrupt_cb(decode_interrupt_cb);
3925

    
3926
    for(i=0; i<CODEC_TYPE_NB; i++){
3927
        avcodec_opts[i]= avcodec_alloc_context2(i);
3928
    }
3929
    avformat_opts = avformat_alloc_context();
3930
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3931

    
3932
    show_banner();
3933

    
3934
    /* parse options */
3935
    parse_options(argc, argv, options, opt_output_file);
3936

    
3937
    /* file converter / grab */
3938
    if (nb_output_files <= 0) {
3939
        fprintf(stderr, "At least one output file must be specified\n");
3940
        av_exit(1);
3941
    }
3942

    
3943
    if (nb_input_files == 0) {
3944
        fprintf(stderr, "At least one input file must be specified\n");
3945
        av_exit(1);
3946
    }
3947

    
3948
    ti = getutime();
3949
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3950
                  stream_maps, nb_stream_maps) < 0)
3951
        av_exit(1);
3952
    ti = getutime() - ti;
3953
    if (do_benchmark) {
3954
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3955
    }
3956

    
3957
    return av_exit(0);
3958
}