Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 3e66a740

History | View | Annotate | Download (138 KB)

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

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

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

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

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

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

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

    
69
extern const OptionDef options[];
70

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

    
75
#define MAX_FILES 20
76

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

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

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

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

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

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

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

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

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

    
179
static int rate_emu = 0;
180

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

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

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

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

    
215
static int sws_flags = SWS_BICUBIC;
216

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

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

    
226
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
227

    
228
struct AVInputStream;
229

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

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

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

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

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

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

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

    
290
#ifndef __MINGW32__
291

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

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

    
300
static volatile sig_atomic_t received_sigterm = 0;
301

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

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

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

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

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

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

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

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

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

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

    
369
#else
370

    
371
static volatile int received_sigterm = 0;
372

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

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

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

    
387
#endif
388

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

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

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

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

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

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

    
434
        bsfc= bsfc->next;
435
    }
436

    
437
    av_interleaved_write_frame(s, pkt);
438
}
439

    
440
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
441

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
712
    *frame_size = 0;
713

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
940

    
941
    oc = output_files[0];
942

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

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

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

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

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

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

    
1015
        fflush(stderr);
1016
    }
1017

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

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

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

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

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

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

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

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

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

    
1176
                ist->frame++;
1177
            }
1178

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1361

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

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

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

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

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

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

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

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

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

    
1452
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1453
    if (!ost_table)
1454
        goto fail;
1455
    for(i=0;i<nb_ostreams;i++) {
1456
        ost = av_mallocz(sizeof(AVOutputStream));
1457
        if (!ost)
1458
            goto fail;
1459
        ost_table[i] = ost;
1460
    }
1461

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

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

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

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

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

    
1525
        codec = ost->st->codec;
1526
        icodec = ist->st->codec;
1527

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

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

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

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

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

    
1698
    if (!bit_buffer)
1699
        bit_buffer = av_malloc(bit_buffer_size);
1700
    if (!bit_buffer)
1701
        goto fail;
1702

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

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

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

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

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

    
1781
    /* compute buffer size max (should use a complete heuristic) */
1782
    for(i=0;i<nb_input_files;i++) {
1783
        file_table[i].buffer_size_max = 2048;
1784
    }
1785

    
1786
    /* set meta data information from input file if required */
1787
    for (i=0;i<nb_meta_data_maps;i++) {
1788
        AVFormatContext *out_file;
1789
        AVFormatContext *in_file;
1790

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

    
1804
        out_file = output_files[out_file_index];
1805
        in_file = input_files[in_file_index];
1806

    
1807
        strcpy(out_file->title, in_file->title);
1808
        strcpy(out_file->author, in_file->author);
1809
        strcpy(out_file->copyright, in_file->copyright);
1810
        strcpy(out_file->comment, in_file->comment);
1811
        strcpy(out_file->album, in_file->album);
1812
        out_file->year = in_file->year;
1813
        out_file->track = in_file->track;
1814
        strcpy(out_file->genre, in_file->genre);
1815
    }
1816

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

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

    
1835
    stream_no_data = 0;
1836
    key = -1;
1837

    
1838
    for(; received_sigterm == 0;) {
1839
        int file_index, ist_index;
1840
        AVPacket pkt;
1841
        double ipts_min;
1842
        double opts_min;
1843

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

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

    
1890
        /* finish if recording time exhausted */
1891
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1892
            break;
1893

    
1894
        /* finish if limit size exhausted */
1895
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1896
            break;
1897

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

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

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

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

    
1940
            if (verbose >= 0)
1941
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1942
                        ist->file_index, ist->index);
1943

    
1944
            av_free_packet(&pkt);
1945
            goto redo;
1946
        }
1947

    
1948
    discard_packet:
1949
        av_free_packet(&pkt);
1950

    
1951
        /* dump report by using the output first video and audio streams */
1952
        print_report(output_files, ost_table, nb_ostreams, 0);
1953
    }
1954

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

    
1963
    term_exit();
1964

    
1965
    /* write the trailer if needed and close file */
1966
    for(i=0;i<nb_output_files;i++) {
1967
        os = output_files[i];
1968
        av_write_trailer(os);
1969
    }
1970

    
1971
    /* dump report by using the first video and audio streams */
1972
    print_report(output_files, ost_table, nb_ostreams, 1);
1973

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

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

    
1991
    /* finished ! */
1992

    
1993
    ret = 0;
1994
 fail1:
1995
    av_freep(&bit_buffer);
1996
    av_free(file_table);
1997

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

    
2031
#if 0
2032
int file_read(const char *filename)
2033
{
2034
    URLContext *h;
2035
    unsigned char buffer[1024];
2036
    int len, i;
2037

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

    
2053
static void opt_image_format(const char *arg)
2054
{
2055
    AVImageFormat *f;
2056

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

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

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

    
2085
static void opt_video_rc_eq(char *arg)
2086
{
2087
    video_rc_eq = arg;
2088
}
2089

    
2090
static void opt_video_rc_override_string(char *arg)
2091
{
2092
    video_rc_override_string = arg;
2093
}
2094

    
2095
static void opt_me_threshold(const char *arg)
2096
{
2097
    me_threshold = atoi(arg);
2098
}
2099

    
2100
static void opt_verbose(const char *arg)
2101
{
2102
    verbose = atoi(arg);
2103
    av_log_set_level(atoi(arg));
2104
}
2105

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

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

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

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

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

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

    
2198

    
2199
#define SCALEBITS 10
2200
#define ONE_HALF  (1 << (SCALEBITS - 1))
2201
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2202

    
2203
#define RGB_TO_Y(r, g, b) \
2204
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2205
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2206

    
2207
#define RGB_TO_U(r1, g1, b1, shift)\
2208
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2209
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2210

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

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

    
2221
    r = (rgb >> 16);
2222
    g = ((rgb >> 8) & 255);
2223
    b = (rgb & 255);
2224

    
2225
    padcolor[0] = RGB_TO_Y(r,g,b);
2226
    padcolor[1] = RGB_TO_U(r,g,b,0);
2227
    padcolor[2] = RGB_TO_V(r,g,b,0);
2228
}
2229

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

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

    
2256

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

    
2270

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

    
2284

    
2285
static void opt_frame_pix_fmt(const char *arg)
2286
{
2287
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2288
}
2289

    
2290
static void opt_frame_aspect_ratio(const char *arg)
2291
{
2292
    int x = 0, y = 0;
2293
    double ar = 0;
2294
    const char *p;
2295

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

    
2306
    if (!ar) {
2307
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2308
        exit(1);
2309
    }
2310
    frame_aspect_ratio = ar;
2311
}
2312

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

    
2323
static void opt_qdiff(const char *arg)
2324
{
2325
    video_qdiff = atoi(arg);
2326
    if (video_qdiff < 0 ||
2327
        video_qdiff > 31) {
2328
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2329
        exit(1);
2330
    }
2331
}
2332

    
2333
static void opt_packet_size(const char *arg)
2334
{
2335
    packet_size= atoi(arg);
2336
}
2337

    
2338
static void opt_strict(const char *arg)
2339
{
2340
    strict= atoi(arg);
2341
}
2342

    
2343
static void opt_top_field_first(const char *arg)
2344
{
2345
    top_field_first= atoi(arg);
2346
}
2347

    
2348
static void opt_thread_count(const char *arg)
2349
{
2350
    thread_count= atoi(arg);
2351
#if !defined(HAVE_THREADS)
2352
    if (verbose >= 0)
2353
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2354
#endif
2355
}
2356

    
2357
static void opt_audio_bitrate(const char *arg)
2358
{
2359
    audio_bit_rate = atoi(arg) * 1000;
2360
}
2361

    
2362
static void opt_audio_rate(const char *arg)
2363
{
2364
    audio_sample_rate = atoi(arg);
2365
}
2366

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

    
2372
static void opt_video_device(const char *arg)
2373
{
2374
    video_device = av_strdup(arg);
2375
}
2376

    
2377
static void opt_grab_device(const char *arg)
2378
{
2379
    grab_device = av_strdup(arg);
2380
}
2381

    
2382
static void opt_video_channel(const char *arg)
2383
{
2384
    video_channel = strtol(arg, NULL, 0);
2385
}
2386

    
2387
static void opt_video_standard(const char *arg)
2388
{
2389
    video_standard = av_strdup(arg);
2390
}
2391

    
2392
static void opt_audio_device(const char *arg)
2393
{
2394
    audio_device = av_strdup(arg);
2395
}
2396

    
2397
static void opt_codec(int *pstream_copy, int *pcodec_id,
2398
                      int codec_type, const char *arg)
2399
{
2400
    AVCodec *p;
2401

    
2402
    if (!strcmp(arg, "copy")) {
2403
        *pstream_copy = 1;
2404
    } else {
2405
        p = first_avcodec;
2406
        while (p) {
2407
            if (!strcmp(p->name, arg) && p->type == codec_type)
2408
                break;
2409
            p = p->next;
2410
        }
2411
        if (p == NULL) {
2412
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2413
            exit(1);
2414
        } else {
2415
            *pcodec_id = p->id;
2416
        }
2417
    }
2418
}
2419

    
2420
static void opt_audio_codec(const char *arg)
2421
{
2422
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2423
}
2424

    
2425
static void opt_audio_tag(const char *arg)
2426
{
2427
    char *tail;
2428
    audio_codec_tag= strtol(arg, &tail, 0);
2429

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

    
2434
static void opt_video_tag(const char *arg)
2435
{
2436
    char *tail;
2437
    video_codec_tag= strtol(arg, &tail, 0);
2438

    
2439
    if(!tail || *tail)
2440
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2441
}
2442

    
2443
static void add_frame_hooker(const char *arg)
2444
{
2445
    int argc = 0;
2446
    char *argv[64];
2447
    int i;
2448
    char *args = av_strdup(arg);
2449

    
2450
    using_vhook = 1;
2451

    
2452
    argv[0] = strtok(args, " ");
2453
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2454
    }
2455

    
2456
    i = frame_hook_add(argc, argv);
2457

    
2458
    if (i != 0) {
2459
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2460
        exit(1);
2461
    }
2462
}
2463

    
2464
const char *motion_str[] = {
2465
    "zero",
2466
    "full",
2467
    "log",
2468
    "phods",
2469
    "epzs",
2470
    "x1",
2471
    "hex",
2472
    "umh",
2473
    "iter",
2474
    NULL,
2475
};
2476

    
2477
static void opt_motion_estimation(const char *arg)
2478
{
2479
    const char **p;
2480
    p = motion_str;
2481
    for(;;) {
2482
        if (!*p) {
2483
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2484
            exit(1);
2485
        }
2486
        if (!strcmp(*p, arg))
2487
            break;
2488
        p++;
2489
    }
2490
    me_method = (p - motion_str) + 1;
2491
}
2492

    
2493
static void opt_video_codec(const char *arg)
2494
{
2495
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2496
}
2497

    
2498
static void opt_subtitle_codec(const char *arg)
2499
{
2500
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2501
}
2502

    
2503
static void opt_map(const char *arg)
2504
{
2505
    AVStreamMap *m;
2506
    const char *p;
2507

    
2508
    p = arg;
2509
    m = &stream_maps[nb_stream_maps++];
2510

    
2511
    m->file_index = strtol(arg, (char **)&p, 0);
2512
    if (*p)
2513
        p++;
2514

    
2515
    m->stream_index = strtol(p, (char **)&p, 0);
2516
    if (*p) {
2517
        p++;
2518
        m->sync_file_index = strtol(p, (char **)&p, 0);
2519
        if (*p)
2520
            p++;
2521
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2522
    } else {
2523
        m->sync_file_index = m->file_index;
2524
        m->sync_stream_index = m->stream_index;
2525
    }
2526
}
2527

    
2528
static void opt_map_meta_data(const char *arg)
2529
{
2530
    AVMetaDataMap *m;
2531
    const char *p;
2532

    
2533
    p = arg;
2534
    m = &meta_data_maps[nb_meta_data_maps++];
2535

    
2536
    m->out_file = strtol(arg, (char **)&p, 0);
2537
    if (*p)
2538
        p++;
2539

    
2540
    m->in_file = strtol(p, (char **)&p, 0);
2541
}
2542

    
2543
static void opt_recording_time(const char *arg)
2544
{
2545
    recording_time = parse_date(arg, 1);
2546
}
2547

    
2548
static void opt_start_time(const char *arg)
2549
{
2550
    start_time = parse_date(arg, 1);
2551
}
2552

    
2553
static void opt_rec_timestamp(const char *arg)
2554
{
2555
    rec_timestamp = parse_date(arg, 0) / 1000000;
2556
}
2557

    
2558
static void opt_input_ts_offset(const char *arg)
2559
{
2560
    input_ts_offset = parse_date(arg, 1);
2561
}
2562

    
2563
static void opt_input_file(const char *filename)
2564
{
2565
    AVFormatContext *ic;
2566
    AVFormatParameters params, *ap = &params;
2567
    int err, i, ret, rfps, rfps_base;
2568
    int64_t timestamp;
2569

    
2570
    if (!strcmp(filename, "-"))
2571
        filename = "pipe:";
2572

    
2573
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2574
                   !strcmp( filename, "/dev/stdin" );
2575

    
2576
    /* get default parameters from command line */
2577
    ic = av_alloc_format_context();
2578

    
2579
    memset(ap, 0, sizeof(*ap));
2580
    ap->prealloced_context = 1;
2581
    ap->sample_rate = audio_sample_rate;
2582
    ap->channels = audio_channels;
2583
    ap->time_base.den = frame_rate;
2584
    ap->time_base.num = frame_rate_base;
2585
    ap->width = frame_width + frame_padleft + frame_padright;
2586
    ap->height = frame_height + frame_padtop + frame_padbottom;
2587
    ap->image_format = image_format;
2588
    ap->pix_fmt = frame_pix_fmt;
2589
    ap->device  = grab_device;
2590
    ap->channel = video_channel;
2591
    ap->standard = video_standard;
2592
    ap->video_codec_id = video_codec_id;
2593
    ap->audio_codec_id = audio_codec_id;
2594
    if(pgmyuv_compatibility_hack)
2595
        ap->video_codec_id= CODEC_ID_PGMYUV;
2596

    
2597
    for(i=0; i<opt_name_count; i++){
2598
        AVOption *opt;
2599
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2600
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2601
            av_set_double(ic, opt_names[i], d);
2602
    }
2603
    /* open the input file with generic libav function */
2604
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2605
    if (err < 0) {
2606
        print_error(filename, err);
2607
        exit(1);
2608
    }
2609

    
2610
    ic->loop_input = loop_input;
2611

    
2612
    /* If not enough info to get the stream parameters, we decode the
2613
       first frames to get it. (used in mpeg case for example) */
2614
    ret = av_find_stream_info(ic);
2615
    if (ret < 0 && verbose >= 0) {
2616
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2617
        exit(1);
2618
    }
2619

    
2620
    timestamp = start_time;
2621
    /* add the stream start time */
2622
    if (ic->start_time != AV_NOPTS_VALUE)
2623
        timestamp += ic->start_time;
2624

    
2625
    /* if seeking requested, we execute it */
2626
    if (start_time != 0) {
2627
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2628
        if (ret < 0) {
2629
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2630
                    filename, (double)timestamp / AV_TIME_BASE);
2631
        }
2632
        /* reset seek info */
2633
        start_time = 0;
2634
    }
2635

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

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

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

    
2682
                    (float)rfps / rfps_base, rfps, rfps_base);
2683
            }
2684
            /* update the current frame rate to match the stream frame rate */
2685
            frame_rate      = rfps;
2686
            frame_rate_base = rfps_base;
2687

    
2688
            enc->rate_emu = rate_emu;
2689
            if(video_disable)
2690
                ic->streams[i]->discard= AVDISCARD_ALL;
2691
            else if(video_discard)
2692
                ic->streams[i]->discard= video_discard;
2693
            break;
2694
        case CODEC_TYPE_DATA:
2695
            break;
2696
        case CODEC_TYPE_SUBTITLE:
2697
            break;
2698
        case CODEC_TYPE_UNKNOWN:
2699
            break;
2700
        default:
2701
            av_abort();
2702
        }
2703
    }
2704

    
2705
    input_files[nb_input_files] = ic;
2706
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2707
    /* dump the file content */
2708
    if (verbose >= 0)
2709
        dump_format(ic, nb_input_files, filename, 0);
2710

    
2711
    nb_input_files++;
2712
    file_iformat = NULL;
2713
    file_oformat = NULL;
2714
    image_format = NULL;
2715

    
2716
    grab_device = NULL;
2717
    video_channel = 0;
2718

    
2719
    rate_emu = 0;
2720
}
2721

    
2722
static void opt_grab(const char *arg)
2723
{
2724
    file_iformat = av_find_input_format(arg);
2725
    opt_input_file("");
2726
}
2727

    
2728
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2729
{
2730
    int has_video, has_audio, i, j;
2731
    AVFormatContext *ic;
2732

    
2733
    has_video = 0;
2734
    has_audio = 0;
2735
    for(j=0;j<nb_input_files;j++) {
2736
        ic = input_files[j];
2737
        for(i=0;i<ic->nb_streams;i++) {
2738
            AVCodecContext *enc = ic->streams[i]->codec;
2739
            switch(enc->codec_type) {
2740
            case CODEC_TYPE_AUDIO:
2741
                has_audio = 1;
2742
                break;
2743
            case CODEC_TYPE_VIDEO:
2744
                has_video = 1;
2745
                break;
2746
            case CODEC_TYPE_DATA:
2747
            case CODEC_TYPE_UNKNOWN:
2748
            case CODEC_TYPE_SUBTITLE:
2749
                break;
2750
            default:
2751
                av_abort();
2752
            }
2753
        }
2754
    }
2755
    *has_video_ptr = has_video;
2756
    *has_audio_ptr = has_audio;
2757
}
2758

    
2759
static void new_video_stream(AVFormatContext *oc)
2760
{
2761
    AVStream *st;
2762
    AVCodecContext *video_enc;
2763
    int codec_id;
2764

    
2765
    st = av_new_stream(oc, oc->nb_streams);
2766
    if (!st) {
2767
        fprintf(stderr, "Could not alloc stream\n");
2768
        exit(1);
2769
    }
2770
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2771
    video_bitstream_filters= NULL;
2772

    
2773
#if defined(HAVE_THREADS)
2774
    if(thread_count>1)
2775
        avcodec_thread_init(st->codec, thread_count);
2776
#endif
2777

    
2778
    video_enc = st->codec;
2779

    
2780
    if(video_codec_tag)
2781
        video_enc->codec_tag= video_codec_tag;
2782

    
2783
    if(   (video_global_header&1)
2784
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2785
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2786
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2787
    }
2788
    if(video_global_header&2){
2789
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2790
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2791
    }
2792

    
2793
    if (video_stream_copy) {
2794
        st->stream_copy = 1;
2795
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2796
    } else {
2797
        char *p;
2798
        int i;
2799
        AVCodec *codec;
2800

    
2801
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2802
        if (video_codec_id != CODEC_ID_NONE)
2803
            codec_id = video_codec_id;
2804

    
2805
        video_enc->codec_id = codec_id;
2806
        codec = avcodec_find_encoder(codec_id);
2807

    
2808
        for(i=0; i<opt_name_count; i++){
2809
             AVOption *opt;
2810
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2811
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2812
                 av_set_double(video_enc, opt_names[i], d);
2813
        }
2814

    
2815
        video_enc->time_base.den = frame_rate;
2816
        video_enc->time_base.num = frame_rate_base;
2817
        if(codec && codec->supported_framerates){
2818
            const AVRational *p= codec->supported_framerates;
2819
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2820
            const AVRational *best=NULL;
2821
            AVRational best_error= (AVRational){INT_MAX, 1};
2822
            for(; p->den!=0; p++){
2823
                AVRational error= av_sub_q(req, *p);
2824
                if(error.num <0) error.num *= -1;
2825
                if(av_cmp_q(error, best_error) < 0){
2826
                    best_error= error;
2827
                    best= p;
2828
                }
2829
            }
2830
            video_enc->time_base.den= best->num;
2831
            video_enc->time_base.num= best->den;
2832
        }
2833

    
2834
        video_enc->width = frame_width + frame_padright + frame_padleft;
2835
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2836
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2837
        video_enc->pix_fmt = frame_pix_fmt;
2838

    
2839
        if(codec && codec->pix_fmts){
2840
            const enum PixelFormat *p= codec->pix_fmts;
2841
            for(; *p!=-1; p++){
2842
                if(*p == video_enc->pix_fmt)
2843
                    break;
2844
            }
2845
            if(*p == -1)
2846
                video_enc->pix_fmt = codec->pix_fmts[0];
2847
        }
2848

    
2849
        if (intra_only)
2850
            video_enc->gop_size = 0;
2851
        if (video_qscale || same_quality) {
2852
            video_enc->flags |= CODEC_FLAG_QSCALE;
2853
            video_enc->global_quality=
2854
                st->quality = FF_QP2LAMBDA * video_qscale;
2855
        }
2856

    
2857
        if(intra_matrix)
2858
            video_enc->intra_matrix = intra_matrix;
2859
        if(inter_matrix)
2860
            video_enc->inter_matrix = inter_matrix;
2861

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

    
2895
        if(packet_size){
2896
            video_enc->rtp_mode= 1;
2897
            video_enc->rtp_payload_size= packet_size;
2898
        }
2899

    
2900
        if (do_psnr)
2901
            video_enc->flags|= CODEC_FLAG_PSNR;
2902

    
2903
        video_enc->me_method = me_method;
2904

    
2905
        /* two pass mode */
2906
        if (do_pass) {
2907
            if (do_pass == 1) {
2908
                video_enc->flags |= CODEC_FLAG_PASS1;
2909
            } else {
2910
                video_enc->flags |= CODEC_FLAG_PASS2;
2911
            }
2912
        }
2913
    }
2914

    
2915
    /* reset some key parameters */
2916
    video_disable = 0;
2917
    video_codec_id = CODEC_ID_NONE;
2918
    video_stream_copy = 0;
2919
}
2920

    
2921
static void new_audio_stream(AVFormatContext *oc)
2922
{
2923
    AVStream *st;
2924
    AVCodecContext *audio_enc;
2925
    int codec_id, i;
2926

    
2927
    st = av_new_stream(oc, oc->nb_streams);
2928
    if (!st) {
2929
        fprintf(stderr, "Could not alloc stream\n");
2930
        exit(1);
2931
    }
2932

    
2933
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2934
    audio_bitstream_filters= NULL;
2935

    
2936
#if defined(HAVE_THREADS)
2937
    if(thread_count>1)
2938
        avcodec_thread_init(st->codec, thread_count);
2939
#endif
2940

    
2941
    audio_enc = st->codec;
2942
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2943

    
2944
    if(audio_codec_tag)
2945
        audio_enc->codec_tag= audio_codec_tag;
2946

    
2947
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2948
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2949
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2950
    }
2951
    if (audio_stream_copy) {
2952
        st->stream_copy = 1;
2953
        audio_enc->channels = audio_channels;
2954
    } else {
2955
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2956

    
2957
        for(i=0; i<opt_name_count; i++){
2958
            AVOption *opt;
2959
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
2960
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2961
                av_set_double(audio_enc, opt_names[i], d);
2962
        }
2963

    
2964
        if (audio_codec_id != CODEC_ID_NONE)
2965
            codec_id = audio_codec_id;
2966
        audio_enc->codec_id = codec_id;
2967

    
2968
        audio_enc->bit_rate = audio_bit_rate;
2969
        if (audio_qscale > QSCALE_NONE) {
2970
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2971
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2972
        }
2973
        audio_enc->strict_std_compliance = strict;
2974
        audio_enc->thread_count = thread_count;
2975
        /* For audio codecs other than AC3 or DTS we limit */
2976
        /* the number of coded channels to stereo   */
2977
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2978
            && codec_id != CODEC_ID_DTS) {
2979
            audio_enc->channels = 2;
2980
        } else
2981
            audio_enc->channels = audio_channels;
2982
    }
2983
    audio_enc->sample_rate = audio_sample_rate;
2984
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2985
    if (audio_language) {
2986
        pstrcpy(st->language, sizeof(st->language), audio_language);
2987
        av_free(audio_language);
2988
        audio_language = NULL;
2989
    }
2990

    
2991
    /* reset some key parameters */
2992
    audio_disable = 0;
2993
    audio_codec_id = CODEC_ID_NONE;
2994
    audio_stream_copy = 0;
2995
}
2996

    
2997
static void opt_new_subtitle_stream(void)
2998
{
2999
    AVFormatContext *oc;
3000
    AVStream *st;
3001
    AVCodecContext *subtitle_enc;
3002
    int i;
3003

    
3004
    if (nb_output_files <= 0) {
3005
        fprintf(stderr, "At least one output file must be specified\n");
3006
        exit(1);
3007
    }
3008
    oc = output_files[nb_output_files - 1];
3009

    
3010
    st = av_new_stream(oc, oc->nb_streams);
3011
    if (!st) {
3012
        fprintf(stderr, "Could not alloc stream\n");
3013
        exit(1);
3014
    }
3015

    
3016
    subtitle_enc = st->codec;
3017
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3018
    if (subtitle_stream_copy) {
3019
        st->stream_copy = 1;
3020
    } else {
3021
        for(i=0; i<opt_name_count; i++){
3022
             AVOption *opt;
3023
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3024
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3025
                 av_set_double(subtitle_enc, opt_names[i], d);
3026
        }
3027
        subtitle_enc->codec_id = subtitle_codec_id;
3028
    }
3029

    
3030
    if (subtitle_language) {
3031
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3032
        av_free(subtitle_language);
3033
        subtitle_language = NULL;
3034
    }
3035

    
3036
    subtitle_codec_id = CODEC_ID_NONE;
3037
    subtitle_stream_copy = 0;
3038
}
3039

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

    
3051
static void opt_new_video_stream(void)
3052
{
3053
    AVFormatContext *oc;
3054
    if (nb_output_files <= 0) {
3055
        fprintf(stderr, "At least one output file must be specified\n");
3056
        exit(1);
3057
    }
3058
    oc = output_files[nb_output_files - 1];
3059
    new_video_stream(oc);
3060
}
3061

    
3062
static void opt_output_file(const char *filename)
3063
{
3064
    AVFormatContext *oc;
3065
    int use_video, use_audio, input_has_video, input_has_audio, i;
3066
    AVFormatParameters params, *ap = &params;
3067

    
3068
    if (!strcmp(filename, "-"))
3069
        filename = "pipe:";
3070

    
3071
    oc = av_alloc_format_context();
3072

    
3073
    if (!file_oformat) {
3074
        file_oformat = guess_format(NULL, filename, NULL);
3075
        if (!file_oformat) {
3076
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3077
                    filename);
3078
            exit(1);
3079
        }
3080
    }
3081

    
3082
    oc->oformat = file_oformat;
3083
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3084

    
3085
    if (!strcmp(file_oformat->name, "ffm") &&
3086
        strstart(filename, "http:", NULL)) {
3087
        /* special case for files sent to ffserver: we get the stream
3088
           parameters from ffserver */
3089
        if (read_ffserver_streams(oc, filename) < 0) {
3090
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3091
            exit(1);
3092
        }
3093
    } else {
3094
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3095
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3096

    
3097
        /* disable if no corresponding type found and at least one
3098
           input file */
3099
        if (nb_input_files > 0) {
3100
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3101
            if (!input_has_video)
3102
                use_video = 0;
3103
            if (!input_has_audio)
3104
                use_audio = 0;
3105
        }
3106

    
3107
        /* manual disable */
3108
        if (audio_disable) {
3109
            use_audio = 0;
3110
        }
3111
        if (video_disable) {
3112
            use_video = 0;
3113
        }
3114

    
3115
        if (use_video) {
3116
            new_video_stream(oc);
3117
        }
3118

    
3119
        if (use_audio) {
3120
            new_audio_stream(oc);
3121
        }
3122

    
3123
        if (!oc->nb_streams) {
3124
            fprintf(stderr, "No audio or video streams available\n");
3125
            exit(1);
3126
        }
3127

    
3128
        oc->timestamp = rec_timestamp;
3129

    
3130
        if (str_title)
3131
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3132
        if (str_author)
3133
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3134
        if (str_copyright)
3135
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3136
        if (str_comment)
3137
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3138
        if (str_album)
3139
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3140
    }
3141

    
3142
    output_files[nb_output_files++] = oc;
3143

    
3144
    /* check filename in case of an image number is expected */
3145
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3146
        if (!av_filename_number_test(oc->filename)) {
3147
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3148
            exit(1);
3149
        }
3150
    }
3151

    
3152
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3153
        /* test if it already exists to avoid loosing precious files */
3154
        if (!file_overwrite &&
3155
            (strchr(filename, ':') == NULL ||
3156
             strstart(filename, "file:", NULL))) {
3157
            if (url_exist(filename)) {
3158
                int c;
3159

    
3160
                if ( !using_stdin ) {
3161
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3162
                    fflush(stderr);
3163
                    c = getchar();
3164
                    if (toupper(c) != 'Y') {
3165
                        fprintf(stderr, "Not overwriting - exiting\n");
3166
                        exit(1);
3167
                    }
3168
                                }
3169
                                else {
3170
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3171
                    exit(1);
3172
                                }
3173
            }
3174
        }
3175

    
3176
        /* open the file */
3177
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3178
            fprintf(stderr, "Could not open '%s'\n", filename);
3179
            exit(1);
3180
        }
3181
    }
3182

    
3183
    memset(ap, 0, sizeof(*ap));
3184
    ap->image_format = image_format;
3185
    if (av_set_parameters(oc, ap) < 0) {
3186
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3187
                oc->filename);
3188
        exit(1);
3189
    }
3190

    
3191
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3192
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3193
    oc->loop_output = loop_output;
3194

    
3195
    for(i=0; i<opt_name_count; i++){
3196
        AVOption *opt;
3197
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3198
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3199
            av_set_double(oc, opt_names[i], d);
3200
    }
3201

    
3202
    /* reset some options */
3203
    file_oformat = NULL;
3204
    file_iformat = NULL;
3205
    image_format = NULL;
3206
}
3207

    
3208
/* prepare dummy protocols for grab */
3209
static void prepare_grab(void)
3210
{
3211
    int has_video, has_audio, i, j;
3212
    AVFormatContext *oc;
3213
    AVFormatContext *ic;
3214
    AVFormatParameters vp1, *vp = &vp1;
3215
    AVFormatParameters ap1, *ap = &ap1;
3216

    
3217
    /* see if audio/video inputs are needed */
3218
    has_video = 0;
3219
    has_audio = 0;
3220
    memset(ap, 0, sizeof(*ap));
3221
    memset(vp, 0, sizeof(*vp));
3222
    vp->time_base.num= 1;
3223
    for(j=0;j<nb_output_files;j++) {
3224
        oc = output_files[j];
3225
        for(i=0;i<oc->nb_streams;i++) {
3226
            AVCodecContext *enc = oc->streams[i]->codec;
3227
            switch(enc->codec_type) {
3228
            case CODEC_TYPE_AUDIO:
3229
                if (enc->sample_rate > ap->sample_rate)
3230
                    ap->sample_rate = enc->sample_rate;
3231
                if (enc->channels > ap->channels)
3232
                    ap->channels = enc->channels;
3233
                has_audio = 1;
3234
                break;
3235
            case CODEC_TYPE_VIDEO:
3236
                if (enc->width > vp->width)
3237
                    vp->width = enc->width;
3238
                if (enc->height > vp->height)
3239
                    vp->height = enc->height;
3240

    
3241
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3242
                    vp->time_base = enc->time_base;
3243
                    vp->width += frame_leftBand + frame_rightBand;
3244
                    vp->width -= (frame_padleft + frame_padright);
3245
                    vp->height += frame_topBand + frame_bottomBand;
3246
                    vp->height -= (frame_padtop + frame_padbottom);
3247
                }
3248
                has_video = 1;
3249
                break;
3250
            default:
3251
                av_abort();
3252
            }
3253
        }
3254
    }
3255

    
3256
    if (has_video == 0 && has_audio == 0) {
3257
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3258
        exit(1);
3259
    }
3260

    
3261
    if (has_video) {
3262
        AVInputFormat *fmt1;
3263
        fmt1 = av_find_input_format(video_grab_format);
3264
        vp->device  = video_device;
3265
        vp->channel = video_channel;
3266
        vp->standard = video_standard;
3267
        vp->pix_fmt = frame_pix_fmt;
3268
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3269
            fprintf(stderr, "Could not find video grab device\n");
3270
            exit(1);
3271
        }
3272
        /* If not enough info to get the stream parameters, we decode the
3273
           first frames to get it. */
3274
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3275
            fprintf(stderr, "Could not find video grab parameters\n");
3276
            exit(1);
3277
        }
3278
        /* by now video grab has one stream */
3279
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3280
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3281
        input_files[nb_input_files] = ic;
3282

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

    
3286
        nb_input_files++;
3287
    }
3288
    if (has_audio && audio_grab_format) {
3289
        AVInputFormat *fmt1;
3290
        fmt1 = av_find_input_format(audio_grab_format);
3291
        ap->device = audio_device;
3292
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3293
            fprintf(stderr, "Could not find audio grab device\n");
3294
            exit(1);
3295
        }
3296
        input_files[nb_input_files] = ic;
3297

    
3298
        if (verbose >= 0)
3299
            dump_format(ic, nb_input_files, "", 0);
3300

    
3301
        nb_input_files++;
3302
    }
3303
}
3304

    
3305
/* same option as mencoder */
3306
static void opt_pass(const char *pass_str)
3307
{
3308
    int pass;
3309
    pass = atoi(pass_str);
3310
    if (pass != 1 && pass != 2) {
3311
        fprintf(stderr, "pass number can be only 1 or 2\n");
3312
        exit(1);
3313
    }
3314
    do_pass = pass;
3315
}
3316

    
3317
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3318
static int64_t getutime(void)
3319
{
3320
  return av_gettime();
3321
}
3322
#else
3323
static int64_t getutime(void)
3324
{
3325
    struct rusage rusage;
3326

    
3327
    getrusage(RUSAGE_SELF, &rusage);
3328
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3329
}
3330
#endif
3331

    
3332
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3333
extern int ffm_nopts;
3334
#endif
3335

    
3336
static void show_formats(void)
3337
{
3338
    AVInputFormat *ifmt;
3339
    AVOutputFormat *ofmt;
3340
    AVImageFormat *image_fmt;
3341
    URLProtocol *up;
3342
    AVCodec *p, *p2;
3343
    const char **pp, *last_name;
3344

    
3345
    printf("File formats:\n");
3346
    last_name= "000";
3347
    for(;;){
3348
        int decode=0;
3349
        int encode=0;
3350
        const char *name=NULL;
3351
        const char *long_name=NULL;
3352

    
3353
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3354
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3355
                strcmp(ofmt->name, last_name)>0){
3356
                name= ofmt->name;
3357
                long_name= ofmt->long_name;
3358
                encode=1;
3359
            }
3360
        }
3361
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3362
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3363
                strcmp(ifmt->name, last_name)>0){
3364
                name= ifmt->name;
3365
                long_name= ifmt->long_name;
3366
                encode=0;
3367
            }
3368
            if(name && strcmp(ifmt->name, name)==0)
3369
                decode=1;
3370
        }
3371
        if(name==NULL)
3372
            break;
3373
        last_name= name;
3374

    
3375
        printf(
3376
            " %s%s %-15s %s\n",
3377
            decode ? "D":" ",
3378
            encode ? "E":" ",
3379
            name,
3380
            long_name ? long_name:" ");
3381
    }
3382
    printf("\n");
3383

    
3384
    printf("Image formats (filename extensions, if any, follow):\n");
3385
    for(image_fmt = first_image_format; image_fmt != NULL;
3386
        image_fmt = image_fmt->next) {
3387
        printf(
3388
            " %s%s %-6s %s\n",
3389
            image_fmt->img_read  ? "D":" ",
3390
            image_fmt->img_write ? "E":" ",
3391
            image_fmt->name,
3392
            image_fmt->extensions ? image_fmt->extensions:" ");
3393
    }
3394
    printf("\n");
3395

    
3396
    printf("Codecs:\n");
3397
    last_name= "000";
3398
    for(;;){
3399
        int decode=0;
3400
        int encode=0;
3401
        int cap=0;
3402
        const char *type_str;
3403

    
3404
        p2=NULL;
3405
        for(p = first_avcodec; p != NULL; p = p->next) {
3406
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3407
                strcmp(p->name, last_name)>0){
3408
                p2= p;
3409
                decode= encode= cap=0;
3410
            }
3411
            if(p2 && strcmp(p->name, p2->name)==0){
3412
                if(p->decode) decode=1;
3413
                if(p->encode) encode=1;
3414
                cap |= p->capabilities;
3415
            }
3416
        }
3417
        if(p2==NULL)
3418
            break;
3419
        last_name= p2->name;
3420

    
3421
        switch(p2->type) {
3422
        case CODEC_TYPE_VIDEO:
3423
            type_str = "V";
3424
            break;
3425
        case CODEC_TYPE_AUDIO:
3426
            type_str = "A";
3427
            break;
3428
        case CODEC_TYPE_SUBTITLE:
3429
            type_str = "S";
3430
            break;
3431
        default:
3432
            type_str = "?";
3433
            break;
3434
        }
3435
        printf(
3436
            " %s%s%s%s%s%s %s",
3437
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3438
            encode ? "E":" ",
3439
            type_str,
3440
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3441
            cap & CODEC_CAP_DR1 ? "D":" ",
3442
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3443
            p2->name);
3444
       /* if(p2->decoder && decode==0)
3445
            printf(" use %s for decoding", p2->decoder->name);*/
3446
        printf("\n");
3447
    }
3448
    printf("\n");
3449

    
3450
    printf("Supported file protocols:\n");
3451
    for(up = first_protocol; up != NULL; up = up->next)
3452
        printf(" %s:", up->name);
3453
    printf("\n");
3454

    
3455
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3456
    printf("Motion estimation methods:\n");
3457
    pp = motion_str;
3458
    while (*pp) {
3459
        printf(" %s", *pp);
3460
        if ((pp - motion_str + 1) == ME_ZERO)
3461
            printf("(fastest)");
3462
        else if ((pp - motion_str + 1) == ME_FULL)
3463
            printf("(slowest)");
3464
        else if ((pp - motion_str + 1) == ME_EPZS)
3465
            printf("(default)");
3466
        pp++;
3467
    }
3468
    printf("\n\n");
3469
    printf(
3470
"Note, the names of encoders and decoders dont always match, so there are\n"
3471
"several cases where the above table shows encoder only or decoder only entries\n"
3472
"even though both encoding and decoding are supported for example, the h263\n"
3473
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3474
"worse\n");
3475
    exit(1);
3476
}
3477

    
3478
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3479
{
3480
    int i;
3481
    const char *p = str;
3482
    for(i = 0;; i++) {
3483
        dest[i] = atoi(p);
3484
        if(i == 63)
3485
            break;
3486
        p = strchr(p, ',');
3487
        if(!p) {
3488
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3489
            exit(1);
3490
        }
3491
        p++;
3492
    }
3493
}
3494

    
3495
static void opt_inter_matrix(const char *arg)
3496
{
3497
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3498
    parse_matrix_coeffs(inter_matrix, arg);
3499
}
3500

    
3501
static void opt_intra_matrix(const char *arg)
3502
{
3503
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3504
    parse_matrix_coeffs(intra_matrix, arg);
3505
}
3506

    
3507
static void opt_target(const char *arg)
3508
{
3509
    int norm = -1;
3510
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3511

    
3512
    if(!strncmp(arg, "pal-", 4)) {
3513
        norm = 0;
3514
        arg += 4;
3515
    } else if(!strncmp(arg, "ntsc-", 5)) {
3516
        norm = 1;
3517
        arg += 5;
3518
    } else if(!strncmp(arg, "film-", 5)) {
3519
        norm = 2;
3520
        arg += 5;
3521
    } else {
3522
        int fr;
3523
        /* Calculate FR via float to avoid int overflow */
3524
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3525
        if(fr == 25000) {
3526
            norm = 0;
3527
        } else if((fr == 29970) || (fr == 23976)) {
3528
            norm = 1;
3529
        } else {
3530
            /* Try to determine PAL/NTSC by peeking in the input files */
3531
            if(nb_input_files) {
3532
                int i, j;
3533
                for(j = 0; j < nb_input_files; j++) {
3534
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3535
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3536
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3537
                            continue;
3538
                        fr = c->time_base.den * 1000 / c->time_base.num;
3539
                        if(fr == 25000) {
3540
                            norm = 0;
3541
                            break;
3542
                        } else if((fr == 29970) || (fr == 23976)) {
3543
                            norm = 1;
3544
                            break;
3545
                        }
3546
                    }
3547
                    if(norm >= 0)
3548
                        break;
3549
                }
3550
            }
3551
        }
3552
        if(verbose && norm >= 0)
3553
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3554
    }
3555

    
3556
    if(norm < 0) {
3557
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3558
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3559
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3560
        exit(1);
3561
    }
3562

    
3563
    if(!strcmp(arg, "vcd")) {
3564

    
3565
        opt_video_codec("mpeg1video");
3566
        opt_audio_codec("mp2");
3567
        opt_format("vcd");
3568

    
3569
        opt_frame_size(norm ? "352x240" : "352x288");
3570
        opt_frame_rate(frame_rates[norm]);
3571
        opt_default("gop", norm ? "18" : "15");
3572

    
3573
        opt_default("b", "1150000");
3574
        opt_default("maxrate", "1150000");
3575
        opt_default("minrate", "1150000");
3576
        opt_default("bufsize", "327680"); // 40*1024*8;
3577

    
3578
        audio_bit_rate = 224000;
3579
        audio_sample_rate = 44100;
3580

    
3581
        opt_default("packetsize", "2324");
3582
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3583

    
3584
        /* We have to offset the PTS, so that it is consistent with the SCR.
3585
           SCR starts at 36000, but the first two packs contain only padding
3586
           and the first pack from the other stream, respectively, may also have
3587
           been written before.
3588
           So the real data starts at SCR 36000+3*1200. */
3589
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3590
    } else if(!strcmp(arg, "svcd")) {
3591

    
3592
        opt_video_codec("mpeg2video");
3593
        opt_audio_codec("mp2");
3594
        opt_format("svcd");
3595

    
3596
        opt_frame_size(norm ? "480x480" : "480x576");
3597
        opt_frame_rate(frame_rates[norm]);
3598
        opt_default("gop", norm ? "18" : "15");
3599

    
3600
        opt_default("b", "2040000");
3601
        opt_default("maxrate", "2516000");
3602
        opt_default("minrate", "0"); //1145000;
3603
        opt_default("bufsize", "1835008"); //224*1024*8;
3604
        opt_default("flags", "+SCAN_OFFSET");
3605

    
3606

    
3607
        audio_bit_rate = 224000;
3608
        audio_sample_rate = 44100;
3609

    
3610
        opt_default("packetsize", "2324");
3611

    
3612
    } else if(!strcmp(arg, "dvd")) {
3613

    
3614
        opt_video_codec("mpeg2video");
3615
        opt_audio_codec("ac3");
3616
        opt_format("dvd");
3617

    
3618
        opt_frame_size(norm ? "720x480" : "720x576");
3619
        opt_frame_rate(frame_rates[norm]);
3620
        opt_default("gop", norm ? "18" : "15");
3621

    
3622
        opt_default("b", "6000000");
3623
        opt_default("maxrate", "9000000");
3624
        opt_default("minrate", "0"); //1500000;
3625
        opt_default("bufsize", "1835008"); //224*1024*8;
3626

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

    
3630
        audio_bit_rate = 448000;
3631
        audio_sample_rate = 48000;
3632

    
3633
    } else if(!strncmp(arg, "dv", 2)) {
3634

    
3635
        opt_format("dv");
3636

    
3637
        opt_frame_size(norm ? "720x480" : "720x576");
3638
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3639
                                             (norm ? "yuv411p" : "yuv420p"));
3640
        opt_frame_rate(frame_rates[norm]);
3641

    
3642
        audio_sample_rate = 48000;
3643
        audio_channels = 2;
3644

    
3645
    } else {
3646
        fprintf(stderr, "Unknown target: %s\n", arg);
3647
        exit(1);
3648
    }
3649
}
3650

    
3651
static void opt_video_bsf(const char *arg)
3652
{
3653
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3654
    AVBitStreamFilterContext **bsfp;
3655

    
3656
    if(!bsfc){
3657
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3658
        exit(1);
3659
    }
3660

    
3661
    bsfp= &video_bitstream_filters;
3662
    while(*bsfp)
3663
        bsfp= &(*bsfp)->next;
3664

    
3665
    *bsfp= bsfc;
3666
}
3667

    
3668
//FIXME avoid audio - video code duplication
3669
static void opt_audio_bsf(const char *arg)
3670
{
3671
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3672
    AVBitStreamFilterContext **bsfp;
3673

    
3674
    if(!bsfc){
3675
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3676
        exit(1);
3677
    }
3678

    
3679
    bsfp= &audio_bitstream_filters;
3680
    while(*bsfp)
3681
        bsfp= &(*bsfp)->next;
3682

    
3683
    *bsfp= bsfc;
3684
}
3685

    
3686
static void show_version(void)
3687
{
3688
    /* TODO: add function interface to avutil and avformat */
3689
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3690
           "libavutil   %d\n"
3691
           "libavcodec  %d\n"
3692
           "libavformat %d\n",
3693
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3694
    exit(1);
3695
}
3696

    
3697
static int opt_default(const char *opt, const char *arg){
3698
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3699
    if(!o)
3700
        o = av_set_string(avformat_opts, opt, arg);
3701
    if(!o)
3702
        return -1;
3703

    
3704
//    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));
3705

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

    
3710
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3711
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3712
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3713
        ffm_nopts = 1;
3714
#endif
3715

    
3716
    if(avctx_opts->debug)
3717
        av_log_set_level(AV_LOG_DEBUG);
3718
    return 0;
3719
}
3720

    
3721
const OptionDef options[] = {
3722
    /* main options */
3723
    { "L", 0, {(void*)show_license}, "show license" },
3724
    { "h", 0, {(void*)show_help}, "show help" },
3725
    { "version", 0, {(void*)show_version}, "show version" },
3726
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3727
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3728
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3729
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3730
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3731
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3732
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3733
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3734
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3735
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3736
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3737
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3738
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3739
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3740
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3741
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3742
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3743
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3744
      "add timings for benchmarking" },
3745
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3746
      "dump each input packet" },
3747
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3748
      "when dumping packets, also dump the payload" },
3749
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3750
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3751
    { "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)", "" },
3752
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3753
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3754
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3755
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3756
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3757
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3758
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3759
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3760
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3761

    
3762
    /* video options */
3763
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3764
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3765
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3766
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3767
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3768
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3769
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3770
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3771
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3772
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3773
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3774
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3775
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3776
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3777
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3778
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3779
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3780
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3781
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3782
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3783
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3784
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3785
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3786
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3787
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3788
      "method" },
3789
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3790
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3791
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3792
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3793
      "use same video quality as source (implies VBR)" },
3794
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3795
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3796
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3797
      "deinterlace pictures" },
3798
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3799
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3800
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3801
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3802
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3803
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3804
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3805
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3806
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3807
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3808

    
3809
    /* audio options */
3810
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3811
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3812
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3813
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3814
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3815
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3816
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3817
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3818
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3819
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3820

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

    
3826
    /* grab options */
3827
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3828
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3829
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3830
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3831

    
3832
    /* G.2 grab options */
3833
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3834
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3835

    
3836
    /* muxer options */
3837
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3838
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3839

    
3840
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3841
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3842

    
3843
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3844
    { NULL, },
3845
};
3846

    
3847
static void show_banner(void)
3848
{
3849
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
3850
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3851
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3852
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3853
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3854
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3855
#ifdef __GNUC__
3856
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3857
#else
3858
    fprintf(stderr, ", using a non-gcc compiler\n");
3859
#endif
3860
}
3861

    
3862
static void show_license(void)
3863
{
3864
    show_banner();
3865
#ifdef CONFIG_GPL
3866
    printf(
3867
    "This program is free software; you can redistribute it and/or modify\n"
3868
    "it under the terms of the GNU General Public License as published by\n"
3869
    "the Free Software Foundation; either version 2 of the License, or\n"
3870
    "(at your option) any later version.\n"
3871
    "\n"
3872
    "This program is distributed in the hope that it will be useful,\n"
3873
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3874
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3875
    "GNU General Public License for more details.\n"
3876
    "\n"
3877
    "You should have received a copy of the GNU General Public License\n"
3878
    "along with this program; if not, write to the Free Software\n"
3879
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3880
    );
3881
#else
3882
    printf(
3883
    "This library is free software; you can redistribute it and/or\n"
3884
    "modify it under the terms of the GNU Lesser General Public\n"
3885
    "License as published by the Free Software Foundation; either\n"
3886
    "version 2 of the License, or (at your option) any later version.\n"
3887
    "\n"
3888
    "This library is distributed in the hope that it will be useful,\n"
3889
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3890
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3891
    "Lesser General Public License for more details.\n"
3892
    "\n"
3893
    "You should have received a copy of the GNU Lesser General Public\n"
3894
    "License along with this library; if not, write to the Free Software\n"
3895
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3896
    );
3897
#endif
3898
    exit(1);
3899
}
3900

    
3901
static void show_help(void)
3902
{
3903
    show_banner();
3904
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3905
           "Hyper fast Audio and Video encoder\n");
3906
    printf("\n");
3907
    show_help_options(options, "Main options:\n",
3908
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3909
    show_help_options(options, "\nVideo options:\n",
3910
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3911
                      OPT_VIDEO);
3912
    show_help_options(options, "\nAdvanced Video options:\n",
3913
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3914
                      OPT_VIDEO | OPT_EXPERT);
3915
    show_help_options(options, "\nAudio options:\n",
3916
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3917
                      OPT_AUDIO);
3918
    show_help_options(options, "\nAdvanced Audio options:\n",
3919
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3920
                      OPT_AUDIO | OPT_EXPERT);
3921
    show_help_options(options, "\nSubtitle options:\n",
3922
                      OPT_SUBTITLE | OPT_GRAB,
3923
                      OPT_SUBTITLE);
3924
    show_help_options(options, "\nAudio/Video grab options:\n",
3925
                      OPT_GRAB,
3926
                      OPT_GRAB);
3927
    show_help_options(options, "\nAdvanced options:\n",
3928
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3929
                      OPT_EXPERT);
3930
    av_opt_show(avctx_opts, NULL);
3931
    av_opt_show(avformat_opts, NULL);
3932

    
3933
    exit(1);
3934
}
3935

    
3936
void parse_arg_file(const char *filename)
3937
{
3938
    opt_output_file(filename);
3939
}
3940

    
3941
int main(int argc, char **argv)
3942
{
3943
    int i;
3944
    int64_t ti;
3945

    
3946
    av_register_all();
3947

    
3948
    avctx_opts= avcodec_alloc_context();
3949
    avformat_opts = av_alloc_format_context();
3950

    
3951
    if (argc <= 1)
3952
        show_help();
3953
    else
3954
        show_banner();
3955

    
3956
    /* parse options */
3957
    parse_options(argc, argv, options);
3958

    
3959
    /* file converter / grab */
3960
    if (nb_output_files <= 0) {
3961
        fprintf(stderr, "Must supply at least one output file\n");
3962
        exit(1);
3963
    }
3964

    
3965
    if (nb_input_files == 0) {
3966
        input_sync = 1;
3967
        prepare_grab();
3968
    }
3969

    
3970
    ti = getutime();
3971
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3972
              stream_maps, nb_stream_maps);
3973
    ti = getutime() - ti;
3974
    if (do_benchmark) {
3975
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3976
    }
3977

    
3978
    /* close files */
3979
    for(i=0;i<nb_output_files;i++) {
3980
        /* maybe av_close_output_file ??? */
3981
        AVFormatContext *s = output_files[i];
3982
        int j;
3983
        if (!(s->oformat->flags & AVFMT_NOFILE))
3984
            url_fclose(&s->pb);
3985
        for(j=0;j<s->nb_streams;j++)
3986
            av_free(s->streams[j]);
3987
        av_free(s);
3988
    }
3989
    for(i=0;i<nb_input_files;i++)
3990
        av_close_input_file(input_files[i]);
3991

    
3992
    av_free_static();
3993

    
3994
    if(intra_matrix)
3995
        av_free(intra_matrix);
3996
    if(inter_matrix)
3997
        av_free(inter_matrix);
3998

    
3999
#ifdef POWERPC_PERFORMANCE_REPORT
4000
    extern void powerpc_display_perf_report(void);
4001
    powerpc_display_perf_report();
4002
#endif /* POWERPC_PERFORMANCE_REPORT */
4003

    
4004
#ifndef __MINGW32__
4005
    if (received_sigterm) {
4006
        fprintf(stderr,
4007
            "Received signal %d: terminating.\n",
4008
            (int) received_sigterm);
4009
        exit (255);
4010
    }
4011
#endif
4012
    exit(0); /* not all OS-es handle main() return value */
4013
    return 0;
4014
}