Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 7c1d662a

History | View | Annotate | Download (140 KB)

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

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

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

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

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

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

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

    
69
extern const OptionDef options[];
70

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

    
75
#define MAX_FILES 20
76

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

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

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

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

    
90
static AVInputFormat *file_iformat;
91
static AVOutputFormat *file_oformat;
92
static AVImageFormat *image_format;
93
static int frame_width  = 0;
94
static int frame_height = 0;
95
static float frame_aspect_ratio = 0;
96
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
97
static int frame_padtop  = 0;
98
static int frame_padbottom = 0;
99
static int frame_padleft  = 0;
100
static int frame_padright = 0;
101
static int padcolor[3] = {16,128,128}; /* default to black */
102
static int frame_topBand  = 0;
103
static int frame_bottomBand = 0;
104
static int frame_leftBand  = 0;
105
static int frame_rightBand = 0;
106
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
107
static int frame_rate = 25;
108
static int frame_rate_base = 1;
109
static float video_qscale = 0;
110
static int video_lmin = 2*FF_QP2LAMBDA;
111
static int video_lmax = 31*FF_QP2LAMBDA;
112
static int video_mb_lmin = 2*FF_QP2LAMBDA;
113
static int video_mb_lmax = 31*FF_QP2LAMBDA;
114
static int video_qdiff = 3;
115
static uint16_t *intra_matrix = NULL;
116
static uint16_t *inter_matrix = NULL;
117
#if 0 //experimental, (can be removed)
118
static float video_rc_qsquish=1.0;
119
static float video_rc_qmod_amp=0;
120
static int video_rc_qmod_freq=0;
121
#endif
122
static char *video_rc_override_string=NULL;
123
static char *video_rc_eq="tex^qComp";
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 me_threshold = 0;
136
static int intra_dc_precision = 8;
137
static int me_penalty_compensation= 256;
138
static int frame_skip_factor= 0;
139
static int frame_skip_exp= 0;
140
static int loop_input = 0;
141
static int loop_output = AVFMT_NOOUTPUTLOOP;
142
static int qp_hist = 0;
143

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

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

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

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

    
187
static int rate_emu = 0;
188

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

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

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

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

    
223
static int sws_flags = SWS_BICUBIC;
224

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

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

    
234
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
235

    
236
struct AVInputStream;
237

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

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

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

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

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

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

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

    
298
#ifndef __MINGW32__
299

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

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

    
308
static volatile sig_atomic_t received_sigterm = 0;
309

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

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

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

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

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

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

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

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

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

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

    
377
#else
378

    
379
static volatile int received_sigterm = 0;
380

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

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

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

    
395
#endif
396

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

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

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

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

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

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

    
442
        bsfc= bsfc->next;
443
    }
444

    
445
    av_interleaved_write_frame(s, pkt);
446
}
447

    
448
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
449

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

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

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

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

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

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

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

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

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

    
534
        frame_bytes = enc->frame_size * 2 * enc->channels;
535

    
536
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
537
            AVPacket pkt;
538
            av_init_packet(&pkt);
539

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

    
551
            ost->sync_opts += enc->frame_size;
552
        }
553
    } else {
554
        AVPacket pkt;
555
        av_init_packet(&pkt);
556

    
557
        ost->sync_opts += size_out / (2 * enc->channels);
558

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

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

    
604
    dec = ist->st->codec;
605

    
606
    /* deinterlace : must be done before any resize */
607
    if (do_deinterlace || using_vhook) {
608
        int size;
609

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

    
616
        picture2 = &picture_tmp;
617
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
618

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

    
634
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
635

    
636
    if (picture != picture2)
637
        *picture = *picture2;
638
    *bufp = buf;
639
}
640

    
641
/* we begin to correct av delay at this threshold */
642
#define AV_DELAY_MAX 0.100
643

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

    
656
    if (pts == AV_NOPTS_VALUE) {
657
        fprintf(stderr, "Subtitle packets must have a pts\n");
658
        return;
659
    }
660

    
661
    enc = ost->st->codec;
662

    
663
    if (!subtitle_out) {
664
        subtitle_out = av_malloc(subtitle_out_max_size);
665
    }
666

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

    
675
    for(i = 0; i < nb; i++) {
676
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
677
                                                    subtitle_out_max_size, sub);
678

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

    
696
static int bit_buffer_size= 1024*256;
697
static uint8_t *bit_buffer= NULL;
698

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

    
711
    avcodec_get_frame_defaults(&picture_crop_temp);
712
    avcodec_get_frame_defaults(&picture_pad_temp);
713

    
714
    enc = ost->st->codec;
715
    dec = ist->st->codec;
716

    
717
    /* by default, we output a single frame */
718
    nb_frames = 1;
719

    
720
    *frame_size = 0;
721

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

    
743
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
744
    if (nb_frames <= 0)
745
        return;
746

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

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

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

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

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

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

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

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

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

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

    
865
static double psnr(double d){
866
    if(d==0) return INFINITY;
867
    return -10.0*log(d)/log(10.0);
868
}
869

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

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

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

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

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

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

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

    
944

    
945
    oc = output_files[0];
946

    
947
    total_size = url_ftell(&oc->pb);
948

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

    
1005
    if (verbose || is_last_report) {
1006
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1007

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

    
1012
        if (verbose > 1)
1013
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1014
                  nb_frames_dup, nb_frames_drop);
1015

    
1016
        if (verbose >= 0)
1017
            fprintf(stderr, "%s    \r", buf);
1018

    
1019
        fflush(stderr);
1020
    }
1021

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

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

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

    
1060
    if (pkt == NULL) {
1061
        /* EOF handling */
1062
        ptr = NULL;
1063
        len = 0;
1064
        goto handle_eof;
1065
    }
1066

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

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

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

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

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

    
1180
                ist->frame++;
1181
            }
1182

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

    
1202
                    ost = ost_table[i];
1203
                    if (ost->source_index == ist_index) {
1204
                        os = output_files[ost->file_index];
1205

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

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

    
1238
                            /* no reencoding needed : output the packet directly */
1239
                            /* force the input stream PTS */
1240

    
1241
                            avcodec_get_frame_defaults(&avframe);
1242
                            ost->st->codec->coded_frame= &avframe;
1243
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1244

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

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

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

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

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

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

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

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

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

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

    
1360
    return 0;
1361
 fail_decode:
1362
    return -1;
1363
}
1364

    
1365

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

    
1384
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1385
    if (!file_table)
1386
        goto fail;
1387

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

    
1398
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1399
    if (!ist_table)
1400
        goto fail;
1401

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

    
1419
            if (ist->st->codec->rate_emu) {
1420
                ist->start = av_gettime();
1421
                ist->frame = 0;
1422
            }
1423
        }
1424
    }
1425

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1702
    if (!bit_buffer)
1703
        bit_buffer = av_malloc(bit_buffer_size);
1704
    if (!bit_buffer)
1705
        goto fail;
1706

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

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

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

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

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

    
1785
    /* compute buffer size max (should use a complete heuristic) */
1786
    for(i=0;i<nb_input_files;i++) {
1787
        file_table[i].buffer_size_max = 2048;
1788
    }
1789

    
1790
    /* set meta data information from input file if required */
1791
    for (i=0;i<nb_meta_data_maps;i++) {
1792
        AVFormatContext *out_file;
1793
        AVFormatContext *in_file;
1794

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

    
1808
        out_file = output_files[out_file_index];
1809
        in_file = input_files[in_file_index];
1810

    
1811
        strcpy(out_file->title, in_file->title);
1812
        strcpy(out_file->author, in_file->author);
1813
        strcpy(out_file->copyright, in_file->copyright);
1814
        strcpy(out_file->comment, in_file->comment);
1815
        strcpy(out_file->album, in_file->album);
1816
        out_file->year = in_file->year;
1817
        out_file->track = in_file->track;
1818
        strcpy(out_file->genre, in_file->genre);
1819
    }
1820

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

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

    
1839
    stream_no_data = 0;
1840
    key = -1;
1841

    
1842
    for(; received_sigterm == 0;) {
1843
        int file_index, ist_index;
1844
        AVPacket pkt;
1845
        double ipts_min;
1846
        double opts_min;
1847

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

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

    
1894
        /* finish if recording time exhausted */
1895
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1896
            break;
1897

    
1898
        /* finish if limit size exhausted */
1899
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1900
            break;
1901

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

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

    
1926
//        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);
1927
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1928
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1929
            if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1930
                input_files_ts_offset[ist->file_index]-= delta;
1931
                if (verbose > 2)
1932
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1933
                for(i=0; i<file_table[file_index].nb_streams; i++){
1934
                    int index= file_table[file_index].ist_index + i;
1935
                    ist_table[index]->next_pts += delta;
1936
                    ist_table[index]->is_start=1;
1937
                }
1938
            }
1939
        }
1940

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

    
1944
            if (verbose >= 0)
1945
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1946
                        ist->file_index, ist->index);
1947

    
1948
            av_free_packet(&pkt);
1949
            goto redo;
1950
        }
1951

    
1952
    discard_packet:
1953
        av_free_packet(&pkt);
1954

    
1955
        /* dump report by using the output first video and audio streams */
1956
        print_report(output_files, ost_table, nb_ostreams, 0);
1957
    }
1958

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

    
1967
    term_exit();
1968

    
1969
    /* write the trailer if needed and close file */
1970
    for(i=0;i<nb_output_files;i++) {
1971
        os = output_files[i];
1972
        av_write_trailer(os);
1973
    }
1974

    
1975
    /* dump report by using the first video and audio streams */
1976
    print_report(output_files, ost_table, nb_ostreams, 1);
1977

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

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

    
1995
    /* finished ! */
1996

    
1997
    ret = 0;
1998
 fail1:
1999
    av_freep(&bit_buffer);
2000
    av_free(file_table);
2001

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

    
2035
#if 0
2036
int file_read(const char *filename)
2037
{
2038
    URLContext *h;
2039
    unsigned char buffer[1024];
2040
    int len, i;
2041

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

    
2057
static void opt_image_format(const char *arg)
2058
{
2059
    AVImageFormat *f;
2060

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

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

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

    
2089
static void opt_video_rc_eq(char *arg)
2090
{
2091
    video_rc_eq = arg;
2092
}
2093

    
2094
static void opt_video_rc_override_string(char *arg)
2095
{
2096
    video_rc_override_string = arg;
2097
}
2098

    
2099
static void opt_me_threshold(const char *arg)
2100
{
2101
    me_threshold = atoi(arg);
2102
}
2103

    
2104
static void opt_verbose(const char *arg)
2105
{
2106
    verbose = atoi(arg);
2107
    av_log_set_level(atoi(arg));
2108
}
2109

    
2110
static void opt_frame_rate(const char *arg)
2111
{
2112
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2113
        fprintf(stderr, "Incorrect frame rate\n");
2114
        exit(1);
2115
    }
2116
}
2117

    
2118
static void opt_frame_crop_top(const char *arg)
2119
{
2120
    frame_topBand = atoi(arg);
2121
    if (frame_topBand < 0) {
2122
        fprintf(stderr, "Incorrect top crop size\n");
2123
        exit(1);
2124
    }
2125
    if ((frame_topBand % 2) != 0) {
2126
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2127
        exit(1);
2128
    }
2129
    if ((frame_topBand) >= frame_height){
2130
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2131
        exit(1);
2132
    }
2133
    frame_height -= frame_topBand;
2134
}
2135

    
2136
static void opt_frame_crop_bottom(const char *arg)
2137
{
2138
    frame_bottomBand = atoi(arg);
2139
    if (frame_bottomBand < 0) {
2140
        fprintf(stderr, "Incorrect bottom crop size\n");
2141
        exit(1);
2142
    }
2143
    if ((frame_bottomBand % 2) != 0) {
2144
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2145
        exit(1);
2146
    }
2147
    if ((frame_bottomBand) >= frame_height){
2148
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2149
        exit(1);
2150
    }
2151
    frame_height -= frame_bottomBand;
2152
}
2153

    
2154
static void opt_frame_crop_left(const char *arg)
2155
{
2156
    frame_leftBand = atoi(arg);
2157
    if (frame_leftBand < 0) {
2158
        fprintf(stderr, "Incorrect left crop size\n");
2159
        exit(1);
2160
    }
2161
    if ((frame_leftBand % 2) != 0) {
2162
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2163
        exit(1);
2164
    }
2165
    if ((frame_leftBand) >= frame_width){
2166
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2167
        exit(1);
2168
    }
2169
    frame_width -= frame_leftBand;
2170
}
2171

    
2172
static void opt_frame_crop_right(const char *arg)
2173
{
2174
    frame_rightBand = atoi(arg);
2175
    if (frame_rightBand < 0) {
2176
        fprintf(stderr, "Incorrect right crop size\n");
2177
        exit(1);
2178
    }
2179
    if ((frame_rightBand % 2) != 0) {
2180
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2181
        exit(1);
2182
    }
2183
    if ((frame_rightBand) >= frame_width){
2184
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2185
        exit(1);
2186
    }
2187
    frame_width -= frame_rightBand;
2188
}
2189

    
2190
static void opt_frame_size(const char *arg)
2191
{
2192
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2193
        fprintf(stderr, "Incorrect frame size\n");
2194
        exit(1);
2195
    }
2196
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2197
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2198
        exit(1);
2199
    }
2200
}
2201

    
2202

    
2203
#define SCALEBITS 10
2204
#define ONE_HALF  (1 << (SCALEBITS - 1))
2205
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2206

    
2207
#define RGB_TO_Y(r, g, b) \
2208
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2209
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2210

    
2211
#define RGB_TO_U(r1, g1, b1, shift)\
2212
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2213
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2214

    
2215
#define RGB_TO_V(r1, g1, b1, shift)\
2216
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2217
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2218

    
2219
static void opt_pad_color(const char *arg) {
2220
    /* Input is expected to be six hex digits similar to
2221
       how colors are expressed in html tags (but without the #) */
2222
    int rgb = strtol(arg, NULL, 16);
2223
    int r,g,b;
2224

    
2225
    r = (rgb >> 16);
2226
    g = ((rgb >> 8) & 255);
2227
    b = (rgb & 255);
2228

    
2229
    padcolor[0] = RGB_TO_Y(r,g,b);
2230
    padcolor[1] = RGB_TO_U(r,g,b,0);
2231
    padcolor[2] = RGB_TO_V(r,g,b,0);
2232
}
2233

    
2234
static void opt_frame_pad_top(const char *arg)
2235
{
2236
    frame_padtop = atoi(arg);
2237
    if (frame_padtop < 0) {
2238
        fprintf(stderr, "Incorrect top pad size\n");
2239
        exit(1);
2240
    }
2241
    if ((frame_padtop % 2) != 0) {
2242
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2243
        exit(1);
2244
    }
2245
}
2246

    
2247
static void opt_frame_pad_bottom(const char *arg)
2248
{
2249
    frame_padbottom = atoi(arg);
2250
    if (frame_padbottom < 0) {
2251
        fprintf(stderr, "Incorrect bottom pad size\n");
2252
        exit(1);
2253
    }
2254
    if ((frame_padbottom % 2) != 0) {
2255
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2256
        exit(1);
2257
    }
2258
}
2259

    
2260

    
2261
static void opt_frame_pad_left(const char *arg)
2262
{
2263
    frame_padleft = atoi(arg);
2264
    if (frame_padleft < 0) {
2265
        fprintf(stderr, "Incorrect left pad size\n");
2266
        exit(1);
2267
    }
2268
    if ((frame_padleft % 2) != 0) {
2269
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2270
        exit(1);
2271
    }
2272
}
2273

    
2274

    
2275
static void opt_frame_pad_right(const char *arg)
2276
{
2277
    frame_padright = atoi(arg);
2278
    if (frame_padright < 0) {
2279
        fprintf(stderr, "Incorrect right pad size\n");
2280
        exit(1);
2281
    }
2282
    if ((frame_padright % 2) != 0) {
2283
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2284
        exit(1);
2285
    }
2286
}
2287

    
2288

    
2289
static void opt_frame_pix_fmt(const char *arg)
2290
{
2291
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2292
}
2293

    
2294
static void opt_frame_aspect_ratio(const char *arg)
2295
{
2296
    int x = 0, y = 0;
2297
    double ar = 0;
2298
    const char *p;
2299

    
2300
    p = strchr(arg, ':');
2301
    if (p) {
2302
        x = strtol(arg, (char **)&arg, 10);
2303
        if (arg == p)
2304
            y = strtol(arg+1, (char **)&arg, 10);
2305
        if (x > 0 && y > 0)
2306
            ar = (double)x / (double)y;
2307
    } else
2308
        ar = strtod(arg, (char **)&arg);
2309

    
2310
    if (!ar) {
2311
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2312
        exit(1);
2313
    }
2314
    frame_aspect_ratio = ar;
2315
}
2316

    
2317
static void opt_qscale(const char *arg)
2318
{
2319
    video_qscale = atof(arg);
2320
    if (video_qscale <= 0 ||
2321
        video_qscale > 255) {
2322
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2323
        exit(1);
2324
    }
2325
}
2326

    
2327
static void opt_lmax(const char *arg)
2328
{
2329
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2330
}
2331

    
2332
static void opt_lmin(const char *arg)
2333
{
2334
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2335
}
2336

    
2337
static void opt_mb_lmin(const char *arg)
2338
{
2339
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2340
    if (video_mb_lmin < 1 ||
2341
        video_mb_lmin > FF_LAMBDA_MAX) {
2342
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2343
        exit(1);
2344
    }
2345
}
2346

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

    
2357
static void opt_qdiff(const char *arg)
2358
{
2359
    video_qdiff = atoi(arg);
2360
    if (video_qdiff < 0 ||
2361
        video_qdiff > 31) {
2362
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2363
        exit(1);
2364
    }
2365
}
2366

    
2367
static void opt_packet_size(const char *arg)
2368
{
2369
    packet_size= atoi(arg);
2370
}
2371

    
2372
static void opt_error_rate(const char *arg)
2373
{
2374
    error_rate= atoi(arg);
2375
}
2376

    
2377
static void opt_strict(const char *arg)
2378
{
2379
    strict= atoi(arg);
2380
}
2381

    
2382
static void opt_top_field_first(const char *arg)
2383
{
2384
    top_field_first= atoi(arg);
2385
}
2386

    
2387
static void opt_thread_count(const char *arg)
2388
{
2389
    thread_count= atoi(arg);
2390
#if !defined(HAVE_THREADS)
2391
    if (verbose >= 0)
2392
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2393
#endif
2394
}
2395

    
2396
static void opt_audio_bitrate(const char *arg)
2397
{
2398
    audio_bit_rate = atoi(arg) * 1000;
2399
}
2400

    
2401
static void opt_audio_rate(const char *arg)
2402
{
2403
    audio_sample_rate = atoi(arg);
2404
}
2405

    
2406
static void opt_audio_channels(const char *arg)
2407
{
2408
    audio_channels = atoi(arg);
2409
}
2410

    
2411
static void opt_video_device(const char *arg)
2412
{
2413
    video_device = av_strdup(arg);
2414
}
2415

    
2416
static void opt_grab_device(const char *arg)
2417
{
2418
    grab_device = av_strdup(arg);
2419
}
2420

    
2421
static void opt_video_channel(const char *arg)
2422
{
2423
    video_channel = strtol(arg, NULL, 0);
2424
}
2425

    
2426
static void opt_video_standard(const char *arg)
2427
{
2428
    video_standard = av_strdup(arg);
2429
}
2430

    
2431
static void opt_audio_device(const char *arg)
2432
{
2433
    audio_device = av_strdup(arg);
2434
}
2435

    
2436
static void opt_codec(int *pstream_copy, int *pcodec_id,
2437
                      int codec_type, const char *arg)
2438
{
2439
    AVCodec *p;
2440

    
2441
    if (!strcmp(arg, "copy")) {
2442
        *pstream_copy = 1;
2443
    } else {
2444
        p = first_avcodec;
2445
        while (p) {
2446
            if (!strcmp(p->name, arg) && p->type == codec_type)
2447
                break;
2448
            p = p->next;
2449
        }
2450
        if (p == NULL) {
2451
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2452
            exit(1);
2453
        } else {
2454
            *pcodec_id = p->id;
2455
        }
2456
    }
2457
}
2458

    
2459
static void opt_audio_codec(const char *arg)
2460
{
2461
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2462
}
2463

    
2464
static void opt_audio_tag(const char *arg)
2465
{
2466
    char *tail;
2467
    audio_codec_tag= strtol(arg, &tail, 0);
2468

    
2469
    if(!tail || *tail)
2470
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2471
}
2472

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

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

    
2482
static void add_frame_hooker(const char *arg)
2483
{
2484
    int argc = 0;
2485
    char *argv[64];
2486
    int i;
2487
    char *args = av_strdup(arg);
2488

    
2489
    using_vhook = 1;
2490

    
2491
    argv[0] = strtok(args, " ");
2492
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2493
    }
2494

    
2495
    i = frame_hook_add(argc, argv);
2496

    
2497
    if (i != 0) {
2498
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2499
        exit(1);
2500
    }
2501
}
2502

    
2503
const char *motion_str[] = {
2504
    "zero",
2505
    "full",
2506
    "log",
2507
    "phods",
2508
    "epzs",
2509
    "x1",
2510
    "hex",
2511
    "umh",
2512
    "iter",
2513
    NULL,
2514
};
2515

    
2516
static void opt_motion_estimation(const char *arg)
2517
{
2518
    const char **p;
2519
    p = motion_str;
2520
    for(;;) {
2521
        if (!*p) {
2522
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2523
            exit(1);
2524
        }
2525
        if (!strcmp(*p, arg))
2526
            break;
2527
        p++;
2528
    }
2529
    me_method = (p - motion_str) + 1;
2530
}
2531

    
2532
static void opt_video_codec(const char *arg)
2533
{
2534
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2535
}
2536

    
2537
static void opt_subtitle_codec(const char *arg)
2538
{
2539
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2540
}
2541

    
2542
static void opt_map(const char *arg)
2543
{
2544
    AVStreamMap *m;
2545
    const char *p;
2546

    
2547
    p = arg;
2548
    m = &stream_maps[nb_stream_maps++];
2549

    
2550
    m->file_index = strtol(arg, (char **)&p, 0);
2551
    if (*p)
2552
        p++;
2553

    
2554
    m->stream_index = strtol(p, (char **)&p, 0);
2555
    if (*p) {
2556
        p++;
2557
        m->sync_file_index = strtol(p, (char **)&p, 0);
2558
        if (*p)
2559
            p++;
2560
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2561
    } else {
2562
        m->sync_file_index = m->file_index;
2563
        m->sync_stream_index = m->stream_index;
2564
    }
2565
}
2566

    
2567
static void opt_map_meta_data(const char *arg)
2568
{
2569
    AVMetaDataMap *m;
2570
    const char *p;
2571

    
2572
    p = arg;
2573
    m = &meta_data_maps[nb_meta_data_maps++];
2574

    
2575
    m->out_file = strtol(arg, (char **)&p, 0);
2576
    if (*p)
2577
        p++;
2578

    
2579
    m->in_file = strtol(p, (char **)&p, 0);
2580
}
2581

    
2582
static void opt_recording_time(const char *arg)
2583
{
2584
    recording_time = parse_date(arg, 1);
2585
}
2586

    
2587
static void opt_start_time(const char *arg)
2588
{
2589
    start_time = parse_date(arg, 1);
2590
}
2591

    
2592
static void opt_rec_timestamp(const char *arg)
2593
{
2594
    rec_timestamp = parse_date(arg, 0) / 1000000;
2595
}
2596

    
2597
static void opt_input_ts_offset(const char *arg)
2598
{
2599
    input_ts_offset = parse_date(arg, 1);
2600
}
2601

    
2602
static void opt_input_file(const char *filename)
2603
{
2604
    AVFormatContext *ic;
2605
    AVFormatParameters params, *ap = &params;
2606
    int err, i, ret, rfps, rfps_base;
2607
    int64_t timestamp;
2608

    
2609
    if (!strcmp(filename, "-"))
2610
        filename = "pipe:";
2611

    
2612
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2613
                   !strcmp( filename, "/dev/stdin" );
2614

    
2615
    /* get default parameters from command line */
2616
    ic = av_alloc_format_context();
2617

    
2618
    memset(ap, 0, sizeof(*ap));
2619
    ap->prealloced_context = 1;
2620
    ap->sample_rate = audio_sample_rate;
2621
    ap->channels = audio_channels;
2622
    ap->time_base.den = frame_rate;
2623
    ap->time_base.num = frame_rate_base;
2624
    ap->width = frame_width + frame_padleft + frame_padright;
2625
    ap->height = frame_height + frame_padtop + frame_padbottom;
2626
    ap->image_format = image_format;
2627
    ap->pix_fmt = frame_pix_fmt;
2628
    ap->device  = grab_device;
2629
    ap->channel = video_channel;
2630
    ap->standard = video_standard;
2631
    ap->video_codec_id = video_codec_id;
2632
    ap->audio_codec_id = audio_codec_id;
2633
    if(pgmyuv_compatibility_hack)
2634
        ap->video_codec_id= CODEC_ID_PGMYUV;
2635

    
2636
    for(i=0; i<opt_name_count; i++){
2637
        AVOption *opt;
2638
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2639
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2640
            av_set_double(ic, opt_names[i], d);
2641
    }
2642
    /* open the input file with generic libav function */
2643
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2644
    if (err < 0) {
2645
        print_error(filename, err);
2646
        exit(1);
2647
    }
2648

    
2649
    ic->loop_input = loop_input;
2650

    
2651
    /* If not enough info to get the stream parameters, we decode the
2652
       first frames to get it. (used in mpeg case for example) */
2653
    ret = av_find_stream_info(ic);
2654
    if (ret < 0 && verbose >= 0) {
2655
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2656
        exit(1);
2657
    }
2658

    
2659
    timestamp = start_time;
2660
    /* add the stream start time */
2661
    if (ic->start_time != AV_NOPTS_VALUE)
2662
        timestamp += ic->start_time;
2663

    
2664
    /* if seeking requested, we execute it */
2665
    if (start_time != 0) {
2666
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2667
        if (ret < 0) {
2668
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2669
                    filename, (double)timestamp / AV_TIME_BASE);
2670
        }
2671
        /* reset seek info */
2672
        start_time = 0;
2673
    }
2674

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

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

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

    
2721
                    (float)rfps / rfps_base, rfps, rfps_base);
2722
            }
2723
            /* update the current frame rate to match the stream frame rate */
2724
            frame_rate      = rfps;
2725
            frame_rate_base = rfps_base;
2726

    
2727
            enc->rate_emu = rate_emu;
2728
            if(video_disable)
2729
                ic->streams[i]->discard= AVDISCARD_ALL;
2730
            else if(video_discard)
2731
                ic->streams[i]->discard= video_discard;
2732
            break;
2733
        case CODEC_TYPE_DATA:
2734
            break;
2735
        case CODEC_TYPE_SUBTITLE:
2736
            break;
2737
        case CODEC_TYPE_UNKNOWN:
2738
            break;
2739
        default:
2740
            av_abort();
2741
        }
2742
    }
2743

    
2744
    input_files[nb_input_files] = ic;
2745
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2746
    /* dump the file content */
2747
    if (verbose >= 0)
2748
        dump_format(ic, nb_input_files, filename, 0);
2749

    
2750
    nb_input_files++;
2751
    file_iformat = NULL;
2752
    file_oformat = NULL;
2753
    image_format = NULL;
2754

    
2755
    grab_device = NULL;
2756
    video_channel = 0;
2757

    
2758
    rate_emu = 0;
2759
}
2760

    
2761
static void opt_grab(const char *arg)
2762
{
2763
    file_iformat = av_find_input_format(arg);
2764
    opt_input_file("");
2765
}
2766

    
2767
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2768
{
2769
    int has_video, has_audio, i, j;
2770
    AVFormatContext *ic;
2771

    
2772
    has_video = 0;
2773
    has_audio = 0;
2774
    for(j=0;j<nb_input_files;j++) {
2775
        ic = input_files[j];
2776
        for(i=0;i<ic->nb_streams;i++) {
2777
            AVCodecContext *enc = ic->streams[i]->codec;
2778
            switch(enc->codec_type) {
2779
            case CODEC_TYPE_AUDIO:
2780
                has_audio = 1;
2781
                break;
2782
            case CODEC_TYPE_VIDEO:
2783
                has_video = 1;
2784
                break;
2785
            case CODEC_TYPE_DATA:
2786
            case CODEC_TYPE_UNKNOWN:
2787
            case CODEC_TYPE_SUBTITLE:
2788
                break;
2789
            default:
2790
                av_abort();
2791
            }
2792
        }
2793
    }
2794
    *has_video_ptr = has_video;
2795
    *has_audio_ptr = has_audio;
2796
}
2797

    
2798
static void new_video_stream(AVFormatContext *oc)
2799
{
2800
    AVStream *st;
2801
    AVCodecContext *video_enc;
2802
    int codec_id;
2803

    
2804
    st = av_new_stream(oc, oc->nb_streams);
2805
    if (!st) {
2806
        fprintf(stderr, "Could not alloc stream\n");
2807
        exit(1);
2808
    }
2809
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2810
    video_bitstream_filters= NULL;
2811

    
2812
#if defined(HAVE_THREADS)
2813
    if(thread_count>1)
2814
        avcodec_thread_init(st->codec, thread_count);
2815
#endif
2816

    
2817
    video_enc = st->codec;
2818

    
2819
    if(video_codec_tag)
2820
        video_enc->codec_tag= video_codec_tag;
2821

    
2822
    if(   (video_global_header&1)
2823
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2824
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2825
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2826
    }
2827
    if(video_global_header&2){
2828
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2829
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2830
    }
2831

    
2832
    if (video_stream_copy) {
2833
        st->stream_copy = 1;
2834
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2835
    } else {
2836
        char *p;
2837
        int i;
2838
        AVCodec *codec;
2839

    
2840
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2841
        if (video_codec_id != CODEC_ID_NONE)
2842
            codec_id = video_codec_id;
2843

    
2844
        video_enc->codec_id = codec_id;
2845
        codec = avcodec_find_encoder(codec_id);
2846

    
2847
        for(i=0; i<opt_name_count; i++){
2848
             AVOption *opt;
2849
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2850
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2851
                 av_set_double(video_enc, opt_names[i], d);
2852
        }
2853

    
2854
        video_enc->time_base.den = frame_rate;
2855
        video_enc->time_base.num = frame_rate_base;
2856
        if(codec && codec->supported_framerates){
2857
            const AVRational *p= codec->supported_framerates;
2858
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2859
            const AVRational *best=NULL;
2860
            AVRational best_error= (AVRational){INT_MAX, 1};
2861
            for(; p->den!=0; p++){
2862
                AVRational error= av_sub_q(req, *p);
2863
                if(error.num <0) error.num *= -1;
2864
                if(av_cmp_q(error, best_error) < 0){
2865
                    best_error= error;
2866
                    best= p;
2867
                }
2868
            }
2869
            video_enc->time_base.den= best->num;
2870
            video_enc->time_base.num= best->den;
2871
        }
2872

    
2873
        video_enc->width = frame_width + frame_padright + frame_padleft;
2874
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2875
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2876
        video_enc->pix_fmt = frame_pix_fmt;
2877

    
2878
        if(codec && codec->pix_fmts){
2879
            const enum PixelFormat *p= codec->pix_fmts;
2880
            for(; *p!=-1; p++){
2881
                if(*p == video_enc->pix_fmt)
2882
                    break;
2883
            }
2884
            if(*p == -1)
2885
                video_enc->pix_fmt = codec->pix_fmts[0];
2886
        }
2887

    
2888
        if (intra_only)
2889
            video_enc->gop_size = 0;
2890
        if (video_qscale || same_quality) {
2891
            video_enc->flags |= CODEC_FLAG_QSCALE;
2892
            video_enc->global_quality=
2893
                st->quality = FF_QP2LAMBDA * video_qscale;
2894
        }
2895

    
2896
        if(intra_matrix)
2897
            video_enc->intra_matrix = intra_matrix;
2898
        if(inter_matrix)
2899
            video_enc->inter_matrix = inter_matrix;
2900

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

    
2942
        if(packet_size){
2943
            video_enc->rtp_mode= 1;
2944
            video_enc->rtp_payload_size= packet_size;
2945
        }
2946

    
2947
        if (do_psnr)
2948
            video_enc->flags|= CODEC_FLAG_PSNR;
2949

    
2950
        video_enc->me_method = me_method;
2951

    
2952
        /* two pass mode */
2953
        if (do_pass) {
2954
            if (do_pass == 1) {
2955
                video_enc->flags |= CODEC_FLAG_PASS1;
2956
            } else {
2957
                video_enc->flags |= CODEC_FLAG_PASS2;
2958
            }
2959
        }
2960
    }
2961

    
2962
    /* reset some key parameters */
2963
    video_disable = 0;
2964
    video_codec_id = CODEC_ID_NONE;
2965
    video_stream_copy = 0;
2966
}
2967

    
2968
static void new_audio_stream(AVFormatContext *oc)
2969
{
2970
    AVStream *st;
2971
    AVCodecContext *audio_enc;
2972
    int codec_id, i;
2973

    
2974
    st = av_new_stream(oc, oc->nb_streams);
2975
    if (!st) {
2976
        fprintf(stderr, "Could not alloc stream\n");
2977
        exit(1);
2978
    }
2979

    
2980
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2981
    audio_bitstream_filters= NULL;
2982

    
2983
#if defined(HAVE_THREADS)
2984
    if(thread_count>1)
2985
        avcodec_thread_init(st->codec, thread_count);
2986
#endif
2987

    
2988
    audio_enc = st->codec;
2989
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2990

    
2991
    if(audio_codec_tag)
2992
        audio_enc->codec_tag= audio_codec_tag;
2993

    
2994
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2995
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2996
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2997
    }
2998
    if (audio_stream_copy) {
2999
        st->stream_copy = 1;
3000
        audio_enc->channels = audio_channels;
3001
    } else {
3002
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3003

    
3004
        for(i=0; i<opt_name_count; i++){
3005
            AVOption *opt;
3006
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
3007
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3008
                av_set_double(audio_enc, opt_names[i], d);
3009
        }
3010

    
3011
        if (audio_codec_id != CODEC_ID_NONE)
3012
            codec_id = audio_codec_id;
3013
        audio_enc->codec_id = codec_id;
3014

    
3015
        audio_enc->bit_rate = audio_bit_rate;
3016
        if (audio_qscale > QSCALE_NONE) {
3017
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3018
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3019
        }
3020
        audio_enc->strict_std_compliance = strict;
3021
        audio_enc->thread_count = thread_count;
3022
        /* For audio codecs other than AC3 or DTS we limit */
3023
        /* the number of coded channels to stereo   */
3024
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3025
            && codec_id != CODEC_ID_DTS) {
3026
            audio_enc->channels = 2;
3027
        } else
3028
            audio_enc->channels = audio_channels;
3029
    }
3030
    audio_enc->sample_rate = audio_sample_rate;
3031
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3032
    if (audio_language) {
3033
        pstrcpy(st->language, sizeof(st->language), audio_language);
3034
        av_free(audio_language);
3035
        audio_language = NULL;
3036
    }
3037

    
3038
    /* reset some key parameters */
3039
    audio_disable = 0;
3040
    audio_codec_id = CODEC_ID_NONE;
3041
    audio_stream_copy = 0;
3042
}
3043

    
3044
static void opt_new_subtitle_stream(void)
3045
{
3046
    AVFormatContext *oc;
3047
    AVStream *st;
3048
    AVCodecContext *subtitle_enc;
3049
    int i;
3050

    
3051
    if (nb_output_files <= 0) {
3052
        fprintf(stderr, "At least one output file must be specified\n");
3053
        exit(1);
3054
    }
3055
    oc = output_files[nb_output_files - 1];
3056

    
3057
    st = av_new_stream(oc, oc->nb_streams);
3058
    if (!st) {
3059
        fprintf(stderr, "Could not alloc stream\n");
3060
        exit(1);
3061
    }
3062

    
3063
    subtitle_enc = st->codec;
3064
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3065
    if (subtitle_stream_copy) {
3066
        st->stream_copy = 1;
3067
    } else {
3068
        for(i=0; i<opt_name_count; i++){
3069
             AVOption *opt;
3070
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3071
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3072
                 av_set_double(subtitle_enc, opt_names[i], d);
3073
        }
3074
        subtitle_enc->codec_id = subtitle_codec_id;
3075
    }
3076

    
3077
    if (subtitle_language) {
3078
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3079
        av_free(subtitle_language);
3080
        subtitle_language = NULL;
3081
    }
3082

    
3083
    subtitle_codec_id = CODEC_ID_NONE;
3084
    subtitle_stream_copy = 0;
3085
}
3086

    
3087
static void opt_new_audio_stream(void)
3088
{
3089
    AVFormatContext *oc;
3090
    if (nb_output_files <= 0) {
3091
        fprintf(stderr, "At least one output file must be specified\n");
3092
        exit(1);
3093
    }
3094
    oc = output_files[nb_output_files - 1];
3095
    new_audio_stream(oc);
3096
}
3097

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

    
3109
static void opt_output_file(const char *filename)
3110
{
3111
    AVFormatContext *oc;
3112
    int use_video, use_audio, input_has_video, input_has_audio, i;
3113
    AVFormatParameters params, *ap = &params;
3114

    
3115
    if (!strcmp(filename, "-"))
3116
        filename = "pipe:";
3117

    
3118
    oc = av_alloc_format_context();
3119

    
3120
    if (!file_oformat) {
3121
        file_oformat = guess_format(NULL, filename, NULL);
3122
        if (!file_oformat) {
3123
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3124
                    filename);
3125
            exit(1);
3126
        }
3127
    }
3128

    
3129
    oc->oformat = file_oformat;
3130
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3131

    
3132
    if (!strcmp(file_oformat->name, "ffm") &&
3133
        strstart(filename, "http:", NULL)) {
3134
        /* special case for files sent to ffserver: we get the stream
3135
           parameters from ffserver */
3136
        if (read_ffserver_streams(oc, filename) < 0) {
3137
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3138
            exit(1);
3139
        }
3140
    } else {
3141
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3142
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3143

    
3144
        /* disable if no corresponding type found and at least one
3145
           input file */
3146
        if (nb_input_files > 0) {
3147
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3148
            if (!input_has_video)
3149
                use_video = 0;
3150
            if (!input_has_audio)
3151
                use_audio = 0;
3152
        }
3153

    
3154
        /* manual disable */
3155
        if (audio_disable) {
3156
            use_audio = 0;
3157
        }
3158
        if (video_disable) {
3159
            use_video = 0;
3160
        }
3161

    
3162
        if (use_video) {
3163
            new_video_stream(oc);
3164
        }
3165

    
3166
        if (use_audio) {
3167
            new_audio_stream(oc);
3168
        }
3169

    
3170
        if (!oc->nb_streams) {
3171
            fprintf(stderr, "No audio or video streams available\n");
3172
            exit(1);
3173
        }
3174

    
3175
        oc->timestamp = rec_timestamp;
3176

    
3177
        if (str_title)
3178
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3179
        if (str_author)
3180
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3181
        if (str_copyright)
3182
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3183
        if (str_comment)
3184
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3185
        if (str_album)
3186
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3187
    }
3188

    
3189
    output_files[nb_output_files++] = oc;
3190

    
3191
    /* check filename in case of an image number is expected */
3192
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3193
        if (!av_filename_number_test(oc->filename)) {
3194
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3195
            exit(1);
3196
        }
3197
    }
3198

    
3199
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3200
        /* test if it already exists to avoid loosing precious files */
3201
        if (!file_overwrite &&
3202
            (strchr(filename, ':') == NULL ||
3203
             strstart(filename, "file:", NULL))) {
3204
            if (url_exist(filename)) {
3205
                int c;
3206

    
3207
                if ( !using_stdin ) {
3208
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3209
                    fflush(stderr);
3210
                    c = getchar();
3211
                    if (toupper(c) != 'Y') {
3212
                        fprintf(stderr, "Not overwriting - exiting\n");
3213
                        exit(1);
3214
                    }
3215
                                }
3216
                                else {
3217
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3218
                    exit(1);
3219
                                }
3220
            }
3221
        }
3222

    
3223
        /* open the file */
3224
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3225
            fprintf(stderr, "Could not open '%s'\n", filename);
3226
            exit(1);
3227
        }
3228
    }
3229

    
3230
    memset(ap, 0, sizeof(*ap));
3231
    ap->image_format = image_format;
3232
    if (av_set_parameters(oc, ap) < 0) {
3233
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3234
                oc->filename);
3235
        exit(1);
3236
    }
3237

    
3238
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3239
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3240
    oc->loop_output = loop_output;
3241

    
3242
    for(i=0; i<opt_name_count; i++){
3243
        AVOption *opt;
3244
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3245
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3246
            av_set_double(oc, opt_names[i], d);
3247
    }
3248

    
3249
    /* reset some options */
3250
    file_oformat = NULL;
3251
    file_iformat = NULL;
3252
    image_format = NULL;
3253
}
3254

    
3255
/* prepare dummy protocols for grab */
3256
static void prepare_grab(void)
3257
{
3258
    int has_video, has_audio, i, j;
3259
    AVFormatContext *oc;
3260
    AVFormatContext *ic;
3261
    AVFormatParameters vp1, *vp = &vp1;
3262
    AVFormatParameters ap1, *ap = &ap1;
3263

    
3264
    /* see if audio/video inputs are needed */
3265
    has_video = 0;
3266
    has_audio = 0;
3267
    memset(ap, 0, sizeof(*ap));
3268
    memset(vp, 0, sizeof(*vp));
3269
    vp->time_base.num= 1;
3270
    for(j=0;j<nb_output_files;j++) {
3271
        oc = output_files[j];
3272
        for(i=0;i<oc->nb_streams;i++) {
3273
            AVCodecContext *enc = oc->streams[i]->codec;
3274
            switch(enc->codec_type) {
3275
            case CODEC_TYPE_AUDIO:
3276
                if (enc->sample_rate > ap->sample_rate)
3277
                    ap->sample_rate = enc->sample_rate;
3278
                if (enc->channels > ap->channels)
3279
                    ap->channels = enc->channels;
3280
                has_audio = 1;
3281
                break;
3282
            case CODEC_TYPE_VIDEO:
3283
                if (enc->width > vp->width)
3284
                    vp->width = enc->width;
3285
                if (enc->height > vp->height)
3286
                    vp->height = enc->height;
3287

    
3288
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3289
                    vp->time_base = enc->time_base;
3290
                    vp->width += frame_leftBand + frame_rightBand;
3291
                    vp->width -= (frame_padleft + frame_padright);
3292
                    vp->height += frame_topBand + frame_bottomBand;
3293
                    vp->height -= (frame_padtop + frame_padbottom);
3294
                }
3295
                has_video = 1;
3296
                break;
3297
            default:
3298
                av_abort();
3299
            }
3300
        }
3301
    }
3302

    
3303
    if (has_video == 0 && has_audio == 0) {
3304
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3305
        exit(1);
3306
    }
3307

    
3308
    if (has_video) {
3309
        AVInputFormat *fmt1;
3310
        fmt1 = av_find_input_format(video_grab_format);
3311
        vp->device  = video_device;
3312
        vp->channel = video_channel;
3313
        vp->standard = video_standard;
3314
        vp->pix_fmt = frame_pix_fmt;
3315
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3316
            fprintf(stderr, "Could not find video grab device\n");
3317
            exit(1);
3318
        }
3319
        /* If not enough info to get the stream parameters, we decode the
3320
           first frames to get it. */
3321
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3322
            fprintf(stderr, "Could not find video grab parameters\n");
3323
            exit(1);
3324
        }
3325
        /* by now video grab has one stream */
3326
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3327
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3328
        input_files[nb_input_files] = ic;
3329

    
3330
        if (verbose >= 0)
3331
            dump_format(ic, nb_input_files, "", 0);
3332

    
3333
        nb_input_files++;
3334
    }
3335
    if (has_audio && audio_grab_format) {
3336
        AVInputFormat *fmt1;
3337
        fmt1 = av_find_input_format(audio_grab_format);
3338
        ap->device = audio_device;
3339
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3340
            fprintf(stderr, "Could not find audio grab device\n");
3341
            exit(1);
3342
        }
3343
        input_files[nb_input_files] = ic;
3344

    
3345
        if (verbose >= 0)
3346
            dump_format(ic, nb_input_files, "", 0);
3347

    
3348
        nb_input_files++;
3349
    }
3350
}
3351

    
3352
/* same option as mencoder */
3353
static void opt_pass(const char *pass_str)
3354
{
3355
    int pass;
3356
    pass = atoi(pass_str);
3357
    if (pass != 1 && pass != 2) {
3358
        fprintf(stderr, "pass number can be only 1 or 2\n");
3359
        exit(1);
3360
    }
3361
    do_pass = pass;
3362
}
3363

    
3364
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3365
static int64_t getutime(void)
3366
{
3367
  return av_gettime();
3368
}
3369
#else
3370
static int64_t getutime(void)
3371
{
3372
    struct rusage rusage;
3373

    
3374
    getrusage(RUSAGE_SELF, &rusage);
3375
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3376
}
3377
#endif
3378

    
3379
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3380
extern int ffm_nopts;
3381
#endif
3382

    
3383
static void show_formats(void)
3384
{
3385
    AVInputFormat *ifmt;
3386
    AVOutputFormat *ofmt;
3387
    AVImageFormat *image_fmt;
3388
    URLProtocol *up;
3389
    AVCodec *p, *p2;
3390
    const char **pp, *last_name;
3391

    
3392
    printf("File formats:\n");
3393
    last_name= "000";
3394
    for(;;){
3395
        int decode=0;
3396
        int encode=0;
3397
        const char *name=NULL;
3398
        const char *long_name=NULL;
3399

    
3400
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3401
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3402
                strcmp(ofmt->name, last_name)>0){
3403
                name= ofmt->name;
3404
                long_name= ofmt->long_name;
3405
                encode=1;
3406
            }
3407
        }
3408
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3409
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3410
                strcmp(ifmt->name, last_name)>0){
3411
                name= ifmt->name;
3412
                long_name= ifmt->long_name;
3413
                encode=0;
3414
            }
3415
            if(name && strcmp(ifmt->name, name)==0)
3416
                decode=1;
3417
        }
3418
        if(name==NULL)
3419
            break;
3420
        last_name= name;
3421

    
3422
        printf(
3423
            " %s%s %-15s %s\n",
3424
            decode ? "D":" ",
3425
            encode ? "E":" ",
3426
            name,
3427
            long_name ? long_name:" ");
3428
    }
3429
    printf("\n");
3430

    
3431
    printf("Image formats (filename extensions, if any, follow):\n");
3432
    for(image_fmt = first_image_format; image_fmt != NULL;
3433
        image_fmt = image_fmt->next) {
3434
        printf(
3435
            " %s%s %-6s %s\n",
3436
            image_fmt->img_read  ? "D":" ",
3437
            image_fmt->img_write ? "E":" ",
3438
            image_fmt->name,
3439
            image_fmt->extensions ? image_fmt->extensions:" ");
3440
    }
3441
    printf("\n");
3442

    
3443
    printf("Codecs:\n");
3444
    last_name= "000";
3445
    for(;;){
3446
        int decode=0;
3447
        int encode=0;
3448
        int cap=0;
3449
        const char *type_str;
3450

    
3451
        p2=NULL;
3452
        for(p = first_avcodec; p != NULL; p = p->next) {
3453
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3454
                strcmp(p->name, last_name)>0){
3455
                p2= p;
3456
                decode= encode= cap=0;
3457
            }
3458
            if(p2 && strcmp(p->name, p2->name)==0){
3459
                if(p->decode) decode=1;
3460
                if(p->encode) encode=1;
3461
                cap |= p->capabilities;
3462
            }
3463
        }
3464
        if(p2==NULL)
3465
            break;
3466
        last_name= p2->name;
3467

    
3468
        switch(p2->type) {
3469
        case CODEC_TYPE_VIDEO:
3470
            type_str = "V";
3471
            break;
3472
        case CODEC_TYPE_AUDIO:
3473
            type_str = "A";
3474
            break;
3475
        case CODEC_TYPE_SUBTITLE:
3476
            type_str = "S";
3477
            break;
3478
        default:
3479
            type_str = "?";
3480
            break;
3481
        }
3482
        printf(
3483
            " %s%s%s%s%s%s %s",
3484
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3485
            encode ? "E":" ",
3486
            type_str,
3487
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3488
            cap & CODEC_CAP_DR1 ? "D":" ",
3489
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3490
            p2->name);
3491
       /* if(p2->decoder && decode==0)
3492
            printf(" use %s for decoding", p2->decoder->name);*/
3493
        printf("\n");
3494
    }
3495
    printf("\n");
3496

    
3497
    printf("Supported file protocols:\n");
3498
    for(up = first_protocol; up != NULL; up = up->next)
3499
        printf(" %s:", up->name);
3500
    printf("\n");
3501

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

    
3525
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3526
{
3527
    int i;
3528
    const char *p = str;
3529
    for(i = 0;; i++) {
3530
        dest[i] = atoi(p);
3531
        if(i == 63)
3532
            break;
3533
        p = strchr(p, ',');
3534
        if(!p) {
3535
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3536
            exit(1);
3537
        }
3538
        p++;
3539
    }
3540
}
3541

    
3542
static void opt_inter_matrix(const char *arg)
3543
{
3544
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3545
    parse_matrix_coeffs(inter_matrix, arg);
3546
}
3547

    
3548
static void opt_intra_matrix(const char *arg)
3549
{
3550
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3551
    parse_matrix_coeffs(intra_matrix, arg);
3552
}
3553

    
3554
static void opt_target(const char *arg)
3555
{
3556
    int norm = -1;
3557
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3558

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

    
3603
    if(norm < 0) {
3604
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3605
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3606
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3607
        exit(1);
3608
    }
3609

    
3610
    if(!strcmp(arg, "vcd")) {
3611

    
3612
        opt_video_codec("mpeg1video");
3613
        opt_audio_codec("mp2");
3614
        opt_format("vcd");
3615

    
3616
        opt_frame_size(norm ? "352x240" : "352x288");
3617
        opt_frame_rate(frame_rates[norm]);
3618
        opt_default("gop", norm ? "18" : "15");
3619

    
3620
        opt_default("b", "1150000");
3621
        opt_default("maxrate", "1150000");
3622
        opt_default("minrate", "1150000");
3623
        opt_default("bufsize", "327680"); // 40*1024*8;
3624

    
3625
        audio_bit_rate = 224000;
3626
        audio_sample_rate = 44100;
3627

    
3628
        opt_default("packetsize", "2324");
3629
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3630

    
3631
        /* We have to offset the PTS, so that it is consistent with the SCR.
3632
           SCR starts at 36000, but the first two packs contain only padding
3633
           and the first pack from the other stream, respectively, may also have
3634
           been written before.
3635
           So the real data starts at SCR 36000+3*1200. */
3636
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3637
    } else if(!strcmp(arg, "svcd")) {
3638

    
3639
        opt_video_codec("mpeg2video");
3640
        opt_audio_codec("mp2");
3641
        opt_format("svcd");
3642

    
3643
        opt_frame_size(norm ? "480x480" : "480x576");
3644
        opt_frame_rate(frame_rates[norm]);
3645
        opt_default("gop", norm ? "18" : "15");
3646

    
3647
        opt_default("b", "2040000");
3648
        opt_default("maxrate", "2516000");
3649
        opt_default("minrate", "0"); //1145000;
3650
        opt_default("bufsize", "1835008"); //224*1024*8;
3651
        opt_default("flags", "+SCAN_OFFSET");
3652

    
3653

    
3654
        audio_bit_rate = 224000;
3655
        audio_sample_rate = 44100;
3656

    
3657
        opt_default("packetsize", "2324");
3658

    
3659
    } else if(!strcmp(arg, "dvd")) {
3660

    
3661
        opt_video_codec("mpeg2video");
3662
        opt_audio_codec("ac3");
3663
        opt_format("dvd");
3664

    
3665
        opt_frame_size(norm ? "720x480" : "720x576");
3666
        opt_frame_rate(frame_rates[norm]);
3667
        opt_default("gop", norm ? "18" : "15");
3668

    
3669
        opt_default("b", "6000000");
3670
        opt_default("maxrate", "9000000");
3671
        opt_default("minrate", "0"); //1500000;
3672
        opt_default("bufsize", "1835008"); //224*1024*8;
3673

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

    
3677
        audio_bit_rate = 448000;
3678
        audio_sample_rate = 48000;
3679

    
3680
    } else if(!strncmp(arg, "dv", 2)) {
3681

    
3682
        opt_format("dv");
3683

    
3684
        opt_frame_size(norm ? "720x480" : "720x576");
3685
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3686
                                             (norm ? "yuv411p" : "yuv420p"));
3687
        opt_frame_rate(frame_rates[norm]);
3688

    
3689
        audio_sample_rate = 48000;
3690
        audio_channels = 2;
3691

    
3692
    } else {
3693
        fprintf(stderr, "Unknown target: %s\n", arg);
3694
        exit(1);
3695
    }
3696
}
3697

    
3698
static void opt_video_bsf(const char *arg)
3699
{
3700
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3701
    AVBitStreamFilterContext **bsfp;
3702

    
3703
    if(!bsfc){
3704
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3705
        exit(1);
3706
    }
3707

    
3708
    bsfp= &video_bitstream_filters;
3709
    while(*bsfp)
3710
        bsfp= &(*bsfp)->next;
3711

    
3712
    *bsfp= bsfc;
3713
}
3714

    
3715
//FIXME avoid audio - video code duplication
3716
static void opt_audio_bsf(const char *arg)
3717
{
3718
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3719
    AVBitStreamFilterContext **bsfp;
3720

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

    
3726
    bsfp= &audio_bitstream_filters;
3727
    while(*bsfp)
3728
        bsfp= &(*bsfp)->next;
3729

    
3730
    *bsfp= bsfc;
3731
}
3732

    
3733
static void show_version(void)
3734
{
3735
    /* TODO: add function interface to avutil and avformat */
3736
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3737
           "libavutil   %d\n"
3738
           "libavcodec  %d\n"
3739
           "libavformat %d\n",
3740
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3741
    exit(1);
3742
}
3743

    
3744
static int opt_default(const char *opt, const char *arg){
3745
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3746
    if(!o)
3747
        o = av_set_string(avformat_opts, opt, arg);
3748
    if(!o)
3749
        return -1;
3750

    
3751
//    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));
3752

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

    
3757
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3758
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3759
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3760
        ffm_nopts = 1;
3761
#endif
3762

    
3763
    if(avctx_opts->debug)
3764
        av_log_set_level(AV_LOG_DEBUG);
3765
    return 0;
3766
}
3767

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

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

    
3864
    /* audio options */
3865
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3866
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3867
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3868
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3869
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3870
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3871
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3872
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3873
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3874
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3875

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

    
3881
    /* grab options */
3882
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3883
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3884
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3885
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3886

    
3887
    /* G.2 grab options */
3888
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3889
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3890

    
3891
    /* muxer options */
3892
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3893
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3894

    
3895
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3896
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3897

    
3898
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3899
    { NULL, },
3900
};
3901

    
3902
static void show_banner(void)
3903
{
3904
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3905
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3906
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3907
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3908
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3909
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3910
#ifdef __GNUC__
3911
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3912
#else
3913
    fprintf(stderr, ", using a non-gcc compiler\n");
3914
#endif
3915
}
3916

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

    
3956
static void show_help(void)
3957
{
3958
    show_banner();
3959
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3960
           "Hyper fast Audio and Video encoder\n");
3961
    printf("\n");
3962
    show_help_options(options, "Main options:\n",
3963
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3964
    show_help_options(options, "\nVideo options:\n",
3965
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3966
                      OPT_VIDEO);
3967
    show_help_options(options, "\nAdvanced Video options:\n",
3968
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3969
                      OPT_VIDEO | OPT_EXPERT);
3970
    show_help_options(options, "\nAudio options:\n",
3971
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3972
                      OPT_AUDIO);
3973
    show_help_options(options, "\nAdvanced Audio options:\n",
3974
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3975
                      OPT_AUDIO | OPT_EXPERT);
3976
    show_help_options(options, "\nSubtitle options:\n",
3977
                      OPT_SUBTITLE | OPT_GRAB,
3978
                      OPT_SUBTITLE);
3979
    show_help_options(options, "\nAudio/Video grab options:\n",
3980
                      OPT_GRAB,
3981
                      OPT_GRAB);
3982
    show_help_options(options, "\nAdvanced options:\n",
3983
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3984
                      OPT_EXPERT);
3985
    av_opt_show(avctx_opts, NULL);
3986
    av_opt_show(avformat_opts, NULL);
3987

    
3988
    exit(1);
3989
}
3990

    
3991
void parse_arg_file(const char *filename)
3992
{
3993
    opt_output_file(filename);
3994
}
3995

    
3996
int main(int argc, char **argv)
3997
{
3998
    int i;
3999
    int64_t ti;
4000

    
4001
    av_register_all();
4002

    
4003
    avctx_opts= avcodec_alloc_context();
4004
    avformat_opts = av_alloc_format_context();
4005

    
4006
    if (argc <= 1)
4007
        show_help();
4008
    else
4009
        show_banner();
4010

    
4011
    /* parse options */
4012
    parse_options(argc, argv, options);
4013

    
4014
    /* file converter / grab */
4015
    if (nb_output_files <= 0) {
4016
        fprintf(stderr, "Must supply at least one output file\n");
4017
        exit(1);
4018
    }
4019

    
4020
    if (nb_input_files == 0) {
4021
        input_sync = 1;
4022
        prepare_grab();
4023
    }
4024

    
4025
    ti = getutime();
4026
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
4027
              stream_maps, nb_stream_maps);
4028
    ti = getutime() - ti;
4029
    if (do_benchmark) {
4030
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4031
    }
4032

    
4033
    /* close files */
4034
    for(i=0;i<nb_output_files;i++) {
4035
        /* maybe av_close_output_file ??? */
4036
        AVFormatContext *s = output_files[i];
4037
        int j;
4038
        if (!(s->oformat->flags & AVFMT_NOFILE))
4039
            url_fclose(&s->pb);
4040
        for(j=0;j<s->nb_streams;j++)
4041
            av_free(s->streams[j]);
4042
        av_free(s);
4043
    }
4044
    for(i=0;i<nb_input_files;i++)
4045
        av_close_input_file(input_files[i]);
4046

    
4047
    av_free_static();
4048

    
4049
    if(intra_matrix)
4050
        av_free(intra_matrix);
4051
    if(inter_matrix)
4052
        av_free(inter_matrix);
4053

    
4054
#ifdef POWERPC_PERFORMANCE_REPORT
4055
    extern void powerpc_display_perf_report(void);
4056
    powerpc_display_perf_report();
4057
#endif /* POWERPC_PERFORMANCE_REPORT */
4058

    
4059
#ifndef __MINGW32__
4060
    if (received_sigterm) {
4061
        fprintf(stderr,
4062
            "Received signal %d: terminating.\n",
4063
            (int) received_sigterm);
4064
        exit (255);
4065
    }
4066
#endif
4067
    exit(0); /* not all OS-es handle main() return value */
4068
    return 0;
4069
}