Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 09a76db8

History | View | Annotate | Download (138 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 "libavformat/framehook.h"
38
#include "libavcodec/opt.h"
39
#include "libavcodec/audioconvert.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/avstring.h"
42
#include "libavformat/os_support.h"
43

    
44
#ifdef HAVE_SYS_RESOURCE_H
45
#include <sys/types.h>
46
#include <sys/resource.h>
47
#elif defined(HAVE_GETPROCESSTIMES)
48
#include <windows.h>
49
#endif
50

    
51
#ifdef HAVE_SYS_SELECT_H
52
#include <sys/select.h>
53
#endif
54

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

    
163
static int subtitle_disable = 0;
164
static char *subtitle_codec_name = NULL;
165
static char *subtitle_language = NULL;
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 char *str_title = NULL;
176
static char *str_author = NULL;
177
static char *str_copyright = NULL;
178
static char *str_comment = NULL;
179
static char *str_genre = NULL;
180
static char *str_album = NULL;
181
static int do_benchmark = 0;
182
static int do_hex_dump = 0;
183
static int do_pkt_dump = 0;
184
static int do_psnr = 0;
185
static int do_pass = 0;
186
static char *pass_logfilename = NULL;
187
static int audio_stream_copy = 0;
188
static int video_stream_copy = 0;
189
static int subtitle_stream_copy = 0;
190
static int video_sync_method= -1;
191
static int audio_sync_method= 0;
192
static float audio_drift_threshold= 0.1;
193
static int copy_ts= 0;
194
static int opt_shortest = 0;
195
static int video_global_header = 0;
196
static char *vstats_filename;
197
static FILE *vstats_file;
198
static int opt_programid = 0;
199

    
200
static int rate_emu = 0;
201

    
202
static int  video_channel = 0;
203
static char *video_standard;
204

    
205
static int audio_volume = 256;
206

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

    
222
static int pgmyuv_compatibility_hack=0;
223
static float dts_delta_threshold = 10;
224

    
225
static unsigned int sws_flags = SWS_BICUBIC;
226

    
227
static int64_t timer_start;
228

    
229
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
230
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
231
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
232
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
233

    
234
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
235

    
236
struct AVInputStream;
237

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

    
256
    int video_crop;
257
    int topBand;             /* cropping area sizes */
258
    int leftBand;
259

    
260
    int video_pad;
261
    int padtop;              /* padding area sizes */
262
    int padbottom;
263
    int padleft;
264
    int padright;
265

    
266
    /* audio only */
267
    int audio_resample;
268
    ReSampleContext *resample; /* for audio resampling */
269
    int reformat_pair;
270
    AVAudioConvert *reformat_ctx;
271
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
272
    FILE *logfile;
273
} AVOutputStream;
274

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

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

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

    
297
#ifdef HAVE_TERMIOS_H
298

    
299
/* init terminal so that we can grab keys */
300
static struct termios oldtty;
301
#endif
302

    
303
static void term_exit(void)
304
{
305
#ifdef HAVE_TERMIOS_H
306
    tcsetattr (0, TCSANOW, &oldtty);
307
#endif
308
}
309

    
310
static volatile sig_atomic_t received_sigterm = 0;
311

    
312
static void
313
sigterm_handler(int sig)
314
{
315
    received_sigterm = sig;
316
    term_exit();
317
}
318

    
319
static void term_init(void)
320
{
321
#ifdef HAVE_TERMIOS_H
322
    struct termios tty;
323

    
324
    tcgetattr (0, &tty);
325
    oldtty = tty;
326

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

    
336
    tcsetattr (0, TCSANOW, &tty);
337
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
338
#endif
339

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

    
351
/* read a key without blocking */
352
static int read_key(void)
353
{
354
#if defined(HAVE_TERMIOS_H)
355
    int n = 1;
356
    unsigned char ch;
357
#ifndef CONFIG_BEOS_NETSERVER
358
    struct timeval tv;
359
    fd_set rfds;
360

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

    
372
        return n;
373
    }
374
#elif defined(HAVE_CONIO_H)
375
    if(kbhit())
376
        return(getch());
377
#endif
378
    return -1;
379
}
380

    
381
static int decode_interrupt_cb(void)
382
{
383
    return q_pressed || (q_pressed = read_key() == 'q');
384
}
385

    
386
static int av_exit(int ret)
387
{
388
    int i;
389

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

    
406
    av_free(intra_matrix);
407
    av_free(inter_matrix);
408

    
409
    if (vstats_file)
410
        fclose(vstats_file);
411
    av_free(vstats_filename);
412

    
413
    av_free(opt_names);
414

    
415
    av_free(video_codec_name);
416
    av_free(audio_codec_name);
417
    av_free(subtitle_codec_name);
418

    
419
    av_free(video_standard);
420

    
421
#ifdef CONFIG_POWERPC_PERF
422
    void powerpc_display_perf_report(void);
423
    powerpc_display_perf_report();
424
#endif /* CONFIG_POWERPC_PERF */
425

    
426
    if (received_sigterm) {
427
        fprintf(stderr,
428
            "Received signal %d: terminating.\n",
429
            (int) received_sigterm);
430
        exit (255);
431
    }
432

    
433
    exit(ret); /* not all OS-es handle main() return value */
434
    return ret;
435
}
436

    
437
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
438
{
439
    int i, err;
440
    AVFormatContext *ic;
441
    int nopts = 0;
442

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

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

    
458
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
459
            st->stream_copy = 1;
460
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
461
            st->stream_copy = 1;
462

    
463
        if(!st->codec->thread_count)
464
            st->codec->thread_count = 1;
465
        if(st->codec->thread_count>1)
466
            avcodec_thread_init(st->codec, st->codec->thread_count);
467

    
468
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
469
            nopts = 1;
470
    }
471

    
472
    if (!nopts)
473
        s->timestamp = av_gettime();
474

    
475
    av_close_input_file(ic);
476
    return 0;
477
}
478

    
479
static double
480
get_sync_ipts(const AVOutputStream *ost)
481
{
482
    const AVInputStream *ist = ost->sync_ist;
483
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
484
}
485

    
486
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
487
    int ret;
488

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

    
508
        bsfc= bsfc->next;
509
    }
510

    
511
    ret= av_interleaved_write_frame(s, pkt);
512
    if(ret < 0){
513
        print_error("av_interleaved_write_frame()", ret);
514
        av_exit(1);
515
    }
516
}
517

    
518
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
519

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

    
531
    int size_out, frame_bytes, ret;
532
    AVCodecContext *enc= ost->st->codec;
533
    AVCodecContext *dec= ist->st->codec;
534
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
535
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
536

    
537
    /* SC: dynamic allocation of buffers */
538
    if (!audio_buf)
539
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
540
    if (!audio_out)
541
        audio_out = av_malloc(audio_out_size);
542
    if (!audio_buf || !audio_out)
543
        return;               /* Should signal an error ! */
544

    
545
    if (enc->channels != dec->channels)
546
        ost->audio_resample = 1;
547

    
548
    if (ost->audio_resample && !ost->resample) {
549
        if (dec->sample_fmt != SAMPLE_FMT_S16) {
550
            fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
551
            av_exit(1);
552
        }
553
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
554
                                            enc->sample_rate, dec->sample_rate);
555
        if (!ost->resample) {
556
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
557
                    dec->channels, dec->sample_rate,
558
                    enc->channels, enc->sample_rate);
559
            av_exit(1);
560
        }
561
    }
562

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

    
583
    if(audio_sync_method){
584
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
585
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
586
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
587
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
588

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

    
605
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
606
                        ist->is_start=0;
607
                    else
608
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
609

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

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

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

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

    
666
        frame_bytes = enc->frame_size * osize * enc->channels;
667

    
668
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
669
            AVPacket pkt;
670
            av_init_packet(&pkt);
671

    
672
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
673

    
674
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
675

    
676
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
677
                                       (short *)audio_buf);
678
            audio_size += ret;
679
            pkt.stream_index= ost->index;
680
            pkt.data= audio_out;
681
            pkt.size= ret;
682
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
683
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
684
            pkt.flags |= PKT_FLAG_KEY;
685
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
686

    
687
            ost->sync_opts += enc->frame_size;
688
        }
689
    } else {
690
        AVPacket pkt;
691
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
692
        av_init_packet(&pkt);
693

    
694
        ost->sync_opts += size_out / (osize * enc->channels);
695

    
696
        /* output a pcm frame */
697
        /* determine the size of the coded buffer */
698
        size_out /= osize;
699
        if (coded_bps)
700
            size_out *= coded_bps;
701

    
702
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
703
        ret = avcodec_encode_audio(enc, audio_out, size_out,
704
                                   (short *)buftmp);
705
        audio_size += ret;
706
        pkt.stream_index= ost->index;
707
        pkt.data= audio_out;
708
        pkt.size= ret;
709
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
710
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
711
        pkt.flags |= PKT_FLAG_KEY;
712
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
713
    }
714
}
715

    
716
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
717
{
718
    AVCodecContext *dec;
719
    AVPicture *picture2;
720
    AVPicture picture_tmp;
721
    uint8_t *buf = 0;
722

    
723
    dec = ist->st->codec;
724

    
725
    /* deinterlace : must be done before any resize */
726
    if (do_deinterlace || using_vhook) {
727
        int size;
728

    
729
        /* create temporary picture */
730
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
731
        buf = av_malloc(size);
732
        if (!buf)
733
            return;
734

    
735
        picture2 = &picture_tmp;
736
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
737

    
738
        if (do_deinterlace){
739
            if(avpicture_deinterlace(picture2, picture,
740
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
741
                /* if error, do not deinterlace */
742
                fprintf(stderr, "Deinterlacing failed\n");
743
                av_free(buf);
744
                buf = NULL;
745
                picture2 = picture;
746
            }
747
        } else {
748
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
749
        }
750
    } else {
751
        picture2 = picture;
752
    }
753

    
754
    if (ENABLE_VHOOK)
755
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
756
                           1000000 * ist->pts / AV_TIME_BASE);
757

    
758
    if (picture != picture2)
759
        *picture = *picture2;
760
    *bufp = buf;
761
}
762

    
763
/* we begin to correct av delay at this threshold */
764
#define AV_DELAY_MAX 0.100
765

    
766
static void do_subtitle_out(AVFormatContext *s,
767
                            AVOutputStream *ost,
768
                            AVInputStream *ist,
769
                            AVSubtitle *sub,
770
                            int64_t pts)
771
{
772
    static uint8_t *subtitle_out = NULL;
773
    int subtitle_out_max_size = 65536;
774
    int subtitle_out_size, nb, i;
775
    AVCodecContext *enc;
776
    AVPacket pkt;
777

    
778
    if (pts == AV_NOPTS_VALUE) {
779
        fprintf(stderr, "Subtitle packets must have a pts\n");
780
        if (exit_on_error)
781
            av_exit(1);
782
        return;
783
    }
784

    
785
    enc = ost->st->codec;
786

    
787
    if (!subtitle_out) {
788
        subtitle_out = av_malloc(subtitle_out_max_size);
789
    }
790

    
791
    /* Note: DVB subtitle need one packet to draw them and one other
792
       packet to clear them */
793
    /* XXX: signal it in the codec context ? */
794
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
795
        nb = 2;
796
    else
797
        nb = 1;
798

    
799
    for(i = 0; i < nb; i++) {
800
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
801
                                                    subtitle_out_max_size, sub);
802

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

    
820
static int bit_buffer_size= 1024*256;
821
static uint8_t *bit_buffer= NULL;
822

    
823
static void do_video_out(AVFormatContext *s,
824
                         AVOutputStream *ost,
825
                         AVInputStream *ist,
826
                         AVFrame *in_picture,
827
                         int *frame_size)
828
{
829
    int nb_frames, i, ret;
830
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
831
    AVFrame picture_crop_temp, picture_pad_temp;
832
    AVCodecContext *enc, *dec;
833

    
834
    avcodec_get_frame_defaults(&picture_crop_temp);
835
    avcodec_get_frame_defaults(&picture_pad_temp);
836

    
837
    enc = ost->st->codec;
838
    dec = ist->st->codec;
839

    
840
    /* by default, we output a single frame */
841
    nb_frames = 1;
842

    
843
    *frame_size = 0;
844

    
845
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
846
        double vdelta;
847
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
848
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
849
        if (vdelta < -1.1)
850
            nb_frames = 0;
851
        else if (video_sync_method == 2)
852
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
853
        else if (vdelta > 1.1)
854
            nb_frames = lrintf(vdelta);
855
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
856
        if (nb_frames == 0){
857
            ++nb_frames_drop;
858
            if (verbose>2)
859
                fprintf(stderr, "*** drop!\n");
860
        }else if (nb_frames > 1) {
861
            nb_frames_dup += nb_frames;
862
            if (verbose>2)
863
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
864
        }
865
    }else
866
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
867

    
868
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
869
    if (nb_frames <= 0)
870
        return;
871

    
872
    if (ost->video_crop) {
873
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
874
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
875
            if (exit_on_error)
876
                av_exit(1);
877
            return;
878
        }
879
        formatted_picture = &picture_crop_temp;
880
    } else {
881
        formatted_picture = in_picture;
882
    }
883

    
884
    final_picture = formatted_picture;
885
    padding_src = formatted_picture;
886
    resampling_dst = &ost->pict_tmp;
887
    if (ost->video_pad) {
888
        final_picture = &ost->pict_tmp;
889
        if (ost->video_resample) {
890
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
891
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
892
                if (exit_on_error)
893
                    av_exit(1);
894
                return;
895
            }
896
            resampling_dst = &picture_pad_temp;
897
        }
898
    }
899

    
900
    if (ost->video_resample) {
901
        padding_src = NULL;
902
        final_picture = &ost->pict_tmp;
903
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
904
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
905
    }
906

    
907
    if (ost->video_pad) {
908
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
909
                enc->height, enc->width, enc->pix_fmt,
910
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
911
    }
912

    
913
    /* duplicates frame if needed */
914
    for(i=0;i<nb_frames;i++) {
915
        AVPacket pkt;
916
        av_init_packet(&pkt);
917
        pkt.stream_index= ost->index;
918

    
919
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
920
            /* raw pictures are written as AVPicture structure to
921
               avoid any copies. We support temorarily the older
922
               method. */
923
            AVFrame* old_frame = enc->coded_frame;
924
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
925
            pkt.data= (uint8_t *)final_picture;
926
            pkt.size=  sizeof(AVPicture);
927
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
928
            pkt.flags |= PKT_FLAG_KEY;
929

    
930
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
931
            enc->coded_frame = old_frame;
932
        } else {
933
            AVFrame big_picture;
934

    
935
            big_picture= *final_picture;
936
            /* better than nothing: use input picture interlaced
937
               settings */
938
            big_picture.interlaced_frame = in_picture->interlaced_frame;
939
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
940
                if(top_field_first == -1)
941
                    big_picture.top_field_first = in_picture->top_field_first;
942
                else
943
                    big_picture.top_field_first = top_field_first;
944
            }
945

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

    
975
                if(enc->coded_frame->key_frame)
976
                    pkt.flags |= PKT_FLAG_KEY;
977
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
978
                *frame_size = ret;
979
                video_size += ret;
980
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
981
                //        enc->frame_number-1, enc->real_pict_num, ret,
982
                //        enc->pict_type);
983
                /* if two pass, output log */
984
                if (ost->logfile && enc->stats_out) {
985
                    fprintf(ost->logfile, "%s", enc->stats_out);
986
                }
987
            }
988
        }
989
        ost->sync_opts++;
990
        ost->frame_number++;
991
    }
992
}
993

    
994
static double psnr(double d){
995
    return -10.0*log(d)/log(10.0);
996
}
997

    
998
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
999
                           int frame_size)
1000
{
1001
    AVCodecContext *enc;
1002
    int frame_number;
1003
    double ti1, bitrate, avg_bitrate;
1004

    
1005
    /* this is executed just the first time do_video_stats is called */
1006
    if (!vstats_file) {
1007
        vstats_file = fopen(vstats_filename, "w");
1008
        if (!vstats_file) {
1009
            perror("fopen");
1010
            av_exit(1);
1011
        }
1012
    }
1013

    
1014
    enc = ost->st->codec;
1015
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1016
        frame_number = ost->frame_number;
1017
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1018
        if (enc->flags&CODEC_FLAG_PSNR)
1019
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1020

    
1021
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1022
        /* compute pts value */
1023
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1024
        if (ti1 < 0.01)
1025
            ti1 = 0.01;
1026

    
1027
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1028
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1029
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1030
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1031
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1032
    }
1033
}
1034

    
1035
static void print_report(AVFormatContext **output_files,
1036
                         AVOutputStream **ost_table, int nb_ostreams,
1037
                         int is_last_report)
1038
{
1039
    char buf[1024];
1040
    AVOutputStream *ost;
1041
    AVFormatContext *oc, *os;
1042
    int64_t total_size;
1043
    AVCodecContext *enc;
1044
    int frame_number, vid, i;
1045
    double bitrate, ti1, pts;
1046
    static int64_t last_time = -1;
1047
    static int qp_histogram[52];
1048

    
1049
    if (!is_last_report) {
1050
        int64_t cur_time;
1051
        /* display the report every 0.5 seconds */
1052
        cur_time = av_gettime();
1053
        if (last_time == -1) {
1054
            last_time = cur_time;
1055
            return;
1056
        }
1057
        if ((cur_time - last_time) < 500000)
1058
            return;
1059
        last_time = cur_time;
1060
    }
1061

    
1062

    
1063
    oc = output_files[0];
1064

    
1065
    total_size = url_fsize(oc->pb);
1066
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1067
        total_size= url_ftell(oc->pb);
1068

    
1069
    buf[0] = '\0';
1070
    ti1 = 1e10;
1071
    vid = 0;
1072
    for(i=0;i<nb_ostreams;i++) {
1073
        ost = ost_table[i];
1074
        os = output_files[ost->file_index];
1075
        enc = ost->st->codec;
1076
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1077
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1078
                     !ost->st->stream_copy ?
1079
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1080
        }
1081
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1082
            float t = (av_gettime()-timer_start) / 1000000.0;
1083

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

    
1130
    if (verbose || is_last_report) {
1131
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1132

    
1133
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1134
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1135
            (double)total_size / 1024, ti1, bitrate);
1136

    
1137
        if (verbose > 1)
1138
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1139
                  nb_frames_dup, nb_frames_drop);
1140

    
1141
        if (verbose >= 0)
1142
            fprintf(stderr, "%s    \r", buf);
1143

    
1144
        fflush(stderr);
1145
    }
1146

    
1147
    if (is_last_report && verbose >= 0){
1148
        int64_t raw= audio_size + video_size + extra_size;
1149
        fprintf(stderr, "\n");
1150
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1151
                video_size/1024.0,
1152
                audio_size/1024.0,
1153
                extra_size/1024.0,
1154
                100.0*(total_size - raw)/raw
1155
        );
1156
    }
1157
}
1158

    
1159
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1160
static int output_packet(AVInputStream *ist, int ist_index,
1161
                         AVOutputStream **ost_table, int nb_ostreams,
1162
                         const AVPacket *pkt)
1163
{
1164
    AVFormatContext *os;
1165
    AVOutputStream *ost;
1166
    uint8_t *ptr;
1167
    int len, ret, i;
1168
    uint8_t *data_buf;
1169
    int data_size, got_picture;
1170
    AVFrame picture;
1171
    void *buffer_to_free;
1172
    static unsigned int samples_size= 0;
1173
    static short *samples= NULL;
1174
    AVSubtitle subtitle, *subtitle_to_free;
1175
    int got_subtitle;
1176

    
1177
    if(ist->next_pts == AV_NOPTS_VALUE)
1178
        ist->next_pts= ist->pts;
1179

    
1180
    if (pkt == NULL) {
1181
        /* EOF handling */
1182
        ptr = NULL;
1183
        len = 0;
1184
        goto handle_eof;
1185
    }
1186

    
1187
    if(pkt->dts != AV_NOPTS_VALUE)
1188
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1189

    
1190
    len = pkt->size;
1191
    ptr = pkt->data;
1192

    
1193
    //while we have more to decode or while the decoder did output something on EOF
1194
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1195
    handle_eof:
1196
        ist->pts= ist->next_pts;
1197

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

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

    
1237
                    ret = avcodec_decode_video(ist->st->codec,
1238
                                               &picture, &got_picture, ptr, len);
1239
                    ist->st->quality= picture.quality;
1240
                    if (ret < 0)
1241
                        goto fail_decode;
1242
                    if (!got_picture) {
1243
                        /* no picture yet */
1244
                        goto discard_packet;
1245
                    }
1246
                    if (ist->st->codec->time_base.num != 0) {
1247
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1248
                                          ist->st->codec->time_base.num) /
1249
                            ist->st->codec->time_base.den;
1250
                    }
1251
                    len = 0;
1252
                    break;
1253
            case CODEC_TYPE_SUBTITLE:
1254
                ret = avcodec_decode_subtitle(ist->st->codec,
1255
                                              &subtitle, &got_subtitle, ptr, len);
1256
                if (ret < 0)
1257
                    goto fail_decode;
1258
                if (!got_subtitle) {
1259
                    goto discard_packet;
1260
                }
1261
                subtitle_to_free = &subtitle;
1262
                len = 0;
1263
                break;
1264
            default:
1265
                goto fail_decode;
1266
            }
1267
        } else {
1268
            switch(ist->st->codec->codec_type) {
1269
            case CODEC_TYPE_AUDIO:
1270
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1271
                    ist->st->codec->sample_rate;
1272
                break;
1273
            case CODEC_TYPE_VIDEO:
1274
                if (ist->st->codec->time_base.num != 0) {
1275
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1276
                                      ist->st->codec->time_base.num) /
1277
                        ist->st->codec->time_base.den;
1278
                }
1279
                break;
1280
            }
1281
            data_buf = ptr;
1282
            data_size = len;
1283
            ret = len;
1284
            len = 0;
1285
        }
1286

    
1287
        buffer_to_free = NULL;
1288
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1289
            pre_process_video_frame(ist, (AVPicture *)&picture,
1290
                                    &buffer_to_free);
1291
        }
1292

    
1293
        // preprocess audio (volume)
1294
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1295
            if (audio_volume != 256) {
1296
                short *volp;
1297
                volp = samples;
1298
                for(i=0;i<(data_size / sizeof(short));i++) {
1299
                    int v = ((*volp) * audio_volume + 128) >> 8;
1300
                    if (v < -32768) v = -32768;
1301
                    if (v >  32767) v = 32767;
1302
                    *volp++ = v;
1303
                }
1304
            }
1305
        }
1306

    
1307
        /* frame rate emulation */
1308
        if (rate_emu) {
1309
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1310
            int64_t now = av_gettime() - ist->start;
1311
            if (pts > now)
1312
                usleep(pts - now);
1313
        }
1314

    
1315
        /* if output time reached then transcode raw format,
1316
           encode packets and output them */
1317
        if (start_time == 0 || ist->pts >= start_time)
1318
            for(i=0;i<nb_ostreams;i++) {
1319
                int frame_size;
1320

    
1321
                ost = ost_table[i];
1322
                if (ost->source_index == ist_index) {
1323
                    os = output_files[ost->file_index];
1324

    
1325
#if 0
1326
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1327
                           (double)pkt->pts / AV_TIME_BASE,
1328
                           ((double)ist->pts / AV_TIME_BASE) -
1329
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1330
#endif
1331
                    /* set the input output pts pairs */
1332
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1333

    
1334
                    if (ost->encoding_needed) {
1335
                        switch(ost->st->codec->codec_type) {
1336
                        case CODEC_TYPE_AUDIO:
1337
                            do_audio_out(os, ost, ist, data_buf, data_size);
1338
                            break;
1339
                        case CODEC_TYPE_VIDEO:
1340
                            do_video_out(os, ost, ist, &picture, &frame_size);
1341
                            if (vstats_filename && frame_size)
1342
                                do_video_stats(os, ost, frame_size);
1343
                            break;
1344
                        case CODEC_TYPE_SUBTITLE:
1345
                            do_subtitle_out(os, ost, ist, &subtitle,
1346
                                            pkt->pts);
1347
                            break;
1348
                        default:
1349
                            abort();
1350
                        }
1351
                    } else {
1352
                        AVFrame avframe; //FIXME/XXX remove this
1353
                        AVPacket opkt;
1354
                        av_init_packet(&opkt);
1355

    
1356
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && start_time)
1357
                            continue;
1358

    
1359
                        /* no reencoding needed : output the packet directly */
1360
                        /* force the input stream PTS */
1361

    
1362
                        avcodec_get_frame_defaults(&avframe);
1363
                        ost->st->codec->coded_frame= &avframe;
1364
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1365

    
1366
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1367
                            audio_size += data_size;
1368
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1369
                            video_size += data_size;
1370
                            ost->sync_opts++;
1371
                        }
1372

    
1373
                        opkt.stream_index= ost->index;
1374
                        if(pkt->pts != AV_NOPTS_VALUE)
1375
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1376
                        else
1377
                            opkt.pts= AV_NOPTS_VALUE;
1378

    
1379
                        if (pkt->dts == AV_NOPTS_VALUE)
1380
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1381
                        else
1382
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1383

    
1384
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1385
                        opkt.flags= pkt->flags;
1386

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

    
1391
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1392
                        ost->st->codec->frame_number++;
1393
                        ost->frame_number++;
1394
                        av_free_packet(&opkt);
1395
                    }
1396
                }
1397
            }
1398
        av_free(buffer_to_free);
1399
        /* XXX: allocate the subtitles in the codec ? */
1400
        if (subtitle_to_free) {
1401
            if (subtitle_to_free->rects != NULL) {
1402
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1403
                    av_free(subtitle_to_free->rects[i].bitmap);
1404
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1405
                }
1406
                av_freep(&subtitle_to_free->rects);
1407
            }
1408
            subtitle_to_free->num_rects = 0;
1409
            subtitle_to_free = NULL;
1410
        }
1411
    }
1412
 discard_packet:
1413
    if (pkt == NULL) {
1414
        /* EOF handling */
1415

    
1416
        for(i=0;i<nb_ostreams;i++) {
1417
            ost = ost_table[i];
1418
            if (ost->source_index == ist_index) {
1419
                AVCodecContext *enc= ost->st->codec;
1420
                os = output_files[ost->file_index];
1421

    
1422
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1423
                    continue;
1424
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1425
                    continue;
1426

    
1427
                if (ost->encoding_needed) {
1428
                    for(;;) {
1429
                        AVPacket pkt;
1430
                        int fifo_bytes;
1431
                        av_init_packet(&pkt);
1432
                        pkt.stream_index= ost->index;
1433

    
1434
                        switch(ost->st->codec->codec_type) {
1435
                        case CODEC_TYPE_AUDIO:
1436
                            fifo_bytes = av_fifo_size(&ost->fifo);
1437
                            ret = 0;
1438
                            /* encode any samples remaining in fifo */
1439
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1440
                                int fs_tmp = enc->frame_size;
1441
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1442
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1443
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1444
                                enc->frame_size = fs_tmp;
1445
                            }
1446
                            if(ret <= 0) {
1447
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1448
                            }
1449
                            audio_size += ret;
1450
                            pkt.flags |= PKT_FLAG_KEY;
1451
                            break;
1452
                        case CODEC_TYPE_VIDEO:
1453
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1454
                            video_size += ret;
1455
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1456
                                pkt.flags |= PKT_FLAG_KEY;
1457
                            if (ost->logfile && enc->stats_out) {
1458
                                fprintf(ost->logfile, "%s", enc->stats_out);
1459
                            }
1460
                            break;
1461
                        default:
1462
                            ret=-1;
1463
                        }
1464

    
1465
                        if(ret<=0)
1466
                            break;
1467
                        pkt.data= bit_buffer;
1468
                        pkt.size= ret;
1469
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1470
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1471
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1472
                    }
1473
                }
1474
            }
1475
        }
1476
    }
1477

    
1478
    return 0;
1479
 fail_decode:
1480
    return -1;
1481
}
1482

    
1483
static void print_sdp(AVFormatContext **avc, int n)
1484
{
1485
    char sdp[2048];
1486

    
1487
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1488
    printf("SDP:\n%s\n", sdp);
1489
    fflush(stdout);
1490
}
1491

    
1492
static int stream_index_from_inputs(AVFormatContext **input_files,
1493
                                    int nb_input_files,
1494
                                    AVInputFile *file_table,
1495
                                    AVInputStream **ist_table,
1496
                                    enum CodecType type,
1497
                                    int programid)
1498
{
1499
    int p, q, z;
1500
    for(z=0; z<nb_input_files; z++) {
1501
        AVFormatContext *ic = input_files[z];
1502
        for(p=0; p<ic->nb_programs; p++) {
1503
            AVProgram *program = ic->programs[p];
1504
            if(program->id != programid)
1505
                continue;
1506
            for(q=0; q<program->nb_stream_indexes; q++) {
1507
                int sidx = program->stream_index[q];
1508
                int ris = file_table[z].ist_index + sidx;
1509
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1510
                    return ris;
1511
            }
1512
        }
1513
    }
1514

    
1515
    return -1;
1516
}
1517

    
1518
/*
1519
 * The following code is the main loop of the file converter
1520
 */
1521
static int av_encode(AVFormatContext **output_files,
1522
                     int nb_output_files,
1523
                     AVFormatContext **input_files,
1524
                     int nb_input_files,
1525
                     AVStreamMap *stream_maps, int nb_stream_maps)
1526
{
1527
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1528
    AVFormatContext *is, *os;
1529
    AVCodecContext *codec, *icodec;
1530
    AVOutputStream *ost, **ost_table = NULL;
1531
    AVInputStream *ist, **ist_table = NULL;
1532
    AVInputFile *file_table;
1533
    int key;
1534
    int want_sdp = 1;
1535

    
1536
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1537
    if (!file_table)
1538
        goto fail;
1539

    
1540
    /* input stream init */
1541
    j = 0;
1542
    for(i=0;i<nb_input_files;i++) {
1543
        is = input_files[i];
1544
        file_table[i].ist_index = j;
1545
        file_table[i].nb_streams = is->nb_streams;
1546
        j += is->nb_streams;
1547
    }
1548
    nb_istreams = j;
1549

    
1550
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1551
    if (!ist_table)
1552
        goto fail;
1553

    
1554
    for(i=0;i<nb_istreams;i++) {
1555
        ist = av_mallocz(sizeof(AVInputStream));
1556
        if (!ist)
1557
            goto fail;
1558
        ist_table[i] = ist;
1559
    }
1560
    j = 0;
1561
    for(i=0;i<nb_input_files;i++) {
1562
        is = input_files[i];
1563
        for(k=0;k<is->nb_streams;k++) {
1564
            ist = ist_table[j++];
1565
            ist->st = is->streams[k];
1566
            ist->file_index = i;
1567
            ist->index = k;
1568
            ist->discard = 1; /* the stream is discarded by default
1569
                                 (changed later) */
1570

    
1571
            if (rate_emu) {
1572
                ist->start = av_gettime();
1573
            }
1574
        }
1575
    }
1576

    
1577
    /* output stream init */
1578
    nb_ostreams = 0;
1579
    for(i=0;i<nb_output_files;i++) {
1580
        os = output_files[i];
1581
        if (!os->nb_streams) {
1582
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1583
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1584
            av_exit(1);
1585
        }
1586
        nb_ostreams += os->nb_streams;
1587
    }
1588
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1589
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1590
        av_exit(1);
1591
    }
1592

    
1593
    /* Sanity check the mapping args -- do the input files & streams exist? */
1594
    for(i=0;i<nb_stream_maps;i++) {
1595
        int fi = stream_maps[i].file_index;
1596
        int si = stream_maps[i].stream_index;
1597

    
1598
        if (fi < 0 || fi > nb_input_files - 1 ||
1599
            si < 0 || si > file_table[fi].nb_streams - 1) {
1600
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1601
            av_exit(1);
1602
        }
1603
        fi = stream_maps[i].sync_file_index;
1604
        si = stream_maps[i].sync_stream_index;
1605
        if (fi < 0 || fi > nb_input_files - 1 ||
1606
            si < 0 || si > file_table[fi].nb_streams - 1) {
1607
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1608
            av_exit(1);
1609
        }
1610
    }
1611

    
1612
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1613
    if (!ost_table)
1614
        goto fail;
1615
    for(i=0;i<nb_ostreams;i++) {
1616
        ost = av_mallocz(sizeof(AVOutputStream));
1617
        if (!ost)
1618
            goto fail;
1619
        ost_table[i] = ost;
1620
    }
1621

    
1622
    n = 0;
1623
    for(k=0;k<nb_output_files;k++) {
1624
        os = output_files[k];
1625
        for(i=0;i<os->nb_streams;i++,n++) {
1626
            int found;
1627
            ost = ost_table[n];
1628
            ost->file_index = k;
1629
            ost->index = i;
1630
            ost->st = os->streams[i];
1631
            if (nb_stream_maps > 0) {
1632
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1633
                    stream_maps[n].stream_index;
1634

    
1635
                /* Sanity check that the stream types match */
1636
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1637
                    int i= ost->file_index;
1638
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1639
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1640
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1641
                        ost->file_index, ost->index);
1642
                    av_exit(1);
1643
                }
1644

    
1645
            } else {
1646
                if(opt_programid) {
1647
                    found = 0;
1648
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1649
                    if(j != -1) {
1650
                        ost->source_index = j;
1651
                        found = 1;
1652
                    }
1653
                } else {
1654
                    /* get corresponding input stream index : we select the first one with the right type */
1655
                    found = 0;
1656
                    for(j=0;j<nb_istreams;j++) {
1657
                        ist = ist_table[j];
1658
                        if (ist->discard &&
1659
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1660
                            ost->source_index = j;
1661
                            found = 1;
1662
                            break;
1663
                        }
1664
                    }
1665
                }
1666

    
1667
                if (!found) {
1668
                    if(! opt_programid) {
1669
                        /* try again and reuse existing stream */
1670
                        for(j=0;j<nb_istreams;j++) {
1671
                            ist = ist_table[j];
1672
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1673
                                ost->source_index = j;
1674
                                found = 1;
1675
                            }
1676
                        }
1677
                    }
1678
                    if (!found) {
1679
                        int i= ost->file_index;
1680
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1681
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1682
                                ost->file_index, ost->index);
1683
                        av_exit(1);
1684
                    }
1685
                }
1686
            }
1687
            ist = ist_table[ost->source_index];
1688
            ist->discard = 0;
1689
            ost->sync_ist = (nb_stream_maps > 0) ?
1690
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1691
                         stream_maps[n].sync_stream_index] : ist;
1692
        }
1693
    }
1694

    
1695
    /* for each output stream, we compute the right encoding parameters */
1696
    for(i=0;i<nb_ostreams;i++) {
1697
        ost = ost_table[i];
1698
        os = output_files[ost->file_index];
1699
        ist = ist_table[ost->source_index];
1700

    
1701
        codec = ost->st->codec;
1702
        icodec = ist->st->codec;
1703

    
1704
        if (!ost->st->language[0])
1705
            av_strlcpy(ost->st->language, ist->st->language,
1706
                       sizeof(ost->st->language));
1707

    
1708
        ost->st->disposition = ist->st->disposition;
1709

    
1710
        if (ost->st->stream_copy) {
1711
            /* if stream_copy is selected, no need to decode or encode */
1712
            codec->codec_id = icodec->codec_id;
1713
            codec->codec_type = icodec->codec_type;
1714

    
1715
            if(!codec->codec_tag){
1716
                if(   !os->oformat->codec_tag
1717
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1718
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1719
                    codec->codec_tag = icodec->codec_tag;
1720
            }
1721

    
1722
            codec->bit_rate = icodec->bit_rate;
1723
            codec->extradata= icodec->extradata;
1724
            codec->extradata_size= icodec->extradata_size;
1725
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1726
                codec->time_base = icodec->time_base;
1727
            else
1728
                codec->time_base = ist->st->time_base;
1729
            switch(codec->codec_type) {
1730
            case CODEC_TYPE_AUDIO:
1731
                if(audio_volume != 256) {
1732
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1733
                    av_exit(1);
1734
                }
1735
                codec->channel_layout = icodec->channel_layout;
1736
                codec->sample_rate = icodec->sample_rate;
1737
                codec->channels = icodec->channels;
1738
                codec->frame_size = icodec->frame_size;
1739
                codec->block_align= icodec->block_align;
1740
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1741
                    codec->block_align= 0;
1742
                if(codec->codec_id == CODEC_ID_AC3)
1743
                    codec->block_align= 0;
1744
                break;
1745
            case CODEC_TYPE_VIDEO:
1746
                if(using_vhook) {
1747
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1748
                    av_exit(1);
1749
                }
1750
                codec->pix_fmt = icodec->pix_fmt;
1751
                codec->width = icodec->width;
1752
                codec->height = icodec->height;
1753
                codec->has_b_frames = icodec->has_b_frames;
1754
                break;
1755
            case CODEC_TYPE_SUBTITLE:
1756
                break;
1757
            default:
1758
                abort();
1759
            }
1760
        } else {
1761
            switch(codec->codec_type) {
1762
            case CODEC_TYPE_AUDIO:
1763
                if (av_fifo_init(&ost->fifo, 1024))
1764
                    goto fail;
1765
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1766
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1767
                icodec->request_channels = codec->channels;
1768
                ist->decoding_needed = 1;
1769
                ost->encoding_needed = 1;
1770
                break;
1771
            case CODEC_TYPE_VIDEO:
1772
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1773
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1774
                ost->video_resample = ((codec->width != icodec->width -
1775
                                (frame_leftBand + frame_rightBand) +
1776
                                (frame_padleft + frame_padright)) ||
1777
                        (codec->height != icodec->height -
1778
                                (frame_topBand  + frame_bottomBand) +
1779
                                (frame_padtop + frame_padbottom)) ||
1780
                        (codec->pix_fmt != icodec->pix_fmt));
1781
                if (ost->video_crop) {
1782
                    ost->topBand = frame_topBand;
1783
                    ost->leftBand = frame_leftBand;
1784
                }
1785
                if (ost->video_pad) {
1786
                    ost->padtop = frame_padtop;
1787
                    ost->padleft = frame_padleft;
1788
                    ost->padbottom = frame_padbottom;
1789
                    ost->padright = frame_padright;
1790
                    if (!ost->video_resample) {
1791
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1792
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1793
                                         codec->width, codec->height))
1794
                            goto fail;
1795
                    }
1796
                }
1797
                if (ost->video_resample) {
1798
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1799
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1800
                                         codec->width, codec->height)) {
1801
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1802
                        av_exit(1);
1803
                    }
1804
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1805
                    ost->img_resample_ctx = sws_getContext(
1806
                            icodec->width - (frame_leftBand + frame_rightBand),
1807
                            icodec->height - (frame_topBand + frame_bottomBand),
1808
                            icodec->pix_fmt,
1809
                            codec->width - (frame_padleft + frame_padright),
1810
                            codec->height - (frame_padtop + frame_padbottom),
1811
                            codec->pix_fmt,
1812
                            sws_flags, NULL, NULL, NULL);
1813
                    if (ost->img_resample_ctx == NULL) {
1814
                        fprintf(stderr, "Cannot get resampling context\n");
1815
                        av_exit(1);
1816
                    }
1817
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1818
                }
1819
                ost->encoding_needed = 1;
1820
                ist->decoding_needed = 1;
1821
                break;
1822
            case CODEC_TYPE_SUBTITLE:
1823
                ost->encoding_needed = 1;
1824
                ist->decoding_needed = 1;
1825
                break;
1826
            default:
1827
                abort();
1828
                break;
1829
            }
1830
            /* two pass mode */
1831
            if (ost->encoding_needed &&
1832
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1833
                char logfilename[1024];
1834
                FILE *f;
1835
                int size;
1836
                char *logbuffer;
1837

    
1838
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1839
                         pass_logfilename ?
1840
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1841
                if (codec->flags & CODEC_FLAG_PASS1) {
1842
                    f = fopen(logfilename, "w");
1843
                    if (!f) {
1844
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1845
                        av_exit(1);
1846
                    }
1847
                    ost->logfile = f;
1848
                } else {
1849
                    /* read the log file */
1850
                    f = fopen(logfilename, "r");
1851
                    if (!f) {
1852
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1853
                        av_exit(1);
1854
                    }
1855
                    fseek(f, 0, SEEK_END);
1856
                    size = ftell(f);
1857
                    fseek(f, 0, SEEK_SET);
1858
                    logbuffer = av_malloc(size + 1);
1859
                    if (!logbuffer) {
1860
                        fprintf(stderr, "Could not allocate log buffer\n");
1861
                        av_exit(1);
1862
                    }
1863
                    size = fread(logbuffer, 1, size, f);
1864
                    fclose(f);
1865
                    logbuffer[size] = '\0';
1866
                    codec->stats_in = logbuffer;
1867
                }
1868
            }
1869
        }
1870
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1871
            int size= codec->width * codec->height;
1872
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1873
        }
1874
    }
1875

    
1876
    if (!bit_buffer)
1877
        bit_buffer = av_malloc(bit_buffer_size);
1878
    if (!bit_buffer)
1879
        goto fail;
1880

    
1881
    /* dump the file output parameters - cannot be done before in case
1882
       of stream copy */
1883
    for(i=0;i<nb_output_files;i++) {
1884
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1885
    }
1886

    
1887
    /* dump the stream mapping */
1888
    if (verbose >= 0) {
1889
        fprintf(stderr, "Stream mapping:\n");
1890
        for(i=0;i<nb_ostreams;i++) {
1891
            ost = ost_table[i];
1892
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1893
                    ist_table[ost->source_index]->file_index,
1894
                    ist_table[ost->source_index]->index,
1895
                    ost->file_index,
1896
                    ost->index);
1897
            if (ost->sync_ist != ist_table[ost->source_index])
1898
                fprintf(stderr, " [sync #%d.%d]",
1899
                        ost->sync_ist->file_index,
1900
                        ost->sync_ist->index);
1901
            fprintf(stderr, "\n");
1902
        }
1903
    }
1904

    
1905
    /* open each encoder */
1906
    for(i=0;i<nb_ostreams;i++) {
1907
        ost = ost_table[i];
1908
        if (ost->encoding_needed) {
1909
            AVCodec *codec = output_codecs[i];
1910
            if (!codec)
1911
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1912
            if (!codec) {
1913
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1914
                        ost->file_index, ost->index);
1915
                av_exit(1);
1916
            }
1917
            if (avcodec_open(ost->st->codec, codec) < 0) {
1918
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1919
                        ost->file_index, ost->index);
1920
                av_exit(1);
1921
            }
1922
            extra_size += ost->st->codec->extradata_size;
1923
        }
1924
    }
1925

    
1926
    /* open each decoder */
1927
    for(i=0;i<nb_istreams;i++) {
1928
        ist = ist_table[i];
1929
        if (ist->decoding_needed) {
1930
            AVCodec *codec = input_codecs[i];
1931
            if (!codec)
1932
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1933
            if (!codec) {
1934
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1935
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1936
                av_exit(1);
1937
            }
1938
            if (avcodec_open(ist->st->codec, codec) < 0) {
1939
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1940
                        ist->file_index, ist->index);
1941
                av_exit(1);
1942
            }
1943
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1944
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1945
        }
1946
    }
1947

    
1948
    /* init pts */
1949
    for(i=0;i<nb_istreams;i++) {
1950
        ist = ist_table[i];
1951
        is = input_files[ist->file_index];
1952
        ist->pts = 0;
1953
        ist->next_pts = AV_NOPTS_VALUE;
1954
        ist->is_start = 1;
1955
    }
1956

    
1957
    /* set meta data information from input file if required */
1958
    for (i=0;i<nb_meta_data_maps;i++) {
1959
        AVFormatContext *out_file;
1960
        AVFormatContext *in_file;
1961

    
1962
        int out_file_index = meta_data_maps[i].out_file;
1963
        int in_file_index = meta_data_maps[i].in_file;
1964
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1965
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1966
            ret = AVERROR(EINVAL);
1967
            goto fail;
1968
        }
1969
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1970
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1971
            ret = AVERROR(EINVAL);
1972
            goto fail;
1973
        }
1974

    
1975
        out_file = output_files[out_file_index];
1976
        in_file = input_files[in_file_index];
1977

    
1978
        strcpy(out_file->title, in_file->title);
1979
        strcpy(out_file->author, in_file->author);
1980
        strcpy(out_file->copyright, in_file->copyright);
1981
        strcpy(out_file->comment, in_file->comment);
1982
        strcpy(out_file->album, in_file->album);
1983
        out_file->year = in_file->year;
1984
        out_file->track = in_file->track;
1985
        strcpy(out_file->genre, in_file->genre);
1986
    }
1987

    
1988
    /* open files and write file headers */
1989
    for(i=0;i<nb_output_files;i++) {
1990
        os = output_files[i];
1991
        if (av_write_header(os) < 0) {
1992
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1993
            ret = AVERROR(EINVAL);
1994
            goto fail;
1995
        }
1996
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1997
            want_sdp = 0;
1998
        }
1999
    }
2000
    if (want_sdp) {
2001
        print_sdp(output_files, nb_output_files);
2002
    }
2003

    
2004
    if (!using_stdin && verbose >= 0) {
2005
        fprintf(stderr, "Press [q] to stop encoding\n");
2006
        url_set_interrupt_cb(decode_interrupt_cb);
2007
    }
2008
    term_init();
2009

    
2010
    key = -1;
2011
    timer_start = av_gettime();
2012

    
2013
    for(; received_sigterm == 0;) {
2014
        int file_index, ist_index;
2015
        AVPacket pkt;
2016
        double ipts_min;
2017
        double opts_min;
2018

    
2019
    redo:
2020
        ipts_min= 1e100;
2021
        opts_min= 1e100;
2022
        /* if 'q' pressed, exits */
2023
        if (!using_stdin) {
2024
            if (q_pressed)
2025
                break;
2026
            /* read_key() returns 0 on EOF */
2027
            key = read_key();
2028
            if (key == 'q')
2029
                break;
2030
        }
2031

    
2032
        /* select the stream that we must read now by looking at the
2033
           smallest output pts */
2034
        file_index = -1;
2035
        for(i=0;i<nb_ostreams;i++) {
2036
            double ipts, opts;
2037
            ost = ost_table[i];
2038
            os = output_files[ost->file_index];
2039
            ist = ist_table[ost->source_index];
2040
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2041
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2042
            else
2043
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2044
            ipts = (double)ist->pts;
2045
            if (!file_table[ist->file_index].eof_reached){
2046
                if(ipts < ipts_min) {
2047
                    ipts_min = ipts;
2048
                    if(input_sync ) file_index = ist->file_index;
2049
                }
2050
                if(opts < opts_min) {
2051
                    opts_min = opts;
2052
                    if(!input_sync) file_index = ist->file_index;
2053
                }
2054
            }
2055
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2056
                file_index= -1;
2057
                break;
2058
            }
2059
        }
2060
        /* if none, if is finished */
2061
        if (file_index < 0) {
2062
            break;
2063
        }
2064

    
2065
        /* finish if recording time exhausted */
2066
        if (opts_min >= (recording_time / 1000000.0))
2067
            break;
2068

    
2069
        /* finish if limit size exhausted */
2070
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2071
            break;
2072

    
2073
        /* read a frame from it and output it in the fifo */
2074
        is = input_files[file_index];
2075
        if (av_read_frame(is, &pkt) < 0) {
2076
            file_table[file_index].eof_reached = 1;
2077
            if (opt_shortest)
2078
                break;
2079
            else
2080
                continue;
2081
        }
2082

    
2083
        if (do_pkt_dump) {
2084
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2085
        }
2086
        /* the following test is needed in case new streams appear
2087
           dynamically in stream : we ignore them */
2088
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2089
            goto discard_packet;
2090
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2091
        ist = ist_table[ist_index];
2092
        if (ist->discard)
2093
            goto discard_packet;
2094

    
2095
        if (pkt.dts != AV_NOPTS_VALUE)
2096
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2097
        if (pkt.pts != AV_NOPTS_VALUE)
2098
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2099

    
2100
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2101
            if(pkt.pts != AV_NOPTS_VALUE)
2102
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2103
            if(pkt.dts != AV_NOPTS_VALUE)
2104
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2105
        }
2106

    
2107
//        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);
2108
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2109
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2110
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2111
            int64_t delta= pkt_dts - ist->next_pts;
2112
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2113
                input_files_ts_offset[ist->file_index]-= delta;
2114
                if (verbose > 2)
2115
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2116
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2117
                if(pkt.pts != AV_NOPTS_VALUE)
2118
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2119
            }
2120
        }
2121

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

    
2125
            if (verbose >= 0)
2126
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2127
                        ist->file_index, ist->index);
2128
            if (exit_on_error)
2129
                av_exit(1);
2130
            av_free_packet(&pkt);
2131
            goto redo;
2132
        }
2133

    
2134
    discard_packet:
2135
        av_free_packet(&pkt);
2136

    
2137
        /* dump report by using the output first video and audio streams */
2138
        print_report(output_files, ost_table, nb_ostreams, 0);
2139
    }
2140

    
2141
    /* at the end of stream, we must flush the decoder buffers */
2142
    for(i=0;i<nb_istreams;i++) {
2143
        ist = ist_table[i];
2144
        if (ist->decoding_needed) {
2145
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2146
        }
2147
    }
2148

    
2149
    term_exit();
2150

    
2151
    /* write the trailer if needed and close file */
2152
    for(i=0;i<nb_output_files;i++) {
2153
        os = output_files[i];
2154
        av_write_trailer(os);
2155
    }
2156

    
2157
    /* dump report by using the first video and audio streams */
2158
    print_report(output_files, ost_table, nb_ostreams, 1);
2159

    
2160
    /* close each encoder */
2161
    for(i=0;i<nb_ostreams;i++) {
2162
        ost = ost_table[i];
2163
        if (ost->encoding_needed) {
2164
            av_freep(&ost->st->codec->stats_in);
2165
            avcodec_close(ost->st->codec);
2166
        }
2167
    }
2168

    
2169
    /* close each decoder */
2170
    for(i=0;i<nb_istreams;i++) {
2171
        ist = ist_table[i];
2172
        if (ist->decoding_needed) {
2173
            avcodec_close(ist->st->codec);
2174
        }
2175
    }
2176

    
2177
    /* finished ! */
2178

    
2179
    ret = 0;
2180
 fail1:
2181
    av_freep(&bit_buffer);
2182
    av_free(file_table);
2183

    
2184
    if (ist_table) {
2185
        for(i=0;i<nb_istreams;i++) {
2186
            ist = ist_table[i];
2187
            av_free(ist);
2188
        }
2189
        av_free(ist_table);
2190
    }
2191
    if (ost_table) {
2192
        for(i=0;i<nb_ostreams;i++) {
2193
            ost = ost_table[i];
2194
            if (ost) {
2195
                if (ost->logfile) {
2196
                    fclose(ost->logfile);
2197
                    ost->logfile = NULL;
2198
                }
2199
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2200
                                             initialized but set to zero */
2201
                av_free(ost->pict_tmp.data[0]);
2202
                if (ost->video_resample)
2203
                    sws_freeContext(ost->img_resample_ctx);
2204
                if (ost->resample)
2205
                    audio_resample_close(ost->resample);
2206
                if (ost->reformat_ctx)
2207
                    av_audio_convert_free(ost->reformat_ctx);
2208
                av_free(ost);
2209
            }
2210
        }
2211
        av_free(ost_table);
2212
    }
2213
    return ret;
2214
 fail:
2215
    ret = AVERROR(ENOMEM);
2216
    goto fail1;
2217
}
2218

    
2219
#if 0
2220
int file_read(const char *filename)
2221
{
2222
    URLContext *h;
2223
    unsigned char buffer[1024];
2224
    int len, i;
2225

2226
    if (url_open(&h, filename, O_RDONLY) < 0) {
2227
        printf("could not open '%s'\n", filename);
2228
        return -1;
2229
    }
2230
    for(;;) {
2231
        len = url_read(h, buffer, sizeof(buffer));
2232
        if (len <= 0)
2233
            break;
2234
        for(i=0;i<len;i++) putchar(buffer[i]);
2235
    }
2236
    url_close(h);
2237
    return 0;
2238
}
2239
#endif
2240

    
2241
static void opt_format(const char *arg)
2242
{
2243
    /* compatibility stuff for pgmyuv */
2244
    if (!strcmp(arg, "pgmyuv")) {
2245
        pgmyuv_compatibility_hack=1;
2246
//        opt_image_format(arg);
2247
        arg = "image2";
2248
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2249
    }
2250

    
2251
    file_iformat = av_find_input_format(arg);
2252
    file_oformat = guess_format(arg, NULL, NULL);
2253
    if (!file_iformat && !file_oformat) {
2254
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2255
        av_exit(1);
2256
    }
2257
}
2258

    
2259
static void opt_video_rc_override_string(const char *arg)
2260
{
2261
    video_rc_override_string = arg;
2262
}
2263

    
2264
static int opt_me_threshold(const char *opt, const char *arg)
2265
{
2266
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2267
    return 0;
2268
}
2269

    
2270
static int opt_verbose(const char *opt, const char *arg)
2271
{
2272
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2273
    av_log_set_level(verbose);
2274
    return 0;
2275
}
2276

    
2277
static int opt_frame_rate(const char *opt, const char *arg)
2278
{
2279
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2280
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2281
        av_exit(1);
2282
    }
2283
    return 0;
2284
}
2285

    
2286
static int opt_bitrate(const char *opt, const char *arg)
2287
{
2288
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2289

    
2290
    opt_default(opt, arg);
2291

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

    
2295
    return 0;
2296
}
2297

    
2298
static void opt_frame_crop_top(const char *arg)
2299
{
2300
    frame_topBand = atoi(arg);
2301
    if (frame_topBand < 0) {
2302
        fprintf(stderr, "Incorrect top crop size\n");
2303
        av_exit(1);
2304
    }
2305
    if ((frame_topBand % 2) != 0) {
2306
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2307
        av_exit(1);
2308
    }
2309
    if ((frame_topBand) >= frame_height){
2310
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2311
        av_exit(1);
2312
    }
2313
    frame_height -= frame_topBand;
2314
}
2315

    
2316
static void opt_frame_crop_bottom(const char *arg)
2317
{
2318
    frame_bottomBand = atoi(arg);
2319
    if (frame_bottomBand < 0) {
2320
        fprintf(stderr, "Incorrect bottom crop size\n");
2321
        av_exit(1);
2322
    }
2323
    if ((frame_bottomBand % 2) != 0) {
2324
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2325
        av_exit(1);
2326
    }
2327
    if ((frame_bottomBand) >= frame_height){
2328
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2329
        av_exit(1);
2330
    }
2331
    frame_height -= frame_bottomBand;
2332
}
2333

    
2334
static void opt_frame_crop_left(const char *arg)
2335
{
2336
    frame_leftBand = atoi(arg);
2337
    if (frame_leftBand < 0) {
2338
        fprintf(stderr, "Incorrect left crop size\n");
2339
        av_exit(1);
2340
    }
2341
    if ((frame_leftBand % 2) != 0) {
2342
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2343
        av_exit(1);
2344
    }
2345
    if ((frame_leftBand) >= frame_width){
2346
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2347
        av_exit(1);
2348
    }
2349
    frame_width -= frame_leftBand;
2350
}
2351

    
2352
static void opt_frame_crop_right(const char *arg)
2353
{
2354
    frame_rightBand = atoi(arg);
2355
    if (frame_rightBand < 0) {
2356
        fprintf(stderr, "Incorrect right crop size\n");
2357
        av_exit(1);
2358
    }
2359
    if ((frame_rightBand % 2) != 0) {
2360
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2361
        av_exit(1);
2362
    }
2363
    if ((frame_rightBand) >= frame_width){
2364
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2365
        av_exit(1);
2366
    }
2367
    frame_width -= frame_rightBand;
2368
}
2369

    
2370
static void opt_frame_size(const char *arg)
2371
{
2372
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2373
        fprintf(stderr, "Incorrect frame size\n");
2374
        av_exit(1);
2375
    }
2376
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2377
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2378
        av_exit(1);
2379
    }
2380
}
2381

    
2382

    
2383
#define SCALEBITS 10
2384
#define ONE_HALF  (1 << (SCALEBITS - 1))
2385
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2386

    
2387
#define RGB_TO_Y(r, g, b) \
2388
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2389
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2390

    
2391
#define RGB_TO_U(r1, g1, b1, shift)\
2392
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2393
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2394

    
2395
#define RGB_TO_V(r1, g1, b1, shift)\
2396
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2397
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2398

    
2399
static void opt_pad_color(const char *arg) {
2400
    /* Input is expected to be six hex digits similar to
2401
       how colors are expressed in html tags (but without the #) */
2402
    int rgb = strtol(arg, NULL, 16);
2403
    int r,g,b;
2404

    
2405
    r = (rgb >> 16);
2406
    g = ((rgb >> 8) & 255);
2407
    b = (rgb & 255);
2408

    
2409
    padcolor[0] = RGB_TO_Y(r,g,b);
2410
    padcolor[1] = RGB_TO_U(r,g,b,0);
2411
    padcolor[2] = RGB_TO_V(r,g,b,0);
2412
}
2413

    
2414
static void opt_frame_pad_top(const char *arg)
2415
{
2416
    frame_padtop = atoi(arg);
2417
    if (frame_padtop < 0) {
2418
        fprintf(stderr, "Incorrect top pad size\n");
2419
        av_exit(1);
2420
    }
2421
    if ((frame_padtop % 2) != 0) {
2422
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2423
        av_exit(1);
2424
    }
2425
}
2426

    
2427
static void opt_frame_pad_bottom(const char *arg)
2428
{
2429
    frame_padbottom = atoi(arg);
2430
    if (frame_padbottom < 0) {
2431
        fprintf(stderr, "Incorrect bottom pad size\n");
2432
        av_exit(1);
2433
    }
2434
    if ((frame_padbottom % 2) != 0) {
2435
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2436
        av_exit(1);
2437
    }
2438
}
2439

    
2440

    
2441
static void opt_frame_pad_left(const char *arg)
2442
{
2443
    frame_padleft = atoi(arg);
2444
    if (frame_padleft < 0) {
2445
        fprintf(stderr, "Incorrect left pad size\n");
2446
        av_exit(1);
2447
    }
2448
    if ((frame_padleft % 2) != 0) {
2449
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2450
        av_exit(1);
2451
    }
2452
}
2453

    
2454

    
2455
static void opt_frame_pad_right(const char *arg)
2456
{
2457
    frame_padright = atoi(arg);
2458
    if (frame_padright < 0) {
2459
        fprintf(stderr, "Incorrect right pad size\n");
2460
        av_exit(1);
2461
    }
2462
    if ((frame_padright % 2) != 0) {
2463
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2464
        av_exit(1);
2465
    }
2466
}
2467

    
2468
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2469
{
2470
    int i;
2471
    char fmt_str[128];
2472
    for (i=-1; i < nb_fmts; i++) {
2473
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2474
        fprintf(stdout, "%s\n", fmt_str);
2475
    }
2476
}
2477

    
2478
static void opt_frame_pix_fmt(const char *arg)
2479
{
2480
    if (strcmp(arg, "list"))
2481
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2482
    else {
2483
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2484
        av_exit(0);
2485
    }
2486
}
2487

    
2488
static void opt_frame_aspect_ratio(const char *arg)
2489
{
2490
    int x = 0, y = 0;
2491
    double ar = 0;
2492
    const char *p;
2493
    char *end;
2494

    
2495
    p = strchr(arg, ':');
2496
    if (p) {
2497
        x = strtol(arg, &end, 10);
2498
        if (end == p)
2499
            y = strtol(end+1, &end, 10);
2500
        if (x > 0 && y > 0)
2501
            ar = (double)x / (double)y;
2502
    } else
2503
        ar = strtod(arg, NULL);
2504

    
2505
    if (!ar) {
2506
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2507
        av_exit(1);
2508
    }
2509
    frame_aspect_ratio = ar;
2510
}
2511

    
2512
static void opt_qscale(const char *arg)
2513
{
2514
    video_qscale = atof(arg);
2515
    if (video_qscale <= 0 ||
2516
        video_qscale > 255) {
2517
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2518
        av_exit(1);
2519
    }
2520
}
2521

    
2522
static void opt_top_field_first(const char *arg)
2523
{
2524
    top_field_first= atoi(arg);
2525
}
2526

    
2527
static int opt_thread_count(const char *opt, const char *arg)
2528
{
2529
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2530
#if !defined(HAVE_THREADS)
2531
    if (verbose >= 0)
2532
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2533
#endif
2534
    return 0;
2535
}
2536

    
2537
static void opt_audio_sample_fmt(const char *arg)
2538
{
2539
    if (strcmp(arg, "list"))
2540
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2541
    else {
2542
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2543
        av_exit(0);
2544
    }
2545
}
2546

    
2547
static int opt_audio_rate(const char *opt, const char *arg)
2548
{
2549
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2550
    return 0;
2551
}
2552

    
2553
static int opt_audio_channels(const char *opt, const char *arg)
2554
{
2555
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2556
    return 0;
2557
}
2558

    
2559
static void opt_video_channel(const char *arg)
2560
{
2561
    video_channel = strtol(arg, NULL, 0);
2562
}
2563

    
2564
static void opt_video_standard(const char *arg)
2565
{
2566
    video_standard = av_strdup(arg);
2567
}
2568

    
2569
static void opt_codec(int *pstream_copy, char **pcodec_name,
2570
                      int codec_type, const char *arg)
2571
{
2572
    av_freep(pcodec_name);
2573
    if (!strcmp(arg, "copy")) {
2574
        *pstream_copy = 1;
2575
    } else {
2576
        *pcodec_name = av_strdup(arg);
2577
    }
2578
}
2579

    
2580
static void opt_audio_codec(const char *arg)
2581
{
2582
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2583
}
2584

    
2585
static void opt_audio_tag(const char *arg)
2586
{
2587
    char *tail;
2588
    audio_codec_tag= strtol(arg, &tail, 0);
2589

    
2590
    if(!tail || *tail)
2591
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2592
}
2593

    
2594
static void opt_video_tag(const char *arg)
2595
{
2596
    char *tail;
2597
    video_codec_tag= strtol(arg, &tail, 0);
2598

    
2599
    if(!tail || *tail)
2600
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2601
}
2602

    
2603
#ifdef CONFIG_VHOOK
2604
static void add_frame_hooker(const char *arg)
2605
{
2606
    int argc = 0;
2607
    char *argv[64];
2608
    int i;
2609
    char *args = av_strdup(arg);
2610

    
2611
    using_vhook = 1;
2612

    
2613
    argv[0] = strtok(args, " ");
2614
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2615
    }
2616

    
2617
    i = frame_hook_add(argc, argv);
2618

    
2619
    if (i != 0) {
2620
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2621
        av_exit(1);
2622
    }
2623
}
2624
#endif
2625

    
2626
static void opt_video_codec(const char *arg)
2627
{
2628
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2629
}
2630

    
2631
static void opt_subtitle_codec(const char *arg)
2632
{
2633
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2634
}
2635

    
2636
static void opt_map(const char *arg)
2637
{
2638
    AVStreamMap *m;
2639
    char *p;
2640

    
2641
    m = &stream_maps[nb_stream_maps++];
2642

    
2643
    m->file_index = strtol(arg, &p, 0);
2644
    if (*p)
2645
        p++;
2646

    
2647
    m->stream_index = strtol(p, &p, 0);
2648
    if (*p) {
2649
        p++;
2650
        m->sync_file_index = strtol(p, &p, 0);
2651
        if (*p)
2652
            p++;
2653
        m->sync_stream_index = strtol(p, &p, 0);
2654
    } else {
2655
        m->sync_file_index = m->file_index;
2656
        m->sync_stream_index = m->stream_index;
2657
    }
2658
}
2659

    
2660
static void opt_map_meta_data(const char *arg)
2661
{
2662
    AVMetaDataMap *m;
2663
    char *p;
2664

    
2665
    m = &meta_data_maps[nb_meta_data_maps++];
2666

    
2667
    m->out_file = strtol(arg, &p, 0);
2668
    if (*p)
2669
        p++;
2670

    
2671
    m->in_file = strtol(p, &p, 0);
2672
}
2673

    
2674
static void opt_input_ts_scale(const char *arg)
2675
{
2676
    unsigned int stream;
2677
    double scale;
2678
    char *p;
2679

    
2680
    stream = strtol(arg, &p, 0);
2681
    if (*p)
2682
        p++;
2683
    scale= strtod(p, &p);
2684

    
2685
    if(stream >= MAX_STREAMS)
2686
        av_exit(1);
2687

    
2688
    input_files_ts_scale[nb_input_files][stream]= scale;
2689
}
2690

    
2691
static int opt_recording_time(const char *opt, const char *arg)
2692
{
2693
    recording_time = parse_time_or_die(opt, arg, 1);
2694
    return 0;
2695
}
2696

    
2697
static int opt_start_time(const char *opt, const char *arg)
2698
{
2699
    start_time = parse_time_or_die(opt, arg, 1);
2700
    return 0;
2701
}
2702

    
2703
static int opt_rec_timestamp(const char *opt, const char *arg)
2704
{
2705
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2706
    return 0;
2707
}
2708

    
2709
static int opt_input_ts_offset(const char *opt, const char *arg)
2710
{
2711
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2712
    return 0;
2713
}
2714

    
2715
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2716
{
2717
    const char *codec_string = encoder ? "encoder" : "decoder";
2718
    AVCodec *codec;
2719

    
2720
    if(!name)
2721
        return CODEC_ID_NONE;
2722
    codec = encoder ?
2723
        avcodec_find_encoder_by_name(name) :
2724
        avcodec_find_decoder_by_name(name);
2725
    if(!codec) {
2726
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2727
        av_exit(1);
2728
    }
2729
    if(codec->type != type) {
2730
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2731
        av_exit(1);
2732
    }
2733
    return codec->id;
2734
}
2735

    
2736
static void opt_input_file(const char *filename)
2737
{
2738
    AVFormatContext *ic;
2739
    AVFormatParameters params, *ap = &params;
2740
    int err, i, ret, rfps, rfps_base;
2741
    int64_t timestamp;
2742

    
2743
    if (!strcmp(filename, "-"))
2744
        filename = "pipe:";
2745

    
2746
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2747
                    !strcmp(filename, "/dev/stdin");
2748

    
2749
    /* get default parameters from command line */
2750
    ic = av_alloc_format_context();
2751

    
2752
    memset(ap, 0, sizeof(*ap));
2753
    ap->prealloced_context = 1;
2754
    ap->sample_rate = audio_sample_rate;
2755
    ap->channels = audio_channels;
2756
    ap->time_base.den = frame_rate.num;
2757
    ap->time_base.num = frame_rate.den;
2758
    ap->width = frame_width + frame_padleft + frame_padright;
2759
    ap->height = frame_height + frame_padtop + frame_padbottom;
2760
    ap->pix_fmt = frame_pix_fmt;
2761
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2762
    ap->channel = video_channel;
2763
    ap->standard = video_standard;
2764
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2765
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2766
    if(pgmyuv_compatibility_hack)
2767
        ap->video_codec_id= CODEC_ID_PGMYUV;
2768

    
2769
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2770

    
2771
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2772
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2773
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2774

    
2775
    /* open the input file with generic libav function */
2776
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2777
    if (err < 0) {
2778
        print_error(filename, err);
2779
        av_exit(1);
2780
    }
2781
    if(opt_programid) {
2782
        int i;
2783
        for(i=0; i<ic->nb_programs; i++)
2784
            if(ic->programs[i]->id != opt_programid)
2785
                ic->programs[i]->discard = AVDISCARD_ALL;
2786
    }
2787

    
2788
    ic->loop_input = loop_input;
2789

    
2790
    /* If not enough info to get the stream parameters, we decode the
2791
       first frames to get it. (used in mpeg case for example) */
2792
    ret = av_find_stream_info(ic);
2793
    if (ret < 0 && verbose >= 0) {
2794
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2795
        av_exit(1);
2796
    }
2797

    
2798
    timestamp = start_time;
2799
    /* add the stream start time */
2800
    if (ic->start_time != AV_NOPTS_VALUE)
2801
        timestamp += ic->start_time;
2802

    
2803
    /* if seeking requested, we execute it */
2804
    if (start_time != 0) {
2805
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2806
        if (ret < 0) {
2807
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2808
                    filename, (double)timestamp / AV_TIME_BASE);
2809
        }
2810
        /* reset seek info */
2811
        start_time = 0;
2812
    }
2813

    
2814
    /* update the current parameters so that they match the one of the input stream */
2815
    for(i=0;i<ic->nb_streams;i++) {
2816
        AVCodecContext *enc = ic->streams[i]->codec;
2817
        if(thread_count>1)
2818
            avcodec_thread_init(enc, thread_count);
2819
        enc->thread_count= thread_count;
2820
        switch(enc->codec_type) {
2821
        case CODEC_TYPE_AUDIO:
2822
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2823
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2824
            channel_layout = enc->channel_layout;
2825
            audio_channels = enc->channels;
2826
            audio_sample_rate = enc->sample_rate;
2827
            audio_sample_fmt = enc->sample_fmt;
2828
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2829
            if(audio_disable)
2830
                ic->streams[i]->discard= AVDISCARD_ALL;
2831
            break;
2832
        case CODEC_TYPE_VIDEO:
2833
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2834
            frame_height = enc->height;
2835
            frame_width = enc->width;
2836
            if(ic->streams[i]->sample_aspect_ratio.num)
2837
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2838
            else
2839
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2840
            frame_aspect_ratio *= (float) enc->width / enc->height;
2841
            frame_pix_fmt = enc->pix_fmt;
2842
            rfps      = ic->streams[i]->r_frame_rate.num;
2843
            rfps_base = ic->streams[i]->r_frame_rate.den;
2844
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2845
            if(me_threshold)
2846
                enc->debug |= FF_DEBUG_MV;
2847

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

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

    
2854
                    (float)rfps / rfps_base, rfps, rfps_base);
2855
            }
2856
            /* update the current frame rate to match the stream frame rate */
2857
            frame_rate.num = rfps;
2858
            frame_rate.den = rfps_base;
2859

    
2860
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2861
            if(video_disable)
2862
                ic->streams[i]->discard= AVDISCARD_ALL;
2863
            else if(video_discard)
2864
                ic->streams[i]->discard= video_discard;
2865
            break;
2866
        case CODEC_TYPE_DATA:
2867
            break;
2868
        case CODEC_TYPE_SUBTITLE:
2869
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2870
            if(subtitle_disable)
2871
                ic->streams[i]->discard = AVDISCARD_ALL;
2872
            break;
2873
        case CODEC_TYPE_ATTACHMENT:
2874
        case CODEC_TYPE_UNKNOWN:
2875
            nb_icodecs++;
2876
            break;
2877
        default:
2878
            abort();
2879
        }
2880
    }
2881

    
2882
    input_files[nb_input_files] = ic;
2883
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2884
    /* dump the file content */
2885
    if (verbose >= 0)
2886
        dump_format(ic, nb_input_files, filename, 0);
2887

    
2888
    nb_input_files++;
2889
    file_iformat = NULL;
2890
    file_oformat = NULL;
2891

    
2892
    video_channel = 0;
2893

    
2894
    av_freep(&video_codec_name);
2895
    av_freep(&audio_codec_name);
2896
    av_freep(&subtitle_codec_name);
2897
}
2898

    
2899
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2900
                                         int *has_subtitle_ptr)
2901
{
2902
    int has_video, has_audio, has_subtitle, i, j;
2903
    AVFormatContext *ic;
2904

    
2905
    has_video = 0;
2906
    has_audio = 0;
2907
    has_subtitle = 0;
2908
    for(j=0;j<nb_input_files;j++) {
2909
        ic = input_files[j];
2910
        for(i=0;i<ic->nb_streams;i++) {
2911
            AVCodecContext *enc = ic->streams[i]->codec;
2912
            switch(enc->codec_type) {
2913
            case CODEC_TYPE_AUDIO:
2914
                has_audio = 1;
2915
                break;
2916
            case CODEC_TYPE_VIDEO:
2917
                has_video = 1;
2918
                break;
2919
            case CODEC_TYPE_SUBTITLE:
2920
                has_subtitle = 1;
2921
                break;
2922
            case CODEC_TYPE_DATA:
2923
            case CODEC_TYPE_ATTACHMENT:
2924
            case CODEC_TYPE_UNKNOWN:
2925
                break;
2926
            default:
2927
                abort();
2928
            }
2929
        }
2930
    }
2931
    *has_video_ptr = has_video;
2932
    *has_audio_ptr = has_audio;
2933
    *has_subtitle_ptr = has_subtitle;
2934
}
2935

    
2936
static void new_video_stream(AVFormatContext *oc)
2937
{
2938
    AVStream *st;
2939
    AVCodecContext *video_enc;
2940
    int codec_id;
2941

    
2942
    st = av_new_stream(oc, oc->nb_streams);
2943
    if (!st) {
2944
        fprintf(stderr, "Could not alloc stream\n");
2945
        av_exit(1);
2946
    }
2947
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2948
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2949
    video_bitstream_filters= NULL;
2950

    
2951
    if(thread_count>1)
2952
        avcodec_thread_init(st->codec, thread_count);
2953

    
2954
    video_enc = st->codec;
2955

    
2956
    if(video_codec_tag)
2957
        video_enc->codec_tag= video_codec_tag;
2958

    
2959
    if(   (video_global_header&1)
2960
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2961
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2962
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2963
    }
2964
    if(video_global_header&2){
2965
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2966
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2967
    }
2968

    
2969
    if (video_stream_copy) {
2970
        st->stream_copy = 1;
2971
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2972
        video_enc->sample_aspect_ratio =
2973
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2974
    } else {
2975
        const char *p;
2976
        int i;
2977
        AVCodec *codec;
2978
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2979

    
2980
        if (video_codec_name) {
2981
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2982
            codec = avcodec_find_encoder_by_name(video_codec_name);
2983
            output_codecs[nb_ocodecs] = codec;
2984
        } else {
2985
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2986
            codec = avcodec_find_encoder(codec_id);
2987
        }
2988

    
2989
        video_enc->codec_id = codec_id;
2990

    
2991
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2992

    
2993
        if (codec && codec->supported_framerates && !force_fps)
2994
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
2995
        video_enc->time_base.den = fps.num;
2996
        video_enc->time_base.num = fps.den;
2997

    
2998
        video_enc->width = frame_width + frame_padright + frame_padleft;
2999
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3000
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3001
        video_enc->pix_fmt = frame_pix_fmt;
3002
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3003

    
3004
        if(codec && codec->pix_fmts){
3005
            const enum PixelFormat *p= codec->pix_fmts;
3006
            for(; *p!=-1; p++){
3007
                if(*p == video_enc->pix_fmt)
3008
                    break;
3009
            }
3010
            if(*p == -1)
3011
                video_enc->pix_fmt = codec->pix_fmts[0];
3012
        }
3013

    
3014
        if (intra_only)
3015
            video_enc->gop_size = 0;
3016
        if (video_qscale || same_quality) {
3017
            video_enc->flags |= CODEC_FLAG_QSCALE;
3018
            video_enc->global_quality=
3019
                st->quality = FF_QP2LAMBDA * video_qscale;
3020
        }
3021

    
3022
        if(intra_matrix)
3023
            video_enc->intra_matrix = intra_matrix;
3024
        if(inter_matrix)
3025
            video_enc->inter_matrix = inter_matrix;
3026

    
3027
        video_enc->thread_count = thread_count;
3028
        p= video_rc_override_string;
3029
        for(i=0; p; i++){
3030
            int start, end, q;
3031
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3032
            if(e!=3){
3033
                fprintf(stderr, "error parsing rc_override\n");
3034
                av_exit(1);
3035
            }
3036
            video_enc->rc_override=
3037
                av_realloc(video_enc->rc_override,
3038
                           sizeof(RcOverride)*(i+1));
3039
            video_enc->rc_override[i].start_frame= start;
3040
            video_enc->rc_override[i].end_frame  = end;
3041
            if(q>0){
3042
                video_enc->rc_override[i].qscale= q;
3043
                video_enc->rc_override[i].quality_factor= 1.0;
3044
            }
3045
            else{
3046
                video_enc->rc_override[i].qscale= 0;
3047
                video_enc->rc_override[i].quality_factor= -q/100.0;
3048
            }
3049
            p= strchr(p, '/');
3050
            if(p) p++;
3051
        }
3052
        video_enc->rc_override_count=i;
3053
        if (!video_enc->rc_initial_buffer_occupancy)
3054
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3055
        video_enc->me_threshold= me_threshold;
3056
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3057

    
3058
        if (do_psnr)
3059
            video_enc->flags|= CODEC_FLAG_PSNR;
3060

    
3061
        /* two pass mode */
3062
        if (do_pass) {
3063
            if (do_pass == 1) {
3064
                video_enc->flags |= CODEC_FLAG_PASS1;
3065
            } else {
3066
                video_enc->flags |= CODEC_FLAG_PASS2;
3067
            }
3068
        }
3069
    }
3070
    nb_ocodecs++;
3071

    
3072
    /* reset some key parameters */
3073
    video_disable = 0;
3074
    av_freep(&video_codec_name);
3075
    video_stream_copy = 0;
3076
}
3077

    
3078
static void new_audio_stream(AVFormatContext *oc)
3079
{
3080
    AVStream *st;
3081
    AVCodecContext *audio_enc;
3082
    int codec_id;
3083

    
3084
    st = av_new_stream(oc, oc->nb_streams);
3085
    if (!st) {
3086
        fprintf(stderr, "Could not alloc stream\n");
3087
        av_exit(1);
3088
    }
3089
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3090

    
3091
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3092
    audio_bitstream_filters= NULL;
3093

    
3094
    if(thread_count>1)
3095
        avcodec_thread_init(st->codec, thread_count);
3096

    
3097
    audio_enc = st->codec;
3098
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3099

    
3100
    if(audio_codec_tag)
3101
        audio_enc->codec_tag= audio_codec_tag;
3102

    
3103
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3104
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3105
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3106
    }
3107
    if (audio_stream_copy) {
3108
        st->stream_copy = 1;
3109
        audio_enc->channels = audio_channels;
3110
    } else {
3111
        AVCodec *codec;
3112

    
3113
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3114

    
3115
        if (audio_codec_name) {
3116
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3117
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3118
            output_codecs[nb_ocodecs] = codec;
3119
        } else {
3120
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3121
            codec = avcodec_find_encoder(codec_id);
3122
        }
3123
        audio_enc->codec_id = codec_id;
3124

    
3125
        if (audio_qscale > QSCALE_NONE) {
3126
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3127
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3128
        }
3129
        audio_enc->thread_count = thread_count;
3130
        audio_enc->channels = audio_channels;
3131
        audio_enc->sample_fmt = audio_sample_fmt;
3132
        audio_enc->channel_layout = channel_layout;
3133

    
3134
        if(codec && codec->sample_fmts){
3135
            const enum SampleFormat *p= codec->sample_fmts;
3136
            for(; *p!=-1; p++){
3137
                if(*p == audio_enc->sample_fmt)
3138
                    break;
3139
            }
3140
            if(*p == -1)
3141
                audio_enc->sample_fmt = codec->sample_fmts[0];
3142
        }
3143
    }
3144
    nb_ocodecs++;
3145
    audio_enc->sample_rate = audio_sample_rate;
3146
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3147
    if (audio_language) {
3148
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3149
        av_free(audio_language);
3150
        audio_language = NULL;
3151
    }
3152

    
3153
    /* reset some key parameters */
3154
    audio_disable = 0;
3155
    av_freep(&audio_codec_name);
3156
    audio_stream_copy = 0;
3157
}
3158

    
3159
static void new_subtitle_stream(AVFormatContext *oc)
3160
{
3161
    AVStream *st;
3162
    AVCodecContext *subtitle_enc;
3163

    
3164
    st = av_new_stream(oc, oc->nb_streams);
3165
    if (!st) {
3166
        fprintf(stderr, "Could not alloc stream\n");
3167
        av_exit(1);
3168
    }
3169
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3170

    
3171
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3172
    subtitle_bitstream_filters= NULL;
3173

    
3174
    subtitle_enc = st->codec;
3175
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3176
    if (subtitle_stream_copy) {
3177
        st->stream_copy = 1;
3178
    } else {
3179
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3180
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3181
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3182
    }
3183
    nb_ocodecs++;
3184

    
3185
    if (subtitle_language) {
3186
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3187
        av_free(subtitle_language);
3188
        subtitle_language = NULL;
3189
    }
3190

    
3191
    subtitle_disable = 0;
3192
    av_freep(&subtitle_codec_name);
3193
    subtitle_stream_copy = 0;
3194
}
3195

    
3196
static void opt_new_audio_stream(void)
3197
{
3198
    AVFormatContext *oc;
3199
    if (nb_output_files <= 0) {
3200
        fprintf(stderr, "At least one output file must be specified\n");
3201
        av_exit(1);
3202
    }
3203
    oc = output_files[nb_output_files - 1];
3204
    new_audio_stream(oc);
3205
}
3206

    
3207
static void opt_new_video_stream(void)
3208
{
3209
    AVFormatContext *oc;
3210
    if (nb_output_files <= 0) {
3211
        fprintf(stderr, "At least one output file must be specified\n");
3212
        av_exit(1);
3213
    }
3214
    oc = output_files[nb_output_files - 1];
3215
    new_video_stream(oc);
3216
}
3217

    
3218
static void opt_new_subtitle_stream(void)
3219
{
3220
    AVFormatContext *oc;
3221
    if (nb_output_files <= 0) {
3222
        fprintf(stderr, "At least one output file must be specified\n");
3223
        av_exit(1);
3224
    }
3225
    oc = output_files[nb_output_files - 1];
3226
    new_subtitle_stream(oc);
3227
}
3228

    
3229
static void opt_output_file(const char *filename)
3230
{
3231
    AVFormatContext *oc;
3232
    int use_video, use_audio, use_subtitle;
3233
    int input_has_video, input_has_audio, input_has_subtitle;
3234
    AVFormatParameters params, *ap = &params;
3235

    
3236
    if (!strcmp(filename, "-"))
3237
        filename = "pipe:";
3238

    
3239
    oc = av_alloc_format_context();
3240

    
3241
    if (!file_oformat) {
3242
        file_oformat = guess_format(NULL, filename, NULL);
3243
        if (!file_oformat) {
3244
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3245
                    filename);
3246
            av_exit(1);
3247
        }
3248
    }
3249

    
3250
    oc->oformat = file_oformat;
3251
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3252

    
3253
    if (!strcmp(file_oformat->name, "ffm") &&
3254
        av_strstart(filename, "http:", NULL)) {
3255
        /* special case for files sent to ffserver: we get the stream
3256
           parameters from ffserver */
3257
        int err = read_ffserver_streams(oc, filename);
3258
        if (err < 0) {
3259
            print_error(filename, err);
3260
            av_exit(1);
3261
        }
3262
    } else {
3263
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3264
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3265
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3266

    
3267
        /* disable if no corresponding type found and at least one
3268
           input file */
3269
        if (nb_input_files > 0) {
3270
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3271
                                         &input_has_subtitle);
3272
            if (!input_has_video)
3273
                use_video = 0;
3274
            if (!input_has_audio)
3275
                use_audio = 0;
3276
            if (!input_has_subtitle)
3277
                use_subtitle = 0;
3278
        }
3279

    
3280
        /* manual disable */
3281
        if (audio_disable) {
3282
            use_audio = 0;
3283
        }
3284
        if (video_disable) {
3285
            use_video = 0;
3286
        }
3287
        if (subtitle_disable) {
3288
            use_subtitle = 0;
3289
        }
3290

    
3291
        if (use_video) {
3292
            new_video_stream(oc);
3293
        }
3294

    
3295
        if (use_audio) {
3296
            new_audio_stream(oc);
3297
        }
3298

    
3299
        if (use_subtitle) {
3300
            new_subtitle_stream(oc);
3301
        }
3302

    
3303
        oc->timestamp = rec_timestamp;
3304

    
3305
        if (str_title)
3306
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3307
        if (str_author)
3308
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3309
        if (str_copyright)
3310
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3311
        if (str_comment)
3312
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3313
        if (str_album)
3314
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3315
        if (str_genre)
3316
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3317
    }
3318

    
3319
    output_files[nb_output_files++] = oc;
3320

    
3321
    /* check filename in case of an image number is expected */
3322
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3323
        if (!av_filename_number_test(oc->filename)) {
3324
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3325
            av_exit(1);
3326
        }
3327
    }
3328

    
3329
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3330
        /* test if it already exists to avoid loosing precious files */
3331
        if (!file_overwrite &&
3332
            (strchr(filename, ':') == NULL ||
3333
             filename[1] == ':' ||
3334
             av_strstart(filename, "file:", NULL))) {
3335
            if (url_exist(filename)) {
3336
                int c;
3337

    
3338
                if (!using_stdin) {
3339
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3340
                    fflush(stderr);
3341
                    c = getchar();
3342
                    if (toupper(c) != 'Y') {
3343
                        fprintf(stderr, "Not overwriting - exiting\n");
3344
                        av_exit(1);
3345
                    }
3346
                }
3347
                else {
3348
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3349
                    av_exit(1);
3350
                }
3351
            }
3352
        }
3353

    
3354
        /* open the file */
3355
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3356
            fprintf(stderr, "Could not open '%s'\n", filename);
3357
            av_exit(1);
3358
        }
3359
    }
3360

    
3361
    memset(ap, 0, sizeof(*ap));
3362
    if (av_set_parameters(oc, ap) < 0) {
3363
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3364
                oc->filename);
3365
        av_exit(1);
3366
    }
3367

    
3368
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3369
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3370
    oc->loop_output = loop_output;
3371

    
3372
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3373

    
3374
    /* reset some options */
3375
    file_oformat = NULL;
3376
    file_iformat = NULL;
3377
}
3378

    
3379
/* same option as mencoder */
3380
static void opt_pass(const char *pass_str)
3381
{
3382
    int pass;
3383
    pass = atoi(pass_str);
3384
    if (pass != 1 && pass != 2) {
3385
        fprintf(stderr, "pass number can be only 1 or 2\n");
3386
        av_exit(1);
3387
    }
3388
    do_pass = pass;
3389
}
3390

    
3391
static int64_t getutime(void)
3392
{
3393
#ifdef HAVE_GETRUSAGE
3394
    struct rusage rusage;
3395

    
3396
    getrusage(RUSAGE_SELF, &rusage);
3397
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3398
#elif defined(HAVE_GETPROCESSTIMES)
3399
    HANDLE proc;
3400
    FILETIME c, e, k, u;
3401
    proc = GetCurrentProcess();
3402
    GetProcessTimes(proc, &c, &e, &k, &u);
3403
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3404
#else
3405
    return av_gettime();
3406
#endif
3407
}
3408

    
3409
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3410
{
3411
    int i;
3412
    const char *p = str;
3413
    for(i = 0;; i++) {
3414
        dest[i] = atoi(p);
3415
        if(i == 63)
3416
            break;
3417
        p = strchr(p, ',');
3418
        if(!p) {
3419
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3420
            av_exit(1);
3421
        }
3422
        p++;
3423
    }
3424
}
3425

    
3426
static void opt_inter_matrix(const char *arg)
3427
{
3428
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3429
    parse_matrix_coeffs(inter_matrix, arg);
3430
}
3431

    
3432
static void opt_intra_matrix(const char *arg)
3433
{
3434
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3435
    parse_matrix_coeffs(intra_matrix, arg);
3436
}
3437

    
3438
/**
3439
 * Trivial log callback.
3440
 * Only suitable for show_help and similar since it lacks prefix handling.
3441
 */
3442
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3443
{
3444
    vfprintf(stdout, fmt, vl);
3445
}
3446

    
3447
static void show_help(void)
3448
{
3449
    av_log_set_callback(log_callback_help);
3450
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3451
           "Hyper fast Audio and Video encoder\n");
3452
    printf("\n");
3453
    show_help_options(options, "Main options:\n",
3454
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3455
    show_help_options(options, "\nAdvanced options:\n",
3456
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3457
                      OPT_EXPERT);
3458
    show_help_options(options, "\nVideo options:\n",
3459
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3460
                      OPT_VIDEO);
3461
    show_help_options(options, "\nAdvanced Video options:\n",
3462
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3463
                      OPT_VIDEO | OPT_EXPERT);
3464
    show_help_options(options, "\nAudio options:\n",
3465
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3466
                      OPT_AUDIO);
3467
    show_help_options(options, "\nAdvanced Audio options:\n",
3468
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3469
                      OPT_AUDIO | OPT_EXPERT);
3470
    show_help_options(options, "\nSubtitle options:\n",
3471
                      OPT_SUBTITLE | OPT_GRAB,
3472
                      OPT_SUBTITLE);
3473
    show_help_options(options, "\nAudio/Video grab options:\n",
3474
                      OPT_GRAB,
3475
                      OPT_GRAB);
3476
    printf("\n");
3477
    av_opt_show(avctx_opts[0], NULL);
3478
    printf("\n");
3479
    av_opt_show(avformat_opts, NULL);
3480
    printf("\n");
3481
    av_opt_show(sws_opts, NULL);
3482
}
3483

    
3484
static void opt_target(const char *arg)
3485
{
3486
    int norm = -1;
3487
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3488

    
3489
    if(!strncmp(arg, "pal-", 4)) {
3490
        norm = 0;
3491
        arg += 4;
3492
    } else if(!strncmp(arg, "ntsc-", 5)) {
3493
        norm = 1;
3494
        arg += 5;
3495
    } else if(!strncmp(arg, "film-", 5)) {
3496
        norm = 2;
3497
        arg += 5;
3498
    } else {
3499
        int fr;
3500
        /* Calculate FR via float to avoid int overflow */
3501
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3502
        if(fr == 25000) {
3503
            norm = 0;
3504
        } else if((fr == 29970) || (fr == 23976)) {
3505
            norm = 1;
3506
        } else {
3507
            /* Try to determine PAL/NTSC by peeking in the input files */
3508
            if(nb_input_files) {
3509
                int i, j;
3510
                for(j = 0; j < nb_input_files; j++) {
3511
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3512
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3513
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3514
                            continue;
3515
                        fr = c->time_base.den * 1000 / c->time_base.num;
3516
                        if(fr == 25000) {
3517
                            norm = 0;
3518
                            break;
3519
                        } else if((fr == 29970) || (fr == 23976)) {
3520
                            norm = 1;
3521
                            break;
3522
                        }
3523
                    }
3524
                    if(norm >= 0)
3525
                        break;
3526
                }
3527
            }
3528
        }
3529
        if(verbose && norm >= 0)
3530
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3531
    }
3532

    
3533
    if(norm < 0) {
3534
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3535
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3536
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3537
        av_exit(1);
3538
    }
3539

    
3540
    if(!strcmp(arg, "vcd")) {
3541

    
3542
        opt_video_codec("mpeg1video");
3543
        opt_audio_codec("mp2");
3544
        opt_format("vcd");
3545

    
3546
        opt_frame_size(norm ? "352x240" : "352x288");
3547
        opt_frame_rate(NULL, frame_rates[norm]);
3548
        opt_default("gop", norm ? "18" : "15");
3549

    
3550
        opt_default("b", "1150000");
3551
        opt_default("maxrate", "1150000");
3552
        opt_default("minrate", "1150000");
3553
        opt_default("bufsize", "327680"); // 40*1024*8;
3554

    
3555
        opt_default("ab", "224000");
3556
        audio_sample_rate = 44100;
3557
        audio_channels = 2;
3558

    
3559
        opt_default("packetsize", "2324");
3560
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3561

    
3562
        /* We have to offset the PTS, so that it is consistent with the SCR.
3563
           SCR starts at 36000, but the first two packs contain only padding
3564
           and the first pack from the other stream, respectively, may also have
3565
           been written before.
3566
           So the real data starts at SCR 36000+3*1200. */
3567
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3568
    } else if(!strcmp(arg, "svcd")) {
3569

    
3570
        opt_video_codec("mpeg2video");
3571
        opt_audio_codec("mp2");
3572
        opt_format("svcd");
3573

    
3574
        opt_frame_size(norm ? "480x480" : "480x576");
3575
        opt_frame_rate(NULL, frame_rates[norm]);
3576
        opt_default("gop", norm ? "18" : "15");
3577

    
3578
        opt_default("b", "2040000");
3579
        opt_default("maxrate", "2516000");
3580
        opt_default("minrate", "0"); //1145000;
3581
        opt_default("bufsize", "1835008"); //224*1024*8;
3582
        opt_default("flags", "+scan_offset");
3583

    
3584

    
3585
        opt_default("ab", "224000");
3586
        audio_sample_rate = 44100;
3587

    
3588
        opt_default("packetsize", "2324");
3589

    
3590
    } else if(!strcmp(arg, "dvd")) {
3591

    
3592
        opt_video_codec("mpeg2video");
3593
        opt_audio_codec("ac3");
3594
        opt_format("dvd");
3595

    
3596
        opt_frame_size(norm ? "720x480" : "720x576");
3597
        opt_frame_rate(NULL, frame_rates[norm]);
3598
        opt_default("gop", norm ? "18" : "15");
3599

    
3600
        opt_default("b", "6000000");
3601
        opt_default("maxrate", "9000000");
3602
        opt_default("minrate", "0"); //1500000;
3603
        opt_default("bufsize", "1835008"); //224*1024*8;
3604

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

    
3608
        opt_default("ab", "448000");
3609
        audio_sample_rate = 48000;
3610

    
3611
    } else if(!strncmp(arg, "dv", 2)) {
3612

    
3613
        opt_format("dv");
3614

    
3615
        opt_frame_size(norm ? "720x480" : "720x576");
3616
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3617
                                             (norm ? "yuv411p" : "yuv420p"));
3618
        opt_frame_rate(NULL, frame_rates[norm]);
3619

    
3620
        audio_sample_rate = 48000;
3621
        audio_channels = 2;
3622

    
3623
    } else {
3624
        fprintf(stderr, "Unknown target: %s\n", arg);
3625
        av_exit(1);
3626
    }
3627
}
3628

    
3629
static void opt_vstats_file (const char *arg)
3630
{
3631
    av_free (vstats_filename);
3632
    vstats_filename=av_strdup (arg);
3633
}
3634

    
3635
static void opt_vstats (void)
3636
{
3637
    char filename[40];
3638
    time_t today2 = time(NULL);
3639
    struct tm *today = localtime(&today2);
3640

    
3641
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3642
             today->tm_sec);
3643
    opt_vstats_file(filename);
3644
}
3645

    
3646
static int opt_bsf(const char *opt, const char *arg)
3647
{
3648
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3649
    AVBitStreamFilterContext **bsfp;
3650

    
3651
    if(!bsfc){
3652
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3653
        av_exit(1);
3654
    }
3655

    
3656
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3657
          *opt == 'a' ? &audio_bitstream_filters :
3658
                        &subtitle_bitstream_filters;
3659
    while(*bsfp)
3660
        bsfp= &(*bsfp)->next;
3661

    
3662
    *bsfp= bsfc;
3663

    
3664
    return 0;
3665
}
3666

    
3667
static int opt_preset(const char *opt, const char *arg)
3668
{
3669
    FILE *f=NULL;
3670
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3671
    int i;
3672
    const char *base[3]= { getenv("HOME"),
3673
                           "/usr/local/share",
3674
                           "/usr/share",
3675
                         };
3676

    
3677
    for(i=!base[0]; i<3 && !f; i++){
3678
        snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3679
        f= fopen(filename, "r");
3680
        if(!f){
3681
            char *codec_name= *opt == 'v' ? video_codec_name :
3682
                              *opt == 'a' ? audio_codec_name :
3683
                                            subtitle_codec_name;
3684
            snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3685
            f= fopen(filename, "r");
3686
        }
3687
    }
3688
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3689
              is_dos_path(arg))){
3690
        snprintf(filename, sizeof(filename), arg);
3691
        f= fopen(filename, "r");
3692
    }
3693

    
3694
    if(!f){
3695
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3696
        av_exit(1);
3697
    }
3698

    
3699
    while(!feof(f)){
3700
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3701
        if(line[0] == '#' && !e)
3702
            continue;
3703
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3704
        if(e){
3705
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3706
            av_exit(1);
3707
        }
3708
        if(!strcmp(tmp, "acodec")){
3709
            opt_audio_codec(tmp2);
3710
        }else if(!strcmp(tmp, "vcodec")){
3711
            opt_video_codec(tmp2);
3712
        }else if(!strcmp(tmp, "scodec")){
3713
            opt_subtitle_codec(tmp2);
3714
        }else if(opt_default(tmp, tmp2) < 0){
3715
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3716
            av_exit(1);
3717
        }
3718
    }
3719

    
3720
    fclose(f);
3721

    
3722
    return 0;
3723
}
3724

    
3725
static const OptionDef options[] = {
3726
    /* main options */
3727
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3728
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3729
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3730
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3731
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3732
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3733
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3734
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3735
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3736
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3737
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3738
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3739
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3740
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3741
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3742
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3743
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3744
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3745
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3746
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3747
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3748
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3749
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3750
      "add timings for benchmarking" },
3751
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3752
      "dump each input packet" },
3753
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3754
      "when dumping packets, also dump the payload" },
3755
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3756
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3757
    { "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)", "" },
3758
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3759
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3760
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3761
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3762
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3763
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3764
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3765
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3766
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3767
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3768
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3769
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3770

    
3771
    /* video options */
3772
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3773
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3774
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3775
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3776
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3777
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3778
    { "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" },
3779
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3780
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3781
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3782
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3783
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3784
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3785
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3786
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3787
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3788
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3789
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3790
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3791
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3792
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3793
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3794
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3795
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3796
      "use same video quality as source (implies VBR)" },
3797
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3798
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3799
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3800
      "deinterlace pictures" },
3801
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3802
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3803
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3804
#ifdef CONFIG_VHOOK
3805
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3806
#endif
3807
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3808
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3809
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3810
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3811
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3812
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3813
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3814
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3815

    
3816
    /* audio options */
3817
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3818
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3819
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3820
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3821
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3822
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3823
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3824
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3825
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3826
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3827
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3828
    { "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" },
3829

    
3830
    /* subtitle options */
3831
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3832
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3833
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3834
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3835

    
3836
    /* grab options */
3837
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3838
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3839
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3840

    
3841
    /* muxer options */
3842
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3843
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3844

    
3845
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3846
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3847
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3848

    
3849
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3850
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3851
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3852

    
3853
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3854
    { NULL, },
3855
};
3856

    
3857
int main(int argc, char **argv)
3858
{
3859
    int i;
3860
    int64_t ti;
3861

    
3862
    avcodec_register_all();
3863
    avdevice_register_all();
3864
    av_register_all();
3865

    
3866
    if(isatty(STDIN_FILENO))
3867
        url_set_interrupt_cb(decode_interrupt_cb);
3868

    
3869
    for(i=0; i<CODEC_TYPE_NB; i++){
3870
        avctx_opts[i]= avcodec_alloc_context2(i);
3871
    }
3872
    avformat_opts = av_alloc_format_context();
3873
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3874

    
3875
    show_banner();
3876

    
3877
    /* parse options */
3878
    parse_options(argc, argv, options, opt_output_file);
3879

    
3880
    /* file converter / grab */
3881
    if (nb_output_files <= 0) {
3882
        fprintf(stderr, "At least one output file must be specified\n");
3883
        av_exit(1);
3884
    }
3885

    
3886
    if (nb_input_files == 0) {
3887
        fprintf(stderr, "At least one input file must be specified\n");
3888
        av_exit(1);
3889
    }
3890

    
3891
    ti = getutime();
3892
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3893
              stream_maps, nb_stream_maps);
3894
    ti = getutime() - ti;
3895
    if (do_benchmark) {
3896
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3897
    }
3898

    
3899
    return av_exit(0);
3900
}