Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 56f68a41

History | View | Annotate | Download (140 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
 */
19
#define HAVE_AV_CONFIG_H
20
#include <limits.h>
21
#include "avformat.h"
22
#include "swscale.h"
23
#include "framehook.h"
24
#include "dsputil.h"
25
#include "opt.h"
26

    
27
#ifndef __MINGW32__
28
#include <unistd.h>
29
#include <fcntl.h>
30
#include <sys/ioctl.h>
31
#include <sys/time.h>
32
#include <termios.h>
33
#include <sys/resource.h>
34
#include <signal.h>
35
#endif
36
#ifdef CONFIG_OS2
37
#include <sys/types.h>
38
#include <sys/select.h>
39
#include <stdlib.h>
40
#endif
41
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
42
#include <time.h>
43

    
44
#include "version.h"
45
#include "cmdutils.h"
46

    
47
#undef NDEBUG
48
#include <assert.h>
49

    
50
#if !defined(INFINITY) && defined(HUGE_VAL)
51
#define INFINITY HUGE_VAL
52
#endif
53

    
54
/* select an input stream for an output stream */
55
typedef struct AVStreamMap {
56
    int file_index;
57
    int stream_index;
58
    int sync_file_index;
59
    int sync_stream_index;
60
} AVStreamMap;
61

    
62
/** select an input file for an output file */
63
typedef struct AVMetaDataMap {
64
    int out_file;
65
    int in_file;
66
} AVMetaDataMap;
67

    
68
extern const OptionDef options[];
69

    
70
static void show_help(void);
71
static void show_license(void);
72
static int opt_default(const char *opt, const char *arg);
73

    
74
#define MAX_FILES 20
75

    
76
static AVFormatContext *input_files[MAX_FILES];
77
static int64_t input_files_ts_offset[MAX_FILES];
78
static int nb_input_files = 0;
79

    
80
static AVFormatContext *output_files[MAX_FILES];
81
static int nb_output_files = 0;
82

    
83
static AVStreamMap stream_maps[MAX_FILES];
84
static int nb_stream_maps;
85

    
86
static AVMetaDataMap meta_data_maps[MAX_FILES];
87
static int nb_meta_data_maps;
88

    
89
static AVInputFormat *file_iformat;
90
static AVOutputFormat *file_oformat;
91
static AVImageFormat *image_format;
92
static int frame_width  = 0;
93
static int frame_height = 0;
94
static float frame_aspect_ratio = 0;
95
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
96
static int frame_padtop  = 0;
97
static int frame_padbottom = 0;
98
static int frame_padleft  = 0;
99
static int frame_padright = 0;
100
static int padcolor[3] = {16,128,128}; /* default to black */
101
static int frame_topBand  = 0;
102
static int frame_bottomBand = 0;
103
static int frame_leftBand  = 0;
104
static int frame_rightBand = 0;
105
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
106
static int frame_rate = 25;
107
static int frame_rate_base = 1;
108
static float video_qscale = 0;
109
static int video_lmin = 2*FF_QP2LAMBDA;
110
static int video_lmax = 31*FF_QP2LAMBDA;
111
static int video_mb_lmin = 2*FF_QP2LAMBDA;
112
static int video_mb_lmax = 31*FF_QP2LAMBDA;
113
static int video_qdiff = 3;
114
static uint16_t *intra_matrix = NULL;
115
static uint16_t *inter_matrix = NULL;
116
#if 0 //experimental, (can be removed)
117
static float video_rc_qsquish=1.0;
118
static float video_rc_qmod_amp=0;
119
static int video_rc_qmod_freq=0;
120
#endif
121
static char *video_rc_override_string=NULL;
122
static char *video_rc_eq="tex^qComp";
123
static int me_method = ME_EPZS;
124
static int video_disable = 0;
125
static int video_discard = 0;
126
static int video_codec_id = CODEC_ID_NONE;
127
static int video_codec_tag = 0;
128
static int same_quality = 0;
129
static int do_deinterlace = 0;
130
static int packet_size = 0;
131
static int error_rate = 0;
132
static int strict = 0;
133
static int top_field_first = -1;
134
static int me_threshold = 0;
135
static int mb_threshold = 0;
136
static int intra_dc_precision = 8;
137
static int me_penalty_compensation= 256;
138
static int frame_skip_threshold= 0;
139
static int frame_skip_factor= 0;
140
static int frame_skip_exp= 0;
141
static int loop_input = 0;
142
static int loop_output = AVFMT_NOOUTPUTLOOP;
143
static int qp_hist = 0;
144

    
145
static int intra_only = 0;
146
static int audio_sample_rate = 44100;
147
static int audio_bit_rate = 64000;
148
#define QSCALE_NONE -99999
149
static float audio_qscale = QSCALE_NONE;
150
static int audio_disable = 0;
151
static int audio_channels = 1;
152
static int audio_codec_id = CODEC_ID_NONE;
153
static int audio_codec_tag = 0;
154
static char *audio_language = NULL;
155

    
156
static int subtitle_codec_id = CODEC_ID_NONE;
157
static char *subtitle_language = NULL;
158

    
159
static float mux_preload= 0.5;
160
static float mux_max_delay= 0.7;
161

    
162
static int64_t recording_time = 0;
163
static int64_t start_time = 0;
164
static int64_t rec_timestamp = 0;
165
static int64_t input_ts_offset = 0;
166
static int file_overwrite = 0;
167
static char *str_title = NULL;
168
static char *str_author = NULL;
169
static char *str_copyright = NULL;
170
static char *str_comment = NULL;
171
static char *str_album = NULL;
172
static int do_benchmark = 0;
173
static int do_hex_dump = 0;
174
static int do_pkt_dump = 0;
175
static int do_psnr = 0;
176
static int do_vstats = 0;
177
static int do_pass = 0;
178
static char *pass_logfilename = NULL;
179
static int audio_stream_copy = 0;
180
static int video_stream_copy = 0;
181
static int subtitle_stream_copy = 0;
182
static int video_sync_method= 1;
183
static int audio_sync_method= 0;
184
static int copy_ts= 0;
185
static int opt_shortest = 0; //
186
static int video_global_header = 0;
187

    
188
static int rate_emu = 0;
189

    
190
#ifdef CONFIG_BKTR
191
static const char *video_grab_format = "bktr";
192
#else
193
#ifdef CONFIG_VIDEO4LINUX2
194
static const char *video_grab_format = "video4linux2";
195
#else
196
static const char *video_grab_format = "video4linux";
197
#endif
198
#endif
199
static char *video_device = NULL;
200
static char *grab_device = NULL;
201
static int  video_channel = 0;
202
static char *video_standard = "ntsc";
203

    
204
static const char *audio_grab_format = "audio_device";
205
static char *audio_device = NULL;
206
static int audio_volume = 256;
207

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

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

    
224
static int sws_flags = SWS_BICUBIC;
225

    
226
const char **opt_names=NULL;
227
int opt_name_count=0;
228
AVCodecContext *avctx_opts;
229
AVFormatContext *avformat_opts;
230

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

    
235
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
236

    
237
struct AVInputStream;
238

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

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

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

    
267
    /* audio only */
268
    int audio_resample;
269
    ReSampleContext *resample; /* for audio resampling */
270
    FifoBuffer 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 buffer_size_max;  /* buffer size at which we consider we can stop
295
                             buffering */
296
    int nb_streams;       /* nb streams we are aware of */
297
} AVInputFile;
298

    
299
#ifndef __MINGW32__
300

    
301
/* init terminal so that we can grab keys */
302
static struct termios oldtty;
303

    
304
static void term_exit(void)
305
{
306
    tcsetattr (0, TCSANOW, &oldtty);
307
}
308

    
309
static volatile sig_atomic_t received_sigterm = 0;
310

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

    
318
static void term_init(void)
319
{
320
    struct termios tty;
321

    
322
    tcgetattr (0, &tty);
323
    oldtty = tty;
324

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

    
334
    tcsetattr (0, TCSANOW, &tty);
335

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

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

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

    
368
        return n;
369
    }
370
    return -1;
371
}
372

    
373
static int decode_interrupt_cb(void)
374
{
375
    return q_pressed || (q_pressed = read_key() == 'q');
376
}
377

    
378
#else
379

    
380
static volatile int received_sigterm = 0;
381

    
382
/* no interactive support */
383
static void term_exit(void)
384
{
385
}
386

    
387
static void term_init(void)
388
{
389
}
390

    
391
static int read_key(void)
392
{
393
    return 0;
394
}
395

    
396
#endif
397

    
398
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
399
{
400
    int i, err;
401
    AVFormatContext *ic;
402

    
403
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
404
    if (err < 0)
405
        return err;
406
    /* copy stream format */
407
    s->nb_streams = ic->nb_streams;
408
    for(i=0;i<ic->nb_streams;i++) {
409
        AVStream *st;
410

    
411
        // FIXME: a more elegant solution is needed
412
        st = av_mallocz(sizeof(AVStream));
413
        memcpy(st, ic->streams[i], sizeof(AVStream));
414
        st->codec = avcodec_alloc_context();
415
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
416
        s->streams[i] = st;
417
    }
418

    
419
    av_close_input_file(ic);
420
    return 0;
421
}
422

    
423
static double
424
get_sync_ipts(const AVOutputStream *ost)
425
{
426
    const AVInputStream *ist = ost->sync_ist;
427
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
428
}
429

    
430
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
431
    while(bsfc){
432
        AVPacket new_pkt= *pkt;
433
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
434
                                          &new_pkt.data, &new_pkt.size,
435
                                          pkt->data, pkt->size,
436
                                          pkt->flags & PKT_FLAG_KEY);
437
        if(a){
438
            av_free_packet(pkt);
439
            new_pkt.destruct= av_destruct_packet;
440
        }
441
        *pkt= new_pkt;
442

    
443
        bsfc= bsfc->next;
444
    }
445

    
446
    av_interleaved_write_frame(s, pkt);
447
}
448

    
449
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
450

    
451
static void do_audio_out(AVFormatContext *s,
452
                         AVOutputStream *ost,
453
                         AVInputStream *ist,
454
                         unsigned char *buf, int size)
455
{
456
    uint8_t *buftmp;
457
    static uint8_t *audio_buf = NULL;
458
    static uint8_t *audio_out = NULL;
459
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
460

    
461
    int size_out, frame_bytes, ret;
462
    AVCodecContext *enc= ost->st->codec;
463

    
464
    /* SC: dynamic allocation of buffers */
465
    if (!audio_buf)
466
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
467
    if (!audio_out)
468
        audio_out = av_malloc(audio_out_size);
469
    if (!audio_buf || !audio_out)
470
        return;               /* Should signal an error ! */
471

    
472
    if(audio_sync_method){
473
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
474
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
475
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
476
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
477

    
478
        //FIXME resample delay
479
        if(fabs(delta) > 50){
480
            if(ist->is_start){
481
                if(byte_delta < 0){
482
                    byte_delta= FFMAX(byte_delta, -size);
483
                    size += byte_delta;
484
                    buf  -= byte_delta;
485
                    if(verbose > 2)
486
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
487
                    if(!size)
488
                        return;
489
                    ist->is_start=0;
490
                }else{
491
                    static uint8_t *input_tmp= NULL;
492
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
493

    
494
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
495
                        ist->is_start=0;
496
                    else
497
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
498

    
499
                    memset(input_tmp, 0, byte_delta);
500
                    memcpy(input_tmp + byte_delta, buf, size);
501
                    buf= input_tmp;
502
                    size += byte_delta;
503
                    if(verbose > 2)
504
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
505
                }
506
            }else if(audio_sync_method>1){
507
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
508
                assert(ost->audio_resample);
509
                if(verbose > 2)
510
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
511
//                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
512
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
513
            }
514
        }
515
    }else
516
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
517
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
518

    
519
    if (ost->audio_resample) {
520
        buftmp = audio_buf;
521
        size_out = audio_resample(ost->resample,
522
                                  (short *)buftmp, (short *)buf,
523
                                  size / (ist->st->codec->channels * 2));
524
        size_out = size_out * enc->channels * 2;
525
    } else {
526
        buftmp = buf;
527
        size_out = size;
528
    }
529

    
530
    /* now encode as many frames as possible */
531
    if (enc->frame_size > 1) {
532
        /* output resampled raw samples */
533
        fifo_write(&ost->fifo, buftmp, size_out,
534
                   &ost->fifo.wptr);
535

    
536
        frame_bytes = enc->frame_size * 2 * enc->channels;
537

    
538
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
539
                     &ost->fifo.rptr) == 0) {
540
            AVPacket pkt;
541
            av_init_packet(&pkt);
542

    
543
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
544
                                       (short *)audio_buf);
545
            audio_size += ret;
546
            pkt.stream_index= ost->index;
547
            pkt.data= audio_out;
548
            pkt.size= ret;
549
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
550
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
551
            pkt.flags |= PKT_FLAG_KEY;
552
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
553

    
554
            ost->sync_opts += enc->frame_size;
555
        }
556
    } else {
557
        AVPacket pkt;
558
        av_init_packet(&pkt);
559

    
560
        ost->sync_opts += size_out / (2 * enc->channels);
561

    
562
        /* output a pcm frame */
563
        /* XXX: change encoding codec API to avoid this ? */
564
        switch(enc->codec->id) {
565
        case CODEC_ID_PCM_S32LE:
566
        case CODEC_ID_PCM_S32BE:
567
        case CODEC_ID_PCM_U32LE:
568
        case CODEC_ID_PCM_U32BE:
569
            size_out = size_out << 1;
570
            break;
571
        case CODEC_ID_PCM_S24LE:
572
        case CODEC_ID_PCM_S24BE:
573
        case CODEC_ID_PCM_U24LE:
574
        case CODEC_ID_PCM_U24BE:
575
        case CODEC_ID_PCM_S24DAUD:
576
            size_out = size_out / 2 * 3;
577
            break;
578
        case CODEC_ID_PCM_S16LE:
579
        case CODEC_ID_PCM_S16BE:
580
        case CODEC_ID_PCM_U16LE:
581
        case CODEC_ID_PCM_U16BE:
582
            break;
583
        default:
584
            size_out = size_out >> 1;
585
            break;
586
        }
587
        ret = avcodec_encode_audio(enc, audio_out, size_out,
588
                                   (short *)buftmp);
589
        audio_size += ret;
590
        pkt.stream_index= ost->index;
591
        pkt.data= audio_out;
592
        pkt.size= ret;
593
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
594
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
595
        pkt.flags |= PKT_FLAG_KEY;
596
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
597
    }
598
}
599

    
600
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
601
{
602
    AVCodecContext *dec;
603
    AVPicture *picture2;
604
    AVPicture picture_tmp;
605
    uint8_t *buf = 0;
606

    
607
    dec = ist->st->codec;
608

    
609
    /* deinterlace : must be done before any resize */
610
    if (do_deinterlace || using_vhook) {
611
        int size;
612

    
613
        /* create temporary picture */
614
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
615
        buf = av_malloc(size);
616
        if (!buf)
617
            return;
618

    
619
        picture2 = &picture_tmp;
620
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
621

    
622
        if (do_deinterlace){
623
            if(avpicture_deinterlace(picture2, picture,
624
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
625
                /* if error, do not deinterlace */
626
                av_free(buf);
627
                buf = NULL;
628
                picture2 = picture;
629
            }
630
        } else {
631
            img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
632
        }
633
    } else {
634
        picture2 = picture;
635
    }
636

    
637
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
638

    
639
    if (picture != picture2)
640
        *picture = *picture2;
641
    *bufp = buf;
642
}
643

    
644
/* we begin to correct av delay at this threshold */
645
#define AV_DELAY_MAX 0.100
646

    
647
static void do_subtitle_out(AVFormatContext *s,
648
                            AVOutputStream *ost,
649
                            AVInputStream *ist,
650
                            AVSubtitle *sub,
651
                            int64_t pts)
652
{
653
    static uint8_t *subtitle_out = NULL;
654
    int subtitle_out_max_size = 65536;
655
    int subtitle_out_size, nb, i;
656
    AVCodecContext *enc;
657
    AVPacket pkt;
658

    
659
    if (pts == AV_NOPTS_VALUE) {
660
        fprintf(stderr, "Subtitle packets must have a pts\n");
661
        return;
662
    }
663

    
664
    enc = ost->st->codec;
665

    
666
    if (!subtitle_out) {
667
        subtitle_out = av_malloc(subtitle_out_max_size);
668
    }
669

    
670
    /* Note: DVB subtitle need one packet to draw them and one other
671
       packet to clear them */
672
    /* XXX: signal it in the codec context ? */
673
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
674
        nb = 2;
675
    else
676
        nb = 1;
677

    
678
    for(i = 0; i < nb; i++) {
679
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
680
                                                    subtitle_out_max_size, sub);
681

    
682
        av_init_packet(&pkt);
683
        pkt.stream_index = ost->index;
684
        pkt.data = subtitle_out;
685
        pkt.size = subtitle_out_size;
686
        pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
687
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
688
            /* XXX: the pts correction is handled here. Maybe handling
689
               it in the codec would be better */
690
            if (i == 0)
691
                pkt.pts += 90 * sub->start_display_time;
692
            else
693
                pkt.pts += 90 * sub->end_display_time;
694
        }
695
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
696
    }
697
}
698

    
699
static int bit_buffer_size= 1024*256;
700
static uint8_t *bit_buffer= NULL;
701

    
702
static void do_video_out(AVFormatContext *s,
703
                         AVOutputStream *ost,
704
                         AVInputStream *ist,
705
                         AVFrame *in_picture,
706
                         int *frame_size)
707
{
708
    int nb_frames, i, ret;
709
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
710
    AVFrame picture_crop_temp, picture_pad_temp;
711
    uint8_t *buf = NULL, *buf1 = NULL;
712
    AVCodecContext *enc, *dec;
713

    
714
    avcodec_get_frame_defaults(&picture_crop_temp);
715
    avcodec_get_frame_defaults(&picture_pad_temp);
716

    
717
    enc = ost->st->codec;
718
    dec = ist->st->codec;
719

    
720
    /* by default, we output a single frame */
721
    nb_frames = 1;
722

    
723
    *frame_size = 0;
724

    
725
    if(video_sync_method){
726
        double vdelta;
727
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
728
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
729
        if (vdelta < -1.1)
730
            nb_frames = 0;
731
        else if (vdelta > 1.1)
732
            nb_frames = lrintf(vdelta);
733
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
734
        if (nb_frames == 0){
735
            ++nb_frames_drop;
736
            if (verbose>2)
737
                fprintf(stderr, "*** drop!\n");
738
        }else if (nb_frames > 1) {
739
            nb_frames_dup += nb_frames;
740
            if (verbose>2)
741
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
742
        }
743
    }else
744
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
745

    
746
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
747
    if (nb_frames <= 0)
748
        return;
749

    
750
    if (ost->video_crop) {
751
        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
752
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
753
            goto the_end;
754
        }
755
        formatted_picture = &picture_crop_temp;
756
    } else {
757
        formatted_picture = in_picture;
758
    }
759

    
760
    final_picture = formatted_picture;
761
    padding_src = formatted_picture;
762
    resampling_dst = &ost->pict_tmp;
763
    if (ost->video_pad) {
764
        final_picture = &ost->pict_tmp;
765
        if (ost->video_resample) {
766
            if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
767
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
768
                goto the_end;
769
            }
770
            resampling_dst = &picture_pad_temp;
771
        }
772
    }
773

    
774
    if (ost->video_resample) {
775
        padding_src = NULL;
776
        final_picture = &ost->pict_tmp;
777
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
778
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
779
    }
780

    
781
    if (ost->video_pad) {
782
        img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
783
                enc->height, enc->width, enc->pix_fmt,
784
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
785
    }
786

    
787
    /* duplicates frame if needed */
788
    for(i=0;i<nb_frames;i++) {
789
        AVPacket pkt;
790
        av_init_packet(&pkt);
791
        pkt.stream_index= ost->index;
792

    
793
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
794
            /* raw pictures are written as AVPicture structure to
795
               avoid any copies. We support temorarily the older
796
               method. */
797
            AVFrame* old_frame = enc->coded_frame;
798
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
799
            pkt.data= (uint8_t *)final_picture;
800
            pkt.size=  sizeof(AVPicture);
801
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
802
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
803
            if(dec->coded_frame && dec->coded_frame->key_frame)
804
                pkt.flags |= PKT_FLAG_KEY;
805

    
806
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
807
            enc->coded_frame = old_frame;
808
        } else {
809
            AVFrame big_picture;
810

    
811
            big_picture= *final_picture;
812
            /* better than nothing: use input picture interlaced
813
               settings */
814
            big_picture.interlaced_frame = in_picture->interlaced_frame;
815
            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
816
                if(top_field_first == -1)
817
                    big_picture.top_field_first = in_picture->top_field_first;
818
                else
819
                    big_picture.top_field_first = top_field_first;
820
            }
821

    
822
            /* handles sameq here. This is not correct because it may
823
               not be a global option */
824
            if (same_quality) {
825
                big_picture.quality = ist->st->quality;
826
            }else
827
                big_picture.quality = ost->st->quality;
828
            if(!me_threshold)
829
                big_picture.pict_type = 0;
830
//            big_picture.pts = AV_NOPTS_VALUE;
831
            big_picture.pts= ost->sync_opts;
832
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
833
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
834
            ret = avcodec_encode_video(enc,
835
                                       bit_buffer, bit_buffer_size,
836
                                       &big_picture);
837
            //enc->frame_number = enc->real_pict_num;
838
            if(ret>0){
839
                pkt.data= bit_buffer;
840
                pkt.size= ret;
841
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
842
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
843
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
844
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
845
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
846

    
847
                if(enc->coded_frame && enc->coded_frame->key_frame)
848
                    pkt.flags |= PKT_FLAG_KEY;
849
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
850
                *frame_size = ret;
851
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
852
                //        enc->frame_number-1, enc->real_pict_num, ret,
853
                //        enc->pict_type);
854
                /* if two pass, output log */
855
                if (ost->logfile && enc->stats_out) {
856
                    fprintf(ost->logfile, "%s", enc->stats_out);
857
                }
858
            }
859
        }
860
        ost->sync_opts++;
861
        ost->frame_number++;
862
    }
863
 the_end:
864
    av_free(buf);
865
    av_free(buf1);
866
}
867

    
868
static double psnr(double d){
869
    if(d==0) return INFINITY;
870
    return -10.0*log(d)/log(10.0);
871
}
872

    
873
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
874
                           int frame_size)
875
{
876
    static FILE *fvstats=NULL;
877
    char filename[40];
878
    time_t today2;
879
    struct tm *today;
880
    AVCodecContext *enc;
881
    int frame_number;
882
    int64_t ti;
883
    double ti1, bitrate, avg_bitrate;
884

    
885
    if (!fvstats) {
886
        today2 = time(NULL);
887
        today = localtime(&today2);
888
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
889
                                               today->tm_min,
890
                                               today->tm_sec);
891
        fvstats = fopen(filename,"w");
892
        if (!fvstats) {
893
            perror("fopen");
894
            exit(1);
895
        }
896
    }
897

    
898
    ti = MAXINT64;
899
    enc = ost->st->codec;
900
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
901
        frame_number = ost->frame_number;
902
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
903
        if (enc->flags&CODEC_FLAG_PSNR)
904
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
905

    
906
        fprintf(fvstats,"f_size= %6d ", frame_size);
907
        /* compute pts value */
908
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
909
        if (ti1 < 0.01)
910
            ti1 = 0.01;
911

    
912
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
913
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
914
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
915
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
916
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
917
    }
918
}
919

    
920
static void print_report(AVFormatContext **output_files,
921
                         AVOutputStream **ost_table, int nb_ostreams,
922
                         int is_last_report)
923
{
924
    char buf[1024];
925
    AVOutputStream *ost;
926
    AVFormatContext *oc, *os;
927
    int64_t total_size;
928
    AVCodecContext *enc;
929
    int frame_number, vid, i;
930
    double bitrate, ti1, pts;
931
    static int64_t last_time = -1;
932
    static int qp_histogram[52];
933

    
934
    if (!is_last_report) {
935
        int64_t cur_time;
936
        /* display the report every 0.5 seconds */
937
        cur_time = av_gettime();
938
        if (last_time == -1) {
939
            last_time = cur_time;
940
            return;
941
        }
942
        if ((cur_time - last_time) < 500000)
943
            return;
944
        last_time = cur_time;
945
    }
946

    
947

    
948
    oc = output_files[0];
949

    
950
    total_size = url_ftell(&oc->pb);
951

    
952
    buf[0] = '\0';
953
    ti1 = 1e10;
954
    vid = 0;
955
    for(i=0;i<nb_ostreams;i++) {
956
        ost = ost_table[i];
957
        os = output_files[ost->file_index];
958
        enc = ost->st->codec;
959
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
960
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
961
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
962
        }
963
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
964
            frame_number = ost->frame_number;
965
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
966
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
967
            if(is_last_report)
968
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
969
            if(qp_hist && enc->coded_frame){
970
                int j;
971
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
972
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
973
                    qp_histogram[qp]++;
974
                for(j=0; j<32; j++)
975
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
976
            }
977
            if (enc->flags&CODEC_FLAG_PSNR){
978
                int j;
979
                double error, error_sum=0;
980
                double scale, scale_sum=0;
981
                char type[3]= {'Y','U','V'};
982
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
983
                for(j=0; j<3; j++){
984
                    if(is_last_report){
985
                        error= enc->error[j];
986
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
987
                    }else{
988
                        error= enc->coded_frame->error[j];
989
                        scale= enc->width*enc->height*255.0*255.0;
990
                    }
991
                    if(j) scale/=4;
992
                    error_sum += error;
993
                    scale_sum += scale;
994
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
995
                }
996
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
997
            }
998
            vid = 1;
999
        }
1000
        /* compute min output value */
1001
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1002
        if ((pts < ti1) && (pts > 0))
1003
            ti1 = pts;
1004
    }
1005
    if (ti1 < 0.01)
1006
        ti1 = 0.01;
1007

    
1008
    if (verbose || is_last_report) {
1009
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1010

    
1011
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1012
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1013
            (double)total_size / 1024, ti1, bitrate);
1014

    
1015
        if (verbose > 1)
1016
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1017
                  nb_frames_dup, nb_frames_drop);
1018

    
1019
        if (verbose >= 0)
1020
            fprintf(stderr, "%s    \r", buf);
1021

    
1022
        fflush(stderr);
1023
    }
1024

    
1025
    if (is_last_report && verbose >= 0){
1026
        int64_t raw= audio_size + video_size + extra_size;
1027
        fprintf(stderr, "\n");
1028
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1029
                video_size/1024.0,
1030
                audio_size/1024.0,
1031
                extra_size/1024.0,
1032
                100.0*(total_size - raw)/raw
1033
        );
1034
    }
1035
}
1036

    
1037
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1038
static int output_packet(AVInputStream *ist, int ist_index,
1039
                         AVOutputStream **ost_table, int nb_ostreams,
1040
                         const AVPacket *pkt)
1041
{
1042
    AVFormatContext *os;
1043
    AVOutputStream *ost;
1044
    uint8_t *ptr;
1045
    int len, ret, i;
1046
    uint8_t *data_buf;
1047
    int data_size, got_picture;
1048
    AVFrame picture;
1049
    void *buffer_to_free;
1050
    static unsigned int samples_size= 0;
1051
    static short *samples= NULL;
1052
    AVSubtitle subtitle, *subtitle_to_free;
1053
    int got_subtitle;
1054

    
1055
    if(!pkt){
1056
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1057
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1058
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1059
    } else {
1060
//        assert(ist->pts == ist->next_pts);
1061
    }
1062

    
1063
    if (pkt == NULL) {
1064
        /* EOF handling */
1065
        ptr = NULL;
1066
        len = 0;
1067
        goto handle_eof;
1068
    }
1069

    
1070
    len = pkt->size;
1071
    ptr = pkt->data;
1072
    while (len > 0) {
1073
    handle_eof:
1074
        /* decode the packet if needed */
1075
        data_buf = NULL; /* fail safe */
1076
        data_size = 0;
1077
        subtitle_to_free = NULL;
1078
        if (ist->decoding_needed) {
1079
            switch(ist->st->codec->codec_type) {
1080
            case CODEC_TYPE_AUDIO:{
1081
                if(pkt)
1082
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1083
                    /* XXX: could avoid copy if PCM 16 bits with same
1084
                       endianness as CPU */
1085
                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1086
                                           ptr, len);
1087
                if (ret < 0)
1088
                    goto fail_decode;
1089
                ptr += ret;
1090
                len -= ret;
1091
                /* Some bug in mpeg audio decoder gives */
1092
                /* data_size < 0, it seems they are overflows */
1093
                if (data_size <= 0) {
1094
                    /* no audio frame */
1095
                    continue;
1096
                }
1097
                data_buf = (uint8_t *)samples;
1098
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1099
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1100
                break;}
1101
            case CODEC_TYPE_VIDEO:
1102
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1103
                    /* XXX: allocate picture correctly */
1104
                    avcodec_get_frame_defaults(&picture);
1105

    
1106
                    ret = avcodec_decode_video(ist->st->codec,
1107
                                               &picture, &got_picture, ptr, len);
1108
                    ist->st->quality= picture.quality;
1109
                    if (ret < 0)
1110
                        goto fail_decode;
1111
                    if (!got_picture) {
1112
                        /* no picture yet */
1113
                        goto discard_packet;
1114
                    }
1115
                    if (ist->st->codec->time_base.num != 0) {
1116
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1117
                                          ist->st->codec->time_base.num) /
1118
                            ist->st->codec->time_base.den;
1119
                    }
1120
                    len = 0;
1121
                    break;
1122
            case CODEC_TYPE_SUBTITLE:
1123
                ret = avcodec_decode_subtitle(ist->st->codec,
1124
                                              &subtitle, &got_subtitle, ptr, len);
1125
                if (ret < 0)
1126
                    goto fail_decode;
1127
                if (!got_subtitle) {
1128
                    goto discard_packet;
1129
                }
1130
                subtitle_to_free = &subtitle;
1131
                len = 0;
1132
                break;
1133
            default:
1134
                goto fail_decode;
1135
            }
1136
        } else {
1137
                switch(ist->st->codec->codec_type) {
1138
                case CODEC_TYPE_AUDIO:
1139
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1140
                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1141
                    break;
1142
                case CODEC_TYPE_VIDEO:
1143
                    if (ist->st->codec->time_base.num != 0) {
1144
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1145
                                          ist->st->codec->time_base.num) /
1146
                            ist->st->codec->time_base.den;
1147
                    }
1148
                    break;
1149
                }
1150
                data_buf = ptr;
1151
                data_size = len;
1152
                ret = len;
1153
                len = 0;
1154
            }
1155

    
1156
            buffer_to_free = NULL;
1157
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1158
                pre_process_video_frame(ist, (AVPicture *)&picture,
1159
                                        &buffer_to_free);
1160
            }
1161

    
1162
            // preprocess audio (volume)
1163
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1164
                if (audio_volume != 256) {
1165
                    short *volp;
1166
                    volp = samples;
1167
                    for(i=0;i<(data_size / sizeof(short));i++) {
1168
                        int v = ((*volp) * audio_volume + 128) >> 8;
1169
                        if (v < -32768) v = -32768;
1170
                        if (v >  32767) v = 32767;
1171
                        *volp++ = v;
1172
                    }
1173
                }
1174
            }
1175

    
1176
            /* frame rate emulation */
1177
            if (ist->st->codec->rate_emu) {
1178
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1179
                int64_t now = av_gettime() - ist->start;
1180
                if (pts > now)
1181
                    usleep(pts - now);
1182

    
1183
                ist->frame++;
1184
            }
1185

    
1186
#if 0
1187
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1188
               is the one of the next displayed one */
1189
            /* XXX: add mpeg4 too ? */
1190
            if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1191
                if (ist->st->codec->pict_type != B_TYPE) {
1192
                    int64_t tmp;
1193
                    tmp = ist->last_ip_pts;
1194
                    ist->last_ip_pts  = ist->frac_pts.val;
1195
                    ist->frac_pts.val = tmp;
1196
                }
1197
            }
1198
#endif
1199
            /* if output time reached then transcode raw format,
1200
               encode packets and output them */
1201
            if (start_time == 0 || ist->pts >= start_time)
1202
                for(i=0;i<nb_ostreams;i++) {
1203
                    int frame_size;
1204

    
1205
                    ost = ost_table[i];
1206
                    if (ost->source_index == ist_index) {
1207
                        os = output_files[ost->file_index];
1208

    
1209
#if 0
1210
                        printf("%d: got pts=%0.3f %0.3f\n", i,
1211
                               (double)pkt->pts / AV_TIME_BASE,
1212
                               ((double)ist->pts / AV_TIME_BASE) -
1213
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1214
#endif
1215
                        /* set the input output pts pairs */
1216
                        //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1217

    
1218
                        if (ost->encoding_needed) {
1219
                            switch(ost->st->codec->codec_type) {
1220
                            case CODEC_TYPE_AUDIO:
1221
                                do_audio_out(os, ost, ist, data_buf, data_size);
1222
                                break;
1223
                            case CODEC_TYPE_VIDEO:
1224
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1225
                                    video_size += frame_size;
1226
                                    if (do_vstats && frame_size)
1227
                                        do_video_stats(os, ost, frame_size);
1228
                                break;
1229
                            case CODEC_TYPE_SUBTITLE:
1230
                                do_subtitle_out(os, ost, ist, &subtitle,
1231
                                                pkt->pts);
1232
                                break;
1233
                            default:
1234
                                av_abort();
1235
                            }
1236
                        } else {
1237
                            AVFrame avframe; //FIXME/XXX remove this
1238
                            AVPacket opkt;
1239
                            av_init_packet(&opkt);
1240

    
1241
                            /* no reencoding needed : output the packet directly */
1242
                            /* force the input stream PTS */
1243

    
1244
                            avcodec_get_frame_defaults(&avframe);
1245
                            ost->st->codec->coded_frame= &avframe;
1246
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1247

    
1248
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1249
                                audio_size += data_size;
1250
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1251
                                video_size += data_size;
1252
                                ost->sync_opts++;
1253
                            }
1254

    
1255
                            opkt.stream_index= ost->index;
1256
                            if(pkt->pts != AV_NOPTS_VALUE)
1257
                                opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1258
                            else
1259
                                opkt.pts= AV_NOPTS_VALUE;
1260

    
1261
                            {
1262
                                int64_t dts;
1263
                                if (pkt->dts == AV_NOPTS_VALUE)
1264
                                    dts = ist->next_pts;
1265
                                else
1266
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1267
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1268
                            }
1269
                            opkt.flags= pkt->flags;
1270

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

    
1275
                            write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1276
                            ost->st->codec->frame_number++;
1277
                            ost->frame_number++;
1278
                            av_free_packet(&opkt);
1279
                        }
1280
                    }
1281
                }
1282
            av_free(buffer_to_free);
1283
            /* XXX: allocate the subtitles in the codec ? */
1284
            if (subtitle_to_free) {
1285
                if (subtitle_to_free->rects != NULL) {
1286
                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
1287
                        av_free(subtitle_to_free->rects[i].bitmap);
1288
                        av_free(subtitle_to_free->rects[i].rgba_palette);
1289
                    }
1290
                    av_freep(&subtitle_to_free->rects);
1291
                }
1292
                subtitle_to_free->num_rects = 0;
1293
                subtitle_to_free = NULL;
1294
            }
1295
        }
1296
 discard_packet:
1297
    if (pkt == NULL) {
1298
        /* EOF handling */
1299

    
1300
        for(i=0;i<nb_ostreams;i++) {
1301
            ost = ost_table[i];
1302
            if (ost->source_index == ist_index) {
1303
                AVCodecContext *enc= ost->st->codec;
1304
                os = output_files[ost->file_index];
1305

    
1306
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1307
                    continue;
1308
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1309
                    continue;
1310

    
1311
                if (ost->encoding_needed) {
1312
                    for(;;) {
1313
                        AVPacket pkt;
1314
                        int fifo_bytes;
1315
                        av_init_packet(&pkt);
1316
                        pkt.stream_index= ost->index;
1317

    
1318
                        switch(ost->st->codec->codec_type) {
1319
                        case CODEC_TYPE_AUDIO:
1320
                            fifo_bytes = fifo_size(&ost->fifo, NULL);
1321
                            ret = 0;
1322
                            /* encode any samples remaining in fifo */
1323
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1324
                                int fs_tmp = enc->frame_size;
1325
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1326
                                if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1327
                                        &ost->fifo.rptr) == 0) {
1328
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1329
                                }
1330
                                enc->frame_size = fs_tmp;
1331
                            }
1332
                            if(ret <= 0) {
1333
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1334
                            }
1335
                            audio_size += ret;
1336
                            pkt.flags |= PKT_FLAG_KEY;
1337
                            break;
1338
                        case CODEC_TYPE_VIDEO:
1339
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1340
                            video_size += ret;
1341
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1342
                                pkt.flags |= PKT_FLAG_KEY;
1343
                            if (ost->logfile && enc->stats_out) {
1344
                                fprintf(ost->logfile, "%s", enc->stats_out);
1345
                            }
1346
                            break;
1347
                        default:
1348
                            ret=-1;
1349
                        }
1350

    
1351
                        if(ret<=0)
1352
                            break;
1353
                        pkt.data= bit_buffer;
1354
                        pkt.size= ret;
1355
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1356
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1357
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1358
                    }
1359
                }
1360
            }
1361
        }
1362
    }
1363

    
1364
    return 0;
1365
 fail_decode:
1366
    return -1;
1367
}
1368

    
1369

    
1370
/*
1371
 * The following code is the main loop of the file converter
1372
 */
1373
static int av_encode(AVFormatContext **output_files,
1374
                     int nb_output_files,
1375
                     AVFormatContext **input_files,
1376
                     int nb_input_files,
1377
                     AVStreamMap *stream_maps, int nb_stream_maps)
1378
{
1379
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1380
    AVFormatContext *is, *os;
1381
    AVCodecContext *codec, *icodec;
1382
    AVOutputStream *ost, **ost_table = NULL;
1383
    AVInputStream *ist, **ist_table = NULL;
1384
    AVInputFile *file_table;
1385
    AVFormatContext *stream_no_data;
1386
    int key;
1387

    
1388
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1389
    if (!file_table)
1390
        goto fail;
1391

    
1392
    /* input stream init */
1393
    j = 0;
1394
    for(i=0;i<nb_input_files;i++) {
1395
        is = input_files[i];
1396
        file_table[i].ist_index = j;
1397
        file_table[i].nb_streams = is->nb_streams;
1398
        j += is->nb_streams;
1399
    }
1400
    nb_istreams = j;
1401

    
1402
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1403
    if (!ist_table)
1404
        goto fail;
1405

    
1406
    for(i=0;i<nb_istreams;i++) {
1407
        ist = av_mallocz(sizeof(AVInputStream));
1408
        if (!ist)
1409
            goto fail;
1410
        ist_table[i] = ist;
1411
    }
1412
    j = 0;
1413
    for(i=0;i<nb_input_files;i++) {
1414
        is = input_files[i];
1415
        for(k=0;k<is->nb_streams;k++) {
1416
            ist = ist_table[j++];
1417
            ist->st = is->streams[k];
1418
            ist->file_index = i;
1419
            ist->index = k;
1420
            ist->discard = 1; /* the stream is discarded by default
1421
                                 (changed later) */
1422

    
1423
            if (ist->st->codec->rate_emu) {
1424
                ist->start = av_gettime();
1425
                ist->frame = 0;
1426
            }
1427
        }
1428
    }
1429

    
1430
    /* output stream init */
1431
    nb_ostreams = 0;
1432
    for(i=0;i<nb_output_files;i++) {
1433
        os = output_files[i];
1434
        nb_ostreams += os->nb_streams;
1435
    }
1436
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1437
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1438
        exit(1);
1439
    }
1440

    
1441
    /* Sanity check the mapping args -- do the input files & streams exist? */
1442
    for(i=0;i<nb_stream_maps;i++) {
1443
        int fi = stream_maps[i].file_index;
1444
        int si = stream_maps[i].stream_index;
1445

    
1446
        if (fi < 0 || fi > nb_input_files - 1 ||
1447
            si < 0 || si > file_table[fi].nb_streams - 1) {
1448
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1449
            exit(1);
1450
        }
1451
        fi = stream_maps[i].sync_file_index;
1452
        si = stream_maps[i].sync_stream_index;
1453
        if (fi < 0 || fi > nb_input_files - 1 ||
1454
            si < 0 || si > file_table[fi].nb_streams - 1) {
1455
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1456
            exit(1);
1457
        }
1458
    }
1459

    
1460
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1461
    if (!ost_table)
1462
        goto fail;
1463
    for(i=0;i<nb_ostreams;i++) {
1464
        ost = av_mallocz(sizeof(AVOutputStream));
1465
        if (!ost)
1466
            goto fail;
1467
        ost_table[i] = ost;
1468
    }
1469

    
1470
    n = 0;
1471
    for(k=0;k<nb_output_files;k++) {
1472
        os = output_files[k];
1473
        for(i=0;i<os->nb_streams;i++) {
1474
            int found;
1475
            ost = ost_table[n++];
1476
            ost->file_index = k;
1477
            ost->index = i;
1478
            ost->st = os->streams[i];
1479
            if (nb_stream_maps > 0) {
1480
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1481
                    stream_maps[n-1].stream_index;
1482

    
1483
                /* Sanity check that the stream types match */
1484
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1485
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1486
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1487
                        ost->file_index, ost->index);
1488
                    exit(1);
1489
                }
1490

    
1491
            } else {
1492
                /* get corresponding input stream index : we select the first one with the right type */
1493
                found = 0;
1494
                for(j=0;j<nb_istreams;j++) {
1495
                    ist = ist_table[j];
1496
                    if (ist->discard &&
1497
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1498
                        ost->source_index = j;
1499
                        found = 1;
1500
                        break;
1501
                    }
1502
                }
1503

    
1504
                if (!found) {
1505
                    /* try again and reuse existing stream */
1506
                    for(j=0;j<nb_istreams;j++) {
1507
                        ist = ist_table[j];
1508
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1509
                            ost->source_index = j;
1510
                            found = 1;
1511
                        }
1512
                    }
1513
                    if (!found) {
1514
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1515
                                ost->file_index, ost->index);
1516
                        exit(1);
1517
                    }
1518
                }
1519
            }
1520
            ist = ist_table[ost->source_index];
1521
            ist->discard = 0;
1522
            ost->sync_ist = (nb_stream_maps > 0) ?
1523
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1524
                         stream_maps[n-1].sync_stream_index] : ist;
1525
        }
1526
    }
1527

    
1528
    /* for each output stream, we compute the right encoding parameters */
1529
    for(i=0;i<nb_ostreams;i++) {
1530
        ost = ost_table[i];
1531
        ist = ist_table[ost->source_index];
1532

    
1533
        codec = ost->st->codec;
1534
        icodec = ist->st->codec;
1535

    
1536
        if (ost->st->stream_copy) {
1537
            /* if stream_copy is selected, no need to decode or encode */
1538
            codec->codec_id = icodec->codec_id;
1539
            codec->codec_type = icodec->codec_type;
1540
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1541
            codec->bit_rate = icodec->bit_rate;
1542
            codec->extradata= icodec->extradata;
1543
            codec->extradata_size= icodec->extradata_size;
1544
            codec->time_base = icodec->time_base;
1545
            switch(codec->codec_type) {
1546
            case CODEC_TYPE_AUDIO:
1547
                codec->sample_rate = icodec->sample_rate;
1548
                codec->channels = icodec->channels;
1549
                codec->frame_size = icodec->frame_size;
1550
                codec->block_align= icodec->block_align;
1551
                break;
1552
            case CODEC_TYPE_VIDEO:
1553
                codec->pix_fmt = icodec->pix_fmt;
1554
                codec->width = icodec->width;
1555
                codec->height = icodec->height;
1556
                codec->has_b_frames = icodec->has_b_frames;
1557
                break;
1558
            case CODEC_TYPE_SUBTITLE:
1559
                break;
1560
            default:
1561
                av_abort();
1562
            }
1563
        } else {
1564
            switch(codec->codec_type) {
1565
            case CODEC_TYPE_AUDIO:
1566
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1567
                    goto fail;
1568

    
1569
                if (codec->channels == icodec->channels &&
1570
                    codec->sample_rate == icodec->sample_rate) {
1571
                    ost->audio_resample = 0;
1572
                } else {
1573
                    if (codec->channels != icodec->channels &&
1574
                        (icodec->codec_id == CODEC_ID_AC3 ||
1575
                         icodec->codec_id == CODEC_ID_DTS)) {
1576
                        /* Special case for 5:1 AC3 and DTS input */
1577
                        /* and mono or stereo output      */
1578
                        /* Request specific number of channels */
1579
                        icodec->channels = codec->channels;
1580
                        if (codec->sample_rate == icodec->sample_rate)
1581
                            ost->audio_resample = 0;
1582
                        else {
1583
                            ost->audio_resample = 1;
1584
                        }
1585
                    } else {
1586
                        ost->audio_resample = 1;
1587
                    }
1588
                }
1589
                if(audio_sync_method>1)
1590
                    ost->audio_resample = 1;
1591

    
1592
                if(ost->audio_resample){
1593
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1594
                                                    codec->sample_rate, icodec->sample_rate);
1595
                    if(!ost->resample){
1596
                        printf("Can't resample.  Aborting.\n");
1597
                        av_abort();
1598
                    }
1599
                }
1600
                ist->decoding_needed = 1;
1601
                ost->encoding_needed = 1;
1602
                break;
1603
            case CODEC_TYPE_VIDEO:
1604
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1605
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1606
                ost->video_resample = ((codec->width != icodec->width -
1607
                                (frame_leftBand + frame_rightBand) +
1608
                                (frame_padleft + frame_padright)) ||
1609
                        (codec->height != icodec->height -
1610
                                (frame_topBand  + frame_bottomBand) +
1611
                                (frame_padtop + frame_padbottom)) ||
1612
                        (codec->pix_fmt != icodec->pix_fmt));
1613
                if (ost->video_crop) {
1614
                    ost->topBand = frame_topBand;
1615
                    ost->leftBand = frame_leftBand;
1616
                }
1617
                if (ost->video_pad) {
1618
                    ost->padtop = frame_padtop;
1619
                    ost->padleft = frame_padleft;
1620
                    ost->padbottom = frame_padbottom;
1621
                    ost->padright = frame_padright;
1622
                    if (!ost->video_resample) {
1623
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1624
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1625
                                         codec->width, codec->height ) )
1626
                            goto fail;
1627
                    }
1628
                }
1629
                if (ost->video_resample) {
1630
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1631
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1632
                                         codec->width, codec->height ) )
1633
                        goto fail;
1634

    
1635
                    ost->img_resample_ctx = sws_getContext(
1636
                            icodec->width - (frame_leftBand + frame_rightBand),
1637
                            icodec->height - (frame_topBand + frame_bottomBand),
1638
                            icodec->pix_fmt,
1639
                            codec->width - (frame_padleft + frame_padright),
1640
                            codec->height - (frame_padtop + frame_padbottom),
1641
                            codec->pix_fmt,
1642
                            sws_flags, NULL, NULL, NULL);
1643
                    if (ost->img_resample_ctx == NULL) {
1644
                        fprintf(stderr, "Cannot get resampling context\n");
1645
                        exit(1);
1646
                    }
1647
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1648
                }
1649
                ost->encoding_needed = 1;
1650
                ist->decoding_needed = 1;
1651
                break;
1652
            case CODEC_TYPE_SUBTITLE:
1653
                ost->encoding_needed = 1;
1654
                ist->decoding_needed = 1;
1655
                break;
1656
            default:
1657
                av_abort();
1658
                break;
1659
            }
1660
            /* two pass mode */
1661
            if (ost->encoding_needed &&
1662
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1663
                char logfilename[1024];
1664
                FILE *f;
1665
                int size;
1666
                char *logbuffer;
1667

    
1668
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1669
                         pass_logfilename ?
1670
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1671
                if (codec->flags & CODEC_FLAG_PASS1) {
1672
                    f = fopen(logfilename, "w");
1673
                    if (!f) {
1674
                        perror(logfilename);
1675
                        exit(1);
1676
                    }
1677
                    ost->logfile = f;
1678
                } else {
1679
                    /* read the log file */
1680
                    f = fopen(logfilename, "r");
1681
                    if (!f) {
1682
                        perror(logfilename);
1683
                        exit(1);
1684
                    }
1685
                    fseek(f, 0, SEEK_END);
1686
                    size = ftell(f);
1687
                    fseek(f, 0, SEEK_SET);
1688
                    logbuffer = av_malloc(size + 1);
1689
                    if (!logbuffer) {
1690
                        fprintf(stderr, "Could not allocate log buffer\n");
1691
                        exit(1);
1692
                    }
1693
                    size = fread(logbuffer, 1, size, f);
1694
                    fclose(f);
1695
                    logbuffer[size] = '\0';
1696
                    codec->stats_in = logbuffer;
1697
                }
1698
            }
1699
        }
1700
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1701
            int size= codec->width * codec->height;
1702
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1703
        }
1704
    }
1705

    
1706
    if (!bit_buffer)
1707
        bit_buffer = av_malloc(bit_buffer_size);
1708
    if (!bit_buffer)
1709
        goto fail;
1710

    
1711
    /* dump the file output parameters - cannot be done before in case
1712
       of stream copy */
1713
    for(i=0;i<nb_output_files;i++) {
1714
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1715
    }
1716

    
1717
    /* dump the stream mapping */
1718
    if (verbose >= 0) {
1719
        fprintf(stderr, "Stream mapping:\n");
1720
        for(i=0;i<nb_ostreams;i++) {
1721
            ost = ost_table[i];
1722
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1723
                    ist_table[ost->source_index]->file_index,
1724
                    ist_table[ost->source_index]->index,
1725
                    ost->file_index,
1726
                    ost->index);
1727
            if (ost->sync_ist != ist_table[ost->source_index])
1728
                fprintf(stderr, " [sync #%d.%d]",
1729
                        ost->sync_ist->file_index,
1730
                        ost->sync_ist->index);
1731
            fprintf(stderr, "\n");
1732
        }
1733
    }
1734

    
1735
    /* open each encoder */
1736
    for(i=0;i<nb_ostreams;i++) {
1737
        ost = ost_table[i];
1738
        if (ost->encoding_needed) {
1739
            AVCodec *codec;
1740
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1741
            if (!codec) {
1742
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1743
                        ost->file_index, ost->index);
1744
                exit(1);
1745
            }
1746
            if (avcodec_open(ost->st->codec, codec) < 0) {
1747
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1748
                        ost->file_index, ost->index);
1749
                exit(1);
1750
            }
1751
            extra_size += ost->st->codec->extradata_size;
1752
        }
1753
    }
1754

    
1755
    /* open each decoder */
1756
    for(i=0;i<nb_istreams;i++) {
1757
        ist = ist_table[i];
1758
        if (ist->decoding_needed) {
1759
            AVCodec *codec;
1760
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1761
            if (!codec) {
1762
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1763
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1764
                exit(1);
1765
            }
1766
            if (avcodec_open(ist->st->codec, codec) < 0) {
1767
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1768
                        ist->file_index, ist->index);
1769
                exit(1);
1770
            }
1771
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1772
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1773
        }
1774
    }
1775

    
1776
    /* init pts */
1777
    for(i=0;i<nb_istreams;i++) {
1778
        ist = ist_table[i];
1779
        is = input_files[ist->file_index];
1780
        ist->pts = 0;
1781
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1782
        if(ist->st->start_time == AV_NOPTS_VALUE)
1783
            ist->next_pts=0;
1784
        if(input_files_ts_offset[ist->file_index])
1785
            ist->next_pts= AV_NOPTS_VALUE;
1786
        ist->is_start = 1;
1787
    }
1788

    
1789
    /* compute buffer size max (should use a complete heuristic) */
1790
    for(i=0;i<nb_input_files;i++) {
1791
        file_table[i].buffer_size_max = 2048;
1792
    }
1793

    
1794
    /* set meta data information from input file if required */
1795
    for (i=0;i<nb_meta_data_maps;i++) {
1796
        AVFormatContext *out_file;
1797
        AVFormatContext *in_file;
1798

    
1799
        int out_file_index = meta_data_maps[i].out_file;
1800
        int in_file_index = meta_data_maps[i].in_file;
1801
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1802
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1803
            ret = -EINVAL;
1804
            goto fail;
1805
        }
1806
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1807
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1808
            ret = -EINVAL;
1809
            goto fail;
1810
        }
1811

    
1812
        out_file = output_files[out_file_index];
1813
        in_file = input_files[in_file_index];
1814

    
1815
        strcpy(out_file->title, in_file->title);
1816
        strcpy(out_file->author, in_file->author);
1817
        strcpy(out_file->copyright, in_file->copyright);
1818
        strcpy(out_file->comment, in_file->comment);
1819
        strcpy(out_file->album, in_file->album);
1820
        out_file->year = in_file->year;
1821
        out_file->track = in_file->track;
1822
        strcpy(out_file->genre, in_file->genre);
1823
    }
1824

    
1825
    /* open files and write file headers */
1826
    for(i=0;i<nb_output_files;i++) {
1827
        os = output_files[i];
1828
        if (av_write_header(os) < 0) {
1829
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1830
            ret = -EINVAL;
1831
            goto fail;
1832
        }
1833
    }
1834

    
1835
#ifndef __MINGW32__
1836
    if ( !using_stdin && verbose >= 0) {
1837
        fprintf(stderr, "Press [q] to stop encoding\n");
1838
        url_set_interrupt_cb(decode_interrupt_cb);
1839
    }
1840
#endif
1841
    term_init();
1842

    
1843
    stream_no_data = 0;
1844
    key = -1;
1845

    
1846
    for(; received_sigterm == 0;) {
1847
        int file_index, ist_index;
1848
        AVPacket pkt;
1849
        double ipts_min;
1850
        double opts_min;
1851

    
1852
    redo:
1853
        ipts_min= 1e100;
1854
        opts_min= 1e100;
1855
        /* if 'q' pressed, exits */
1856
        if (!using_stdin) {
1857
            if (q_pressed)
1858
                break;
1859
            /* read_key() returns 0 on EOF */
1860
            key = read_key();
1861
            if (key == 'q')
1862
                break;
1863
        }
1864

    
1865
        /* select the stream that we must read now by looking at the
1866
           smallest output pts */
1867
        file_index = -1;
1868
        for(i=0;i<nb_ostreams;i++) {
1869
            double ipts, opts;
1870
            ost = ost_table[i];
1871
            os = output_files[ost->file_index];
1872
            ist = ist_table[ost->source_index];
1873
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1874
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1875
            else
1876
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1877
            ipts = (double)ist->pts;
1878
            if (!file_table[ist->file_index].eof_reached){
1879
                if(ipts < ipts_min) {
1880
                    ipts_min = ipts;
1881
                    if(input_sync ) file_index = ist->file_index;
1882
                }
1883
                if(opts < opts_min) {
1884
                    opts_min = opts;
1885
                    if(!input_sync) file_index = ist->file_index;
1886
                }
1887
            }
1888
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1889
                file_index= -1;
1890
                break;
1891
            }
1892
        }
1893
        /* if none, if is finished */
1894
        if (file_index < 0) {
1895
            break;
1896
        }
1897

    
1898
        /* finish if recording time exhausted */
1899
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1900
            break;
1901

    
1902
        /* finish if limit size exhausted */
1903
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1904
            break;
1905

    
1906
        /* read a frame from it and output it in the fifo */
1907
        is = input_files[file_index];
1908
        if (av_read_frame(is, &pkt) < 0) {
1909
            file_table[file_index].eof_reached = 1;
1910
            if (opt_shortest) break; else continue; //
1911
        }
1912

    
1913
        if (!pkt.size) {
1914
            stream_no_data = is;
1915
        } else {
1916
            stream_no_data = 0;
1917
        }
1918
        if (do_pkt_dump) {
1919
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1920
        }
1921
        /* the following test is needed in case new streams appear
1922
           dynamically in stream : we ignore them */
1923
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1924
            goto discard_packet;
1925
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1926
        ist = ist_table[ist_index];
1927
        if (ist->discard)
1928
            goto discard_packet;
1929

    
1930
//        fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1931
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1932
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1933
            if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1934
                input_files_ts_offset[ist->file_index]-= delta;
1935
                if (verbose > 2)
1936
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1937
                for(i=0; i<file_table[file_index].nb_streams; i++){
1938
                    int index= file_table[file_index].ist_index + i;
1939
                    ist_table[index]->next_pts += delta;
1940
                    ist_table[index]->is_start=1;
1941
                }
1942
            }
1943
        }
1944

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

    
1948
            if (verbose >= 0)
1949
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1950
                        ist->file_index, ist->index);
1951

    
1952
            av_free_packet(&pkt);
1953
            goto redo;
1954
        }
1955

    
1956
    discard_packet:
1957
        av_free_packet(&pkt);
1958

    
1959
        /* dump report by using the output first video and audio streams */
1960
        print_report(output_files, ost_table, nb_ostreams, 0);
1961
    }
1962

    
1963
    /* at the end of stream, we must flush the decoder buffers */
1964
    for(i=0;i<nb_istreams;i++) {
1965
        ist = ist_table[i];
1966
        if (ist->decoding_needed) {
1967
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1968
        }
1969
    }
1970

    
1971
    term_exit();
1972

    
1973
    /* write the trailer if needed and close file */
1974
    for(i=0;i<nb_output_files;i++) {
1975
        os = output_files[i];
1976
        av_write_trailer(os);
1977
    }
1978

    
1979
    /* dump report by using the first video and audio streams */
1980
    print_report(output_files, ost_table, nb_ostreams, 1);
1981

    
1982
    /* close each encoder */
1983
    for(i=0;i<nb_ostreams;i++) {
1984
        ost = ost_table[i];
1985
        if (ost->encoding_needed) {
1986
            av_freep(&ost->st->codec->stats_in);
1987
            avcodec_close(ost->st->codec);
1988
        }
1989
    }
1990

    
1991
    /* close each decoder */
1992
    for(i=0;i<nb_istreams;i++) {
1993
        ist = ist_table[i];
1994
        if (ist->decoding_needed) {
1995
            avcodec_close(ist->st->codec);
1996
        }
1997
    }
1998

    
1999
    /* finished ! */
2000

    
2001
    ret = 0;
2002
 fail1:
2003
    av_freep(&bit_buffer);
2004
    av_free(file_table);
2005

    
2006
    if (ist_table) {
2007
        for(i=0;i<nb_istreams;i++) {
2008
            ist = ist_table[i];
2009
            av_free(ist);
2010
        }
2011
        av_free(ist_table);
2012
    }
2013
    if (ost_table) {
2014
        for(i=0;i<nb_ostreams;i++) {
2015
            ost = ost_table[i];
2016
            if (ost) {
2017
                if (ost->logfile) {
2018
                    fclose(ost->logfile);
2019
                    ost->logfile = NULL;
2020
                }
2021
                fifo_free(&ost->fifo); /* works even if fifo is not
2022
                                          initialized but set to zero */
2023
                av_free(ost->pict_tmp.data[0]);
2024
                if (ost->video_resample)
2025
                    sws_freeContext(ost->img_resample_ctx);
2026
                if (ost->audio_resample)
2027
                    audio_resample_close(ost->resample);
2028
                av_free(ost);
2029
            }
2030
        }
2031
        av_free(ost_table);
2032
    }
2033
    return ret;
2034
 fail:
2035
    ret = -ENOMEM;
2036
    goto fail1;
2037
}
2038

    
2039
#if 0
2040
int file_read(const char *filename)
2041
{
2042
    URLContext *h;
2043
    unsigned char buffer[1024];
2044
    int len, i;
2045

2046
    if (url_open(&h, filename, O_RDONLY) < 0) {
2047
        printf("could not open '%s'\n", filename);
2048
        return -1;
2049
    }
2050
    for(;;) {
2051
        len = url_read(h, buffer, sizeof(buffer));
2052
        if (len <= 0)
2053
            break;
2054
        for(i=0;i<len;i++) putchar(buffer[i]);
2055
    }
2056
    url_close(h);
2057
    return 0;
2058
}
2059
#endif
2060

    
2061
static void opt_image_format(const char *arg)
2062
{
2063
    AVImageFormat *f;
2064

    
2065
    for(f = first_image_format; f != NULL; f = f->next) {
2066
        if (!strcmp(arg, f->name))
2067
            break;
2068
    }
2069
    if (!f) {
2070
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2071
        exit(1);
2072
    }
2073
    image_format = f;
2074
}
2075

    
2076
static void opt_format(const char *arg)
2077
{
2078
    /* compatibility stuff for pgmyuv */
2079
    if (!strcmp(arg, "pgmyuv")) {
2080
        pgmyuv_compatibility_hack=1;
2081
//        opt_image_format(arg);
2082
        arg = "image2";
2083
    }
2084

    
2085
    file_iformat = av_find_input_format(arg);
2086
    file_oformat = guess_format(arg, NULL, NULL);
2087
    if (!file_iformat && !file_oformat) {
2088
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2089
        exit(1);
2090
    }
2091
}
2092

    
2093
static void opt_video_rc_eq(char *arg)
2094
{
2095
    video_rc_eq = arg;
2096
}
2097

    
2098
static void opt_video_rc_override_string(char *arg)
2099
{
2100
    video_rc_override_string = arg;
2101
}
2102

    
2103
static void opt_me_threshold(const char *arg)
2104
{
2105
    me_threshold = atoi(arg);
2106
}
2107

    
2108
static void opt_mb_threshold(const char *arg)
2109
{
2110
    mb_threshold = atoi(arg);
2111
}
2112

    
2113
static void opt_verbose(const char *arg)
2114
{
2115
    verbose = atoi(arg);
2116
    av_log_set_level(atoi(arg));
2117
}
2118

    
2119
static void opt_frame_rate(const char *arg)
2120
{
2121
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2122
        fprintf(stderr, "Incorrect frame rate\n");
2123
        exit(1);
2124
    }
2125
}
2126

    
2127
static void opt_frame_crop_top(const char *arg)
2128
{
2129
    frame_topBand = atoi(arg);
2130
    if (frame_topBand < 0) {
2131
        fprintf(stderr, "Incorrect top crop size\n");
2132
        exit(1);
2133
    }
2134
    if ((frame_topBand % 2) != 0) {
2135
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2136
        exit(1);
2137
    }
2138
    if ((frame_topBand) >= frame_height){
2139
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2140
        exit(1);
2141
    }
2142
    frame_height -= frame_topBand;
2143
}
2144

    
2145
static void opt_frame_crop_bottom(const char *arg)
2146
{
2147
    frame_bottomBand = atoi(arg);
2148
    if (frame_bottomBand < 0) {
2149
        fprintf(stderr, "Incorrect bottom crop size\n");
2150
        exit(1);
2151
    }
2152
    if ((frame_bottomBand % 2) != 0) {
2153
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2154
        exit(1);
2155
    }
2156
    if ((frame_bottomBand) >= frame_height){
2157
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2158
        exit(1);
2159
    }
2160
    frame_height -= frame_bottomBand;
2161
}
2162

    
2163
static void opt_frame_crop_left(const char *arg)
2164
{
2165
    frame_leftBand = atoi(arg);
2166
    if (frame_leftBand < 0) {
2167
        fprintf(stderr, "Incorrect left crop size\n");
2168
        exit(1);
2169
    }
2170
    if ((frame_leftBand % 2) != 0) {
2171
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2172
        exit(1);
2173
    }
2174
    if ((frame_leftBand) >= frame_width){
2175
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2176
        exit(1);
2177
    }
2178
    frame_width -= frame_leftBand;
2179
}
2180

    
2181
static void opt_frame_crop_right(const char *arg)
2182
{
2183
    frame_rightBand = atoi(arg);
2184
    if (frame_rightBand < 0) {
2185
        fprintf(stderr, "Incorrect right crop size\n");
2186
        exit(1);
2187
    }
2188
    if ((frame_rightBand % 2) != 0) {
2189
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2190
        exit(1);
2191
    }
2192
    if ((frame_rightBand) >= frame_width){
2193
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2194
        exit(1);
2195
    }
2196
    frame_width -= frame_rightBand;
2197
}
2198

    
2199
static void opt_frame_size(const char *arg)
2200
{
2201
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2202
        fprintf(stderr, "Incorrect frame size\n");
2203
        exit(1);
2204
    }
2205
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2206
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2207
        exit(1);
2208
    }
2209
}
2210

    
2211

    
2212
#define SCALEBITS 10
2213
#define ONE_HALF  (1 << (SCALEBITS - 1))
2214
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2215

    
2216
#define RGB_TO_Y(r, g, b) \
2217
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2218
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2219

    
2220
#define RGB_TO_U(r1, g1, b1, shift)\
2221
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2222
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2223

    
2224
#define RGB_TO_V(r1, g1, b1, shift)\
2225
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2226
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2227

    
2228
static void opt_pad_color(const char *arg) {
2229
    /* Input is expected to be six hex digits similar to
2230
       how colors are expressed in html tags (but without the #) */
2231
    int rgb = strtol(arg, NULL, 16);
2232
    int r,g,b;
2233

    
2234
    r = (rgb >> 16);
2235
    g = ((rgb >> 8) & 255);
2236
    b = (rgb & 255);
2237

    
2238
    padcolor[0] = RGB_TO_Y(r,g,b);
2239
    padcolor[1] = RGB_TO_U(r,g,b,0);
2240
    padcolor[2] = RGB_TO_V(r,g,b,0);
2241
}
2242

    
2243
static void opt_frame_pad_top(const char *arg)
2244
{
2245
    frame_padtop = atoi(arg);
2246
    if (frame_padtop < 0) {
2247
        fprintf(stderr, "Incorrect top pad size\n");
2248
        exit(1);
2249
    }
2250
    if ((frame_padtop % 2) != 0) {
2251
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2252
        exit(1);
2253
    }
2254
}
2255

    
2256
static void opt_frame_pad_bottom(const char *arg)
2257
{
2258
    frame_padbottom = atoi(arg);
2259
    if (frame_padbottom < 0) {
2260
        fprintf(stderr, "Incorrect bottom pad size\n");
2261
        exit(1);
2262
    }
2263
    if ((frame_padbottom % 2) != 0) {
2264
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2265
        exit(1);
2266
    }
2267
}
2268

    
2269

    
2270
static void opt_frame_pad_left(const char *arg)
2271
{
2272
    frame_padleft = atoi(arg);
2273
    if (frame_padleft < 0) {
2274
        fprintf(stderr, "Incorrect left pad size\n");
2275
        exit(1);
2276
    }
2277
    if ((frame_padleft % 2) != 0) {
2278
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2279
        exit(1);
2280
    }
2281
}
2282

    
2283

    
2284
static void opt_frame_pad_right(const char *arg)
2285
{
2286
    frame_padright = atoi(arg);
2287
    if (frame_padright < 0) {
2288
        fprintf(stderr, "Incorrect right pad size\n");
2289
        exit(1);
2290
    }
2291
    if ((frame_padright % 2) != 0) {
2292
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2293
        exit(1);
2294
    }
2295
}
2296

    
2297

    
2298
static void opt_frame_pix_fmt(const char *arg)
2299
{
2300
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2301
}
2302

    
2303
static void opt_frame_aspect_ratio(const char *arg)
2304
{
2305
    int x = 0, y = 0;
2306
    double ar = 0;
2307
    const char *p;
2308

    
2309
    p = strchr(arg, ':');
2310
    if (p) {
2311
        x = strtol(arg, (char **)&arg, 10);
2312
        if (arg == p)
2313
            y = strtol(arg+1, (char **)&arg, 10);
2314
        if (x > 0 && y > 0)
2315
            ar = (double)x / (double)y;
2316
    } else
2317
        ar = strtod(arg, (char **)&arg);
2318

    
2319
    if (!ar) {
2320
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2321
        exit(1);
2322
    }
2323
    frame_aspect_ratio = ar;
2324
}
2325

    
2326
static void opt_qscale(const char *arg)
2327
{
2328
    video_qscale = atof(arg);
2329
    if (video_qscale <= 0 ||
2330
        video_qscale > 255) {
2331
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2332
        exit(1);
2333
    }
2334
}
2335

    
2336
static void opt_lmax(const char *arg)
2337
{
2338
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2339
}
2340

    
2341
static void opt_lmin(const char *arg)
2342
{
2343
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2344
}
2345

    
2346
static void opt_mb_lmin(const char *arg)
2347
{
2348
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2349
    if (video_mb_lmin < 1 ||
2350
        video_mb_lmin > FF_LAMBDA_MAX) {
2351
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2352
        exit(1);
2353
    }
2354
}
2355

    
2356
static void opt_mb_lmax(const char *arg)
2357
{
2358
    video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2359
    if (video_mb_lmax < 1 ||
2360
        video_mb_lmax > FF_LAMBDA_MAX) {
2361
        fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2362
        exit(1);
2363
    }
2364
}
2365

    
2366
static void opt_qdiff(const char *arg)
2367
{
2368
    video_qdiff = atoi(arg);
2369
    if (video_qdiff < 0 ||
2370
        video_qdiff > 31) {
2371
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2372
        exit(1);
2373
    }
2374
}
2375

    
2376
static void opt_packet_size(const char *arg)
2377
{
2378
    packet_size= atoi(arg);
2379
}
2380

    
2381
static void opt_error_rate(const char *arg)
2382
{
2383
    error_rate= atoi(arg);
2384
}
2385

    
2386
static void opt_strict(const char *arg)
2387
{
2388
    strict= atoi(arg);
2389
}
2390

    
2391
static void opt_top_field_first(const char *arg)
2392
{
2393
    top_field_first= atoi(arg);
2394
}
2395

    
2396
static void opt_thread_count(const char *arg)
2397
{
2398
    thread_count= atoi(arg);
2399
#if !defined(HAVE_THREADS)
2400
    if (verbose >= 0)
2401
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2402
#endif
2403
}
2404

    
2405
static void opt_audio_bitrate(const char *arg)
2406
{
2407
    audio_bit_rate = atoi(arg) * 1000;
2408
}
2409

    
2410
static void opt_audio_rate(const char *arg)
2411
{
2412
    audio_sample_rate = atoi(arg);
2413
}
2414

    
2415
static void opt_audio_channels(const char *arg)
2416
{
2417
    audio_channels = atoi(arg);
2418
}
2419

    
2420
static void opt_video_device(const char *arg)
2421
{
2422
    video_device = av_strdup(arg);
2423
}
2424

    
2425
static void opt_grab_device(const char *arg)
2426
{
2427
    grab_device = av_strdup(arg);
2428
}
2429

    
2430
static void opt_video_channel(const char *arg)
2431
{
2432
    video_channel = strtol(arg, NULL, 0);
2433
}
2434

    
2435
static void opt_video_standard(const char *arg)
2436
{
2437
    video_standard = av_strdup(arg);
2438
}
2439

    
2440
static void opt_audio_device(const char *arg)
2441
{
2442
    audio_device = av_strdup(arg);
2443
}
2444

    
2445
static void opt_codec(int *pstream_copy, int *pcodec_id,
2446
                      int codec_type, const char *arg)
2447
{
2448
    AVCodec *p;
2449

    
2450
    if (!strcmp(arg, "copy")) {
2451
        *pstream_copy = 1;
2452
    } else {
2453
        p = first_avcodec;
2454
        while (p) {
2455
            if (!strcmp(p->name, arg) && p->type == codec_type)
2456
                break;
2457
            p = p->next;
2458
        }
2459
        if (p == NULL) {
2460
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2461
            exit(1);
2462
        } else {
2463
            *pcodec_id = p->id;
2464
        }
2465
    }
2466
}
2467

    
2468
static void opt_audio_codec(const char *arg)
2469
{
2470
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2471
}
2472

    
2473
static void opt_audio_tag(const char *arg)
2474
{
2475
    char *tail;
2476
    audio_codec_tag= strtol(arg, &tail, 0);
2477

    
2478
    if(!tail || *tail)
2479
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2480
}
2481

    
2482
static void opt_video_tag(const char *arg)
2483
{
2484
    char *tail;
2485
    video_codec_tag= strtol(arg, &tail, 0);
2486

    
2487
    if(!tail || *tail)
2488
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2489
}
2490

    
2491
static void add_frame_hooker(const char *arg)
2492
{
2493
    int argc = 0;
2494
    char *argv[64];
2495
    int i;
2496
    char *args = av_strdup(arg);
2497

    
2498
    using_vhook = 1;
2499

    
2500
    argv[0] = strtok(args, " ");
2501
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2502
    }
2503

    
2504
    i = frame_hook_add(argc, argv);
2505

    
2506
    if (i != 0) {
2507
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2508
        exit(1);
2509
    }
2510
}
2511

    
2512
const char *motion_str[] = {
2513
    "zero",
2514
    "full",
2515
    "log",
2516
    "phods",
2517
    "epzs",
2518
    "x1",
2519
    "hex",
2520
    "umh",
2521
    "iter",
2522
    NULL,
2523
};
2524

    
2525
static void opt_motion_estimation(const char *arg)
2526
{
2527
    const char **p;
2528
    p = motion_str;
2529
    for(;;) {
2530
        if (!*p) {
2531
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2532
            exit(1);
2533
        }
2534
        if (!strcmp(*p, arg))
2535
            break;
2536
        p++;
2537
    }
2538
    me_method = (p - motion_str) + 1;
2539
}
2540

    
2541
static void opt_video_codec(const char *arg)
2542
{
2543
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2544
}
2545

    
2546
static void opt_subtitle_codec(const char *arg)
2547
{
2548
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2549
}
2550

    
2551
static void opt_map(const char *arg)
2552
{
2553
    AVStreamMap *m;
2554
    const char *p;
2555

    
2556
    p = arg;
2557
    m = &stream_maps[nb_stream_maps++];
2558

    
2559
    m->file_index = strtol(arg, (char **)&p, 0);
2560
    if (*p)
2561
        p++;
2562

    
2563
    m->stream_index = strtol(p, (char **)&p, 0);
2564
    if (*p) {
2565
        p++;
2566
        m->sync_file_index = strtol(p, (char **)&p, 0);
2567
        if (*p)
2568
            p++;
2569
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2570
    } else {
2571
        m->sync_file_index = m->file_index;
2572
        m->sync_stream_index = m->stream_index;
2573
    }
2574
}
2575

    
2576
static void opt_map_meta_data(const char *arg)
2577
{
2578
    AVMetaDataMap *m;
2579
    const char *p;
2580

    
2581
    p = arg;
2582
    m = &meta_data_maps[nb_meta_data_maps++];
2583

    
2584
    m->out_file = strtol(arg, (char **)&p, 0);
2585
    if (*p)
2586
        p++;
2587

    
2588
    m->in_file = strtol(p, (char **)&p, 0);
2589
}
2590

    
2591
static void opt_recording_time(const char *arg)
2592
{
2593
    recording_time = parse_date(arg, 1);
2594
}
2595

    
2596
static void opt_start_time(const char *arg)
2597
{
2598
    start_time = parse_date(arg, 1);
2599
}
2600

    
2601
static void opt_rec_timestamp(const char *arg)
2602
{
2603
    rec_timestamp = parse_date(arg, 0) / 1000000;
2604
}
2605

    
2606
static void opt_input_ts_offset(const char *arg)
2607
{
2608
    input_ts_offset = parse_date(arg, 1);
2609
}
2610

    
2611
static void opt_input_file(const char *filename)
2612
{
2613
    AVFormatContext *ic;
2614
    AVFormatParameters params, *ap = &params;
2615
    int err, i, ret, rfps, rfps_base;
2616
    int64_t timestamp;
2617

    
2618
    if (!strcmp(filename, "-"))
2619
        filename = "pipe:";
2620

    
2621
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2622
                   !strcmp( filename, "/dev/stdin" );
2623

    
2624
    /* get default parameters from command line */
2625
    ic = av_alloc_format_context();
2626

    
2627
    memset(ap, 0, sizeof(*ap));
2628
    ap->prealloced_context = 1;
2629
    ap->sample_rate = audio_sample_rate;
2630
    ap->channels = audio_channels;
2631
    ap->time_base.den = frame_rate;
2632
    ap->time_base.num = frame_rate_base;
2633
    ap->width = frame_width + frame_padleft + frame_padright;
2634
    ap->height = frame_height + frame_padtop + frame_padbottom;
2635
    ap->image_format = image_format;
2636
    ap->pix_fmt = frame_pix_fmt;
2637
    ap->device  = grab_device;
2638
    ap->channel = video_channel;
2639
    ap->standard = video_standard;
2640
    ap->video_codec_id = video_codec_id;
2641
    ap->audio_codec_id = audio_codec_id;
2642
    if(pgmyuv_compatibility_hack)
2643
        ap->video_codec_id= CODEC_ID_PGMYUV;
2644

    
2645
    for(i=0; i<opt_name_count; i++){
2646
        AVOption *opt;
2647
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2648
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2649
            av_set_double(ic, opt_names[i], d);
2650
    }
2651
    /* open the input file with generic libav function */
2652
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2653
    if (err < 0) {
2654
        print_error(filename, err);
2655
        exit(1);
2656
    }
2657

    
2658
    ic->loop_input = loop_input;
2659

    
2660
    /* If not enough info to get the stream parameters, we decode the
2661
       first frames to get it. (used in mpeg case for example) */
2662
    ret = av_find_stream_info(ic);
2663
    if (ret < 0 && verbose >= 0) {
2664
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2665
        exit(1);
2666
    }
2667

    
2668
    timestamp = start_time;
2669
    /* add the stream start time */
2670
    if (ic->start_time != AV_NOPTS_VALUE)
2671
        timestamp += ic->start_time;
2672

    
2673
    /* if seeking requested, we execute it */
2674
    if (start_time != 0) {
2675
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2676
        if (ret < 0) {
2677
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2678
                    filename, (double)timestamp / AV_TIME_BASE);
2679
        }
2680
        /* reset seek info */
2681
        start_time = 0;
2682
    }
2683

    
2684
    /* update the current parameters so that they match the one of the input stream */
2685
    for(i=0;i<ic->nb_streams;i++) {
2686
        int j;
2687
        AVCodecContext *enc = ic->streams[i]->codec;
2688
#if defined(HAVE_THREADS)
2689
        if(thread_count>1)
2690
            avcodec_thread_init(enc, thread_count);
2691
#endif
2692
        enc->thread_count= thread_count;
2693
        switch(enc->codec_type) {
2694
        case CODEC_TYPE_AUDIO:
2695
            for(j=0; j<opt_name_count; j++){
2696
                AVOption *opt;
2697
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2698
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2699
                    av_set_double(enc, opt_names[j], d);
2700
            }
2701
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2702
            audio_channels = enc->channels;
2703
            audio_sample_rate = enc->sample_rate;
2704
            if(audio_disable)
2705
                ic->streams[i]->discard= AVDISCARD_ALL;
2706
            break;
2707
        case CODEC_TYPE_VIDEO:
2708
            for(j=0; j<opt_name_count; j++){
2709
                AVOption *opt;
2710
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2711
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2712
                    av_set_double(enc, opt_names[j], d);
2713
            }
2714
            frame_height = enc->height;
2715
            frame_width = enc->width;
2716
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2717
            frame_pix_fmt = enc->pix_fmt;
2718
            rfps      = ic->streams[i]->r_frame_rate.num;
2719
            rfps_base = ic->streams[i]->r_frame_rate.den;
2720
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2721
            if(me_threshold)
2722
                enc->debug |= FF_DEBUG_MV;
2723

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

    
2726
                if (verbose >= 0)
2727
                    fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2728
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2729

    
2730
                    (float)rfps / rfps_base, rfps, rfps_base);
2731
            }
2732
            /* update the current frame rate to match the stream frame rate */
2733
            frame_rate      = rfps;
2734
            frame_rate_base = rfps_base;
2735

    
2736
            enc->rate_emu = rate_emu;
2737
            if(video_disable)
2738
                ic->streams[i]->discard= AVDISCARD_ALL;
2739
            else if(video_discard)
2740
                ic->streams[i]->discard= video_discard;
2741
            break;
2742
        case CODEC_TYPE_DATA:
2743
            break;
2744
        case CODEC_TYPE_SUBTITLE:
2745
            break;
2746
        case CODEC_TYPE_UNKNOWN:
2747
            break;
2748
        default:
2749
            av_abort();
2750
        }
2751
    }
2752

    
2753
    input_files[nb_input_files] = ic;
2754
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2755
    /* dump the file content */
2756
    if (verbose >= 0)
2757
        dump_format(ic, nb_input_files, filename, 0);
2758

    
2759
    nb_input_files++;
2760
    file_iformat = NULL;
2761
    file_oformat = NULL;
2762
    image_format = NULL;
2763

    
2764
    grab_device = NULL;
2765
    video_channel = 0;
2766

    
2767
    rate_emu = 0;
2768
}
2769

    
2770
static void opt_grab(const char *arg)
2771
{
2772
    file_iformat = av_find_input_format(arg);
2773
    opt_input_file("");
2774
}
2775

    
2776
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2777
{
2778
    int has_video, has_audio, i, j;
2779
    AVFormatContext *ic;
2780

    
2781
    has_video = 0;
2782
    has_audio = 0;
2783
    for(j=0;j<nb_input_files;j++) {
2784
        ic = input_files[j];
2785
        for(i=0;i<ic->nb_streams;i++) {
2786
            AVCodecContext *enc = ic->streams[i]->codec;
2787
            switch(enc->codec_type) {
2788
            case CODEC_TYPE_AUDIO:
2789
                has_audio = 1;
2790
                break;
2791
            case CODEC_TYPE_VIDEO:
2792
                has_video = 1;
2793
                break;
2794
            case CODEC_TYPE_DATA:
2795
            case CODEC_TYPE_UNKNOWN:
2796
            case CODEC_TYPE_SUBTITLE:
2797
                break;
2798
            default:
2799
                av_abort();
2800
            }
2801
        }
2802
    }
2803
    *has_video_ptr = has_video;
2804
    *has_audio_ptr = has_audio;
2805
}
2806

    
2807
static void new_video_stream(AVFormatContext *oc)
2808
{
2809
    AVStream *st;
2810
    AVCodecContext *video_enc;
2811
    int codec_id;
2812

    
2813
    st = av_new_stream(oc, oc->nb_streams);
2814
    if (!st) {
2815
        fprintf(stderr, "Could not alloc stream\n");
2816
        exit(1);
2817
    }
2818
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2819
    video_bitstream_filters= NULL;
2820

    
2821
#if defined(HAVE_THREADS)
2822
    if(thread_count>1)
2823
        avcodec_thread_init(st->codec, thread_count);
2824
#endif
2825

    
2826
    video_enc = st->codec;
2827

    
2828
    if(video_codec_tag)
2829
        video_enc->codec_tag= video_codec_tag;
2830

    
2831
    if(   (video_global_header&1)
2832
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2833
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2834
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2835
    }
2836
    if(video_global_header&2){
2837
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2838
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2839
    }
2840

    
2841
    if (video_stream_copy) {
2842
        st->stream_copy = 1;
2843
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2844
    } else {
2845
        char *p;
2846
        int i;
2847
        AVCodec *codec;
2848

    
2849
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2850
        if (video_codec_id != CODEC_ID_NONE)
2851
            codec_id = video_codec_id;
2852

    
2853
        video_enc->codec_id = codec_id;
2854
        codec = avcodec_find_encoder(codec_id);
2855

    
2856
        for(i=0; i<opt_name_count; i++){
2857
             AVOption *opt;
2858
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2859
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2860
                 av_set_double(video_enc, opt_names[i], d);
2861
        }
2862

    
2863
        video_enc->time_base.den = frame_rate;
2864
        video_enc->time_base.num = frame_rate_base;
2865
        if(codec && codec->supported_framerates){
2866
            const AVRational *p= codec->supported_framerates;
2867
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2868
            const AVRational *best=NULL;
2869
            AVRational best_error= (AVRational){INT_MAX, 1};
2870
            for(; p->den!=0; p++){
2871
                AVRational error= av_sub_q(req, *p);
2872
                if(error.num <0) error.num *= -1;
2873
                if(av_cmp_q(error, best_error) < 0){
2874
                    best_error= error;
2875
                    best= p;
2876
                }
2877
            }
2878
            video_enc->time_base.den= best->num;
2879
            video_enc->time_base.num= best->den;
2880
        }
2881

    
2882
        video_enc->width = frame_width + frame_padright + frame_padleft;
2883
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2884
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2885
        video_enc->pix_fmt = frame_pix_fmt;
2886

    
2887
        if(codec && codec->pix_fmts){
2888
            const enum PixelFormat *p= codec->pix_fmts;
2889
            for(; *p!=-1; p++){
2890
                if(*p == video_enc->pix_fmt)
2891
                    break;
2892
            }
2893
            if(*p == -1)
2894
                video_enc->pix_fmt = codec->pix_fmts[0];
2895
        }
2896

    
2897
        if (intra_only)
2898
            video_enc->gop_size = 0;
2899
        if (video_qscale || same_quality) {
2900
            video_enc->flags |= CODEC_FLAG_QSCALE;
2901
            video_enc->global_quality=
2902
                st->quality = FF_QP2LAMBDA * video_qscale;
2903
        }
2904

    
2905
        if(intra_matrix)
2906
            video_enc->intra_matrix = intra_matrix;
2907
        if(inter_matrix)
2908
            video_enc->inter_matrix = inter_matrix;
2909

    
2910
        video_enc->lmin = video_lmin;
2911
        video_enc->lmax = video_lmax;
2912
        video_enc->mb_lmin = video_mb_lmin;
2913
        video_enc->mb_lmax = video_mb_lmax;
2914
        video_enc->max_qdiff = video_qdiff;
2915
        video_enc->rc_eq = video_rc_eq;
2916
        video_enc->thread_count = thread_count;
2917
        p= video_rc_override_string;
2918
        for(i=0; p; i++){
2919
            int start, end, q;
2920
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2921
            if(e!=3){
2922
                fprintf(stderr, "error parsing rc_override\n");
2923
                exit(1);
2924
            }
2925
            video_enc->rc_override=
2926
                av_realloc(video_enc->rc_override,
2927
                           sizeof(RcOverride)*(i+1));
2928
            video_enc->rc_override[i].start_frame= start;
2929
            video_enc->rc_override[i].end_frame  = end;
2930
            if(q>0){
2931
                video_enc->rc_override[i].qscale= q;
2932
                video_enc->rc_override[i].quality_factor= 1.0;
2933
            }
2934
            else{
2935
                video_enc->rc_override[i].qscale= 0;
2936
                video_enc->rc_override[i].quality_factor= -q/100.0;
2937
            }
2938
            p= strchr(p, '/');
2939
            if(p) p++;
2940
        }
2941
        video_enc->rc_override_count=i;
2942
        video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2943
        video_enc->me_threshold= me_threshold;
2944
        video_enc->mb_threshold= mb_threshold;
2945
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2946
        video_enc->strict_std_compliance = strict;
2947
        video_enc->error_rate = error_rate;
2948
        video_enc->me_penalty_compensation= me_penalty_compensation;
2949
        video_enc->frame_skip_threshold= frame_skip_threshold;
2950
        video_enc->frame_skip_factor= frame_skip_factor;
2951
        video_enc->frame_skip_exp= frame_skip_exp;
2952

    
2953
        if(packet_size){
2954
            video_enc->rtp_mode= 1;
2955
            video_enc->rtp_payload_size= packet_size;
2956
        }
2957

    
2958
        if (do_psnr)
2959
            video_enc->flags|= CODEC_FLAG_PSNR;
2960

    
2961
        video_enc->me_method = me_method;
2962

    
2963
        /* two pass mode */
2964
        if (do_pass) {
2965
            if (do_pass == 1) {
2966
                video_enc->flags |= CODEC_FLAG_PASS1;
2967
            } else {
2968
                video_enc->flags |= CODEC_FLAG_PASS2;
2969
            }
2970
        }
2971
    }
2972

    
2973
    /* reset some key parameters */
2974
    video_disable = 0;
2975
    video_codec_id = CODEC_ID_NONE;
2976
    video_stream_copy = 0;
2977
}
2978

    
2979
static void new_audio_stream(AVFormatContext *oc)
2980
{
2981
    AVStream *st;
2982
    AVCodecContext *audio_enc;
2983
    int codec_id, i;
2984

    
2985
    st = av_new_stream(oc, oc->nb_streams);
2986
    if (!st) {
2987
        fprintf(stderr, "Could not alloc stream\n");
2988
        exit(1);
2989
    }
2990

    
2991
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2992
    audio_bitstream_filters= NULL;
2993

    
2994
#if defined(HAVE_THREADS)
2995
    if(thread_count>1)
2996
        avcodec_thread_init(st->codec, thread_count);
2997
#endif
2998

    
2999
    audio_enc = st->codec;
3000
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3001

    
3002
    if(audio_codec_tag)
3003
        audio_enc->codec_tag= audio_codec_tag;
3004

    
3005
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3006
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3007
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3008
    }
3009
    if (audio_stream_copy) {
3010
        st->stream_copy = 1;
3011
        audio_enc->channels = audio_channels;
3012
    } else {
3013
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3014

    
3015
        for(i=0; i<opt_name_count; i++){
3016
            AVOption *opt;
3017
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
3018
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3019
                av_set_double(audio_enc, opt_names[i], d);
3020
        }
3021

    
3022
        if (audio_codec_id != CODEC_ID_NONE)
3023
            codec_id = audio_codec_id;
3024
        audio_enc->codec_id = codec_id;
3025

    
3026
        audio_enc->bit_rate = audio_bit_rate;
3027
        if (audio_qscale > QSCALE_NONE) {
3028
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3029
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3030
        }
3031
        audio_enc->strict_std_compliance = strict;
3032
        audio_enc->thread_count = thread_count;
3033
        /* For audio codecs other than AC3 or DTS we limit */
3034
        /* the number of coded channels to stereo   */
3035
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3036
            && codec_id != CODEC_ID_DTS) {
3037
            audio_enc->channels = 2;
3038
        } else
3039
            audio_enc->channels = audio_channels;
3040
    }
3041
    audio_enc->sample_rate = audio_sample_rate;
3042
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3043
    if (audio_language) {
3044
        pstrcpy(st->language, sizeof(st->language), audio_language);
3045
        av_free(audio_language);
3046
        audio_language = NULL;
3047
    }
3048

    
3049
    /* reset some key parameters */
3050
    audio_disable = 0;
3051
    audio_codec_id = CODEC_ID_NONE;
3052
    audio_stream_copy = 0;
3053
}
3054

    
3055
static void opt_new_subtitle_stream(void)
3056
{
3057
    AVFormatContext *oc;
3058
    AVStream *st;
3059
    AVCodecContext *subtitle_enc;
3060
    int i;
3061

    
3062
    if (nb_output_files <= 0) {
3063
        fprintf(stderr, "At least one output file must be specified\n");
3064
        exit(1);
3065
    }
3066
    oc = output_files[nb_output_files - 1];
3067

    
3068
    st = av_new_stream(oc, oc->nb_streams);
3069
    if (!st) {
3070
        fprintf(stderr, "Could not alloc stream\n");
3071
        exit(1);
3072
    }
3073

    
3074
    subtitle_enc = st->codec;
3075
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3076
    if (subtitle_stream_copy) {
3077
        st->stream_copy = 1;
3078
    } else {
3079
        for(i=0; i<opt_name_count; i++){
3080
             AVOption *opt;
3081
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3082
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3083
                 av_set_double(subtitle_enc, opt_names[i], d);
3084
        }
3085
        subtitle_enc->codec_id = subtitle_codec_id;
3086
    }
3087

    
3088
    if (subtitle_language) {
3089
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3090
        av_free(subtitle_language);
3091
        subtitle_language = NULL;
3092
    }
3093

    
3094
    subtitle_codec_id = CODEC_ID_NONE;
3095
    subtitle_stream_copy = 0;
3096
}
3097

    
3098
static void opt_new_audio_stream(void)
3099
{
3100
    AVFormatContext *oc;
3101
    if (nb_output_files <= 0) {
3102
        fprintf(stderr, "At least one output file must be specified\n");
3103
        exit(1);
3104
    }
3105
    oc = output_files[nb_output_files - 1];
3106
    new_audio_stream(oc);
3107
}
3108

    
3109
static void opt_new_video_stream(void)
3110
{
3111
    AVFormatContext *oc;
3112
    if (nb_output_files <= 0) {
3113
        fprintf(stderr, "At least one output file must be specified\n");
3114
        exit(1);
3115
    }
3116
    oc = output_files[nb_output_files - 1];
3117
    new_video_stream(oc);
3118
}
3119

    
3120
static void opt_output_file(const char *filename)
3121
{
3122
    AVFormatContext *oc;
3123
    int use_video, use_audio, input_has_video, input_has_audio, i;
3124
    AVFormatParameters params, *ap = &params;
3125

    
3126
    if (!strcmp(filename, "-"))
3127
        filename = "pipe:";
3128

    
3129
    oc = av_alloc_format_context();
3130

    
3131
    if (!file_oformat) {
3132
        file_oformat = guess_format(NULL, filename, NULL);
3133
        if (!file_oformat) {
3134
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3135
                    filename);
3136
            exit(1);
3137
        }
3138
    }
3139

    
3140
    oc->oformat = file_oformat;
3141
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3142

    
3143
    if (!strcmp(file_oformat->name, "ffm") &&
3144
        strstart(filename, "http:", NULL)) {
3145
        /* special case for files sent to ffserver: we get the stream
3146
           parameters from ffserver */
3147
        if (read_ffserver_streams(oc, filename) < 0) {
3148
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3149
            exit(1);
3150
        }
3151
    } else {
3152
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3153
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3154

    
3155
        /* disable if no corresponding type found and at least one
3156
           input file */
3157
        if (nb_input_files > 0) {
3158
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3159
            if (!input_has_video)
3160
                use_video = 0;
3161
            if (!input_has_audio)
3162
                use_audio = 0;
3163
        }
3164

    
3165
        /* manual disable */
3166
        if (audio_disable) {
3167
            use_audio = 0;
3168
        }
3169
        if (video_disable) {
3170
            use_video = 0;
3171
        }
3172

    
3173
        if (use_video) {
3174
            new_video_stream(oc);
3175
        }
3176

    
3177
        if (use_audio) {
3178
            new_audio_stream(oc);
3179
        }
3180

    
3181
        if (!oc->nb_streams) {
3182
            fprintf(stderr, "No audio or video streams available\n");
3183
            exit(1);
3184
        }
3185

    
3186
        oc->timestamp = rec_timestamp;
3187

    
3188
        if (str_title)
3189
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3190
        if (str_author)
3191
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3192
        if (str_copyright)
3193
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3194
        if (str_comment)
3195
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3196
        if (str_album)
3197
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3198
    }
3199

    
3200
    output_files[nb_output_files++] = oc;
3201

    
3202
    /* check filename in case of an image number is expected */
3203
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3204
        if (!av_filename_number_test(oc->filename)) {
3205
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3206
            exit(1);
3207
        }
3208
    }
3209

    
3210
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3211
        /* test if it already exists to avoid loosing precious files */
3212
        if (!file_overwrite &&
3213
            (strchr(filename, ':') == NULL ||
3214
             strstart(filename, "file:", NULL))) {
3215
            if (url_exist(filename)) {
3216
                int c;
3217

    
3218
                if ( !using_stdin ) {
3219
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3220
                    fflush(stderr);
3221
                    c = getchar();
3222
                    if (toupper(c) != 'Y') {
3223
                        fprintf(stderr, "Not overwriting - exiting\n");
3224
                        exit(1);
3225
                    }
3226
                                }
3227
                                else {
3228
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3229
                    exit(1);
3230
                                }
3231
            }
3232
        }
3233

    
3234
        /* open the file */
3235
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3236
            fprintf(stderr, "Could not open '%s'\n", filename);
3237
            exit(1);
3238
        }
3239
    }
3240

    
3241
    memset(ap, 0, sizeof(*ap));
3242
    ap->image_format = image_format;
3243
    if (av_set_parameters(oc, ap) < 0) {
3244
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3245
                oc->filename);
3246
        exit(1);
3247
    }
3248

    
3249
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3250
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3251
    oc->loop_output = loop_output;
3252

    
3253
    for(i=0; i<opt_name_count; i++){
3254
        AVOption *opt;
3255
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3256
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3257
            av_set_double(oc, opt_names[i], d);
3258
    }
3259

    
3260
    /* reset some options */
3261
    file_oformat = NULL;
3262
    file_iformat = NULL;
3263
    image_format = NULL;
3264
}
3265

    
3266
/* prepare dummy protocols for grab */
3267
static void prepare_grab(void)
3268
{
3269
    int has_video, has_audio, i, j;
3270
    AVFormatContext *oc;
3271
    AVFormatContext *ic;
3272
    AVFormatParameters vp1, *vp = &vp1;
3273
    AVFormatParameters ap1, *ap = &ap1;
3274

    
3275
    /* see if audio/video inputs are needed */
3276
    has_video = 0;
3277
    has_audio = 0;
3278
    memset(ap, 0, sizeof(*ap));
3279
    memset(vp, 0, sizeof(*vp));
3280
    vp->time_base.num= 1;
3281
    for(j=0;j<nb_output_files;j++) {
3282
        oc = output_files[j];
3283
        for(i=0;i<oc->nb_streams;i++) {
3284
            AVCodecContext *enc = oc->streams[i]->codec;
3285
            switch(enc->codec_type) {
3286
            case CODEC_TYPE_AUDIO:
3287
                if (enc->sample_rate > ap->sample_rate)
3288
                    ap->sample_rate = enc->sample_rate;
3289
                if (enc->channels > ap->channels)
3290
                    ap->channels = enc->channels;
3291
                has_audio = 1;
3292
                break;
3293
            case CODEC_TYPE_VIDEO:
3294
                if (enc->width > vp->width)
3295
                    vp->width = enc->width;
3296
                if (enc->height > vp->height)
3297
                    vp->height = enc->height;
3298

    
3299
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3300
                    vp->time_base = enc->time_base;
3301
                    vp->width += frame_leftBand + frame_rightBand;
3302
                    vp->width -= (frame_padleft + frame_padright);
3303
                    vp->height += frame_topBand + frame_bottomBand;
3304
                    vp->height -= (frame_padtop + frame_padbottom);
3305
                }
3306
                has_video = 1;
3307
                break;
3308
            default:
3309
                av_abort();
3310
            }
3311
        }
3312
    }
3313

    
3314
    if (has_video == 0 && has_audio == 0) {
3315
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3316
        exit(1);
3317
    }
3318

    
3319
    if (has_video) {
3320
        AVInputFormat *fmt1;
3321
        fmt1 = av_find_input_format(video_grab_format);
3322
        vp->device  = video_device;
3323
        vp->channel = video_channel;
3324
        vp->standard = video_standard;
3325
        vp->pix_fmt = frame_pix_fmt;
3326
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3327
            fprintf(stderr, "Could not find video grab device\n");
3328
            exit(1);
3329
        }
3330
        /* If not enough info to get the stream parameters, we decode the
3331
           first frames to get it. */
3332
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3333
            fprintf(stderr, "Could not find video grab parameters\n");
3334
            exit(1);
3335
        }
3336
        /* by now video grab has one stream */
3337
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3338
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3339
        input_files[nb_input_files] = ic;
3340

    
3341
        if (verbose >= 0)
3342
            dump_format(ic, nb_input_files, "", 0);
3343

    
3344
        nb_input_files++;
3345
    }
3346
    if (has_audio && audio_grab_format) {
3347
        AVInputFormat *fmt1;
3348
        fmt1 = av_find_input_format(audio_grab_format);
3349
        ap->device = audio_device;
3350
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3351
            fprintf(stderr, "Could not find audio grab device\n");
3352
            exit(1);
3353
        }
3354
        input_files[nb_input_files] = ic;
3355

    
3356
        if (verbose >= 0)
3357
            dump_format(ic, nb_input_files, "", 0);
3358

    
3359
        nb_input_files++;
3360
    }
3361
}
3362

    
3363
/* same option as mencoder */
3364
static void opt_pass(const char *pass_str)
3365
{
3366
    int pass;
3367
    pass = atoi(pass_str);
3368
    if (pass != 1 && pass != 2) {
3369
        fprintf(stderr, "pass number can be only 1 or 2\n");
3370
        exit(1);
3371
    }
3372
    do_pass = pass;
3373
}
3374

    
3375
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3376
static int64_t getutime(void)
3377
{
3378
  return av_gettime();
3379
}
3380
#else
3381
static int64_t getutime(void)
3382
{
3383
    struct rusage rusage;
3384

    
3385
    getrusage(RUSAGE_SELF, &rusage);
3386
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3387
}
3388
#endif
3389

    
3390
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3391
extern int ffm_nopts;
3392
#endif
3393

    
3394
static void show_formats(void)
3395
{
3396
    AVInputFormat *ifmt;
3397
    AVOutputFormat *ofmt;
3398
    AVImageFormat *image_fmt;
3399
    URLProtocol *up;
3400
    AVCodec *p, *p2;
3401
    const char **pp, *last_name;
3402

    
3403
    printf("File formats:\n");
3404
    last_name= "000";
3405
    for(;;){
3406
        int decode=0;
3407
        int encode=0;
3408
        const char *name=NULL;
3409
        const char *long_name=NULL;
3410

    
3411
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3412
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3413
                strcmp(ofmt->name, last_name)>0){
3414
                name= ofmt->name;
3415
                long_name= ofmt->long_name;
3416
                encode=1;
3417
            }
3418
        }
3419
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3420
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3421
                strcmp(ifmt->name, last_name)>0){
3422
                name= ifmt->name;
3423
                long_name= ifmt->long_name;
3424
                encode=0;
3425
            }
3426
            if(name && strcmp(ifmt->name, name)==0)
3427
                decode=1;
3428
        }
3429
        if(name==NULL)
3430
            break;
3431
        last_name= name;
3432

    
3433
        printf(
3434
            " %s%s %-15s %s\n",
3435
            decode ? "D":" ",
3436
            encode ? "E":" ",
3437
            name,
3438
            long_name ? long_name:" ");
3439
    }
3440
    printf("\n");
3441

    
3442
    printf("Image formats (filename extensions, if any, follow):\n");
3443
    for(image_fmt = first_image_format; image_fmt != NULL;
3444
        image_fmt = image_fmt->next) {
3445
        printf(
3446
            " %s%s %-6s %s\n",
3447
            image_fmt->img_read  ? "D":" ",
3448
            image_fmt->img_write ? "E":" ",
3449
            image_fmt->name,
3450
            image_fmt->extensions ? image_fmt->extensions:" ");
3451
    }
3452
    printf("\n");
3453

    
3454
    printf("Codecs:\n");
3455
    last_name= "000";
3456
    for(;;){
3457
        int decode=0;
3458
        int encode=0;
3459
        int cap=0;
3460
        const char *type_str;
3461

    
3462
        p2=NULL;
3463
        for(p = first_avcodec; p != NULL; p = p->next) {
3464
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3465
                strcmp(p->name, last_name)>0){
3466
                p2= p;
3467
                decode= encode= cap=0;
3468
            }
3469
            if(p2 && strcmp(p->name, p2->name)==0){
3470
                if(p->decode) decode=1;
3471
                if(p->encode) encode=1;
3472
                cap |= p->capabilities;
3473
            }
3474
        }
3475
        if(p2==NULL)
3476
            break;
3477
        last_name= p2->name;
3478

    
3479
        switch(p2->type) {
3480
        case CODEC_TYPE_VIDEO:
3481
            type_str = "V";
3482
            break;
3483
        case CODEC_TYPE_AUDIO:
3484
            type_str = "A";
3485
            break;
3486
        case CODEC_TYPE_SUBTITLE:
3487
            type_str = "S";
3488
            break;
3489
        default:
3490
            type_str = "?";
3491
            break;
3492
        }
3493
        printf(
3494
            " %s%s%s%s%s%s %s",
3495
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3496
            encode ? "E":" ",
3497
            type_str,
3498
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3499
            cap & CODEC_CAP_DR1 ? "D":" ",
3500
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3501
            p2->name);
3502
       /* if(p2->decoder && decode==0)
3503
            printf(" use %s for decoding", p2->decoder->name);*/
3504
        printf("\n");
3505
    }
3506
    printf("\n");
3507

    
3508
    printf("Supported file protocols:\n");
3509
    for(up = first_protocol; up != NULL; up = up->next)
3510
        printf(" %s:", up->name);
3511
    printf("\n");
3512

    
3513
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3514
    printf("Motion estimation methods:\n");
3515
    pp = motion_str;
3516
    while (*pp) {
3517
        printf(" %s", *pp);
3518
        if ((pp - motion_str + 1) == ME_ZERO)
3519
            printf("(fastest)");
3520
        else if ((pp - motion_str + 1) == ME_FULL)
3521
            printf("(slowest)");
3522
        else if ((pp - motion_str + 1) == ME_EPZS)
3523
            printf("(default)");
3524
        pp++;
3525
    }
3526
    printf("\n\n");
3527
    printf(
3528
"Note, the names of encoders and decoders dont always match, so there are\n"
3529
"several cases where the above table shows encoder only or decoder only entries\n"
3530
"even though both encoding and decoding are supported for example, the h263\n"
3531
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3532
"worse\n");
3533
    exit(1);
3534
}
3535

    
3536
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3537
{
3538
    int i;
3539
    const char *p = str;
3540
    for(i = 0;; i++) {
3541
        dest[i] = atoi(p);
3542
        if(i == 63)
3543
            break;
3544
        p = strchr(p, ',');
3545
        if(!p) {
3546
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3547
            exit(1);
3548
        }
3549
        p++;
3550
    }
3551
}
3552

    
3553
static void opt_inter_matrix(const char *arg)
3554
{
3555
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3556
    parse_matrix_coeffs(inter_matrix, arg);
3557
}
3558

    
3559
static void opt_intra_matrix(const char *arg)
3560
{
3561
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3562
    parse_matrix_coeffs(intra_matrix, arg);
3563
}
3564

    
3565
static void opt_target(const char *arg)
3566
{
3567
    int norm = -1;
3568
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3569

    
3570
    if(!strncmp(arg, "pal-", 4)) {
3571
        norm = 0;
3572
        arg += 4;
3573
    } else if(!strncmp(arg, "ntsc-", 5)) {
3574
        norm = 1;
3575
        arg += 5;
3576
    } else if(!strncmp(arg, "film-", 5)) {
3577
        norm = 2;
3578
        arg += 5;
3579
    } else {
3580
        int fr;
3581
        /* Calculate FR via float to avoid int overflow */
3582
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3583
        if(fr == 25000) {
3584
            norm = 0;
3585
        } else if((fr == 29970) || (fr == 23976)) {
3586
            norm = 1;
3587
        } else {
3588
            /* Try to determine PAL/NTSC by peeking in the input files */
3589
            if(nb_input_files) {
3590
                int i, j;
3591
                for(j = 0; j < nb_input_files; j++) {
3592
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3593
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3594
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3595
                            continue;
3596
                        fr = c->time_base.den * 1000 / c->time_base.num;
3597
                        if(fr == 25000) {
3598
                            norm = 0;
3599
                            break;
3600
                        } else if((fr == 29970) || (fr == 23976)) {
3601
                            norm = 1;
3602
                            break;
3603
                        }
3604
                    }
3605
                    if(norm >= 0)
3606
                        break;
3607
                }
3608
            }
3609
        }
3610
        if(verbose && norm >= 0)
3611
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3612
    }
3613

    
3614
    if(norm < 0) {
3615
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3616
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3617
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3618
        exit(1);
3619
    }
3620

    
3621
    if(!strcmp(arg, "vcd")) {
3622

    
3623
        opt_video_codec("mpeg1video");
3624
        opt_audio_codec("mp2");
3625
        opt_format("vcd");
3626

    
3627
        opt_frame_size(norm ? "352x240" : "352x288");
3628
        opt_frame_rate(frame_rates[norm]);
3629
        opt_default("gop", norm ? "18" : "15");
3630

    
3631
        opt_default("b", "1150000");
3632
        opt_default("maxrate", "1150000");
3633
        opt_default("minrate", "1150000");
3634
        opt_default("bufsize", "327680"); // 40*1024*8;
3635

    
3636
        audio_bit_rate = 224000;
3637
        audio_sample_rate = 44100;
3638

    
3639
        opt_default("packetsize", "2324");
3640
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3641

    
3642
        /* We have to offset the PTS, so that it is consistent with the SCR.
3643
           SCR starts at 36000, but the first two packs contain only padding
3644
           and the first pack from the other stream, respectively, may also have
3645
           been written before.
3646
           So the real data starts at SCR 36000+3*1200. */
3647
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3648
    } else if(!strcmp(arg, "svcd")) {
3649

    
3650
        opt_video_codec("mpeg2video");
3651
        opt_audio_codec("mp2");
3652
        opt_format("svcd");
3653

    
3654
        opt_frame_size(norm ? "480x480" : "480x576");
3655
        opt_frame_rate(frame_rates[norm]);
3656
        opt_default("gop", norm ? "18" : "15");
3657

    
3658
        opt_default("b", "2040000");
3659
        opt_default("maxrate", "2516000");
3660
        opt_default("minrate", "0"); //1145000;
3661
        opt_default("bufsize", "1835008"); //224*1024*8;
3662
        opt_default("flags", "+SCAN_OFFSET");
3663

    
3664

    
3665
        audio_bit_rate = 224000;
3666
        audio_sample_rate = 44100;
3667

    
3668
        opt_default("packetsize", "2324");
3669

    
3670
    } else if(!strcmp(arg, "dvd")) {
3671

    
3672
        opt_video_codec("mpeg2video");
3673
        opt_audio_codec("ac3");
3674
        opt_format("dvd");
3675

    
3676
        opt_frame_size(norm ? "720x480" : "720x576");
3677
        opt_frame_rate(frame_rates[norm]);
3678
        opt_default("gop", norm ? "18" : "15");
3679

    
3680
        opt_default("b", "6000000");
3681
        opt_default("maxrate", "9000000");
3682
        opt_default("minrate", "0"); //1500000;
3683
        opt_default("bufsize", "1835008"); //224*1024*8;
3684

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

    
3688
        audio_bit_rate = 448000;
3689
        audio_sample_rate = 48000;
3690

    
3691
    } else if(!strncmp(arg, "dv", 2)) {
3692

    
3693
        opt_format("dv");
3694

    
3695
        opt_frame_size(norm ? "720x480" : "720x576");
3696
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3697
                                             (norm ? "yuv411p" : "yuv420p"));
3698
        opt_frame_rate(frame_rates[norm]);
3699

    
3700
        audio_sample_rate = 48000;
3701
        audio_channels = 2;
3702

    
3703
    } else {
3704
        fprintf(stderr, "Unknown target: %s\n", arg);
3705
        exit(1);
3706
    }
3707
}
3708

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

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

    
3719
    bsfp= &video_bitstream_filters;
3720
    while(*bsfp)
3721
        bsfp= &(*bsfp)->next;
3722

    
3723
    *bsfp= bsfc;
3724
}
3725

    
3726
//FIXME avoid audio - video code duplication
3727
static void opt_audio_bsf(const char *arg)
3728
{
3729
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3730
    AVBitStreamFilterContext **bsfp;
3731

    
3732
    if(!bsfc){
3733
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3734
        exit(1);
3735
    }
3736

    
3737
    bsfp= &audio_bitstream_filters;
3738
    while(*bsfp)
3739
        bsfp= &(*bsfp)->next;
3740

    
3741
    *bsfp= bsfc;
3742
}
3743

    
3744
static void show_version(void)
3745
{
3746
    /* TODO: add function interface to avutil and avformat */
3747
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3748
           "libavutil   %d\n"
3749
           "libavcodec  %d\n"
3750
           "libavformat %d\n",
3751
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3752
    exit(1);
3753
}
3754

    
3755
static int opt_default(const char *opt, const char *arg){
3756
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3757
    if(!o)
3758
        o = av_set_string(avformat_opts, opt, arg);
3759
    if(!o)
3760
        return -1;
3761

    
3762
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3763

    
3764
    //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3765
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3766
    opt_names[opt_name_count++]= o->name;
3767

    
3768
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3769
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3770
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3771
        ffm_nopts = 1;
3772
#endif
3773

    
3774
    if(avctx_opts->debug)
3775
        av_log_set_level(AV_LOG_DEBUG);
3776
    return 0;
3777
}
3778

    
3779
const OptionDef options[] = {
3780
    /* main options */
3781
    { "L", 0, {(void*)show_license}, "show license" },
3782
    { "h", 0, {(void*)show_help}, "show help" },
3783
    { "version", 0, {(void*)show_version}, "show version" },
3784
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3785
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3786
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3787
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3788
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3789
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3790
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3791
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3792
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3793
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3794
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3795
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3796
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3797
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3798
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3799
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3800
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3801
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3802
      "add timings for benchmarking" },
3803
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3804
      "dump each input packet" },
3805
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3806
      "when dumping packets, also dump the payload" },
3807
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3808
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3809
    { "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)", "" },
3810
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3811
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3812
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3813
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3814
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3815
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3816
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3817
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3818
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3819

    
3820
    /* video options */
3821
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3822
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3823
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3824
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3825
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3826
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3827
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3828
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3829
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3830
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3831
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3832
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3833
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3834
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3835
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3836
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3837
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3838
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3839
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3840
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3841
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3842
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3843
    { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3844
    { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3845
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3846
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3847
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3848
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3849
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3850
      "method" },
3851
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3852
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3853
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3854
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3855
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3856
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3857
      "use same video quality as source (implies VBR)" },
3858
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3859
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3860
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3861
      "deinterlace pictures" },
3862
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3863
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3864
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3865
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3866
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3867
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3868
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3869
    { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
3870
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3871
    { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3872
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3873
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3874
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3875
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3876

    
3877
    /* audio options */
3878
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3879
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3880
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3881
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3882
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3883
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3884
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3885
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3886
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3887
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3888

    
3889
    /* subtitle options */
3890
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3891
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3892
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3893

    
3894
    /* grab options */
3895
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3896
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3897
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3898
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3899

    
3900
    /* G.2 grab options */
3901
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3902
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3903

    
3904
    /* muxer options */
3905
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3906
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3907

    
3908
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3909
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3910

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

    
3915
static void show_banner(void)
3916
{
3917
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3918
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3919
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3920
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3921
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3922
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3923
#ifdef __GNUC__
3924
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3925
#else
3926
    fprintf(stderr, ", using a non-gcc compiler\n");
3927
#endif
3928
}
3929

    
3930
static void show_license(void)
3931
{
3932
    show_banner();
3933
#ifdef CONFIG_GPL
3934
    printf(
3935
    "This program is free software; you can redistribute it and/or modify\n"
3936
    "it under the terms of the GNU General Public License as published by\n"
3937
    "the Free Software Foundation; either version 2 of the License, or\n"
3938
    "(at your option) any later version.\n"
3939
    "\n"
3940
    "This program is distributed in the hope that it will be useful,\n"
3941
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3942
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3943
    "GNU General Public License for more details.\n"
3944
    "\n"
3945
    "You should have received a copy of the GNU General Public License\n"
3946
    "along with this program; if not, write to the Free Software\n"
3947
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3948
    );
3949
#else
3950
    printf(
3951
    "This library is free software; you can redistribute it and/or\n"
3952
    "modify it under the terms of the GNU Lesser General Public\n"
3953
    "License as published by the Free Software Foundation; either\n"
3954
    "version 2 of the License, or (at your option) any later version.\n"
3955
    "\n"
3956
    "This library is distributed in the hope that it will be useful,\n"
3957
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3958
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3959
    "Lesser General Public License for more details.\n"
3960
    "\n"
3961
    "You should have received a copy of the GNU Lesser General Public\n"
3962
    "License along with this library; if not, write to the Free Software\n"
3963
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3964
    );
3965
#endif
3966
    exit(1);
3967
}
3968

    
3969
static void show_help(void)
3970
{
3971
    show_banner();
3972
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3973
           "Hyper fast Audio and Video encoder\n");
3974
    printf("\n");
3975
    show_help_options(options, "Main options:\n",
3976
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3977
    show_help_options(options, "\nVideo options:\n",
3978
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3979
                      OPT_VIDEO);
3980
    show_help_options(options, "\nAdvanced Video options:\n",
3981
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3982
                      OPT_VIDEO | OPT_EXPERT);
3983
    show_help_options(options, "\nAudio options:\n",
3984
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3985
                      OPT_AUDIO);
3986
    show_help_options(options, "\nAdvanced Audio options:\n",
3987
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3988
                      OPT_AUDIO | OPT_EXPERT);
3989
    show_help_options(options, "\nSubtitle options:\n",
3990
                      OPT_SUBTITLE | OPT_GRAB,
3991
                      OPT_SUBTITLE);
3992
    show_help_options(options, "\nAudio/Video grab options:\n",
3993
                      OPT_GRAB,
3994
                      OPT_GRAB);
3995
    show_help_options(options, "\nAdvanced options:\n",
3996
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3997
                      OPT_EXPERT);
3998
    av_opt_show(avctx_opts, NULL);
3999
    av_opt_show(avformat_opts, NULL);
4000

    
4001
    exit(1);
4002
}
4003

    
4004
void parse_arg_file(const char *filename)
4005
{
4006
    opt_output_file(filename);
4007
}
4008

    
4009
int main(int argc, char **argv)
4010
{
4011
    int i;
4012
    int64_t ti;
4013

    
4014
    av_register_all();
4015

    
4016
    avctx_opts= avcodec_alloc_context();
4017
    avformat_opts = av_alloc_format_context();
4018

    
4019
    if (argc <= 1)
4020
        show_help();
4021
    else
4022
        show_banner();
4023

    
4024
    /* parse options */
4025
    parse_options(argc, argv, options);
4026

    
4027
    /* file converter / grab */
4028
    if (nb_output_files <= 0) {
4029
        fprintf(stderr, "Must supply at least one output file\n");
4030
        exit(1);
4031
    }
4032

    
4033
    if (nb_input_files == 0) {
4034
        input_sync = 1;
4035
        prepare_grab();
4036
    }
4037

    
4038
    ti = getutime();
4039
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
4040
              stream_maps, nb_stream_maps);
4041
    ti = getutime() - ti;
4042
    if (do_benchmark) {
4043
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4044
    }
4045

    
4046
    /* close files */
4047
    for(i=0;i<nb_output_files;i++) {
4048
        /* maybe av_close_output_file ??? */
4049
        AVFormatContext *s = output_files[i];
4050
        int j;
4051
        if (!(s->oformat->flags & AVFMT_NOFILE))
4052
            url_fclose(&s->pb);
4053
        for(j=0;j<s->nb_streams;j++)
4054
            av_free(s->streams[j]);
4055
        av_free(s);
4056
    }
4057
    for(i=0;i<nb_input_files;i++)
4058
        av_close_input_file(input_files[i]);
4059

    
4060
    av_free_static();
4061

    
4062
    if(intra_matrix)
4063
        av_free(intra_matrix);
4064
    if(inter_matrix)
4065
        av_free(inter_matrix);
4066

    
4067
#ifdef POWERPC_PERFORMANCE_REPORT
4068
    extern void powerpc_display_perf_report(void);
4069
    powerpc_display_perf_report();
4070
#endif /* POWERPC_PERFORMANCE_REPORT */
4071

    
4072
#ifndef __MINGW32__
4073
    if (received_sigterm) {
4074
        fprintf(stderr,
4075
            "Received signal %d: terminating.\n",
4076
            (int) received_sigterm);
4077
        exit (255);
4078
    }
4079
#endif
4080
    exit(0); /* not all OS-es handle main() return value */
4081
    return 0;
4082
}