Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ e178d7fd

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
#define QSCALE_NONE -99999
155
static float audio_qscale = QSCALE_NONE;
156
static int audio_disable = 0;
157
static int audio_channels = 1;
158
static char  *audio_codec_name = NULL;
159
static int audio_codec_tag = 0;
160
static char *audio_language = NULL;
161

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

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

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

    
199
static int rate_emu = 0;
200

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

    
204
static int audio_volume = 256;
205

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

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

    
224
static unsigned int sws_flags = SWS_BICUBIC;
225

    
226
static int64_t timer_start;
227

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

    
233
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
234

    
235
struct AVInputStream;
236

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

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

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

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

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

    
282
    int64_t       start;     /* time when read started */
283
    unsigned long frame;     /* current frame */
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
    extern 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 (ist->st->codec->rate_emu) {
1309
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1310
            int64_t now = av_gettime() - ist->start;
1311
            if (pts > now)
1312
                usleep(pts - now);
1313

    
1314
            ist->frame++;
1315
        }
1316

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

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

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

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

    
1358
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1359
                            continue;
1360

    
1361
                        /* no reencoding needed : output the packet directly */
1362
                        /* force the input stream PTS */
1363

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

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

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

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

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

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

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

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

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

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

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

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

    
1480
    return 0;
1481
 fail_decode:
1482
    return -1;
1483
}
1484

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

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

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

    
1517
    return -1;
1518
}
1519

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

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

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

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

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

    
1573
            if (ist->st->codec->rate_emu) {
1574
                ist->start = av_gettime();
1575
                ist->frame = 0;
1576
            }
1577
        }
1578
    }
1579

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

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

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

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

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

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

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

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

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

    
1704
        codec = ost->st->codec;
1705
        icodec = ist->st->codec;
1706

    
1707
        if (!ost->st->language[0])
1708
            av_strlcpy(ost->st->language, ist->st->language,
1709
                       sizeof(ost->st->language));
1710

    
1711
        ost->st->disposition = ist->st->disposition;
1712

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

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

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

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

    
1878
    if (!bit_buffer)
1879
        bit_buffer = av_malloc(bit_buffer_size);
1880
    if (!bit_buffer)
1881
        goto fail;
1882

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

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

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

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

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

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

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

    
1977
        out_file = output_files[out_file_index];
1978
        in_file = input_files[in_file_index];
1979

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

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

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

    
2012
    key = -1;
2013
    timer_start = av_gettime();
2014

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

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

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

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

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

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

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

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

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

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

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

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

    
2136
    discard_packet:
2137
        av_free_packet(&pkt);
2138

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

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

    
2151
    term_exit();
2152

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

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

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

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

    
2179
    /* finished ! */
2180

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

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

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

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

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

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

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

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

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

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

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

    
2292
    opt_default(opt, arg);
2293

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

    
2297
    return 0;
2298
}
2299

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

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

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

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

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

    
2384

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

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

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

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

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

    
2407
    r = (rgb >> 16);
2408
    g = ((rgb >> 8) & 255);
2409
    b = (rgb & 255);
2410

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

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

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

    
2442

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

    
2456

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2613
    using_vhook = 1;
2614

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

    
2619
    i = frame_hook_add(argc, argv);
2620

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

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

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

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

    
2643
    m = &stream_maps[nb_stream_maps++];
2644

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

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

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

    
2667
    m = &meta_data_maps[nb_meta_data_maps++];
2668

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

    
2673
    m->in_file = strtol(p, &p, 0);
2674
}
2675

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

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

    
2687
    if(stream >= MAX_STREAMS)
2688
        av_exit(1);
2689

    
2690
    input_files_ts_scale[nb_input_files][stream]= scale;
2691
}
2692

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

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

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

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

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

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

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

    
2745
    if (!strcmp(filename, "-"))
2746
        filename = "pipe:";
2747

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

    
2751
    /* get default parameters from command line */
2752
    ic = av_alloc_format_context();
2753

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

    
2771
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2772

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

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

    
2790
    ic->loop_input = loop_input;
2791

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

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

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

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

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

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

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

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

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

    
2890
    nb_input_files++;
2891
    file_iformat = NULL;
2892
    file_oformat = NULL;
2893

    
2894
    video_channel = 0;
2895

    
2896
    rate_emu = 0;
2897
    av_freep(&video_codec_name);
2898
    av_freep(&audio_codec_name);
2899
    av_freep(&subtitle_codec_name);
2900
}
2901

    
2902
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2903
                                         int *has_subtitle_ptr)
2904
{
2905
    int has_video, has_audio, has_subtitle, i, j;
2906
    AVFormatContext *ic;
2907

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

    
2939
static void new_video_stream(AVFormatContext *oc)
2940
{
2941
    AVStream *st;
2942
    AVCodecContext *video_enc;
2943
    int codec_id;
2944

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

    
2954
    if(thread_count>1)
2955
        avcodec_thread_init(st->codec, thread_count);
2956

    
2957
    video_enc = st->codec;
2958

    
2959
    if(video_codec_tag)
2960
        video_enc->codec_tag= video_codec_tag;
2961

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

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

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

    
2992
        video_enc->codec_id = codec_id;
2993

    
2994
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2995

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

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

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

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

    
3025
        if(intra_matrix)
3026
            video_enc->intra_matrix = intra_matrix;
3027
        if(inter_matrix)
3028
            video_enc->inter_matrix = inter_matrix;
3029

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

    
3061
        if (do_psnr)
3062
            video_enc->flags|= CODEC_FLAG_PSNR;
3063

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

    
3075
    /* reset some key parameters */
3076
    video_disable = 0;
3077
    av_freep(&video_codec_name);
3078
    video_stream_copy = 0;
3079
}
3080

    
3081
static void new_audio_stream(AVFormatContext *oc)
3082
{
3083
    AVStream *st;
3084
    AVCodecContext *audio_enc;
3085
    int codec_id;
3086

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

    
3094
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3095
    audio_bitstream_filters= NULL;
3096

    
3097
    if(thread_count>1)
3098
        avcodec_thread_init(st->codec, thread_count);
3099

    
3100
    audio_enc = st->codec;
3101
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3102

    
3103
    if(audio_codec_tag)
3104
        audio_enc->codec_tag= audio_codec_tag;
3105

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

    
3116
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3117

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

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

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

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

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

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

    
3173
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3174
    subtitle_bitstream_filters= NULL;
3175

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

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

    
3193
    subtitle_disable = 0;
3194
    av_freep(&subtitle_codec_name);
3195
    subtitle_stream_copy = 0;
3196
}
3197

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

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

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

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

    
3238
    if (!strcmp(filename, "-"))
3239
        filename = "pipe:";
3240

    
3241
    oc = av_alloc_format_context();
3242

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

    
3252
    oc->oformat = file_oformat;
3253
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3254

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

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

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

    
3293
        if (use_video) {
3294
            new_video_stream(oc);
3295
        }
3296

    
3297
        if (use_audio) {
3298
            new_audio_stream(oc);
3299
        }
3300

    
3301
        if (use_subtitle) {
3302
            new_subtitle_stream(oc);
3303
        }
3304

    
3305
        oc->timestamp = rec_timestamp;
3306

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

    
3321
    output_files[nb_output_files++] = oc;
3322

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

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

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

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

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

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

    
3374
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3375

    
3376
    /* reset some options */
3377
    file_oformat = NULL;
3378
    file_iformat = NULL;
3379
}
3380

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

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

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

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

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

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

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

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

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

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

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

    
3542
    if(!strcmp(arg, "vcd")) {
3543

    
3544
        opt_video_codec("mpeg1video");
3545
        opt_audio_codec("mp2");
3546
        opt_format("vcd");
3547

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

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

    
3557
        opt_default("ab", "224000");
3558
        audio_sample_rate = 44100;
3559
        audio_channels = 2;
3560

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

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

    
3572
        opt_video_codec("mpeg2video");
3573
        opt_audio_codec("mp2");
3574
        opt_format("svcd");
3575

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

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

    
3586

    
3587
        opt_default("ab", "224000");
3588
        audio_sample_rate = 44100;
3589

    
3590
        opt_default("packetsize", "2324");
3591

    
3592
    } else if(!strcmp(arg, "dvd")) {
3593

    
3594
        opt_video_codec("mpeg2video");
3595
        opt_audio_codec("ac3");
3596
        opt_format("dvd");
3597

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

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

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

    
3610
        opt_default("ab", "448000");
3611
        audio_sample_rate = 48000;
3612

    
3613
    } else if(!strncmp(arg, "dv", 2)) {
3614

    
3615
        opt_format("dv");
3616

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

    
3622
        audio_sample_rate = 48000;
3623
        audio_channels = 2;
3624

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

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

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

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

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

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

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

    
3664
    *bsfp= bsfc;
3665

    
3666
    return 0;
3667
}
3668

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

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

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

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

    
3722
    fclose(f);
3723

    
3724
    return 0;
3725
}
3726

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

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

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

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

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

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

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

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

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

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

    
3864
    avcodec_register_all();
3865
    avdevice_register_all();
3866
    av_register_all();
3867

    
3868
    if(isatty(STDIN_FILENO))
3869
        url_set_interrupt_cb(decode_interrupt_cb);
3870

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

    
3877
    show_banner();
3878

    
3879
    /* parse options */
3880
    parse_options(argc, argv, options, opt_output_file);
3881

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

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

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

    
3901
    return av_exit(0);
3902
}