Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 8cd019bd

History | View | Annotate | Download (141 KB)

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

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

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

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

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

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

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

    
68
extern const OptionDef options[];
69

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

    
74
#define MAX_FILES 20
75

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

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

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

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

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

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

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

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

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

    
189
static int rate_emu = 0;
190

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

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

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

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

    
225
static int sws_flags = SWS_BICUBIC;
226

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

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

    
236
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
237

    
238
struct AVInputStream;
239

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

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

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

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

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

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

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

    
300
#ifndef __MINGW32__
301

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

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

    
310
static volatile sig_atomic_t received_sigterm = 0;
311

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

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

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

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

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

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

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

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

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

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

    
379
#else
380

    
381
static volatile int received_sigterm = 0;
382

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

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

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

    
397
#endif
398

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

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

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

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

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

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

    
444
        bsfc= bsfc->next;
445
    }
446

    
447
    av_interleaved_write_frame(s, pkt);
448
}
449

    
450
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
451

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
724
    *frame_size = 0;
725

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
948

    
949
    oc = output_files[0];
950

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

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

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

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

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

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

    
1023
        fflush(stderr);
1024
    }
1025

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

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

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

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

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

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

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

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

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

    
1184
                ist->frame++;
1185
            }
1186

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1370

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1957
    discard_packet:
1958
        av_free_packet(&pkt);
1959

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

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

    
1972
    term_exit();
1973

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

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

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

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

    
2000
    /* finished ! */
2001

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2212

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

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

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

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

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

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

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

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

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

    
2270

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

    
2284

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

    
2298

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2499
    using_vhook = 1;
2500

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

    
2505
    i = frame_hook_add(argc, argv);
2506

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2659
    ic->loop_input = loop_input;
2660

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

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

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

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

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

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

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

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

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

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

    
2765
    grab_device = NULL;
2766
    video_channel = 0;
2767

    
2768
    rate_emu = 0;
2769
}
2770

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

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

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

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

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

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

    
2827
    video_enc = st->codec;
2828

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2960
        if (do_psnr)
2961
            video_enc->flags|= CODEC_FLAG_PSNR;
2962

    
2963
        video_enc->me_method = me_method;
2964

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

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

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

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

    
2993
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2994
    audio_bitstream_filters= NULL;
2995

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

    
3001
    audio_enc = st->codec;
3002
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3003

    
3004
    if(audio_codec_tag)
3005
        audio_enc->codec_tag= audio_codec_tag;
3006

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

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

    
3024
        if (audio_codec_id != CODEC_ID_NONE)
3025
            codec_id = audio_codec_id;
3026
        audio_enc->codec_id = codec_id;
3027

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

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

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

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

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

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

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

    
3096
    subtitle_codec_id = CODEC_ID_NONE;
3097
    subtitle_stream_copy = 0;
3098
}
3099

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

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

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

    
3128
    if (!strcmp(filename, "-"))
3129
        filename = "pipe:";
3130

    
3131
    oc = av_alloc_format_context();
3132

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

    
3142
    oc->oformat = file_oformat;
3143
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3144

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

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

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

    
3175
        if (use_video) {
3176
            new_video_stream(oc);
3177
        }
3178

    
3179
        if (use_audio) {
3180
            new_audio_stream(oc);
3181
        }
3182

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

    
3188
        oc->timestamp = rec_timestamp;
3189

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

    
3202
    output_files[nb_output_files++] = oc;
3203

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3343
        if (verbose >= 0)
3344
            dump_format(ic, nb_input_files, "", 0);
3345

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

    
3358
        if (verbose >= 0)
3359
            dump_format(ic, nb_input_files, "", 0);
3360

    
3361
        nb_input_files++;
3362
    }
3363
}
3364

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

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

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

    
3392
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3393
extern int ffm_nopts;
3394
#endif
3395

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3623
    if(!strcmp(arg, "vcd")) {
3624

    
3625
        opt_video_codec("mpeg1video");
3626
        opt_audio_codec("mp2");
3627
        opt_format("vcd");
3628

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

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

    
3638
        audio_bit_rate = 224000;
3639
        audio_sample_rate = 44100;
3640

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

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

    
3652
        opt_video_codec("mpeg2video");
3653
        opt_audio_codec("mp2");
3654
        opt_format("svcd");
3655

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

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

    
3666

    
3667
        audio_bit_rate = 224000;
3668
        audio_sample_rate = 44100;
3669

    
3670
        opt_default("packetsize", "2324");
3671

    
3672
    } else if(!strcmp(arg, "dvd")) {
3673

    
3674
        opt_video_codec("mpeg2video");
3675
        opt_audio_codec("ac3");
3676
        opt_format("dvd");
3677

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

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

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

    
3690
        audio_bit_rate = 448000;
3691
        audio_sample_rate = 48000;
3692

    
3693
    } else if(!strncmp(arg, "dv", 2)) {
3694

    
3695
        opt_format("dv");
3696

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

    
3702
        audio_sample_rate = 48000;
3703
        audio_channels = 2;
3704

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

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

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

    
3721
    bsfp= &video_bitstream_filters;
3722
    while(*bsfp)
3723
        bsfp= &(*bsfp)->next;
3724

    
3725
    *bsfp= bsfc;
3726
}
3727

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

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

    
3739
    bsfp= &audio_bitstream_filters;
3740
    while(*bsfp)
3741
        bsfp= &(*bsfp)->next;
3742

    
3743
    *bsfp= bsfc;
3744
}
3745

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

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

    
3764
//    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));
3765

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4003
    exit(1);
4004
}
4005

    
4006
void parse_arg_file(const char *filename)
4007
{
4008
    opt_output_file(filename);
4009
}
4010

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

    
4016
    av_register_all();
4017

    
4018
    avctx_opts= avcodec_alloc_context();
4019
    avformat_opts = av_alloc_format_context();
4020

    
4021
    if (argc <= 1)
4022
        show_help();
4023
    else
4024
        show_banner();
4025

    
4026
    /* parse options */
4027
    parse_options(argc, argv, options);
4028

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

    
4035
    if (nb_input_files == 0) {
4036
        input_sync = 1;
4037
        prepare_grab();
4038
    }
4039

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

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

    
4062
    av_free_static();
4063

    
4064
    if(intra_matrix)
4065
        av_free(intra_matrix);
4066
    if(inter_matrix)
4067
        av_free(inter_matrix);
4068

    
4069
#ifdef POWERPC_PERFORMANCE_REPORT
4070
    extern void powerpc_display_perf_report(void);
4071
    powerpc_display_perf_report();
4072
#endif /* POWERPC_PERFORMANCE_REPORT */
4073

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