Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ bb54f6ab

History | View | Annotate | Download (137 KB)

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

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

    
47
#include "version.h"
48
#include "cmdutils.h"
49

    
50
#undef NDEBUG
51
#include <assert.h>
52

    
53
#if !defined(INFINITY) && defined(HUGE_VAL)
54
#define INFINITY HUGE_VAL
55
#endif
56

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

    
65
/** select an input file for an output file */
66
typedef struct AVMetaDataMap {
67
    int out_file;
68
    int in_file;
69
} AVMetaDataMap;
70

    
71
extern const OptionDef options[];
72

    
73
static void show_help(void);
74
static void show_license(void);
75
static int opt_default(const char *opt, const char *arg);
76

    
77
#define MAX_FILES 20
78

    
79
static AVFormatContext *input_files[MAX_FILES];
80
static int64_t input_files_ts_offset[MAX_FILES];
81
static int nb_input_files = 0;
82

    
83
static AVFormatContext *output_files[MAX_FILES];
84
static int nb_output_files = 0;
85

    
86
static AVStreamMap stream_maps[MAX_FILES];
87
static int nb_stream_maps;
88

    
89
static AVMetaDataMap meta_data_maps[MAX_FILES];
90
static int nb_meta_data_maps;
91

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

    
137
static int intra_only = 0;
138
static int audio_sample_rate = 44100;
139
static int audio_bit_rate = 64000;
140
#define QSCALE_NONE -99999
141
static float audio_qscale = QSCALE_NONE;
142
static int audio_disable = 0;
143
static int audio_channels = 1;
144
static int audio_codec_id = CODEC_ID_NONE;
145
static int audio_codec_tag = 0;
146
static char *audio_language = NULL;
147

    
148
static int subtitle_codec_id = CODEC_ID_NONE;
149
static char *subtitle_language = NULL;
150

    
151
static float mux_preload= 0.5;
152
static float mux_max_delay= 0.7;
153

    
154
static int64_t recording_time = 0;
155
static int64_t start_time = 0;
156
static int64_t rec_timestamp = 0;
157
static int64_t input_ts_offset = 0;
158
static int file_overwrite = 0;
159
static char *str_title = NULL;
160
static char *str_author = NULL;
161
static char *str_copyright = NULL;
162
static char *str_comment = NULL;
163
static char *str_album = NULL;
164
static int do_benchmark = 0;
165
static int do_hex_dump = 0;
166
static int do_pkt_dump = 0;
167
static int do_psnr = 0;
168
static int do_vstats = 0;
169
static int do_pass = 0;
170
static char *pass_logfilename = NULL;
171
static int audio_stream_copy = 0;
172
static int video_stream_copy = 0;
173
static int subtitle_stream_copy = 0;
174
static int video_sync_method= 1;
175
static int audio_sync_method= 0;
176
static int copy_ts= 0;
177
static int opt_shortest = 0; //
178
static int video_global_header = 0;
179

    
180
static int rate_emu = 0;
181

    
182
#ifdef CONFIG_BKTR
183
static const char *video_grab_format = "bktr";
184
#else
185
#ifdef CONFIG_VIDEO4LINUX2
186
static const char *video_grab_format = "video4linux2";
187
#else
188
static const char *video_grab_format = "video4linux";
189
#endif
190
#endif
191
static char *video_device = NULL;
192
static char *grab_device = NULL;
193
static int  video_channel = 0;
194
static char *video_standard = "ntsc";
195

    
196
static const char *audio_grab_format = "audio_device";
197
static char *audio_device = NULL;
198
static int audio_volume = 256;
199

    
200
static int using_stdin = 0;
201
static int using_vhook = 0;
202
static int verbose = 1;
203
static int thread_count= 1;
204
static int q_pressed = 0;
205
static int64_t video_size = 0;
206
static int64_t audio_size = 0;
207
static int64_t extra_size = 0;
208
static int nb_frames_dup = 0;
209
static int nb_frames_drop = 0;
210
static int input_sync;
211
static int limit_filesize = 0; //
212

    
213
static int pgmyuv_compatibility_hack=0;
214
static int dts_delta_threshold = 10;
215

    
216
static int sws_flags = SWS_BICUBIC;
217

    
218
const char **opt_names=NULL;
219
int opt_name_count=0;
220
AVCodecContext *avctx_opts;
221
AVFormatContext *avformat_opts;
222

    
223
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
224
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
225
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
226

    
227
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
228

    
229
struct AVInputStream;
230

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

    
249
    int video_crop;
250
    int topBand;             /* cropping area sizes */
251
    int leftBand;
252

    
253
    int video_pad;
254
    int padtop;              /* padding area sizes */
255
    int padbottom;
256
    int padleft;
257
    int padright;
258

    
259
    /* audio only */
260
    int audio_resample;
261
    ReSampleContext *resample; /* for audio resampling */
262
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
263
    FILE *logfile;
264
} AVOutputStream;
265

    
266
typedef struct AVInputStream {
267
    int file_index;
268
    int index;
269
    AVStream *st;
270
    int discard;             /* true if stream data should be discarded */
271
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
272
    int64_t sample_index;      /* current sample */
273

    
274
    int64_t       start;     /* time when read started */
275
    unsigned long frame;     /* current frame */
276
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
277
                                is not defined */
278
    int64_t       pts;       /* current pts */
279
    int is_start;            /* is 1 at the start and after a discontinuity */
280
} AVInputStream;
281

    
282
typedef struct AVInputFile {
283
    int eof_reached;      /* true if eof reached */
284
    int ist_index;        /* index of first stream in ist_table */
285
    int buffer_size;      /* current total buffer size */
286
    int buffer_size_max;  /* buffer size at which we consider we can stop
287
                             buffering */
288
    int nb_streams;       /* nb streams we are aware of */
289
} AVInputFile;
290

    
291
#ifndef __MINGW32__
292

    
293
/* init terminal so that we can grab keys */
294
static struct termios oldtty;
295

    
296
static void term_exit(void)
297
{
298
    tcsetattr (0, TCSANOW, &oldtty);
299
}
300

    
301
static volatile sig_atomic_t received_sigterm = 0;
302

    
303
static void
304
sigterm_handler(int sig)
305
{
306
    received_sigterm = sig;
307
    term_exit();
308
}
309

    
310
static void term_init(void)
311
{
312
    struct termios tty;
313

    
314
    tcgetattr (0, &tty);
315
    oldtty = tty;
316

    
317
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
318
                          |INLCR|IGNCR|ICRNL|IXON);
319
    tty.c_oflag |= OPOST;
320
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
321
    tty.c_cflag &= ~(CSIZE|PARENB);
322
    tty.c_cflag |= CS8;
323
    tty.c_cc[VMIN] = 1;
324
    tty.c_cc[VTIME] = 0;
325

    
326
    tcsetattr (0, TCSANOW, &tty);
327

    
328
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
329
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
330
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
331
    /*
332
    register a function to be called at normal program termination
333
    */
334
    atexit(term_exit);
335
#ifdef CONFIG_BEOS_NETSERVER
336
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
337
#endif
338
}
339

    
340
/* read a key without blocking */
341
static int read_key(void)
342
{
343
    int n = 1;
344
    unsigned char ch;
345
#ifndef CONFIG_BEOS_NETSERVER
346
    struct timeval tv;
347
    fd_set rfds;
348

    
349
    FD_ZERO(&rfds);
350
    FD_SET(0, &rfds);
351
    tv.tv_sec = 0;
352
    tv.tv_usec = 0;
353
    n = select(1, &rfds, NULL, NULL, &tv);
354
#endif
355
    if (n > 0) {
356
        n = read(0, &ch, 1);
357
        if (n == 1)
358
            return ch;
359

    
360
        return n;
361
    }
362
    return -1;
363
}
364

    
365
static int decode_interrupt_cb(void)
366
{
367
    return q_pressed || (q_pressed = read_key() == 'q');
368
}
369

    
370
#else
371

    
372
static volatile int received_sigterm = 0;
373

    
374
/* no interactive support */
375
static void term_exit(void)
376
{
377
}
378

    
379
static void term_init(void)
380
{
381
}
382

    
383
static int read_key(void)
384
{
385
    return 0;
386
}
387

    
388
#endif
389

    
390
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
391
{
392
    int i, err;
393
    AVFormatContext *ic;
394

    
395
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
396
    if (err < 0)
397
        return err;
398
    /* copy stream format */
399
    s->nb_streams = ic->nb_streams;
400
    for(i=0;i<ic->nb_streams;i++) {
401
        AVStream *st;
402

    
403
        // FIXME: a more elegant solution is needed
404
        st = av_mallocz(sizeof(AVStream));
405
        memcpy(st, ic->streams[i], sizeof(AVStream));
406
        st->codec = avcodec_alloc_context();
407
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
408
        s->streams[i] = st;
409
    }
410

    
411
    av_close_input_file(ic);
412
    return 0;
413
}
414

    
415
static double
416
get_sync_ipts(const AVOutputStream *ost)
417
{
418
    const AVInputStream *ist = ost->sync_ist;
419
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
420
}
421

    
422
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
423
    while(bsfc){
424
        AVPacket new_pkt= *pkt;
425
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
426
                                          &new_pkt.data, &new_pkt.size,
427
                                          pkt->data, pkt->size,
428
                                          pkt->flags & PKT_FLAG_KEY);
429
        if(a){
430
            av_free_packet(pkt);
431
            new_pkt.destruct= av_destruct_packet;
432
        }
433
        *pkt= new_pkt;
434

    
435
        bsfc= bsfc->next;
436
    }
437

    
438
    av_interleaved_write_frame(s, pkt);
439
}
440

    
441
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
442

    
443
static void do_audio_out(AVFormatContext *s,
444
                         AVOutputStream *ost,
445
                         AVInputStream *ist,
446
                         unsigned char *buf, int size)
447
{
448
    uint8_t *buftmp;
449
    static uint8_t *audio_buf = NULL;
450
    static uint8_t *audio_out = NULL;
451
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
452

    
453
    int size_out, frame_bytes, ret;
454
    AVCodecContext *enc= ost->st->codec;
455

    
456
    /* SC: dynamic allocation of buffers */
457
    if (!audio_buf)
458
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
459
    if (!audio_out)
460
        audio_out = av_malloc(audio_out_size);
461
    if (!audio_buf || !audio_out)
462
        return;               /* Should signal an error ! */
463

    
464
    if(audio_sync_method){
465
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
466
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
467
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
468
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
469

    
470
        //FIXME resample delay
471
        if(fabs(delta) > 50){
472
            if(ist->is_start){
473
                if(byte_delta < 0){
474
                    byte_delta= FFMAX(byte_delta, -size);
475
                    size += byte_delta;
476
                    buf  -= byte_delta;
477
                    if(verbose > 2)
478
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
479
                    if(!size)
480
                        return;
481
                    ist->is_start=0;
482
                }else{
483
                    static uint8_t *input_tmp= NULL;
484
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
485

    
486
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
487
                        ist->is_start=0;
488
                    else
489
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
490

    
491
                    memset(input_tmp, 0, byte_delta);
492
                    memcpy(input_tmp + byte_delta, buf, size);
493
                    buf= input_tmp;
494
                    size += byte_delta;
495
                    if(verbose > 2)
496
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
497
                }
498
            }else if(audio_sync_method>1){
499
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
500
                assert(ost->audio_resample);
501
                if(verbose > 2)
502
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
503
//                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
504
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
505
            }
506
        }
507
    }else
508
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
509
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
510

    
511
    if (ost->audio_resample) {
512
        buftmp = audio_buf;
513
        size_out = audio_resample(ost->resample,
514
                                  (short *)buftmp, (short *)buf,
515
                                  size / (ist->st->codec->channels * 2));
516
        size_out = size_out * enc->channels * 2;
517
    } else {
518
        buftmp = buf;
519
        size_out = size;
520
    }
521

    
522
    /* now encode as many frames as possible */
523
    if (enc->frame_size > 1) {
524
        /* output resampled raw samples */
525
        av_fifo_write(&ost->fifo, buftmp, size_out);
526

    
527
        frame_bytes = enc->frame_size * 2 * enc->channels;
528

    
529
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
530
            AVPacket pkt;
531
            av_init_packet(&pkt);
532

    
533
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
534
                                       (short *)audio_buf);
535
            audio_size += ret;
536
            pkt.stream_index= ost->index;
537
            pkt.data= audio_out;
538
            pkt.size= ret;
539
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
540
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
541
            pkt.flags |= PKT_FLAG_KEY;
542
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
543

    
544
            ost->sync_opts += enc->frame_size;
545
        }
546
    } else {
547
        AVPacket pkt;
548
        av_init_packet(&pkt);
549

    
550
        ost->sync_opts += size_out / (2 * enc->channels);
551

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

    
590
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
591
{
592
    AVCodecContext *dec;
593
    AVPicture *picture2;
594
    AVPicture picture_tmp;
595
    uint8_t *buf = 0;
596

    
597
    dec = ist->st->codec;
598

    
599
    /* deinterlace : must be done before any resize */
600
    if (do_deinterlace || using_vhook) {
601
        int size;
602

    
603
        /* create temporary picture */
604
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
605
        buf = av_malloc(size);
606
        if (!buf)
607
            return;
608

    
609
        picture2 = &picture_tmp;
610
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
611

    
612
        if (do_deinterlace){
613
            if(avpicture_deinterlace(picture2, picture,
614
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
615
                /* if error, do not deinterlace */
616
                av_free(buf);
617
                buf = NULL;
618
                picture2 = picture;
619
            }
620
        } else {
621
            img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
622
        }
623
    } else {
624
        picture2 = picture;
625
    }
626

    
627
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
628

    
629
    if (picture != picture2)
630
        *picture = *picture2;
631
    *bufp = buf;
632
}
633

    
634
/* we begin to correct av delay at this threshold */
635
#define AV_DELAY_MAX 0.100
636

    
637
static void do_subtitle_out(AVFormatContext *s,
638
                            AVOutputStream *ost,
639
                            AVInputStream *ist,
640
                            AVSubtitle *sub,
641
                            int64_t pts)
642
{
643
    static uint8_t *subtitle_out = NULL;
644
    int subtitle_out_max_size = 65536;
645
    int subtitle_out_size, nb, i;
646
    AVCodecContext *enc;
647
    AVPacket pkt;
648

    
649
    if (pts == AV_NOPTS_VALUE) {
650
        fprintf(stderr, "Subtitle packets must have a pts\n");
651
        return;
652
    }
653

    
654
    enc = ost->st->codec;
655

    
656
    if (!subtitle_out) {
657
        subtitle_out = av_malloc(subtitle_out_max_size);
658
    }
659

    
660
    /* Note: DVB subtitle need one packet to draw them and one other
661
       packet to clear them */
662
    /* XXX: signal it in the codec context ? */
663
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
664
        nb = 2;
665
    else
666
        nb = 1;
667

    
668
    for(i = 0; i < nb; i++) {
669
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
670
                                                    subtitle_out_max_size, sub);
671

    
672
        av_init_packet(&pkt);
673
        pkt.stream_index = ost->index;
674
        pkt.data = subtitle_out;
675
        pkt.size = subtitle_out_size;
676
        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);
677
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
678
            /* XXX: the pts correction is handled here. Maybe handling
679
               it in the codec would be better */
680
            if (i == 0)
681
                pkt.pts += 90 * sub->start_display_time;
682
            else
683
                pkt.pts += 90 * sub->end_display_time;
684
        }
685
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
686
    }
687
}
688

    
689
static int bit_buffer_size= 1024*256;
690
static uint8_t *bit_buffer= NULL;
691

    
692
static void do_video_out(AVFormatContext *s,
693
                         AVOutputStream *ost,
694
                         AVInputStream *ist,
695
                         AVFrame *in_picture,
696
                         int *frame_size)
697
{
698
    int nb_frames, i, ret;
699
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
700
    AVFrame picture_crop_temp, picture_pad_temp;
701
    uint8_t *buf = NULL, *buf1 = NULL;
702
    AVCodecContext *enc, *dec;
703

    
704
    avcodec_get_frame_defaults(&picture_crop_temp);
705
    avcodec_get_frame_defaults(&picture_pad_temp);
706

    
707
    enc = ost->st->codec;
708
    dec = ist->st->codec;
709

    
710
    /* by default, we output a single frame */
711
    nb_frames = 1;
712

    
713
    *frame_size = 0;
714

    
715
    if(video_sync_method){
716
        double vdelta;
717
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
718
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
719
        if (vdelta < -1.1)
720
            nb_frames = 0;
721
        else if (vdelta > 1.1)
722
            nb_frames = lrintf(vdelta);
723
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
724
        if (nb_frames == 0){
725
            ++nb_frames_drop;
726
            if (verbose>2)
727
                fprintf(stderr, "*** drop!\n");
728
        }else if (nb_frames > 1) {
729
            nb_frames_dup += nb_frames;
730
            if (verbose>2)
731
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
732
        }
733
    }else
734
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
735

    
736
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
737
    if (nb_frames <= 0)
738
        return;
739

    
740
    if (ost->video_crop) {
741
        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
742
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
743
            goto the_end;
744
        }
745
        formatted_picture = &picture_crop_temp;
746
    } else {
747
        formatted_picture = in_picture;
748
    }
749

    
750
    final_picture = formatted_picture;
751
    padding_src = formatted_picture;
752
    resampling_dst = &ost->pict_tmp;
753
    if (ost->video_pad) {
754
        final_picture = &ost->pict_tmp;
755
        if (ost->video_resample) {
756
            if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
757
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
758
                goto the_end;
759
            }
760
            resampling_dst = &picture_pad_temp;
761
        }
762
    }
763

    
764
    if (ost->video_resample) {
765
        padding_src = NULL;
766
        final_picture = &ost->pict_tmp;
767
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
768
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
769
    }
770

    
771
    if (ost->video_pad) {
772
        img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
773
                enc->height, enc->width, enc->pix_fmt,
774
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
775
    }
776

    
777
    /* duplicates frame if needed */
778
    for(i=0;i<nb_frames;i++) {
779
        AVPacket pkt;
780
        av_init_packet(&pkt);
781
        pkt.stream_index= ost->index;
782

    
783
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
784
            /* raw pictures are written as AVPicture structure to
785
               avoid any copies. We support temorarily the older
786
               method. */
787
            AVFrame* old_frame = enc->coded_frame;
788
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
789
            pkt.data= (uint8_t *)final_picture;
790
            pkt.size=  sizeof(AVPicture);
791
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
792
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
793
            if(dec->coded_frame && dec->coded_frame->key_frame)
794
                pkt.flags |= PKT_FLAG_KEY;
795

    
796
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
797
            enc->coded_frame = old_frame;
798
        } else {
799
            AVFrame big_picture;
800

    
801
            big_picture= *final_picture;
802
            /* better than nothing: use input picture interlaced
803
               settings */
804
            big_picture.interlaced_frame = in_picture->interlaced_frame;
805
            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
806
                if(top_field_first == -1)
807
                    big_picture.top_field_first = in_picture->top_field_first;
808
                else
809
                    big_picture.top_field_first = top_field_first;
810
            }
811

    
812
            /* handles sameq here. This is not correct because it may
813
               not be a global option */
814
            if (same_quality) {
815
                big_picture.quality = ist->st->quality;
816
            }else
817
                big_picture.quality = ost->st->quality;
818
            if(!me_threshold)
819
                big_picture.pict_type = 0;
820
//            big_picture.pts = AV_NOPTS_VALUE;
821
            big_picture.pts= ost->sync_opts;
822
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
823
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
824
            ret = avcodec_encode_video(enc,
825
                                       bit_buffer, bit_buffer_size,
826
                                       &big_picture);
827
            if (ret == -1) {
828
                fprintf(stderr, "Video encoding failed\n");
829
                exit(1);
830
            }
831
            //enc->frame_number = enc->real_pict_num;
832
            if(ret>0){
833
                pkt.data= bit_buffer;
834
                pkt.size= ret;
835
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
836
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
837
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
838
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
839
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
840

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

    
862
static double psnr(double d){
863
    if(d==0) return INFINITY;
864
    return -10.0*log(d)/log(10.0);
865
}
866

    
867
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
868
                           int frame_size)
869
{
870
    static FILE *fvstats=NULL;
871
    char filename[40];
872
    time_t today2;
873
    struct tm *today;
874
    AVCodecContext *enc;
875
    int frame_number;
876
    int64_t ti;
877
    double ti1, bitrate, avg_bitrate;
878

    
879
    if (!fvstats) {
880
        today2 = time(NULL);
881
        today = localtime(&today2);
882
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
883
                                               today->tm_min,
884
                                               today->tm_sec);
885
        fvstats = fopen(filename,"w");
886
        if (!fvstats) {
887
            perror("fopen");
888
            exit(1);
889
        }
890
    }
891

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

    
900
        fprintf(fvstats,"f_size= %6d ", frame_size);
901
        /* compute pts value */
902
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
903
        if (ti1 < 0.01)
904
            ti1 = 0.01;
905

    
906
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
907
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
908
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
909
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
910
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
911
    }
912
}
913

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

    
928
    if (!is_last_report) {
929
        int64_t cur_time;
930
        /* display the report every 0.5 seconds */
931
        cur_time = av_gettime();
932
        if (last_time == -1) {
933
            last_time = cur_time;
934
            return;
935
        }
936
        if ((cur_time - last_time) < 500000)
937
            return;
938
        last_time = cur_time;
939
    }
940

    
941

    
942
    oc = output_files[0];
943

    
944
    total_size = url_ftell(&oc->pb);
945

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

    
1002
    if (verbose || is_last_report) {
1003
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1004

    
1005
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1006
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1007
            (double)total_size / 1024, ti1, bitrate);
1008

    
1009
        if (verbose > 1)
1010
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1011
                  nb_frames_dup, nb_frames_drop);
1012

    
1013
        if (verbose >= 0)
1014
            fprintf(stderr, "%s    \r", buf);
1015

    
1016
        fflush(stderr);
1017
    }
1018

    
1019
    if (is_last_report && verbose >= 0){
1020
        int64_t raw= audio_size + video_size + extra_size;
1021
        fprintf(stderr, "\n");
1022
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1023
                video_size/1024.0,
1024
                audio_size/1024.0,
1025
                extra_size/1024.0,
1026
                100.0*(total_size - raw)/raw
1027
        );
1028
    }
1029
}
1030

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

    
1049
    if(!pkt){
1050
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1051
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1052
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1053
    } else {
1054
//        assert(ist->pts == ist->next_pts);
1055
    }
1056

    
1057
    if (pkt == NULL) {
1058
        /* EOF handling */
1059
        ptr = NULL;
1060
        len = 0;
1061
        goto handle_eof;
1062
    }
1063

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

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

    
1150
            buffer_to_free = NULL;
1151
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1152
                pre_process_video_frame(ist, (AVPicture *)&picture,
1153
                                        &buffer_to_free);
1154
            }
1155

    
1156
            // preprocess audio (volume)
1157
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1158
                if (audio_volume != 256) {
1159
                    short *volp;
1160
                    volp = samples;
1161
                    for(i=0;i<(data_size / sizeof(short));i++) {
1162
                        int v = ((*volp) * audio_volume + 128) >> 8;
1163
                        if (v < -32768) v = -32768;
1164
                        if (v >  32767) v = 32767;
1165
                        *volp++ = v;
1166
                    }
1167
                }
1168
            }
1169

    
1170
            /* frame rate emulation */
1171
            if (ist->st->codec->rate_emu) {
1172
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1173
                int64_t now = av_gettime() - ist->start;
1174
                if (pts > now)
1175
                    usleep(pts - now);
1176

    
1177
                ist->frame++;
1178
            }
1179

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

    
1199
                    ost = ost_table[i];
1200
                    if (ost->source_index == ist_index) {
1201
                        os = output_files[ost->file_index];
1202

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

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

    
1235
                            /* no reencoding needed : output the packet directly */
1236
                            /* force the input stream PTS */
1237

    
1238
                            avcodec_get_frame_defaults(&avframe);
1239
                            ost->st->codec->coded_frame= &avframe;
1240
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1241

    
1242
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1243
                                audio_size += data_size;
1244
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1245
                                video_size += data_size;
1246
                                ost->sync_opts++;
1247
                            }
1248

    
1249
                            opkt.stream_index= ost->index;
1250
                            if(pkt->pts != AV_NOPTS_VALUE)
1251
                                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);
1252
                            else
1253
                                opkt.pts= AV_NOPTS_VALUE;
1254

    
1255
                            {
1256
                                int64_t dts;
1257
                                if (pkt->dts == AV_NOPTS_VALUE)
1258
                                    dts = ist->next_pts;
1259
                                else
1260
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1261
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1262
                            }
1263
                            opkt.flags= pkt->flags;
1264

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

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

    
1294
        for(i=0;i<nb_ostreams;i++) {
1295
            ost = ost_table[i];
1296
            if (ost->source_index == ist_index) {
1297
                AVCodecContext *enc= ost->st->codec;
1298
                os = output_files[ost->file_index];
1299

    
1300
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1301
                    continue;
1302
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1303
                    continue;
1304

    
1305
                if (ost->encoding_needed) {
1306
                    for(;;) {
1307
                        AVPacket pkt;
1308
                        int fifo_bytes;
1309
                        av_init_packet(&pkt);
1310
                        pkt.stream_index= ost->index;
1311

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

    
1344
                        if(ret<=0)
1345
                            break;
1346
                        pkt.data= bit_buffer;
1347
                        pkt.size= ret;
1348
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1349
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1350
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1351
                    }
1352
                }
1353
            }
1354
        }
1355
    }
1356

    
1357
    return 0;
1358
 fail_decode:
1359
    return -1;
1360
}
1361

    
1362

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

    
1381
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1382
    if (!file_table)
1383
        goto fail;
1384

    
1385
    /* input stream init */
1386
    j = 0;
1387
    for(i=0;i<nb_input_files;i++) {
1388
        is = input_files[i];
1389
        file_table[i].ist_index = j;
1390
        file_table[i].nb_streams = is->nb_streams;
1391
        j += is->nb_streams;
1392
    }
1393
    nb_istreams = j;
1394

    
1395
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1396
    if (!ist_table)
1397
        goto fail;
1398

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

    
1416
            if (ist->st->codec->rate_emu) {
1417
                ist->start = av_gettime();
1418
                ist->frame = 0;
1419
            }
1420
        }
1421
    }
1422

    
1423
    /* output stream init */
1424
    nb_ostreams = 0;
1425
    for(i=0;i<nb_output_files;i++) {
1426
        os = output_files[i];
1427
        if (!os->nb_streams) {
1428
            fprintf(stderr, "Output file does not contain any stream\n");
1429
            exit(1);
1430
        }
1431
        nb_ostreams += os->nb_streams;
1432
    }
1433
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1434
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1435
        exit(1);
1436
    }
1437

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

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

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

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

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

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

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

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

    
1530
        codec = ost->st->codec;
1531
        icodec = ist->st->codec;
1532

    
1533
        if (ost->st->stream_copy) {
1534
            /* if stream_copy is selected, no need to decode or encode */
1535
            codec->codec_id = icodec->codec_id;
1536
            codec->codec_type = icodec->codec_type;
1537
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1538
            codec->bit_rate = icodec->bit_rate;
1539
            codec->extradata= icodec->extradata;
1540
            codec->extradata_size= icodec->extradata_size;
1541
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1542
                codec->time_base = icodec->time_base;
1543
            else
1544
                codec->time_base = ist->st->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 (av_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:%"PRId64" dts:%"PRId64" off:%"PRId64" %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(FFABS(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
                av_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_format(const char *arg)
2062
{
2063
    /* compatibility stuff for pgmyuv */
2064
    if (!strcmp(arg, "pgmyuv")) {
2065
        pgmyuv_compatibility_hack=1;
2066
//        opt_image_format(arg);
2067
        arg = "image2";
2068
    }
2069

    
2070
    file_iformat = av_find_input_format(arg);
2071
    file_oformat = guess_format(arg, NULL, NULL);
2072
    if (!file_iformat && !file_oformat) {
2073
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2074
        exit(1);
2075
    }
2076
}
2077

    
2078
static void opt_video_rc_eq(char *arg)
2079
{
2080
    video_rc_eq = arg;
2081
}
2082

    
2083
static void opt_video_rc_override_string(char *arg)
2084
{
2085
    video_rc_override_string = arg;
2086
}
2087

    
2088
static void opt_me_threshold(const char *arg)
2089
{
2090
    me_threshold = atoi(arg);
2091
}
2092

    
2093
static void opt_verbose(const char *arg)
2094
{
2095
    verbose = atoi(arg);
2096
    av_log_set_level(atoi(arg));
2097
}
2098

    
2099
static void opt_frame_rate(const char *arg)
2100
{
2101
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2102
        fprintf(stderr, "Incorrect frame rate\n");
2103
        exit(1);
2104
    }
2105
}
2106

    
2107
static void opt_frame_crop_top(const char *arg)
2108
{
2109
    frame_topBand = atoi(arg);
2110
    if (frame_topBand < 0) {
2111
        fprintf(stderr, "Incorrect top crop size\n");
2112
        exit(1);
2113
    }
2114
    if ((frame_topBand % 2) != 0) {
2115
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2116
        exit(1);
2117
    }
2118
    if ((frame_topBand) >= frame_height){
2119
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2120
        exit(1);
2121
    }
2122
    frame_height -= frame_topBand;
2123
}
2124

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

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

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

    
2179
static void opt_frame_size(const char *arg)
2180
{
2181
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2182
        fprintf(stderr, "Incorrect frame size\n");
2183
        exit(1);
2184
    }
2185
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2186
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2187
        exit(1);
2188
    }
2189
}
2190

    
2191

    
2192
#define SCALEBITS 10
2193
#define ONE_HALF  (1 << (SCALEBITS - 1))
2194
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2195

    
2196
#define RGB_TO_Y(r, g, b) \
2197
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2198
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2199

    
2200
#define RGB_TO_U(r1, g1, b1, shift)\
2201
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2202
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2203

    
2204
#define RGB_TO_V(r1, g1, b1, shift)\
2205
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2206
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2207

    
2208
static void opt_pad_color(const char *arg) {
2209
    /* Input is expected to be six hex digits similar to
2210
       how colors are expressed in html tags (but without the #) */
2211
    int rgb = strtol(arg, NULL, 16);
2212
    int r,g,b;
2213

    
2214
    r = (rgb >> 16);
2215
    g = ((rgb >> 8) & 255);
2216
    b = (rgb & 255);
2217

    
2218
    padcolor[0] = RGB_TO_Y(r,g,b);
2219
    padcolor[1] = RGB_TO_U(r,g,b,0);
2220
    padcolor[2] = RGB_TO_V(r,g,b,0);
2221
}
2222

    
2223
static void opt_frame_pad_top(const char *arg)
2224
{
2225
    frame_padtop = atoi(arg);
2226
    if (frame_padtop < 0) {
2227
        fprintf(stderr, "Incorrect top pad size\n");
2228
        exit(1);
2229
    }
2230
    if ((frame_padtop % 2) != 0) {
2231
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2232
        exit(1);
2233
    }
2234
}
2235

    
2236
static void opt_frame_pad_bottom(const char *arg)
2237
{
2238
    frame_padbottom = atoi(arg);
2239
    if (frame_padbottom < 0) {
2240
        fprintf(stderr, "Incorrect bottom pad size\n");
2241
        exit(1);
2242
    }
2243
    if ((frame_padbottom % 2) != 0) {
2244
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2245
        exit(1);
2246
    }
2247
}
2248

    
2249

    
2250
static void opt_frame_pad_left(const char *arg)
2251
{
2252
    frame_padleft = atoi(arg);
2253
    if (frame_padleft < 0) {
2254
        fprintf(stderr, "Incorrect left pad size\n");
2255
        exit(1);
2256
    }
2257
    if ((frame_padleft % 2) != 0) {
2258
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2259
        exit(1);
2260
    }
2261
}
2262

    
2263

    
2264
static void opt_frame_pad_right(const char *arg)
2265
{
2266
    frame_padright = atoi(arg);
2267
    if (frame_padright < 0) {
2268
        fprintf(stderr, "Incorrect right pad size\n");
2269
        exit(1);
2270
    }
2271
    if ((frame_padright % 2) != 0) {
2272
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2273
        exit(1);
2274
    }
2275
}
2276

    
2277

    
2278
static void opt_frame_pix_fmt(const char *arg)
2279
{
2280
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2281
}
2282

    
2283
static void opt_frame_aspect_ratio(const char *arg)
2284
{
2285
    int x = 0, y = 0;
2286
    double ar = 0;
2287
    const char *p;
2288

    
2289
    p = strchr(arg, ':');
2290
    if (p) {
2291
        x = strtol(arg, (char **)&arg, 10);
2292
        if (arg == p)
2293
            y = strtol(arg+1, (char **)&arg, 10);
2294
        if (x > 0 && y > 0)
2295
            ar = (double)x / (double)y;
2296
    } else
2297
        ar = strtod(arg, (char **)&arg);
2298

    
2299
    if (!ar) {
2300
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2301
        exit(1);
2302
    }
2303
    frame_aspect_ratio = ar;
2304
}
2305

    
2306
static void opt_qscale(const char *arg)
2307
{
2308
    video_qscale = atof(arg);
2309
    if (video_qscale <= 0 ||
2310
        video_qscale > 255) {
2311
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2312
        exit(1);
2313
    }
2314
}
2315

    
2316
static void opt_qdiff(const char *arg)
2317
{
2318
    video_qdiff = atoi(arg);
2319
    if (video_qdiff < 0 ||
2320
        video_qdiff > 31) {
2321
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2322
        exit(1);
2323
    }
2324
}
2325

    
2326
static void opt_packet_size(const char *arg)
2327
{
2328
    packet_size= atoi(arg);
2329
}
2330

    
2331
static void opt_strict(const char *arg)
2332
{
2333
    strict= atoi(arg);
2334
}
2335

    
2336
static void opt_top_field_first(const char *arg)
2337
{
2338
    top_field_first= atoi(arg);
2339
}
2340

    
2341
static void opt_thread_count(const char *arg)
2342
{
2343
    thread_count= atoi(arg);
2344
#if !defined(HAVE_THREADS)
2345
    if (verbose >= 0)
2346
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2347
#endif
2348
}
2349

    
2350
static void opt_audio_bitrate(const char *arg)
2351
{
2352
    audio_bit_rate = atoi(arg) * 1000;
2353
}
2354

    
2355
static void opt_audio_rate(const char *arg)
2356
{
2357
    audio_sample_rate = atoi(arg);
2358
}
2359

    
2360
static void opt_audio_channels(const char *arg)
2361
{
2362
    audio_channels = atoi(arg);
2363
}
2364

    
2365
static void opt_video_device(const char *arg)
2366
{
2367
    video_device = av_strdup(arg);
2368
}
2369

    
2370
static void opt_grab_device(const char *arg)
2371
{
2372
    grab_device = av_strdup(arg);
2373
}
2374

    
2375
static void opt_video_channel(const char *arg)
2376
{
2377
    video_channel = strtol(arg, NULL, 0);
2378
}
2379

    
2380
static void opt_video_standard(const char *arg)
2381
{
2382
    video_standard = av_strdup(arg);
2383
}
2384

    
2385
static void opt_audio_device(const char *arg)
2386
{
2387
    audio_device = av_strdup(arg);
2388
}
2389

    
2390
static void opt_codec(int *pstream_copy, int *pcodec_id,
2391
                      int codec_type, const char *arg)
2392
{
2393
    AVCodec *p;
2394

    
2395
    if (!strcmp(arg, "copy")) {
2396
        *pstream_copy = 1;
2397
    } else {
2398
        p = first_avcodec;
2399
        while (p) {
2400
            if (!strcmp(p->name, arg) && p->type == codec_type)
2401
                break;
2402
            p = p->next;
2403
        }
2404
        if (p == NULL) {
2405
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2406
            exit(1);
2407
        } else {
2408
            *pcodec_id = p->id;
2409
        }
2410
    }
2411
}
2412

    
2413
static void opt_audio_codec(const char *arg)
2414
{
2415
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2416
}
2417

    
2418
static void opt_audio_tag(const char *arg)
2419
{
2420
    char *tail;
2421
    audio_codec_tag= strtol(arg, &tail, 0);
2422

    
2423
    if(!tail || *tail)
2424
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2425
}
2426

    
2427
static void opt_video_tag(const char *arg)
2428
{
2429
    char *tail;
2430
    video_codec_tag= strtol(arg, &tail, 0);
2431

    
2432
    if(!tail || *tail)
2433
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2434
}
2435

    
2436
static void add_frame_hooker(const char *arg)
2437
{
2438
    int argc = 0;
2439
    char *argv[64];
2440
    int i;
2441
    char *args = av_strdup(arg);
2442

    
2443
    using_vhook = 1;
2444

    
2445
    argv[0] = strtok(args, " ");
2446
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2447
    }
2448

    
2449
    i = frame_hook_add(argc, argv);
2450

    
2451
    if (i != 0) {
2452
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2453
        exit(1);
2454
    }
2455
}
2456

    
2457
const char *motion_str[] = {
2458
    "zero",
2459
    "full",
2460
    "log",
2461
    "phods",
2462
    "epzs",
2463
    "x1",
2464
    "hex",
2465
    "umh",
2466
    "iter",
2467
    NULL,
2468
};
2469

    
2470
static void opt_motion_estimation(const char *arg)
2471
{
2472
    const char **p;
2473
    p = motion_str;
2474
    for(;;) {
2475
        if (!*p) {
2476
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2477
            exit(1);
2478
        }
2479
        if (!strcmp(*p, arg))
2480
            break;
2481
        p++;
2482
    }
2483
    me_method = (p - motion_str) + 1;
2484
}
2485

    
2486
static void opt_video_codec(const char *arg)
2487
{
2488
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2489
}
2490

    
2491
static void opt_subtitle_codec(const char *arg)
2492
{
2493
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2494
}
2495

    
2496
static void opt_map(const char *arg)
2497
{
2498
    AVStreamMap *m;
2499
    const char *p;
2500

    
2501
    p = arg;
2502
    m = &stream_maps[nb_stream_maps++];
2503

    
2504
    m->file_index = strtol(arg, (char **)&p, 0);
2505
    if (*p)
2506
        p++;
2507

    
2508
    m->stream_index = strtol(p, (char **)&p, 0);
2509
    if (*p) {
2510
        p++;
2511
        m->sync_file_index = strtol(p, (char **)&p, 0);
2512
        if (*p)
2513
            p++;
2514
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2515
    } else {
2516
        m->sync_file_index = m->file_index;
2517
        m->sync_stream_index = m->stream_index;
2518
    }
2519
}
2520

    
2521
static void opt_map_meta_data(const char *arg)
2522
{
2523
    AVMetaDataMap *m;
2524
    const char *p;
2525

    
2526
    p = arg;
2527
    m = &meta_data_maps[nb_meta_data_maps++];
2528

    
2529
    m->out_file = strtol(arg, (char **)&p, 0);
2530
    if (*p)
2531
        p++;
2532

    
2533
    m->in_file = strtol(p, (char **)&p, 0);
2534
}
2535

    
2536
static void opt_recording_time(const char *arg)
2537
{
2538
    recording_time = parse_date(arg, 1);
2539
}
2540

    
2541
static void opt_start_time(const char *arg)
2542
{
2543
    start_time = parse_date(arg, 1);
2544
}
2545

    
2546
static void opt_rec_timestamp(const char *arg)
2547
{
2548
    rec_timestamp = parse_date(arg, 0) / 1000000;
2549
}
2550

    
2551
static void opt_input_ts_offset(const char *arg)
2552
{
2553
    input_ts_offset = parse_date(arg, 1);
2554
}
2555

    
2556
static void opt_input_file(const char *filename)
2557
{
2558
    AVFormatContext *ic;
2559
    AVFormatParameters params, *ap = &params;
2560
    int err, i, ret, rfps, rfps_base;
2561
    int64_t timestamp;
2562

    
2563
    if (!strcmp(filename, "-"))
2564
        filename = "pipe:";
2565

    
2566
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2567
                   !strcmp( filename, "/dev/stdin" );
2568

    
2569
    /* get default parameters from command line */
2570
    ic = av_alloc_format_context();
2571

    
2572
    memset(ap, 0, sizeof(*ap));
2573
    ap->prealloced_context = 1;
2574
    ap->sample_rate = audio_sample_rate;
2575
    ap->channels = audio_channels;
2576
    ap->time_base.den = frame_rate;
2577
    ap->time_base.num = frame_rate_base;
2578
    ap->width = frame_width + frame_padleft + frame_padright;
2579
    ap->height = frame_height + frame_padtop + frame_padbottom;
2580
    ap->pix_fmt = frame_pix_fmt;
2581
    ap->device  = grab_device;
2582
    ap->channel = video_channel;
2583
    ap->standard = video_standard;
2584
    ap->video_codec_id = video_codec_id;
2585
    ap->audio_codec_id = audio_codec_id;
2586
    if(pgmyuv_compatibility_hack)
2587
        ap->video_codec_id= CODEC_ID_PGMYUV;
2588

    
2589
    for(i=0; i<opt_name_count; i++){
2590
        AVOption *opt;
2591
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2592
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2593
            av_set_double(ic, opt_names[i], d);
2594
    }
2595
    /* open the input file with generic libav function */
2596
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2597
    if (err < 0) {
2598
        print_error(filename, err);
2599
        exit(1);
2600
    }
2601

    
2602
    ic->loop_input = loop_input;
2603

    
2604
    /* If not enough info to get the stream parameters, we decode the
2605
       first frames to get it. (used in mpeg case for example) */
2606
    ret = av_find_stream_info(ic);
2607
    if (ret < 0 && verbose >= 0) {
2608
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2609
        exit(1);
2610
    }
2611

    
2612
    timestamp = start_time;
2613
    /* add the stream start time */
2614
    if (ic->start_time != AV_NOPTS_VALUE)
2615
        timestamp += ic->start_time;
2616

    
2617
    /* if seeking requested, we execute it */
2618
    if (start_time != 0) {
2619
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2620
        if (ret < 0) {
2621
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2622
                    filename, (double)timestamp / AV_TIME_BASE);
2623
        }
2624
        /* reset seek info */
2625
        start_time = 0;
2626
    }
2627

    
2628
    /* update the current parameters so that they match the one of the input stream */
2629
    for(i=0;i<ic->nb_streams;i++) {
2630
        int j;
2631
        AVCodecContext *enc = ic->streams[i]->codec;
2632
#if defined(HAVE_THREADS)
2633
        if(thread_count>1)
2634
            avcodec_thread_init(enc, thread_count);
2635
#endif
2636
        enc->thread_count= thread_count;
2637
        switch(enc->codec_type) {
2638
        case CODEC_TYPE_AUDIO:
2639
            for(j=0; j<opt_name_count; j++){
2640
                AVOption *opt;
2641
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2642
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2643
                    av_set_double(enc, opt_names[j], d);
2644
            }
2645
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2646
            audio_channels = enc->channels;
2647
            audio_sample_rate = enc->sample_rate;
2648
            if(audio_disable)
2649
                ic->streams[i]->discard= AVDISCARD_ALL;
2650
            break;
2651
        case CODEC_TYPE_VIDEO:
2652
            for(j=0; j<opt_name_count; j++){
2653
                AVOption *opt;
2654
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2655
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2656
                    av_set_double(enc, opt_names[j], d);
2657
            }
2658
            frame_height = enc->height;
2659
            frame_width = enc->width;
2660
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2661
            frame_pix_fmt = enc->pix_fmt;
2662
            rfps      = ic->streams[i]->r_frame_rate.num;
2663
            rfps_base = ic->streams[i]->r_frame_rate.den;
2664
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2665
            if(me_threshold)
2666
                enc->debug |= FF_DEBUG_MV;
2667

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

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

    
2674
                    (float)rfps / rfps_base, rfps, rfps_base);
2675
            }
2676
            /* update the current frame rate to match the stream frame rate */
2677
            frame_rate      = rfps;
2678
            frame_rate_base = rfps_base;
2679

    
2680
            enc->rate_emu = rate_emu;
2681
            if(video_disable)
2682
                ic->streams[i]->discard= AVDISCARD_ALL;
2683
            else if(video_discard)
2684
                ic->streams[i]->discard= video_discard;
2685
            break;
2686
        case CODEC_TYPE_DATA:
2687
            break;
2688
        case CODEC_TYPE_SUBTITLE:
2689
            break;
2690
        case CODEC_TYPE_UNKNOWN:
2691
            break;
2692
        default:
2693
            av_abort();
2694
        }
2695
    }
2696

    
2697
    input_files[nb_input_files] = ic;
2698
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2699
    /* dump the file content */
2700
    if (verbose >= 0)
2701
        dump_format(ic, nb_input_files, filename, 0);
2702

    
2703
    nb_input_files++;
2704
    file_iformat = NULL;
2705
    file_oformat = NULL;
2706

    
2707
    grab_device = NULL;
2708
    video_channel = 0;
2709

    
2710
    rate_emu = 0;
2711
}
2712

    
2713
static void opt_grab(const char *arg)
2714
{
2715
    file_iformat = av_find_input_format(arg);
2716
    opt_input_file("");
2717
}
2718

    
2719
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2720
{
2721
    int has_video, has_audio, i, j;
2722
    AVFormatContext *ic;
2723

    
2724
    has_video = 0;
2725
    has_audio = 0;
2726
    for(j=0;j<nb_input_files;j++) {
2727
        ic = input_files[j];
2728
        for(i=0;i<ic->nb_streams;i++) {
2729
            AVCodecContext *enc = ic->streams[i]->codec;
2730
            switch(enc->codec_type) {
2731
            case CODEC_TYPE_AUDIO:
2732
                has_audio = 1;
2733
                break;
2734
            case CODEC_TYPE_VIDEO:
2735
                has_video = 1;
2736
                break;
2737
            case CODEC_TYPE_DATA:
2738
            case CODEC_TYPE_UNKNOWN:
2739
            case CODEC_TYPE_SUBTITLE:
2740
                break;
2741
            default:
2742
                av_abort();
2743
            }
2744
        }
2745
    }
2746
    *has_video_ptr = has_video;
2747
    *has_audio_ptr = has_audio;
2748
}
2749

    
2750
static void new_video_stream(AVFormatContext *oc)
2751
{
2752
    AVStream *st;
2753
    AVCodecContext *video_enc;
2754
    int codec_id;
2755

    
2756
    st = av_new_stream(oc, oc->nb_streams);
2757
    if (!st) {
2758
        fprintf(stderr, "Could not alloc stream\n");
2759
        exit(1);
2760
    }
2761
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2762
    video_bitstream_filters= NULL;
2763

    
2764
#if defined(HAVE_THREADS)
2765
    if(thread_count>1)
2766
        avcodec_thread_init(st->codec, thread_count);
2767
#endif
2768

    
2769
    video_enc = st->codec;
2770

    
2771
    if(video_codec_tag)
2772
        video_enc->codec_tag= video_codec_tag;
2773

    
2774
    if(   (video_global_header&1)
2775
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2776
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2777
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2778
    }
2779
    if(video_global_header&2){
2780
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2781
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2782
    }
2783

    
2784
    if (video_stream_copy) {
2785
        st->stream_copy = 1;
2786
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2787
    } else {
2788
        char *p;
2789
        int i;
2790
        AVCodec *codec;
2791

    
2792
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2793
        if (video_codec_id != CODEC_ID_NONE)
2794
            codec_id = video_codec_id;
2795

    
2796
        video_enc->codec_id = codec_id;
2797
        codec = avcodec_find_encoder(codec_id);
2798

    
2799
        for(i=0; i<opt_name_count; i++){
2800
             AVOption *opt;
2801
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2802
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2803
                 av_set_double(video_enc, opt_names[i], d);
2804
        }
2805

    
2806
        video_enc->time_base.den = frame_rate;
2807
        video_enc->time_base.num = frame_rate_base;
2808
        if(codec && codec->supported_framerates){
2809
            const AVRational *p= codec->supported_framerates;
2810
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2811
            const AVRational *best=NULL;
2812
            AVRational best_error= (AVRational){INT_MAX, 1};
2813
            for(; p->den!=0; p++){
2814
                AVRational error= av_sub_q(req, *p);
2815
                if(error.num <0) error.num *= -1;
2816
                if(av_cmp_q(error, best_error) < 0){
2817
                    best_error= error;
2818
                    best= p;
2819
                }
2820
            }
2821
            video_enc->time_base.den= best->num;
2822
            video_enc->time_base.num= best->den;
2823
        }
2824

    
2825
        video_enc->width = frame_width + frame_padright + frame_padleft;
2826
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2827
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2828
        video_enc->pix_fmt = frame_pix_fmt;
2829

    
2830
        if(codec && codec->pix_fmts){
2831
            const enum PixelFormat *p= codec->pix_fmts;
2832
            for(; *p!=-1; p++){
2833
                if(*p == video_enc->pix_fmt)
2834
                    break;
2835
            }
2836
            if(*p == -1)
2837
                video_enc->pix_fmt = codec->pix_fmts[0];
2838
        }
2839

    
2840
        if (intra_only)
2841
            video_enc->gop_size = 0;
2842
        if (video_qscale || same_quality) {
2843
            video_enc->flags |= CODEC_FLAG_QSCALE;
2844
            video_enc->global_quality=
2845
                st->quality = FF_QP2LAMBDA * video_qscale;
2846
        }
2847

    
2848
        if(intra_matrix)
2849
            video_enc->intra_matrix = intra_matrix;
2850
        if(inter_matrix)
2851
            video_enc->inter_matrix = inter_matrix;
2852

    
2853
        video_enc->max_qdiff = video_qdiff;
2854
        video_enc->rc_eq = video_rc_eq;
2855
        video_enc->thread_count = thread_count;
2856
        p= video_rc_override_string;
2857
        for(i=0; p; i++){
2858
            int start, end, q;
2859
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2860
            if(e!=3){
2861
                fprintf(stderr, "error parsing rc_override\n");
2862
                exit(1);
2863
            }
2864
            video_enc->rc_override=
2865
                av_realloc(video_enc->rc_override,
2866
                           sizeof(RcOverride)*(i+1));
2867
            video_enc->rc_override[i].start_frame= start;
2868
            video_enc->rc_override[i].end_frame  = end;
2869
            if(q>0){
2870
                video_enc->rc_override[i].qscale= q;
2871
                video_enc->rc_override[i].quality_factor= 1.0;
2872
            }
2873
            else{
2874
                video_enc->rc_override[i].qscale= 0;
2875
                video_enc->rc_override[i].quality_factor= -q/100.0;
2876
            }
2877
            p= strchr(p, '/');
2878
            if(p) p++;
2879
        }
2880
        video_enc->rc_override_count=i;
2881
        video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2882
        video_enc->me_threshold= me_threshold;
2883
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2884
        video_enc->strict_std_compliance = strict;
2885

    
2886
        if(packet_size){
2887
            video_enc->rtp_mode= 1;
2888
            video_enc->rtp_payload_size= packet_size;
2889
        }
2890

    
2891
        if (do_psnr)
2892
            video_enc->flags|= CODEC_FLAG_PSNR;
2893

    
2894
        video_enc->me_method = me_method;
2895

    
2896
        /* two pass mode */
2897
        if (do_pass) {
2898
            if (do_pass == 1) {
2899
                video_enc->flags |= CODEC_FLAG_PASS1;
2900
            } else {
2901
                video_enc->flags |= CODEC_FLAG_PASS2;
2902
            }
2903
        }
2904
    }
2905

    
2906
    /* reset some key parameters */
2907
    video_disable = 0;
2908
    video_codec_id = CODEC_ID_NONE;
2909
    video_stream_copy = 0;
2910
}
2911

    
2912
static void new_audio_stream(AVFormatContext *oc)
2913
{
2914
    AVStream *st;
2915
    AVCodecContext *audio_enc;
2916
    int codec_id, i;
2917

    
2918
    st = av_new_stream(oc, oc->nb_streams);
2919
    if (!st) {
2920
        fprintf(stderr, "Could not alloc stream\n");
2921
        exit(1);
2922
    }
2923

    
2924
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2925
    audio_bitstream_filters= NULL;
2926

    
2927
#if defined(HAVE_THREADS)
2928
    if(thread_count>1)
2929
        avcodec_thread_init(st->codec, thread_count);
2930
#endif
2931

    
2932
    audio_enc = st->codec;
2933
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2934
    audio_enc->strict_std_compliance = strict;
2935

    
2936
    if(audio_codec_tag)
2937
        audio_enc->codec_tag= audio_codec_tag;
2938

    
2939
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2940
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2941
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2942
    }
2943
    if (audio_stream_copy) {
2944
        st->stream_copy = 1;
2945
        audio_enc->channels = audio_channels;
2946
    } else {
2947
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2948

    
2949
        for(i=0; i<opt_name_count; i++){
2950
            AVOption *opt;
2951
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
2952
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2953
                av_set_double(audio_enc, opt_names[i], d);
2954
        }
2955

    
2956
        if (audio_codec_id != CODEC_ID_NONE)
2957
            codec_id = audio_codec_id;
2958
        audio_enc->codec_id = codec_id;
2959

    
2960
        audio_enc->bit_rate = audio_bit_rate;
2961
        if (audio_qscale > QSCALE_NONE) {
2962
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2963
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2964
        }
2965
        audio_enc->thread_count = thread_count;
2966
        /* For audio codecs other than AC3 or DTS we limit */
2967
        /* the number of coded channels to stereo   */
2968
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2969
            && codec_id != CODEC_ID_DTS) {
2970
            audio_enc->channels = 2;
2971
        } else
2972
            audio_enc->channels = audio_channels;
2973
    }
2974
    audio_enc->sample_rate = audio_sample_rate;
2975
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2976
    if (audio_language) {
2977
        pstrcpy(st->language, sizeof(st->language), audio_language);
2978
        av_free(audio_language);
2979
        audio_language = NULL;
2980
    }
2981

    
2982
    /* reset some key parameters */
2983
    audio_disable = 0;
2984
    audio_codec_id = CODEC_ID_NONE;
2985
    audio_stream_copy = 0;
2986
}
2987

    
2988
static void opt_new_subtitle_stream(void)
2989
{
2990
    AVFormatContext *oc;
2991
    AVStream *st;
2992
    AVCodecContext *subtitle_enc;
2993
    int i;
2994

    
2995
    if (nb_output_files <= 0) {
2996
        fprintf(stderr, "At least one output file must be specified\n");
2997
        exit(1);
2998
    }
2999
    oc = output_files[nb_output_files - 1];
3000

    
3001
    st = av_new_stream(oc, oc->nb_streams);
3002
    if (!st) {
3003
        fprintf(stderr, "Could not alloc stream\n");
3004
        exit(1);
3005
    }
3006

    
3007
    subtitle_enc = st->codec;
3008
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3009
    if (subtitle_stream_copy) {
3010
        st->stream_copy = 1;
3011
    } else {
3012
        for(i=0; i<opt_name_count; i++){
3013
             AVOption *opt;
3014
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3015
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3016
                 av_set_double(subtitle_enc, opt_names[i], d);
3017
        }
3018
        subtitle_enc->codec_id = subtitle_codec_id;
3019
    }
3020

    
3021
    if (subtitle_language) {
3022
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3023
        av_free(subtitle_language);
3024
        subtitle_language = NULL;
3025
    }
3026

    
3027
    subtitle_codec_id = CODEC_ID_NONE;
3028
    subtitle_stream_copy = 0;
3029
}
3030

    
3031
static void opt_new_audio_stream(void)
3032
{
3033
    AVFormatContext *oc;
3034
    if (nb_output_files <= 0) {
3035
        fprintf(stderr, "At least one output file must be specified\n");
3036
        exit(1);
3037
    }
3038
    oc = output_files[nb_output_files - 1];
3039
    new_audio_stream(oc);
3040
}
3041

    
3042
static void opt_new_video_stream(void)
3043
{
3044
    AVFormatContext *oc;
3045
    if (nb_output_files <= 0) {
3046
        fprintf(stderr, "At least one output file must be specified\n");
3047
        exit(1);
3048
    }
3049
    oc = output_files[nb_output_files - 1];
3050
    new_video_stream(oc);
3051
}
3052

    
3053
static void opt_output_file(const char *filename)
3054
{
3055
    AVFormatContext *oc;
3056
    int use_video, use_audio, input_has_video, input_has_audio, i;
3057
    AVFormatParameters params, *ap = &params;
3058

    
3059
    if (!strcmp(filename, "-"))
3060
        filename = "pipe:";
3061

    
3062
    oc = av_alloc_format_context();
3063

    
3064
    if (!file_oformat) {
3065
        file_oformat = guess_format(NULL, filename, NULL);
3066
        if (!file_oformat) {
3067
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3068
                    filename);
3069
            exit(1);
3070
        }
3071
    }
3072

    
3073
    oc->oformat = file_oformat;
3074
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3075

    
3076
    if (!strcmp(file_oformat->name, "ffm") &&
3077
        strstart(filename, "http:", NULL)) {
3078
        /* special case for files sent to ffserver: we get the stream
3079
           parameters from ffserver */
3080
        if (read_ffserver_streams(oc, filename) < 0) {
3081
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3082
            exit(1);
3083
        }
3084
    } else {
3085
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3086
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3087

    
3088
        /* disable if no corresponding type found and at least one
3089
           input file */
3090
        if (nb_input_files > 0) {
3091
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3092
            if (!input_has_video)
3093
                use_video = 0;
3094
            if (!input_has_audio)
3095
                use_audio = 0;
3096
        }
3097

    
3098
        /* manual disable */
3099
        if (audio_disable) {
3100
            use_audio = 0;
3101
        }
3102
        if (video_disable) {
3103
            use_video = 0;
3104
        }
3105

    
3106
        if (use_video) {
3107
            new_video_stream(oc);
3108
        }
3109

    
3110
        if (use_audio) {
3111
            new_audio_stream(oc);
3112
        }
3113

    
3114
        oc->timestamp = rec_timestamp;
3115

    
3116
        if (str_title)
3117
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3118
        if (str_author)
3119
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3120
        if (str_copyright)
3121
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3122
        if (str_comment)
3123
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3124
        if (str_album)
3125
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3126
    }
3127

    
3128
    output_files[nb_output_files++] = oc;
3129

    
3130
    /* check filename in case of an image number is expected */
3131
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3132
        if (!av_filename_number_test(oc->filename)) {
3133
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3134
            exit(1);
3135
        }
3136
    }
3137

    
3138
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3139
        /* test if it already exists to avoid loosing precious files */
3140
        if (!file_overwrite &&
3141
            (strchr(filename, ':') == NULL ||
3142
             strstart(filename, "file:", NULL))) {
3143
            if (url_exist(filename)) {
3144
                int c;
3145

    
3146
                if ( !using_stdin ) {
3147
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3148
                    fflush(stderr);
3149
                    c = getchar();
3150
                    if (toupper(c) != 'Y') {
3151
                        fprintf(stderr, "Not overwriting - exiting\n");
3152
                        exit(1);
3153
                    }
3154
                                }
3155
                                else {
3156
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3157
                    exit(1);
3158
                                }
3159
            }
3160
        }
3161

    
3162
        /* open the file */
3163
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3164
            fprintf(stderr, "Could not open '%s'\n", filename);
3165
            exit(1);
3166
        }
3167
    }
3168

    
3169
    memset(ap, 0, sizeof(*ap));
3170
    if (av_set_parameters(oc, ap) < 0) {
3171
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3172
                oc->filename);
3173
        exit(1);
3174
    }
3175

    
3176
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3177
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3178
    oc->loop_output = loop_output;
3179

    
3180
    for(i=0; i<opt_name_count; i++){
3181
        AVOption *opt;
3182
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3183
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3184
            av_set_double(oc, opt_names[i], d);
3185
    }
3186

    
3187
    /* reset some options */
3188
    file_oformat = NULL;
3189
    file_iformat = NULL;
3190
}
3191

    
3192
/* prepare dummy protocols for grab */
3193
static void prepare_grab(void)
3194
{
3195
    int has_video, has_audio, i, j;
3196
    AVFormatContext *oc;
3197
    AVFormatContext *ic;
3198
    AVFormatParameters vp1, *vp = &vp1;
3199
    AVFormatParameters ap1, *ap = &ap1;
3200

    
3201
    /* see if audio/video inputs are needed */
3202
    has_video = 0;
3203
    has_audio = 0;
3204
    memset(ap, 0, sizeof(*ap));
3205
    memset(vp, 0, sizeof(*vp));
3206
    vp->time_base.num= 1;
3207
    for(j=0;j<nb_output_files;j++) {
3208
        oc = output_files[j];
3209
        for(i=0;i<oc->nb_streams;i++) {
3210
            AVCodecContext *enc = oc->streams[i]->codec;
3211
            switch(enc->codec_type) {
3212
            case CODEC_TYPE_AUDIO:
3213
                if (enc->sample_rate > ap->sample_rate)
3214
                    ap->sample_rate = enc->sample_rate;
3215
                if (enc->channels > ap->channels)
3216
                    ap->channels = enc->channels;
3217
                has_audio = 1;
3218
                break;
3219
            case CODEC_TYPE_VIDEO:
3220
                if (enc->width > vp->width)
3221
                    vp->width = enc->width;
3222
                if (enc->height > vp->height)
3223
                    vp->height = enc->height;
3224

    
3225
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3226
                    vp->time_base = enc->time_base;
3227
                    vp->width += frame_leftBand + frame_rightBand;
3228
                    vp->width -= (frame_padleft + frame_padright);
3229
                    vp->height += frame_topBand + frame_bottomBand;
3230
                    vp->height -= (frame_padtop + frame_padbottom);
3231
                }
3232
                has_video = 1;
3233
                break;
3234
            default:
3235
                av_abort();
3236
            }
3237
        }
3238
    }
3239

    
3240
    if (has_video == 0 && has_audio == 0) {
3241
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3242
        exit(1);
3243
    }
3244

    
3245
    if (has_video) {
3246
        AVInputFormat *fmt1;
3247
        fmt1 = av_find_input_format(video_grab_format);
3248
        vp->device  = video_device;
3249
        vp->channel = video_channel;
3250
        vp->standard = video_standard;
3251
        vp->pix_fmt = frame_pix_fmt;
3252
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3253
            fprintf(stderr, "Could not find video grab device\n");
3254
            exit(1);
3255
        }
3256
        /* If not enough info to get the stream parameters, we decode the
3257
           first frames to get it. */
3258
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3259
            fprintf(stderr, "Could not find video grab parameters\n");
3260
            exit(1);
3261
        }
3262
        /* by now video grab has one stream */
3263
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3264
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3265
        input_files[nb_input_files] = ic;
3266

    
3267
        if (verbose >= 0)
3268
            dump_format(ic, nb_input_files, "", 0);
3269

    
3270
        nb_input_files++;
3271
    }
3272
    if (has_audio && audio_grab_format) {
3273
        AVInputFormat *fmt1;
3274
        fmt1 = av_find_input_format(audio_grab_format);
3275
        ap->device = audio_device;
3276
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3277
            fprintf(stderr, "Could not find audio grab device\n");
3278
            exit(1);
3279
        }
3280
        input_files[nb_input_files] = ic;
3281

    
3282
        if (verbose >= 0)
3283
            dump_format(ic, nb_input_files, "", 0);
3284

    
3285
        nb_input_files++;
3286
    }
3287
}
3288

    
3289
/* same option as mencoder */
3290
static void opt_pass(const char *pass_str)
3291
{
3292
    int pass;
3293
    pass = atoi(pass_str);
3294
    if (pass != 1 && pass != 2) {
3295
        fprintf(stderr, "pass number can be only 1 or 2\n");
3296
        exit(1);
3297
    }
3298
    do_pass = pass;
3299
}
3300

    
3301
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3302
static int64_t getutime(void)
3303
{
3304
  return av_gettime();
3305
}
3306
#else
3307
static int64_t getutime(void)
3308
{
3309
    struct rusage rusage;
3310

    
3311
    getrusage(RUSAGE_SELF, &rusage);
3312
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3313
}
3314
#endif
3315

    
3316
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3317
extern int ffm_nopts;
3318
#endif
3319

    
3320
static void show_formats(void)
3321
{
3322
    AVInputFormat *ifmt;
3323
    AVOutputFormat *ofmt;
3324
    URLProtocol *up;
3325
    AVCodec *p, *p2;
3326
    const char **pp, *last_name;
3327

    
3328
    printf("File formats:\n");
3329
    last_name= "000";
3330
    for(;;){
3331
        int decode=0;
3332
        int encode=0;
3333
        const char *name=NULL;
3334
        const char *long_name=NULL;
3335

    
3336
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3337
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3338
                strcmp(ofmt->name, last_name)>0){
3339
                name= ofmt->name;
3340
                long_name= ofmt->long_name;
3341
                encode=1;
3342
            }
3343
        }
3344
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3345
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3346
                strcmp(ifmt->name, last_name)>0){
3347
                name= ifmt->name;
3348
                long_name= ifmt->long_name;
3349
                encode=0;
3350
            }
3351
            if(name && strcmp(ifmt->name, name)==0)
3352
                decode=1;
3353
        }
3354
        if(name==NULL)
3355
            break;
3356
        last_name= name;
3357

    
3358
        printf(
3359
            " %s%s %-15s %s\n",
3360
            decode ? "D":" ",
3361
            encode ? "E":" ",
3362
            name,
3363
            long_name ? long_name:" ");
3364
    }
3365
    printf("\n");
3366

    
3367
    printf("Codecs:\n");
3368
    last_name= "000";
3369
    for(;;){
3370
        int decode=0;
3371
        int encode=0;
3372
        int cap=0;
3373
        const char *type_str;
3374

    
3375
        p2=NULL;
3376
        for(p = first_avcodec; p != NULL; p = p->next) {
3377
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3378
                strcmp(p->name, last_name)>0){
3379
                p2= p;
3380
                decode= encode= cap=0;
3381
            }
3382
            if(p2 && strcmp(p->name, p2->name)==0){
3383
                if(p->decode) decode=1;
3384
                if(p->encode) encode=1;
3385
                cap |= p->capabilities;
3386
            }
3387
        }
3388
        if(p2==NULL)
3389
            break;
3390
        last_name= p2->name;
3391

    
3392
        switch(p2->type) {
3393
        case CODEC_TYPE_VIDEO:
3394
            type_str = "V";
3395
            break;
3396
        case CODEC_TYPE_AUDIO:
3397
            type_str = "A";
3398
            break;
3399
        case CODEC_TYPE_SUBTITLE:
3400
            type_str = "S";
3401
            break;
3402
        default:
3403
            type_str = "?";
3404
            break;
3405
        }
3406
        printf(
3407
            " %s%s%s%s%s%s %s",
3408
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3409
            encode ? "E":" ",
3410
            type_str,
3411
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3412
            cap & CODEC_CAP_DR1 ? "D":" ",
3413
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3414
            p2->name);
3415
       /* if(p2->decoder && decode==0)
3416
            printf(" use %s for decoding", p2->decoder->name);*/
3417
        printf("\n");
3418
    }
3419
    printf("\n");
3420

    
3421
    printf("Supported file protocols:\n");
3422
    for(up = first_protocol; up != NULL; up = up->next)
3423
        printf(" %s:", up->name);
3424
    printf("\n");
3425

    
3426
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3427
    printf("Motion estimation methods:\n");
3428
    pp = motion_str;
3429
    while (*pp) {
3430
        printf(" %s", *pp);
3431
        if ((pp - motion_str + 1) == ME_ZERO)
3432
            printf("(fastest)");
3433
        else if ((pp - motion_str + 1) == ME_FULL)
3434
            printf("(slowest)");
3435
        else if ((pp - motion_str + 1) == ME_EPZS)
3436
            printf("(default)");
3437
        pp++;
3438
    }
3439
    printf("\n\n");
3440
    printf(
3441
"Note, the names of encoders and decoders dont always match, so there are\n"
3442
"several cases where the above table shows encoder only or decoder only entries\n"
3443
"even though both encoding and decoding are supported for example, the h263\n"
3444
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3445
"worse\n");
3446
    exit(1);
3447
}
3448

    
3449
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3450
{
3451
    int i;
3452
    const char *p = str;
3453
    for(i = 0;; i++) {
3454
        dest[i] = atoi(p);
3455
        if(i == 63)
3456
            break;
3457
        p = strchr(p, ',');
3458
        if(!p) {
3459
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3460
            exit(1);
3461
        }
3462
        p++;
3463
    }
3464
}
3465

    
3466
static void opt_inter_matrix(const char *arg)
3467
{
3468
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3469
    parse_matrix_coeffs(inter_matrix, arg);
3470
}
3471

    
3472
static void opt_intra_matrix(const char *arg)
3473
{
3474
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3475
    parse_matrix_coeffs(intra_matrix, arg);
3476
}
3477

    
3478
static void opt_target(const char *arg)
3479
{
3480
    int norm = -1;
3481
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3482

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

    
3527
    if(norm < 0) {
3528
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3529
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3530
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3531
        exit(1);
3532
    }
3533

    
3534
    if(!strcmp(arg, "vcd")) {
3535

    
3536
        opt_video_codec("mpeg1video");
3537
        opt_audio_codec("mp2");
3538
        opt_format("vcd");
3539

    
3540
        opt_frame_size(norm ? "352x240" : "352x288");
3541
        opt_frame_rate(frame_rates[norm]);
3542
        opt_default("gop", norm ? "18" : "15");
3543

    
3544
        opt_default("b", "1150000");
3545
        opt_default("maxrate", "1150000");
3546
        opt_default("minrate", "1150000");
3547
        opt_default("bufsize", "327680"); // 40*1024*8;
3548

    
3549
        audio_bit_rate = 224000;
3550
        audio_sample_rate = 44100;
3551

    
3552
        opt_default("packetsize", "2324");
3553
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3554

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

    
3563
        opt_video_codec("mpeg2video");
3564
        opt_audio_codec("mp2");
3565
        opt_format("svcd");
3566

    
3567
        opt_frame_size(norm ? "480x480" : "480x576");
3568
        opt_frame_rate(frame_rates[norm]);
3569
        opt_default("gop", norm ? "18" : "15");
3570

    
3571
        opt_default("b", "2040000");
3572
        opt_default("maxrate", "2516000");
3573
        opt_default("minrate", "0"); //1145000;
3574
        opt_default("bufsize", "1835008"); //224*1024*8;
3575
        opt_default("flags", "+SCAN_OFFSET");
3576

    
3577

    
3578
        audio_bit_rate = 224000;
3579
        audio_sample_rate = 44100;
3580

    
3581
        opt_default("packetsize", "2324");
3582

    
3583
    } else if(!strcmp(arg, "dvd")) {
3584

    
3585
        opt_video_codec("mpeg2video");
3586
        opt_audio_codec("ac3");
3587
        opt_format("dvd");
3588

    
3589
        opt_frame_size(norm ? "720x480" : "720x576");
3590
        opt_frame_rate(frame_rates[norm]);
3591
        opt_default("gop", norm ? "18" : "15");
3592

    
3593
        opt_default("b", "6000000");
3594
        opt_default("maxrate", "9000000");
3595
        opt_default("minrate", "0"); //1500000;
3596
        opt_default("bufsize", "1835008"); //224*1024*8;
3597

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

    
3601
        audio_bit_rate = 448000;
3602
        audio_sample_rate = 48000;
3603

    
3604
    } else if(!strncmp(arg, "dv", 2)) {
3605

    
3606
        opt_format("dv");
3607

    
3608
        opt_frame_size(norm ? "720x480" : "720x576");
3609
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3610
                                             (norm ? "yuv411p" : "yuv420p"));
3611
        opt_frame_rate(frame_rates[norm]);
3612

    
3613
        audio_sample_rate = 48000;
3614
        audio_channels = 2;
3615

    
3616
    } else {
3617
        fprintf(stderr, "Unknown target: %s\n", arg);
3618
        exit(1);
3619
    }
3620
}
3621

    
3622
static void opt_video_bsf(const char *arg)
3623
{
3624
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3625
    AVBitStreamFilterContext **bsfp;
3626

    
3627
    if(!bsfc){
3628
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3629
        exit(1);
3630
    }
3631

    
3632
    bsfp= &video_bitstream_filters;
3633
    while(*bsfp)
3634
        bsfp= &(*bsfp)->next;
3635

    
3636
    *bsfp= bsfc;
3637
}
3638

    
3639
//FIXME avoid audio - video code duplication
3640
static void opt_audio_bsf(const char *arg)
3641
{
3642
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3643
    AVBitStreamFilterContext **bsfp;
3644

    
3645
    if(!bsfc){
3646
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3647
        exit(1);
3648
    }
3649

    
3650
    bsfp= &audio_bitstream_filters;
3651
    while(*bsfp)
3652
        bsfp= &(*bsfp)->next;
3653

    
3654
    *bsfp= bsfc;
3655
}
3656

    
3657
static void show_version(void)
3658
{
3659
    /* TODO: add function interface to avutil and avformat */
3660
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3661
           "libavutil   %d\n"
3662
           "libavcodec  %d\n"
3663
           "libavformat %d\n",
3664
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3665
    exit(1);
3666
}
3667

    
3668
static int opt_default(const char *opt, const char *arg){
3669
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3670
    if(!o)
3671
        o = av_set_string(avformat_opts, opt, arg);
3672
    if(!o)
3673
        return -1;
3674

    
3675
//    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));
3676

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

    
3681
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3682
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3683
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3684
        ffm_nopts = 1;
3685
#endif
3686

    
3687
    if(avctx_opts->debug)
3688
        av_log_set_level(AV_LOG_DEBUG);
3689
    return 0;
3690
}
3691

    
3692
const OptionDef options[] = {
3693
    /* main options */
3694
    { "L", 0, {(void*)show_license}, "show license" },
3695
    { "h", 0, {(void*)show_help}, "show help" },
3696
    { "version", 0, {(void*)show_version}, "show version" },
3697
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3698
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3699
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3700
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3701
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3702
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3703
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3704
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3705
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3706
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3707
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3708
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3709
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3710
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3711
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3712
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3713
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3714
      "add timings for benchmarking" },
3715
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3716
      "dump each input packet" },
3717
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3718
      "when dumping packets, also dump the payload" },
3719
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3720
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3721
    { "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)", "" },
3722
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3723
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3724
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3725
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3726
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3727
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3728
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3729
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3730
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3731

    
3732
    /* video options */
3733
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3734
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3735
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3736
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3737
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3738
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3739
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3740
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3741
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3742
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3743
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3744
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3745
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3746
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3747
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3748
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3749
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3750
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3751
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3752
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3753
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3754
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3755
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3756
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3757
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3758
      "method" },
3759
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3760
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3761
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3762
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3763
      "use same video quality as source (implies VBR)" },
3764
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3765
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3766
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3767
      "deinterlace pictures" },
3768
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3769
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3770
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3771
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3772
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3773
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3774
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3775
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3776
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3777
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3778

    
3779
    /* audio options */
3780
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3781
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3782
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3783
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3784
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3785
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3786
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3787
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3788
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3789
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3790

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

    
3796
    /* grab options */
3797
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3798
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3799
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3800
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3801

    
3802
    /* G.2 grab options */
3803
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3804
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3805

    
3806
    /* muxer options */
3807
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3808
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3809

    
3810
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3811
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3812

    
3813
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3814
    { NULL, },
3815
};
3816

    
3817
static void show_banner(void)
3818
{
3819
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
3820
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3821
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3822
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3823
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3824
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3825
#ifdef __GNUC__
3826
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3827
#else
3828
    fprintf(stderr, ", using a non-gcc compiler\n");
3829
#endif
3830
}
3831

    
3832
static void show_license(void)
3833
{
3834
    show_banner();
3835
#ifdef CONFIG_GPL
3836
    printf(
3837
    "FFmpeg is free software; you can redistribute it and/or modify\n"
3838
    "it under the terms of the GNU General Public License as published by\n"
3839
    "the Free Software Foundation; either version 2 of the License, or\n"
3840
    "(at your option) any later version.\n"
3841
    "\n"
3842
    "FFmpeg is distributed in the hope that it will be useful,\n"
3843
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3844
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3845
    "GNU General Public License for more details.\n"
3846
    "\n"
3847
    "You should have received a copy of the GNU General Public License\n"
3848
    "along with FFmpeg; if not, write to the Free Software\n"
3849
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3850
    );
3851
#else
3852
    printf(
3853
    "FFmpeg is free software; you can redistribute it and/or\n"
3854
    "modify it under the terms of the GNU Lesser General Public\n"
3855
    "License as published by the Free Software Foundation; either\n"
3856
    "version 2.1 of the License, or (at your option) any later version.\n"
3857
    "\n"
3858
    "FFmpeg is distributed in the hope that it will be useful,\n"
3859
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3860
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3861
    "Lesser General Public License for more details.\n"
3862
    "\n"
3863
    "You should have received a copy of the GNU Lesser General Public\n"
3864
    "License along with FFmpeg; if not, write to the Free Software\n"
3865
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3866
    );
3867
#endif
3868
    exit(1);
3869
}
3870

    
3871
static void show_help(void)
3872
{
3873
    show_banner();
3874
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3875
           "Hyper fast Audio and Video encoder\n");
3876
    printf("\n");
3877
    show_help_options(options, "Main options:\n",
3878
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3879
    show_help_options(options, "\nVideo options:\n",
3880
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3881
                      OPT_VIDEO);
3882
    show_help_options(options, "\nAdvanced Video options:\n",
3883
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3884
                      OPT_VIDEO | OPT_EXPERT);
3885
    show_help_options(options, "\nAudio options:\n",
3886
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3887
                      OPT_AUDIO);
3888
    show_help_options(options, "\nAdvanced Audio options:\n",
3889
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3890
                      OPT_AUDIO | OPT_EXPERT);
3891
    show_help_options(options, "\nSubtitle options:\n",
3892
                      OPT_SUBTITLE | OPT_GRAB,
3893
                      OPT_SUBTITLE);
3894
    show_help_options(options, "\nAudio/Video grab options:\n",
3895
                      OPT_GRAB,
3896
                      OPT_GRAB);
3897
    show_help_options(options, "\nAdvanced options:\n",
3898
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3899
                      OPT_EXPERT);
3900
    av_opt_show(avctx_opts, NULL);
3901
    av_opt_show(avformat_opts, NULL);
3902

    
3903
    exit(1);
3904
}
3905

    
3906
void parse_arg_file(const char *filename)
3907
{
3908
    opt_output_file(filename);
3909
}
3910

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

    
3916
    av_register_all();
3917

    
3918
    avctx_opts= avcodec_alloc_context();
3919
    avformat_opts = av_alloc_format_context();
3920

    
3921
    if (argc <= 1)
3922
        show_help();
3923
    else
3924
        show_banner();
3925

    
3926
    /* parse options */
3927
    parse_options(argc, argv, options);
3928

    
3929
    /* file converter / grab */
3930
    if (nb_output_files <= 0) {
3931
        fprintf(stderr, "Must supply at least one output file\n");
3932
        exit(1);
3933
    }
3934

    
3935
    if (nb_input_files == 0) {
3936
        input_sync = 1;
3937
        prepare_grab();
3938
    }
3939

    
3940
    ti = getutime();
3941
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3942
              stream_maps, nb_stream_maps);
3943
    ti = getutime() - ti;
3944
    if (do_benchmark) {
3945
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3946
    }
3947

    
3948
    /* close files */
3949
    for(i=0;i<nb_output_files;i++) {
3950
        /* maybe av_close_output_file ??? */
3951
        AVFormatContext *s = output_files[i];
3952
        int j;
3953
        if (!(s->oformat->flags & AVFMT_NOFILE))
3954
            url_fclose(&s->pb);
3955
        for(j=0;j<s->nb_streams;j++)
3956
            av_free(s->streams[j]);
3957
        av_free(s);
3958
    }
3959
    for(i=0;i<nb_input_files;i++)
3960
        av_close_input_file(input_files[i]);
3961

    
3962
    av_free_static();
3963

    
3964
    if(intra_matrix)
3965
        av_free(intra_matrix);
3966
    if(inter_matrix)
3967
        av_free(inter_matrix);
3968

    
3969
#ifdef POWERPC_PERFORMANCE_REPORT
3970
    extern void powerpc_display_perf_report(void);
3971
    powerpc_display_perf_report();
3972
#endif /* POWERPC_PERFORMANCE_REPORT */
3973

    
3974
#ifndef __MINGW32__
3975
    if (received_sigterm) {
3976
        fprintf(stderr,
3977
            "Received signal %d: terminating.\n",
3978
            (int) received_sigterm);
3979
        exit (255);
3980
    }
3981
#endif
3982
    exit(0); /* not all OS-es handle main() return value */
3983
    return 0;
3984
}