Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ c5efef7b

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
    else {
2542
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2543
        av_exit(0);
2544
    }
2545
}
2546

    
2547
static void opt_frame_aspect_ratio(const char *arg)
2548
{
2549
    int x = 0, y = 0;
2550
    double ar = 0;
2551
    const char *p;
2552
    char *end;
2553

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

    
2564
    if (!ar) {
2565
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2566
        av_exit(1);
2567
    }
2568
    frame_aspect_ratio = ar;
2569
}
2570

    
2571
static int opt_metadata(const char *opt, const char *arg)
2572
{
2573
    char *mid= strchr(arg, '=');
2574

    
2575
    if(!mid){
2576
        fprintf(stderr, "Missing =\n");
2577
        av_exit(1);
2578
    }
2579
    *mid++= 0;
2580

    
2581
    metadata_count++;
2582
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2583
    metadata[metadata_count-1].key  = av_strdup(arg);
2584
    metadata[metadata_count-1].value= av_strdup(mid);
2585

    
2586
    return 0;
2587
}
2588

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

    
2599
static void opt_top_field_first(const char *arg)
2600
{
2601
    top_field_first= atoi(arg);
2602
}
2603

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

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

    
2624
static int opt_audio_rate(const char *opt, const char *arg)
2625
{
2626
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2627
    return 0;
2628
}
2629

    
2630
static int opt_audio_channels(const char *opt, const char *arg)
2631
{
2632
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2633
    return 0;
2634
}
2635

    
2636
static void opt_video_channel(const char *arg)
2637
{
2638
    video_channel = strtol(arg, NULL, 0);
2639
}
2640

    
2641
static void opt_video_standard(const char *arg)
2642
{
2643
    video_standard = av_strdup(arg);
2644
}
2645

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

    
2657
static void opt_audio_codec(const char *arg)
2658
{
2659
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2660
}
2661

    
2662
static void opt_audio_tag(const char *arg)
2663
{
2664
    char *tail;
2665
    audio_codec_tag= strtol(arg, &tail, 0);
2666

    
2667
    if(!tail || *tail)
2668
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2669
}
2670

    
2671
static void opt_video_tag(const char *arg)
2672
{
2673
    char *tail;
2674
    video_codec_tag= strtol(arg, &tail, 0);
2675

    
2676
    if(!tail || *tail)
2677
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2678
}
2679

    
2680
static void opt_video_codec(const char *arg)
2681
{
2682
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2683
}
2684

    
2685
static void opt_subtitle_codec(const char *arg)
2686
{
2687
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2688
}
2689

    
2690
static void opt_subtitle_tag(const char *arg)
2691
{
2692
    char *tail;
2693
    subtitle_codec_tag= strtol(arg, &tail, 0);
2694

    
2695
    if(!tail || *tail)
2696
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2697
}
2698

    
2699
static void opt_map(const char *arg)
2700
{
2701
    AVStreamMap *m;
2702
    char *p;
2703

    
2704
    m = &stream_maps[nb_stream_maps++];
2705

    
2706
    m->file_index = strtol(arg, &p, 0);
2707
    if (*p)
2708
        p++;
2709

    
2710
    m->stream_index = strtol(p, &p, 0);
2711
    if (*p) {
2712
        p++;
2713
        m->sync_file_index = strtol(p, &p, 0);
2714
        if (*p)
2715
            p++;
2716
        m->sync_stream_index = strtol(p, &p, 0);
2717
    } else {
2718
        m->sync_file_index = m->file_index;
2719
        m->sync_stream_index = m->stream_index;
2720
    }
2721
}
2722

    
2723
static void opt_map_meta_data(const char *arg)
2724
{
2725
    AVMetaDataMap *m;
2726
    char *p;
2727

    
2728
    m = &meta_data_maps[nb_meta_data_maps++];
2729

    
2730
    m->out_file = strtol(arg, &p, 0);
2731
    if (*p)
2732
        p++;
2733

    
2734
    m->in_file = strtol(p, &p, 0);
2735
}
2736

    
2737
static void opt_input_ts_scale(const char *arg)
2738
{
2739
    unsigned int stream;
2740
    double scale;
2741
    char *p;
2742

    
2743
    stream = strtol(arg, &p, 0);
2744
    if (*p)
2745
        p++;
2746
    scale= strtod(p, &p);
2747

    
2748
    if(stream >= MAX_STREAMS)
2749
        av_exit(1);
2750

    
2751
    input_files_ts_scale[nb_input_files][stream]= scale;
2752
}
2753

    
2754
static int opt_recording_time(const char *opt, const char *arg)
2755
{
2756
    recording_time = parse_time_or_die(opt, arg, 1);
2757
    return 0;
2758
}
2759

    
2760
static int opt_start_time(const char *opt, const char *arg)
2761
{
2762
    start_time = parse_time_or_die(opt, arg, 1);
2763
    return 0;
2764
}
2765

    
2766
static int opt_rec_timestamp(const char *opt, const char *arg)
2767
{
2768
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2769
    return 0;
2770
}
2771

    
2772
static int opt_input_ts_offset(const char *opt, const char *arg)
2773
{
2774
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2775
    return 0;
2776
}
2777

    
2778
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2779
{
2780
    const char *codec_string = encoder ? "encoder" : "decoder";
2781
    AVCodec *codec;
2782

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

    
2799
static void opt_input_file(const char *filename)
2800
{
2801
    AVFormatContext *ic;
2802
    AVFormatParameters params, *ap = &params;
2803
    int err, i, ret, rfps, rfps_base;
2804
    int64_t timestamp;
2805

    
2806
    if (!strcmp(filename, "-"))
2807
        filename = "pipe:";
2808

    
2809
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2810
                    !strcmp(filename, "/dev/stdin");
2811

    
2812
    /* get default parameters from command line */
2813
    ic = avformat_alloc_context();
2814

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

    
2832
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2833

    
2834
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2835
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2836
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2837
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2838

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

    
2852
    ic->loop_input = loop_input;
2853

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

    
2862
    timestamp = start_time;
2863
    /* add the stream start time */
2864
    if (ic->start_time != AV_NOPTS_VALUE)
2865
        timestamp += ic->start_time;
2866

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

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

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

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

    
2918
                    (float)rfps / rfps_base, rfps, rfps_base);
2919
            }
2920
            /* update the current frame rate to match the stream frame rate */
2921
            frame_rate.num = rfps;
2922
            frame_rate.den = rfps_base;
2923

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

    
2946
    input_files[nb_input_files] = ic;
2947
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2948
    /* dump the file content */
2949
    if (verbose >= 0)
2950
        dump_format(ic, nb_input_files, filename, 0);
2951

    
2952
    nb_input_files++;
2953
    file_iformat = NULL;
2954
    file_oformat = NULL;
2955

    
2956
    video_channel = 0;
2957

    
2958
    av_freep(&video_codec_name);
2959
    av_freep(&audio_codec_name);
2960
    av_freep(&subtitle_codec_name);
2961
}
2962

    
2963
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2964
                                         int *has_subtitle_ptr)
2965
{
2966
    int has_video, has_audio, has_subtitle, i, j;
2967
    AVFormatContext *ic;
2968

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

    
3000
static void new_video_stream(AVFormatContext *oc)
3001
{
3002
    AVStream *st;
3003
    AVCodecContext *video_enc;
3004
    int codec_id;
3005

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

    
3015
    if(thread_count>1)
3016
        avcodec_thread_init(st->codec, thread_count);
3017

    
3018
    video_enc = st->codec;
3019

    
3020
    if(video_codec_tag)
3021
        video_enc->codec_tag= video_codec_tag;
3022

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

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

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

    
3053
        video_enc->codec_id = codec_id;
3054

    
3055
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3056

    
3057
        if (codec && codec->supported_framerates && !force_fps)
3058
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3059
        video_enc->time_base.den = fps.num;
3060
        video_enc->time_base.num = fps.den;
3061

    
3062
        video_enc->width = frame_width + frame_padright + frame_padleft;
3063
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3064
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3065
        video_enc->pix_fmt = frame_pix_fmt;
3066
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3067

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

    
3078
        if (intra_only)
3079
            video_enc->gop_size = 0;
3080
        if (video_qscale || same_quality) {
3081
            video_enc->flags |= CODEC_FLAG_QSCALE;
3082
            video_enc->global_quality=
3083
                st->quality = FF_QP2LAMBDA * video_qscale;
3084
        }
3085

    
3086
        if(intra_matrix)
3087
            video_enc->intra_matrix = intra_matrix;
3088
        if(inter_matrix)
3089
            video_enc->inter_matrix = inter_matrix;
3090

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

    
3122
        if (do_psnr)
3123
            video_enc->flags|= CODEC_FLAG_PSNR;
3124

    
3125
        /* two pass mode */
3126
        if (do_pass) {
3127
            if (do_pass == 1) {
3128
                video_enc->flags |= CODEC_FLAG_PASS1;
3129
            } else {
3130
                video_enc->flags |= CODEC_FLAG_PASS2;
3131
            }
3132
        }
3133
    }
3134
    nb_ocodecs++;
3135

    
3136
    /* reset some key parameters */
3137
    video_disable = 0;
3138
    av_freep(&video_codec_name);
3139
    video_stream_copy = 0;
3140
}
3141

    
3142
static void new_audio_stream(AVFormatContext *oc)
3143
{
3144
    AVStream *st;
3145
    AVCodecContext *audio_enc;
3146
    int codec_id;
3147

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

    
3155
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3156
    audio_bitstream_filters= NULL;
3157

    
3158
    if(thread_count>1)
3159
        avcodec_thread_init(st->codec, thread_count);
3160

    
3161
    audio_enc = st->codec;
3162
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3163

    
3164
    if(audio_codec_tag)
3165
        audio_enc->codec_tag= audio_codec_tag;
3166

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

    
3177
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3178

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

    
3189
        if (audio_qscale > QSCALE_NONE) {
3190
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3191
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3192
        }
3193
        audio_enc->thread_count = thread_count;
3194
        audio_enc->channels = audio_channels;
3195
        audio_enc->sample_fmt = audio_sample_fmt;
3196
        audio_enc->channel_layout = channel_layout;
3197

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

    
3217
    /* reset some key parameters */
3218
    audio_disable = 0;
3219
    av_freep(&audio_codec_name);
3220
    audio_stream_copy = 0;
3221
}
3222

    
3223
static void new_subtitle_stream(AVFormatContext *oc)
3224
{
3225
    AVStream *st;
3226
    AVCodecContext *subtitle_enc;
3227

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

    
3235
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3236
    subtitle_bitstream_filters= NULL;
3237

    
3238
    subtitle_enc = st->codec;
3239
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3240

    
3241
    if(subtitle_codec_tag)
3242
        subtitle_enc->codec_tag= subtitle_codec_tag;
3243

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

    
3253
    if (subtitle_language) {
3254
        av_metadata_set(&st->metadata, "language", subtitle_language);
3255
        av_free(subtitle_language);
3256
        subtitle_language = NULL;
3257
    }
3258

    
3259
    subtitle_disable = 0;
3260
    av_freep(&subtitle_codec_name);
3261
    subtitle_stream_copy = 0;
3262
}
3263

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

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

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

    
3297
static void opt_output_file(const char *filename)
3298
{
3299
    AVFormatContext *oc;
3300
    int use_video, use_audio, use_subtitle;
3301
    int input_has_video, input_has_audio, input_has_subtitle;
3302
    AVFormatParameters params, *ap = &params;
3303

    
3304
    if (!strcmp(filename, "-"))
3305
        filename = "pipe:";
3306

    
3307
    oc = avformat_alloc_context();
3308

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

    
3318
    oc->oformat = file_oformat;
3319
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3320

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

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

    
3348
        /* manual disable */
3349
        if (audio_disable) {
3350
            use_audio = 0;
3351
        }
3352
        if (video_disable) {
3353
            use_video = 0;
3354
        }
3355
        if (subtitle_disable) {
3356
            use_subtitle = 0;
3357
        }
3358

    
3359
        if (use_video) {
3360
            new_video_stream(oc);
3361
        }
3362

    
3363
        if (use_audio) {
3364
            new_audio_stream(oc);
3365
        }
3366

    
3367
        if (use_subtitle) {
3368
            new_subtitle_stream(oc);
3369
        }
3370

    
3371
        oc->timestamp = rec_timestamp;
3372

    
3373
        for(; metadata_count>0; metadata_count--){
3374
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3375
                                           metadata[metadata_count-1].value);
3376
        }
3377
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3378
    }
3379

    
3380
    output_files[nb_output_files++] = oc;
3381

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

    
3390
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3391
        /* test if it already exists to avoid loosing precious files */
3392
        if (!file_overwrite &&
3393
            (strchr(filename, ':') == NULL ||
3394
             filename[1] == ':' ||
3395
             av_strstart(filename, "file:", NULL))) {
3396
            if (url_exist(filename)) {
3397
                int c;
3398

    
3399
                if (!using_stdin) {
3400
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3401
                    fflush(stderr);
3402
                    c = getchar();
3403
                    if (toupper(c) != 'Y') {
3404
                        fprintf(stderr, "Not overwriting - exiting\n");
3405
                        av_exit(1);
3406
                    }
3407
                }
3408
                else {
3409
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3410
                    av_exit(1);
3411
                }
3412
            }
3413
        }
3414

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

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

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

    
3434
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3435

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3646

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

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

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

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

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

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

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

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

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

    
3675
        opt_format("dv");
3676

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

    
3682
        audio_sample_rate = 48000;
3683
        audio_channels = 2;
3684

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

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

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

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

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

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

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

    
3724
    *bsfp= bsfc;
3725

    
3726
    return 0;
3727
}
3728

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

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

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

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

    
3781
    fclose(f);
3782

    
3783
    return 0;
3784
}
3785

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3931
    show_banner();
3932

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

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

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

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

    
3956
    return av_exit(0);
3957
}