Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ c6dafae9

History | View | Annotate | Download (141 KB)

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

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

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

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

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

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

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

    
68
extern const OptionDef options[];
69

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

    
74
#define MAX_FILES 20
75

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

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

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

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

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

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

    
158
static int subtitle_codec_id = CODEC_ID_NONE;
159
static char *subtitle_language = NULL;
160

    
161
static float mux_preload= 0.5;
162
static float mux_max_delay= 0.7;
163

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

    
190
static int rate_emu = 0;
191

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

    
206
static const char *audio_grab_format = "audio_device";
207
static char *audio_device = NULL;
208
static int audio_volume = 256;
209

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

    
223
static int pgmyuv_compatibility_hack=0;
224
static int dts_delta_threshold = 10;
225

    
226
static int sws_flags = SWS_BICUBIC;
227

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

    
233
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
234
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
235
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
236

    
237
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
238

    
239
struct AVInputStream;
240

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

    
259
    int video_crop;
260
    int topBand;             /* cropping area sizes */
261
    int leftBand;
262

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

    
269
    /* audio only */
270
    int audio_resample;
271
    ReSampleContext *resample; /* for audio resampling */
272
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
273
    FILE *logfile;
274
} AVOutputStream;
275

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

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

    
292
typedef struct AVInputFile {
293
    int eof_reached;      /* true if eof reached */
294
    int ist_index;        /* index of first stream in ist_table */
295
    int buffer_size;      /* current total buffer size */
296
    int buffer_size_max;  /* buffer size at which we consider we can stop
297
                             buffering */
298
    int nb_streams;       /* nb streams we are aware of */
299
} AVInputFile;
300

    
301
#ifndef __MINGW32__
302

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

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

    
311
static volatile sig_atomic_t received_sigterm = 0;
312

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

    
320
static void term_init(void)
321
{
322
    struct termios tty;
323

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

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

    
336
    tcsetattr (0, TCSANOW, &tty);
337

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

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

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

    
370
        return n;
371
    }
372
    return -1;
373
}
374

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

    
380
#else
381

    
382
static volatile int received_sigterm = 0;
383

    
384
/* no interactive support */
385
static void term_exit(void)
386
{
387
}
388

    
389
static void term_init(void)
390
{
391
}
392

    
393
static int read_key(void)
394
{
395
    return 0;
396
}
397

    
398
#endif
399

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

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

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

    
421
    av_close_input_file(ic);
422
    return 0;
423
}
424

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

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

    
445
        bsfc= bsfc->next;
446
    }
447

    
448
    av_interleaved_write_frame(s, pkt);
449
}
450

    
451
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
452

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

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

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

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

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

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

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

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

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

    
538
        frame_bytes = enc->frame_size * 2 * enc->channels;
539

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

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

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

    
562
        ost->sync_opts += size_out / (2 * enc->channels);
563

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

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

    
609
    dec = ist->st->codec;
610

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

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

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

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

    
639
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
640

    
641
    if (picture != picture2)
642
        *picture = *picture2;
643
    *bufp = buf;
644
}
645

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

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

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

    
666
    enc = ost->st->codec;
667

    
668
    if (!subtitle_out) {
669
        subtitle_out = av_malloc(subtitle_out_max_size);
670
    }
671

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

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

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

    
701
static int bit_buffer_size= 1024*256;
702
static uint8_t *bit_buffer= NULL;
703

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

    
716
    avcodec_get_frame_defaults(&picture_crop_temp);
717
    avcodec_get_frame_defaults(&picture_pad_temp);
718

    
719
    enc = ost->st->codec;
720
    dec = ist->st->codec;
721

    
722
    /* by default, we output a single frame */
723
    nb_frames = 1;
724

    
725
    *frame_size = 0;
726

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
949

    
950
    oc = output_files[0];
951

    
952
    total_size = url_ftell(&oc->pb);
953

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

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

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

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

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

    
1024
        fflush(stderr);
1025
    }
1026

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

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

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

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

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

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

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

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

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

    
1185
                ist->frame++;
1186
            }
1187

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

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

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

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

    
1243
                            /* no reencoding needed : output the packet directly */
1244
                            /* force the input stream PTS */
1245

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

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

    
1257
                            opkt.stream_index= ost->index;
1258
                            if(pkt->pts != AV_NOPTS_VALUE)
1259
                                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);
1260
                            else
1261
                                opkt.pts= AV_NOPTS_VALUE;
1262

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

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

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

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

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

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

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

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

    
1366
    return 0;
1367
 fail_decode:
1368
    return -1;
1369
}
1370

    
1371

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1535
        codec = ost->st->codec;
1536
        icodec = ist->st->codec;
1537

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

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

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

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

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

    
1708
    if (!bit_buffer)
1709
        bit_buffer = av_malloc(bit_buffer_size);
1710
    if (!bit_buffer)
1711
        goto fail;
1712

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

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

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

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

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

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

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

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

    
1814
        out_file = output_files[out_file_index];
1815
        in_file = input_files[in_file_index];
1816

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

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

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

    
1845
    stream_no_data = 0;
1846
    key = -1;
1847

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

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

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

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

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

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

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

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

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

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

    
1954
            av_free_packet(&pkt);
1955
            goto redo;
1956
        }
1957

    
1958
    discard_packet:
1959
        av_free_packet(&pkt);
1960

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

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

    
1973
    term_exit();
1974

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

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

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

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

    
2001
    /* finished ! */
2002

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

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

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

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

    
2063
static void opt_image_format(const char *arg)
2064
{
2065
    AVImageFormat *f;
2066

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2213

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

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

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

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

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

    
2236
    r = (rgb >> 16);
2237
    g = ((rgb >> 8) & 255);
2238
    b = (rgb & 255);
2239

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

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

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

    
2271

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

    
2285

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

    
2299

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2398
static void opt_sc_threshold(const char *arg)
2399
{
2400
    sc_threshold= atoi(arg);
2401
}
2402

    
2403
static void opt_thread_count(const char *arg)
2404
{
2405
    thread_count= atoi(arg);
2406
#if !defined(HAVE_THREADS)
2407
    if (verbose >= 0)
2408
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2409
#endif
2410
}
2411

    
2412
static void opt_audio_bitrate(const char *arg)
2413
{
2414
    audio_bit_rate = atoi(arg) * 1000;
2415
}
2416

    
2417
static void opt_audio_rate(const char *arg)
2418
{
2419
    audio_sample_rate = atoi(arg);
2420
}
2421

    
2422
static void opt_audio_channels(const char *arg)
2423
{
2424
    audio_channels = atoi(arg);
2425
}
2426

    
2427
static void opt_video_device(const char *arg)
2428
{
2429
    video_device = av_strdup(arg);
2430
}
2431

    
2432
static void opt_grab_device(const char *arg)
2433
{
2434
    grab_device = av_strdup(arg);
2435
}
2436

    
2437
static void opt_video_channel(const char *arg)
2438
{
2439
    video_channel = strtol(arg, NULL, 0);
2440
}
2441

    
2442
static void opt_video_standard(const char *arg)
2443
{
2444
    video_standard = av_strdup(arg);
2445
}
2446

    
2447
static void opt_audio_device(const char *arg)
2448
{
2449
    audio_device = av_strdup(arg);
2450
}
2451

    
2452
static void opt_codec(int *pstream_copy, int *pcodec_id,
2453
                      int codec_type, const char *arg)
2454
{
2455
    AVCodec *p;
2456

    
2457
    if (!strcmp(arg, "copy")) {
2458
        *pstream_copy = 1;
2459
    } else {
2460
        p = first_avcodec;
2461
        while (p) {
2462
            if (!strcmp(p->name, arg) && p->type == codec_type)
2463
                break;
2464
            p = p->next;
2465
        }
2466
        if (p == NULL) {
2467
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2468
            exit(1);
2469
        } else {
2470
            *pcodec_id = p->id;
2471
        }
2472
    }
2473
}
2474

    
2475
static void opt_audio_codec(const char *arg)
2476
{
2477
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2478
}
2479

    
2480
static void opt_audio_tag(const char *arg)
2481
{
2482
    char *tail;
2483
    audio_codec_tag= strtol(arg, &tail, 0);
2484

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

    
2489
static void opt_video_tag(const char *arg)
2490
{
2491
    char *tail;
2492
    video_codec_tag= strtol(arg, &tail, 0);
2493

    
2494
    if(!tail || *tail)
2495
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2496
}
2497

    
2498
static void add_frame_hooker(const char *arg)
2499
{
2500
    int argc = 0;
2501
    char *argv[64];
2502
    int i;
2503
    char *args = av_strdup(arg);
2504

    
2505
    using_vhook = 1;
2506

    
2507
    argv[0] = strtok(args, " ");
2508
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2509
    }
2510

    
2511
    i = frame_hook_add(argc, argv);
2512

    
2513
    if (i != 0) {
2514
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2515
        exit(1);
2516
    }
2517
}
2518

    
2519
const char *motion_str[] = {
2520
    "zero",
2521
    "full",
2522
    "log",
2523
    "phods",
2524
    "epzs",
2525
    "x1",
2526
    "hex",
2527
    "umh",
2528
    "iter",
2529
    NULL,
2530
};
2531

    
2532
static void opt_motion_estimation(const char *arg)
2533
{
2534
    const char **p;
2535
    p = motion_str;
2536
    for(;;) {
2537
        if (!*p) {
2538
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2539
            exit(1);
2540
        }
2541
        if (!strcmp(*p, arg))
2542
            break;
2543
        p++;
2544
    }
2545
    me_method = (p - motion_str) + 1;
2546
}
2547

    
2548
static void opt_video_codec(const char *arg)
2549
{
2550
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2551
}
2552

    
2553
static void opt_subtitle_codec(const char *arg)
2554
{
2555
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2556
}
2557

    
2558
static void opt_map(const char *arg)
2559
{
2560
    AVStreamMap *m;
2561
    const char *p;
2562

    
2563
    p = arg;
2564
    m = &stream_maps[nb_stream_maps++];
2565

    
2566
    m->file_index = strtol(arg, (char **)&p, 0);
2567
    if (*p)
2568
        p++;
2569

    
2570
    m->stream_index = strtol(p, (char **)&p, 0);
2571
    if (*p) {
2572
        p++;
2573
        m->sync_file_index = strtol(p, (char **)&p, 0);
2574
        if (*p)
2575
            p++;
2576
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2577
    } else {
2578
        m->sync_file_index = m->file_index;
2579
        m->sync_stream_index = m->stream_index;
2580
    }
2581
}
2582

    
2583
static void opt_map_meta_data(const char *arg)
2584
{
2585
    AVMetaDataMap *m;
2586
    const char *p;
2587

    
2588
    p = arg;
2589
    m = &meta_data_maps[nb_meta_data_maps++];
2590

    
2591
    m->out_file = strtol(arg, (char **)&p, 0);
2592
    if (*p)
2593
        p++;
2594

    
2595
    m->in_file = strtol(p, (char **)&p, 0);
2596
}
2597

    
2598
static void opt_recording_time(const char *arg)
2599
{
2600
    recording_time = parse_date(arg, 1);
2601
}
2602

    
2603
static void opt_start_time(const char *arg)
2604
{
2605
    start_time = parse_date(arg, 1);
2606
}
2607

    
2608
static void opt_rec_timestamp(const char *arg)
2609
{
2610
    rec_timestamp = parse_date(arg, 0) / 1000000;
2611
}
2612

    
2613
static void opt_input_ts_offset(const char *arg)
2614
{
2615
    input_ts_offset = parse_date(arg, 1);
2616
}
2617

    
2618
static void opt_input_file(const char *filename)
2619
{
2620
    AVFormatContext *ic;
2621
    AVFormatParameters params, *ap = &params;
2622
    int err, i, ret, rfps, rfps_base;
2623
    int64_t timestamp;
2624

    
2625
    if (!strcmp(filename, "-"))
2626
        filename = "pipe:";
2627

    
2628
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2629
                   !strcmp( filename, "/dev/stdin" );
2630

    
2631
    /* get default parameters from command line */
2632
    ic = av_alloc_format_context();
2633

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

    
2652
    for(i=0; i<opt_name_count; i++){
2653
        AVOption *opt;
2654
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2655
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2656
            av_set_double(ic, opt_names[i], d);
2657
    }
2658
    /* open the input file with generic libav function */
2659
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2660
    if (err < 0) {
2661
        print_error(filename, err);
2662
        exit(1);
2663
    }
2664

    
2665
    ic->loop_input = loop_input;
2666

    
2667
    /* If not enough info to get the stream parameters, we decode the
2668
       first frames to get it. (used in mpeg case for example) */
2669
    ret = av_find_stream_info(ic);
2670
    if (ret < 0 && verbose >= 0) {
2671
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2672
        exit(1);
2673
    }
2674

    
2675
    timestamp = start_time;
2676
    /* add the stream start time */
2677
    if (ic->start_time != AV_NOPTS_VALUE)
2678
        timestamp += ic->start_time;
2679

    
2680
    /* if seeking requested, we execute it */
2681
    if (start_time != 0) {
2682
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2683
        if (ret < 0) {
2684
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2685
                    filename, (double)timestamp / AV_TIME_BASE);
2686
        }
2687
        /* reset seek info */
2688
        start_time = 0;
2689
    }
2690

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

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

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

    
2737
                    (float)rfps / rfps_base, rfps, rfps_base);
2738
            }
2739
            /* update the current frame rate to match the stream frame rate */
2740
            frame_rate      = rfps;
2741
            frame_rate_base = rfps_base;
2742

    
2743
            enc->rate_emu = rate_emu;
2744
            if(video_disable)
2745
                ic->streams[i]->discard= AVDISCARD_ALL;
2746
            else if(video_discard)
2747
                ic->streams[i]->discard= video_discard;
2748
            break;
2749
        case CODEC_TYPE_DATA:
2750
            break;
2751
        case CODEC_TYPE_SUBTITLE:
2752
            break;
2753
        case CODEC_TYPE_UNKNOWN:
2754
            break;
2755
        default:
2756
            av_abort();
2757
        }
2758
    }
2759

    
2760
    input_files[nb_input_files] = ic;
2761
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2762
    /* dump the file content */
2763
    if (verbose >= 0)
2764
        dump_format(ic, nb_input_files, filename, 0);
2765

    
2766
    nb_input_files++;
2767
    file_iformat = NULL;
2768
    file_oformat = NULL;
2769
    image_format = NULL;
2770

    
2771
    grab_device = NULL;
2772
    video_channel = 0;
2773

    
2774
    rate_emu = 0;
2775
}
2776

    
2777
static void opt_grab(const char *arg)
2778
{
2779
    file_iformat = av_find_input_format(arg);
2780
    opt_input_file("");
2781
}
2782

    
2783
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2784
{
2785
    int has_video, has_audio, i, j;
2786
    AVFormatContext *ic;
2787

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

    
2814
static void new_video_stream(AVFormatContext *oc)
2815
{
2816
    AVStream *st;
2817
    AVCodecContext *video_enc;
2818
    int codec_id;
2819

    
2820
    st = av_new_stream(oc, oc->nb_streams);
2821
    if (!st) {
2822
        fprintf(stderr, "Could not alloc stream\n");
2823
        exit(1);
2824
    }
2825
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2826
    video_bitstream_filters= NULL;
2827

    
2828
#if defined(HAVE_THREADS)
2829
    if(thread_count>1)
2830
        avcodec_thread_init(st->codec, thread_count);
2831
#endif
2832

    
2833
    video_enc = st->codec;
2834

    
2835
    if(video_codec_tag)
2836
        video_enc->codec_tag= video_codec_tag;
2837

    
2838
    if(   (video_global_header&1)
2839
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2840
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2841
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2842
    }
2843
    if(video_global_header&2){
2844
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2845
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2846
    }
2847

    
2848
    if (video_stream_copy) {
2849
        st->stream_copy = 1;
2850
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2851
    } else {
2852
        char *p;
2853
        int i;
2854
        AVCodec *codec;
2855

    
2856
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2857
        if (video_codec_id != CODEC_ID_NONE)
2858
            codec_id = video_codec_id;
2859

    
2860
        video_enc->codec_id = codec_id;
2861
        codec = avcodec_find_encoder(codec_id);
2862

    
2863
        for(i=0; i<opt_name_count; i++){
2864
             AVOption *opt;
2865
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2866
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2867
                 av_set_double(video_enc, opt_names[i], d);
2868
        }
2869

    
2870
        video_enc->time_base.den = frame_rate;
2871
        video_enc->time_base.num = frame_rate_base;
2872
        if(codec && codec->supported_framerates){
2873
            const AVRational *p= codec->supported_framerates;
2874
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2875
            const AVRational *best=NULL;
2876
            AVRational best_error= (AVRational){INT_MAX, 1};
2877
            for(; p->den!=0; p++){
2878
                AVRational error= av_sub_q(req, *p);
2879
                if(error.num <0) error.num *= -1;
2880
                if(av_cmp_q(error, best_error) < 0){
2881
                    best_error= error;
2882
                    best= p;
2883
                }
2884
            }
2885
            video_enc->time_base.den= best->num;
2886
            video_enc->time_base.num= best->den;
2887
        }
2888

    
2889
        video_enc->width = frame_width + frame_padright + frame_padleft;
2890
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2891
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2892
        video_enc->pix_fmt = frame_pix_fmt;
2893

    
2894
        if(codec && codec->pix_fmts){
2895
            const enum PixelFormat *p= codec->pix_fmts;
2896
            for(; *p!=-1; p++){
2897
                if(*p == video_enc->pix_fmt)
2898
                    break;
2899
            }
2900
            if(*p == -1)
2901
                video_enc->pix_fmt = codec->pix_fmts[0];
2902
        }
2903

    
2904
        if (intra_only)
2905
            video_enc->gop_size = 0;
2906
        if (video_qscale || same_quality) {
2907
            video_enc->flags |= CODEC_FLAG_QSCALE;
2908
            video_enc->global_quality=
2909
                st->quality = FF_QP2LAMBDA * video_qscale;
2910
        }
2911

    
2912
        if(intra_matrix)
2913
            video_enc->intra_matrix = intra_matrix;
2914
        if(inter_matrix)
2915
            video_enc->inter_matrix = inter_matrix;
2916

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

    
2962
        if(packet_size){
2963
            video_enc->rtp_mode= 1;
2964
            video_enc->rtp_payload_size= packet_size;
2965
        }
2966

    
2967
        if (do_psnr)
2968
            video_enc->flags|= CODEC_FLAG_PSNR;
2969

    
2970
        video_enc->me_method = me_method;
2971

    
2972
        /* two pass mode */
2973
        if (do_pass) {
2974
            if (do_pass == 1) {
2975
                video_enc->flags |= CODEC_FLAG_PASS1;
2976
            } else {
2977
                video_enc->flags |= CODEC_FLAG_PASS2;
2978
            }
2979
        }
2980
    }
2981

    
2982
    /* reset some key parameters */
2983
    video_disable = 0;
2984
    video_codec_id = CODEC_ID_NONE;
2985
    video_stream_copy = 0;
2986
}
2987

    
2988
static void new_audio_stream(AVFormatContext *oc)
2989
{
2990
    AVStream *st;
2991
    AVCodecContext *audio_enc;
2992
    int codec_id, i;
2993

    
2994
    st = av_new_stream(oc, oc->nb_streams);
2995
    if (!st) {
2996
        fprintf(stderr, "Could not alloc stream\n");
2997
        exit(1);
2998
    }
2999

    
3000
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3001
    audio_bitstream_filters= NULL;
3002

    
3003
#if defined(HAVE_THREADS)
3004
    if(thread_count>1)
3005
        avcodec_thread_init(st->codec, thread_count);
3006
#endif
3007

    
3008
    audio_enc = st->codec;
3009
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3010

    
3011
    if(audio_codec_tag)
3012
        audio_enc->codec_tag= audio_codec_tag;
3013

    
3014
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3015
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3016
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3017
    }
3018
    if (audio_stream_copy) {
3019
        st->stream_copy = 1;
3020
        audio_enc->channels = audio_channels;
3021
    } else {
3022
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3023

    
3024
        for(i=0; i<opt_name_count; i++){
3025
            AVOption *opt;
3026
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
3027
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3028
                av_set_double(audio_enc, opt_names[i], d);
3029
        }
3030

    
3031
        if (audio_codec_id != CODEC_ID_NONE)
3032
            codec_id = audio_codec_id;
3033
        audio_enc->codec_id = codec_id;
3034

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

    
3058
    /* reset some key parameters */
3059
    audio_disable = 0;
3060
    audio_codec_id = CODEC_ID_NONE;
3061
    audio_stream_copy = 0;
3062
}
3063

    
3064
static void opt_new_subtitle_stream(void)
3065
{
3066
    AVFormatContext *oc;
3067
    AVStream *st;
3068
    AVCodecContext *subtitle_enc;
3069
    int i;
3070

    
3071
    if (nb_output_files <= 0) {
3072
        fprintf(stderr, "At least one output file must be specified\n");
3073
        exit(1);
3074
    }
3075
    oc = output_files[nb_output_files - 1];
3076

    
3077
    st = av_new_stream(oc, oc->nb_streams);
3078
    if (!st) {
3079
        fprintf(stderr, "Could not alloc stream\n");
3080
        exit(1);
3081
    }
3082

    
3083
    subtitle_enc = st->codec;
3084
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3085
    if (subtitle_stream_copy) {
3086
        st->stream_copy = 1;
3087
    } else {
3088
        for(i=0; i<opt_name_count; i++){
3089
             AVOption *opt;
3090
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3091
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3092
                 av_set_double(subtitle_enc, opt_names[i], d);
3093
        }
3094
        subtitle_enc->codec_id = subtitle_codec_id;
3095
    }
3096

    
3097
    if (subtitle_language) {
3098
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3099
        av_free(subtitle_language);
3100
        subtitle_language = NULL;
3101
    }
3102

    
3103
    subtitle_codec_id = CODEC_ID_NONE;
3104
    subtitle_stream_copy = 0;
3105
}
3106

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

    
3118
static void opt_new_video_stream(void)
3119
{
3120
    AVFormatContext *oc;
3121
    if (nb_output_files <= 0) {
3122
        fprintf(stderr, "At least one output file must be specified\n");
3123
        exit(1);
3124
    }
3125
    oc = output_files[nb_output_files - 1];
3126
    new_video_stream(oc);
3127
}
3128

    
3129
static void opt_output_file(const char *filename)
3130
{
3131
    AVFormatContext *oc;
3132
    int use_video, use_audio, input_has_video, input_has_audio, i;
3133
    AVFormatParameters params, *ap = &params;
3134

    
3135
    if (!strcmp(filename, "-"))
3136
        filename = "pipe:";
3137

    
3138
    oc = av_alloc_format_context();
3139

    
3140
    if (!file_oformat) {
3141
        file_oformat = guess_format(NULL, filename, NULL);
3142
        if (!file_oformat) {
3143
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3144
                    filename);
3145
            exit(1);
3146
        }
3147
    }
3148

    
3149
    oc->oformat = file_oformat;
3150
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3151

    
3152
    if (!strcmp(file_oformat->name, "ffm") &&
3153
        strstart(filename, "http:", NULL)) {
3154
        /* special case for files sent to ffserver: we get the stream
3155
           parameters from ffserver */
3156
        if (read_ffserver_streams(oc, filename) < 0) {
3157
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3158
            exit(1);
3159
        }
3160
    } else {
3161
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3162
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3163

    
3164
        /* disable if no corresponding type found and at least one
3165
           input file */
3166
        if (nb_input_files > 0) {
3167
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3168
            if (!input_has_video)
3169
                use_video = 0;
3170
            if (!input_has_audio)
3171
                use_audio = 0;
3172
        }
3173

    
3174
        /* manual disable */
3175
        if (audio_disable) {
3176
            use_audio = 0;
3177
        }
3178
        if (video_disable) {
3179
            use_video = 0;
3180
        }
3181

    
3182
        if (use_video) {
3183
            new_video_stream(oc);
3184
        }
3185

    
3186
        if (use_audio) {
3187
            new_audio_stream(oc);
3188
        }
3189

    
3190
        if (!oc->nb_streams) {
3191
            fprintf(stderr, "No audio or video streams available\n");
3192
            exit(1);
3193
        }
3194

    
3195
        oc->timestamp = rec_timestamp;
3196

    
3197
        if (str_title)
3198
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3199
        if (str_author)
3200
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3201
        if (str_copyright)
3202
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3203
        if (str_comment)
3204
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3205
        if (str_album)
3206
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3207
    }
3208

    
3209
    output_files[nb_output_files++] = oc;
3210

    
3211
    /* check filename in case of an image number is expected */
3212
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3213
        if (!av_filename_number_test(oc->filename)) {
3214
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3215
            exit(1);
3216
        }
3217
    }
3218

    
3219
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3220
        /* test if it already exists to avoid loosing precious files */
3221
        if (!file_overwrite &&
3222
            (strchr(filename, ':') == NULL ||
3223
             strstart(filename, "file:", NULL))) {
3224
            if (url_exist(filename)) {
3225
                int c;
3226

    
3227
                if ( !using_stdin ) {
3228
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3229
                    fflush(stderr);
3230
                    c = getchar();
3231
                    if (toupper(c) != 'Y') {
3232
                        fprintf(stderr, "Not overwriting - exiting\n");
3233
                        exit(1);
3234
                    }
3235
                                }
3236
                                else {
3237
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3238
                    exit(1);
3239
                                }
3240
            }
3241
        }
3242

    
3243
        /* open the file */
3244
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3245
            fprintf(stderr, "Could not open '%s'\n", filename);
3246
            exit(1);
3247
        }
3248
    }
3249

    
3250
    memset(ap, 0, sizeof(*ap));
3251
    ap->image_format = image_format;
3252
    if (av_set_parameters(oc, ap) < 0) {
3253
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3254
                oc->filename);
3255
        exit(1);
3256
    }
3257

    
3258
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3259
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3260
    oc->loop_output = loop_output;
3261

    
3262
    for(i=0; i<opt_name_count; i++){
3263
        AVOption *opt;
3264
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3265
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3266
            av_set_double(oc, opt_names[i], d);
3267
    }
3268

    
3269
    /* reset some options */
3270
    file_oformat = NULL;
3271
    file_iformat = NULL;
3272
    image_format = NULL;
3273
}
3274

    
3275
/* prepare dummy protocols for grab */
3276
static void prepare_grab(void)
3277
{
3278
    int has_video, has_audio, i, j;
3279
    AVFormatContext *oc;
3280
    AVFormatContext *ic;
3281
    AVFormatParameters vp1, *vp = &vp1;
3282
    AVFormatParameters ap1, *ap = &ap1;
3283

    
3284
    /* see if audio/video inputs are needed */
3285
    has_video = 0;
3286
    has_audio = 0;
3287
    memset(ap, 0, sizeof(*ap));
3288
    memset(vp, 0, sizeof(*vp));
3289
    vp->time_base.num= 1;
3290
    for(j=0;j<nb_output_files;j++) {
3291
        oc = output_files[j];
3292
        for(i=0;i<oc->nb_streams;i++) {
3293
            AVCodecContext *enc = oc->streams[i]->codec;
3294
            switch(enc->codec_type) {
3295
            case CODEC_TYPE_AUDIO:
3296
                if (enc->sample_rate > ap->sample_rate)
3297
                    ap->sample_rate = enc->sample_rate;
3298
                if (enc->channels > ap->channels)
3299
                    ap->channels = enc->channels;
3300
                has_audio = 1;
3301
                break;
3302
            case CODEC_TYPE_VIDEO:
3303
                if (enc->width > vp->width)
3304
                    vp->width = enc->width;
3305
                if (enc->height > vp->height)
3306
                    vp->height = enc->height;
3307

    
3308
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3309
                    vp->time_base = enc->time_base;
3310
                    vp->width += frame_leftBand + frame_rightBand;
3311
                    vp->width -= (frame_padleft + frame_padright);
3312
                    vp->height += frame_topBand + frame_bottomBand;
3313
                    vp->height -= (frame_padtop + frame_padbottom);
3314
                }
3315
                has_video = 1;
3316
                break;
3317
            default:
3318
                av_abort();
3319
            }
3320
        }
3321
    }
3322

    
3323
    if (has_video == 0 && has_audio == 0) {
3324
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3325
        exit(1);
3326
    }
3327

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

    
3350
        if (verbose >= 0)
3351
            dump_format(ic, nb_input_files, "", 0);
3352

    
3353
        nb_input_files++;
3354
    }
3355
    if (has_audio && audio_grab_format) {
3356
        AVInputFormat *fmt1;
3357
        fmt1 = av_find_input_format(audio_grab_format);
3358
        ap->device = audio_device;
3359
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3360
            fprintf(stderr, "Could not find audio grab device\n");
3361
            exit(1);
3362
        }
3363
        input_files[nb_input_files] = ic;
3364

    
3365
        if (verbose >= 0)
3366
            dump_format(ic, nb_input_files, "", 0);
3367

    
3368
        nb_input_files++;
3369
    }
3370
}
3371

    
3372
/* same option as mencoder */
3373
static void opt_pass(const char *pass_str)
3374
{
3375
    int pass;
3376
    pass = atoi(pass_str);
3377
    if (pass != 1 && pass != 2) {
3378
        fprintf(stderr, "pass number can be only 1 or 2\n");
3379
        exit(1);
3380
    }
3381
    do_pass = pass;
3382
}
3383

    
3384
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3385
static int64_t getutime(void)
3386
{
3387
  return av_gettime();
3388
}
3389
#else
3390
static int64_t getutime(void)
3391
{
3392
    struct rusage rusage;
3393

    
3394
    getrusage(RUSAGE_SELF, &rusage);
3395
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3396
}
3397
#endif
3398

    
3399
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3400
extern int ffm_nopts;
3401
#endif
3402

    
3403
static void show_formats(void)
3404
{
3405
    AVInputFormat *ifmt;
3406
    AVOutputFormat *ofmt;
3407
    AVImageFormat *image_fmt;
3408
    URLProtocol *up;
3409
    AVCodec *p, *p2;
3410
    const char **pp, *last_name;
3411

    
3412
    printf("File formats:\n");
3413
    last_name= "000";
3414
    for(;;){
3415
        int decode=0;
3416
        int encode=0;
3417
        const char *name=NULL;
3418
        const char *long_name=NULL;
3419

    
3420
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3421
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3422
                strcmp(ofmt->name, last_name)>0){
3423
                name= ofmt->name;
3424
                long_name= ofmt->long_name;
3425
                encode=1;
3426
            }
3427
        }
3428
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3429
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3430
                strcmp(ifmt->name, last_name)>0){
3431
                name= ifmt->name;
3432
                long_name= ifmt->long_name;
3433
                encode=0;
3434
            }
3435
            if(name && strcmp(ifmt->name, name)==0)
3436
                decode=1;
3437
        }
3438
        if(name==NULL)
3439
            break;
3440
        last_name= name;
3441

    
3442
        printf(
3443
            " %s%s %-15s %s\n",
3444
            decode ? "D":" ",
3445
            encode ? "E":" ",
3446
            name,
3447
            long_name ? long_name:" ");
3448
    }
3449
    printf("\n");
3450

    
3451
    printf("Image formats (filename extensions, if any, follow):\n");
3452
    for(image_fmt = first_image_format; image_fmt != NULL;
3453
        image_fmt = image_fmt->next) {
3454
        printf(
3455
            " %s%s %-6s %s\n",
3456
            image_fmt->img_read  ? "D":" ",
3457
            image_fmt->img_write ? "E":" ",
3458
            image_fmt->name,
3459
            image_fmt->extensions ? image_fmt->extensions:" ");
3460
    }
3461
    printf("\n");
3462

    
3463
    printf("Codecs:\n");
3464
    last_name= "000";
3465
    for(;;){
3466
        int decode=0;
3467
        int encode=0;
3468
        int cap=0;
3469
        const char *type_str;
3470

    
3471
        p2=NULL;
3472
        for(p = first_avcodec; p != NULL; p = p->next) {
3473
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3474
                strcmp(p->name, last_name)>0){
3475
                p2= p;
3476
                decode= encode= cap=0;
3477
            }
3478
            if(p2 && strcmp(p->name, p2->name)==0){
3479
                if(p->decode) decode=1;
3480
                if(p->encode) encode=1;
3481
                cap |= p->capabilities;
3482
            }
3483
        }
3484
        if(p2==NULL)
3485
            break;
3486
        last_name= p2->name;
3487

    
3488
        switch(p2->type) {
3489
        case CODEC_TYPE_VIDEO:
3490
            type_str = "V";
3491
            break;
3492
        case CODEC_TYPE_AUDIO:
3493
            type_str = "A";
3494
            break;
3495
        case CODEC_TYPE_SUBTITLE:
3496
            type_str = "S";
3497
            break;
3498
        default:
3499
            type_str = "?";
3500
            break;
3501
        }
3502
        printf(
3503
            " %s%s%s%s%s%s %s",
3504
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3505
            encode ? "E":" ",
3506
            type_str,
3507
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3508
            cap & CODEC_CAP_DR1 ? "D":" ",
3509
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3510
            p2->name);
3511
       /* if(p2->decoder && decode==0)
3512
            printf(" use %s for decoding", p2->decoder->name);*/
3513
        printf("\n");
3514
    }
3515
    printf("\n");
3516

    
3517
    printf("Supported file protocols:\n");
3518
    for(up = first_protocol; up != NULL; up = up->next)
3519
        printf(" %s:", up->name);
3520
    printf("\n");
3521

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

    
3545
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3546
{
3547
    int i;
3548
    const char *p = str;
3549
    for(i = 0;; i++) {
3550
        dest[i] = atoi(p);
3551
        if(i == 63)
3552
            break;
3553
        p = strchr(p, ',');
3554
        if(!p) {
3555
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3556
            exit(1);
3557
        }
3558
        p++;
3559
    }
3560
}
3561

    
3562
static void opt_inter_matrix(const char *arg)
3563
{
3564
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3565
    parse_matrix_coeffs(inter_matrix, arg);
3566
}
3567

    
3568
static void opt_intra_matrix(const char *arg)
3569
{
3570
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3571
    parse_matrix_coeffs(intra_matrix, arg);
3572
}
3573

    
3574
static void opt_target(const char *arg)
3575
{
3576
    int norm = -1;
3577
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3578

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

    
3623
    if(norm < 0) {
3624
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3625
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3626
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3627
        exit(1);
3628
    }
3629

    
3630
    if(!strcmp(arg, "vcd")) {
3631

    
3632
        opt_video_codec("mpeg1video");
3633
        opt_audio_codec("mp2");
3634
        opt_format("vcd");
3635

    
3636
        opt_frame_size(norm ? "352x240" : "352x288");
3637
        opt_frame_rate(frame_rates[norm]);
3638
        opt_default("gop", norm ? "18" : "15");
3639

    
3640
        opt_default("b", "1150000");
3641
        opt_default("maxrate", "1150000");
3642
        opt_default("minrate", "1150000");
3643
        opt_default("bufsize", "327680"); // 40*1024*8;
3644

    
3645
        audio_bit_rate = 224000;
3646
        audio_sample_rate = 44100;
3647

    
3648
        opt_default("packetsize", "2324");
3649
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3650

    
3651
        /* We have to offset the PTS, so that it is consistent with the SCR.
3652
           SCR starts at 36000, but the first two packs contain only padding
3653
           and the first pack from the other stream, respectively, may also have
3654
           been written before.
3655
           So the real data starts at SCR 36000+3*1200. */
3656
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3657
    } else if(!strcmp(arg, "svcd")) {
3658

    
3659
        opt_video_codec("mpeg2video");
3660
        opt_audio_codec("mp2");
3661
        opt_format("svcd");
3662

    
3663
        opt_frame_size(norm ? "480x480" : "480x576");
3664
        opt_frame_rate(frame_rates[norm]);
3665
        opt_default("gop", norm ? "18" : "15");
3666

    
3667
        opt_default("b", "2040000");
3668
        opt_default("maxrate", "2516000");
3669
        opt_default("minrate", "0"); //1145000;
3670
        opt_default("bufsize", "1835008"); //224*1024*8;
3671
        opt_default("flags", "+SCAN_OFFSET");
3672

    
3673

    
3674
        audio_bit_rate = 224000;
3675
        audio_sample_rate = 44100;
3676

    
3677
        opt_default("packetsize", "2324");
3678

    
3679
    } else if(!strcmp(arg, "dvd")) {
3680

    
3681
        opt_video_codec("mpeg2video");
3682
        opt_audio_codec("ac3");
3683
        opt_format("dvd");
3684

    
3685
        opt_frame_size(norm ? "720x480" : "720x576");
3686
        opt_frame_rate(frame_rates[norm]);
3687
        opt_default("gop", norm ? "18" : "15");
3688

    
3689
        opt_default("b", "6000000");
3690
        opt_default("maxrate", "9000000");
3691
        opt_default("minrate", "0"); //1500000;
3692
        opt_default("bufsize", "1835008"); //224*1024*8;
3693

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

    
3697
        audio_bit_rate = 448000;
3698
        audio_sample_rate = 48000;
3699

    
3700
    } else if(!strncmp(arg, "dv", 2)) {
3701

    
3702
        opt_format("dv");
3703

    
3704
        opt_frame_size(norm ? "720x480" : "720x576");
3705
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3706
                                             (norm ? "yuv411p" : "yuv420p"));
3707
        opt_frame_rate(frame_rates[norm]);
3708

    
3709
        audio_sample_rate = 48000;
3710
        audio_channels = 2;
3711

    
3712
    } else {
3713
        fprintf(stderr, "Unknown target: %s\n", arg);
3714
        exit(1);
3715
    }
3716
}
3717

    
3718
static void opt_video_bsf(const char *arg)
3719
{
3720
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3721
    AVBitStreamFilterContext **bsfp;
3722

    
3723
    if(!bsfc){
3724
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3725
        exit(1);
3726
    }
3727

    
3728
    bsfp= &video_bitstream_filters;
3729
    while(*bsfp)
3730
        bsfp= &(*bsfp)->next;
3731

    
3732
    *bsfp= bsfc;
3733
}
3734

    
3735
//FIXME avoid audio - video code duplication
3736
static void opt_audio_bsf(const char *arg)
3737
{
3738
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3739
    AVBitStreamFilterContext **bsfp;
3740

    
3741
    if(!bsfc){
3742
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3743
        exit(1);
3744
    }
3745

    
3746
    bsfp= &audio_bitstream_filters;
3747
    while(*bsfp)
3748
        bsfp= &(*bsfp)->next;
3749

    
3750
    *bsfp= bsfc;
3751
}
3752

    
3753
static void show_version(void)
3754
{
3755
    /* TODO: add function interface to avutil and avformat */
3756
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3757
           "libavutil   %d\n"
3758
           "libavcodec  %d\n"
3759
           "libavformat %d\n",
3760
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3761
    exit(1);
3762
}
3763

    
3764
static int opt_default(const char *opt, const char *arg){
3765
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3766
    if(!o)
3767
        o = av_set_string(avformat_opts, opt, arg);
3768
    if(!o)
3769
        return -1;
3770

    
3771
//    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));
3772

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

    
3777
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3778
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3779
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3780
        ffm_nopts = 1;
3781
#endif
3782

    
3783
    if(avctx_opts->debug)
3784
        av_log_set_level(AV_LOG_DEBUG);
3785
    return 0;
3786
}
3787

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

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

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

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

    
3904
    /* grab options */
3905
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3906
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3907
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3908
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3909

    
3910
    /* G.2 grab options */
3911
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3912
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3913

    
3914
    /* muxer options */
3915
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3916
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3917

    
3918
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3919
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3920

    
3921
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3922
    { NULL, },
3923
};
3924

    
3925
static void show_banner(void)
3926
{
3927
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3928
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3929
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3930
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3931
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3932
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3933
#ifdef __GNUC__
3934
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3935
#else
3936
    fprintf(stderr, ", using a non-gcc compiler\n");
3937
#endif
3938
}
3939

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

    
3979
static void show_help(void)
3980
{
3981
    show_banner();
3982
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3983
           "Hyper fast Audio and Video encoder\n");
3984
    printf("\n");
3985
    show_help_options(options, "Main options:\n",
3986
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3987
    show_help_options(options, "\nVideo options:\n",
3988
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3989
                      OPT_VIDEO);
3990
    show_help_options(options, "\nAdvanced Video options:\n",
3991
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3992
                      OPT_VIDEO | OPT_EXPERT);
3993
    show_help_options(options, "\nAudio options:\n",
3994
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3995
                      OPT_AUDIO);
3996
    show_help_options(options, "\nAdvanced Audio options:\n",
3997
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3998
                      OPT_AUDIO | OPT_EXPERT);
3999
    show_help_options(options, "\nSubtitle options:\n",
4000
                      OPT_SUBTITLE | OPT_GRAB,
4001
                      OPT_SUBTITLE);
4002
    show_help_options(options, "\nAudio/Video grab options:\n",
4003
                      OPT_GRAB,
4004
                      OPT_GRAB);
4005
    show_help_options(options, "\nAdvanced options:\n",
4006
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4007
                      OPT_EXPERT);
4008
    av_opt_show(avctx_opts, NULL);
4009
    av_opt_show(avformat_opts, NULL);
4010

    
4011
    exit(1);
4012
}
4013

    
4014
void parse_arg_file(const char *filename)
4015
{
4016
    opt_output_file(filename);
4017
}
4018

    
4019
int main(int argc, char **argv)
4020
{
4021
    int i;
4022
    int64_t ti;
4023

    
4024
    av_register_all();
4025

    
4026
    avctx_opts= avcodec_alloc_context();
4027
    avformat_opts = av_alloc_format_context();
4028

    
4029
    if (argc <= 1)
4030
        show_help();
4031
    else
4032
        show_banner();
4033

    
4034
    /* parse options */
4035
    parse_options(argc, argv, options);
4036

    
4037
    /* file converter / grab */
4038
    if (nb_output_files <= 0) {
4039
        fprintf(stderr, "Must supply at least one output file\n");
4040
        exit(1);
4041
    }
4042

    
4043
    if (nb_input_files == 0) {
4044
        input_sync = 1;
4045
        prepare_grab();
4046
    }
4047

    
4048
    ti = getutime();
4049
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
4050
              stream_maps, nb_stream_maps);
4051
    ti = getutime() - ti;
4052
    if (do_benchmark) {
4053
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4054
    }
4055

    
4056
    /* close files */
4057
    for(i=0;i<nb_output_files;i++) {
4058
        /* maybe av_close_output_file ??? */
4059
        AVFormatContext *s = output_files[i];
4060
        int j;
4061
        if (!(s->oformat->flags & AVFMT_NOFILE))
4062
            url_fclose(&s->pb);
4063
        for(j=0;j<s->nb_streams;j++)
4064
            av_free(s->streams[j]);
4065
        av_free(s);
4066
    }
4067
    for(i=0;i<nb_input_files;i++)
4068
        av_close_input_file(input_files[i]);
4069

    
4070
    av_free_static();
4071

    
4072
    if(intra_matrix)
4073
        av_free(intra_matrix);
4074
    if(inter_matrix)
4075
        av_free(inter_matrix);
4076

    
4077
#ifdef POWERPC_PERFORMANCE_REPORT
4078
    extern void powerpc_display_perf_report(void);
4079
    powerpc_display_perf_report();
4080
#endif /* POWERPC_PERFORMANCE_REPORT */
4081

    
4082
#ifndef __MINGW32__
4083
    if (received_sigterm) {
4084
        fprintf(stderr,
4085
            "Received signal %d: terminating.\n",
4086
            (int) received_sigterm);
4087
        exit (255);
4088
    }
4089
#endif
4090
    exit(0); /* not all OS-es handle main() return value */
4091
    return 0;
4092
}