Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4156a436

History | View | Annotate | Download (139 KB)

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

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

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

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

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

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

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

    
69
extern const OptionDef options[];
70

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

    
75
#define MAX_FILES 20
76

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

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

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

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

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

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

    
151
static int subtitle_codec_id = CODEC_ID_NONE;
152
static char *subtitle_language = NULL;
153

    
154
static float mux_preload= 0.5;
155
static float mux_max_delay= 0.7;
156

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

    
183
static int rate_emu = 0;
184

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

    
199
static const char *audio_grab_format = "audio_device";
200
static char *audio_device = NULL;
201
static int audio_volume = 256;
202

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

    
216
static int pgmyuv_compatibility_hack=0;
217
static int dts_delta_threshold = 10;
218

    
219
static int sws_flags = SWS_BICUBIC;
220

    
221
const char **opt_names=NULL;
222
int opt_name_count=0;
223
AVCodecContext *avctx_opts;
224
AVFormatContext *avformat_opts;
225

    
226
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
227
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
228
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
229

    
230
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
231

    
232
struct AVInputStream;
233

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

    
252
    int video_crop;
253
    int topBand;             /* cropping area sizes */
254
    int leftBand;
255

    
256
    int video_pad;
257
    int padtop;              /* padding area sizes */
258
    int padbottom;
259
    int padleft;
260
    int padright;
261

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

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

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

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

    
294
#ifndef __MINGW32__
295

    
296
/* init terminal so that we can grab keys */
297
static struct termios oldtty;
298

    
299
static void term_exit(void)
300
{
301
    tcsetattr (0, TCSANOW, &oldtty);
302
}
303

    
304
static volatile sig_atomic_t received_sigterm = 0;
305

    
306
static void
307
sigterm_handler(int sig)
308
{
309
    received_sigterm = sig;
310
    term_exit();
311
}
312

    
313
static void term_init(void)
314
{
315
    struct termios tty;
316

    
317
    tcgetattr (0, &tty);
318
    oldtty = tty;
319

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

    
329
    tcsetattr (0, TCSANOW, &tty);
330

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

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

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

    
363
        return n;
364
    }
365
    return -1;
366
}
367

    
368
static int decode_interrupt_cb(void)
369
{
370
    return q_pressed || (q_pressed = read_key() == 'q');
371
}
372

    
373
#else
374

    
375
static volatile int received_sigterm = 0;
376

    
377
/* no interactive support */
378
static void term_exit(void)
379
{
380
}
381

    
382
static void term_init(void)
383
{
384
}
385

    
386
static int read_key(void)
387
{
388
    return 0;
389
}
390

    
391
#endif
392

    
393
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
394
{
395
    int i, err;
396
    AVFormatContext *ic;
397

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

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

    
414
    av_close_input_file(ic);
415
    return 0;
416
}
417

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

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

    
438
        bsfc= bsfc->next;
439
    }
440

    
441
    av_interleaved_write_frame(s, pkt);
442
}
443

    
444
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
445

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

    
456
    int size_out, frame_bytes, ret;
457
    AVCodecContext *enc= ost->st->codec;
458

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

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

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

    
489
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
490
                        ist->is_start=0;
491
                    else
492
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
493

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

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

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

    
530
        frame_bytes = enc->frame_size * 2 * enc->channels;
531

    
532
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
533
            AVPacket pkt;
534
            av_init_packet(&pkt);
535

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

    
547
            ost->sync_opts += enc->frame_size;
548
        }
549
    } else {
550
        AVPacket pkt;
551
        av_init_packet(&pkt);
552

    
553
        ost->sync_opts += size_out / (2 * enc->channels);
554

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

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

    
600
    dec = ist->st->codec;
601

    
602
    /* deinterlace : must be done before any resize */
603
    if (do_deinterlace || using_vhook) {
604
        int size;
605

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

    
612
        picture2 = &picture_tmp;
613
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
614

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

    
630
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
631

    
632
    if (picture != picture2)
633
        *picture = *picture2;
634
    *bufp = buf;
635
}
636

    
637
/* we begin to correct av delay at this threshold */
638
#define AV_DELAY_MAX 0.100
639

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

    
652
    if (pts == AV_NOPTS_VALUE) {
653
        fprintf(stderr, "Subtitle packets must have a pts\n");
654
        return;
655
    }
656

    
657
    enc = ost->st->codec;
658

    
659
    if (!subtitle_out) {
660
        subtitle_out = av_malloc(subtitle_out_max_size);
661
    }
662

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

    
671
    for(i = 0; i < nb; i++) {
672
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
673
                                                    subtitle_out_max_size, sub);
674

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

    
692
static int bit_buffer_size= 1024*256;
693
static uint8_t *bit_buffer= NULL;
694

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

    
707
    avcodec_get_frame_defaults(&picture_crop_temp);
708
    avcodec_get_frame_defaults(&picture_pad_temp);
709

    
710
    enc = ost->st->codec;
711
    dec = ist->st->codec;
712

    
713
    /* by default, we output a single frame */
714
    nb_frames = 1;
715

    
716
    *frame_size = 0;
717

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

    
739
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
740
    if (nb_frames <= 0)
741
        return;
742

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
944

    
945
    oc = output_files[0];
946

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

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

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

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

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

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

    
1019
        fflush(stderr);
1020
    }
1021

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

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

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

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

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

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

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

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

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

    
1180
                ist->frame++;
1181
            }
1182

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

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

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

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

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

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

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

    
1252
                            opkt.stream_index= ost->index;
1253
                            if(pkt->pts != AV_NOPTS_VALUE)
1254
                                opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1255
                            else
1256
                                opkt.pts= AV_NOPTS_VALUE;
1257

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

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

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

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

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

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

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

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

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

    
1365

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1952
    discard_packet:
1953
        av_free_packet(&pkt);
1954

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

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

    
1967
    term_exit();
1968

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

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

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

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

    
1995
    /* finished ! */
1996

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2202

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

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

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

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

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

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

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

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

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

    
2260

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

    
2274

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

    
2288

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2391
static void opt_audio_bitrate(const char *arg)
2392
{
2393
    audio_bit_rate = atoi(arg) * 1000;
2394
}
2395

    
2396
static void opt_audio_rate(const char *arg)
2397
{
2398
    audio_sample_rate = atoi(arg);
2399
}
2400

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

    
2406
static void opt_video_device(const char *arg)
2407
{
2408
    video_device = av_strdup(arg);
2409
}
2410

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

    
2416
static void opt_video_channel(const char *arg)
2417
{
2418
    video_channel = strtol(arg, NULL, 0);
2419
}
2420

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

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

    
2431
static void opt_codec(int *pstream_copy, int *pcodec_id,
2432
                      int codec_type, const char *arg)
2433
{
2434
    AVCodec *p;
2435

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

    
2454
static void opt_audio_codec(const char *arg)
2455
{
2456
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2457
}
2458

    
2459
static void opt_audio_tag(const char *arg)
2460
{
2461
    char *tail;
2462
    audio_codec_tag= strtol(arg, &tail, 0);
2463

    
2464
    if(!tail || *tail)
2465
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2466
}
2467

    
2468
static void opt_video_tag(const char *arg)
2469
{
2470
    char *tail;
2471
    video_codec_tag= strtol(arg, &tail, 0);
2472

    
2473
    if(!tail || *tail)
2474
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2475
}
2476

    
2477
static void add_frame_hooker(const char *arg)
2478
{
2479
    int argc = 0;
2480
    char *argv[64];
2481
    int i;
2482
    char *args = av_strdup(arg);
2483

    
2484
    using_vhook = 1;
2485

    
2486
    argv[0] = strtok(args, " ");
2487
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2488
    }
2489

    
2490
    i = frame_hook_add(argc, argv);
2491

    
2492
    if (i != 0) {
2493
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2494
        exit(1);
2495
    }
2496
}
2497

    
2498
const char *motion_str[] = {
2499
    "zero",
2500
    "full",
2501
    "log",
2502
    "phods",
2503
    "epzs",
2504
    "x1",
2505
    "hex",
2506
    "umh",
2507
    "iter",
2508
    NULL,
2509
};
2510

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

    
2527
static void opt_video_codec(const char *arg)
2528
{
2529
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2530
}
2531

    
2532
static void opt_subtitle_codec(const char *arg)
2533
{
2534
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2535
}
2536

    
2537
static void opt_map(const char *arg)
2538
{
2539
    AVStreamMap *m;
2540
    const char *p;
2541

    
2542
    p = arg;
2543
    m = &stream_maps[nb_stream_maps++];
2544

    
2545
    m->file_index = strtol(arg, (char **)&p, 0);
2546
    if (*p)
2547
        p++;
2548

    
2549
    m->stream_index = strtol(p, (char **)&p, 0);
2550
    if (*p) {
2551
        p++;
2552
        m->sync_file_index = strtol(p, (char **)&p, 0);
2553
        if (*p)
2554
            p++;
2555
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2556
    } else {
2557
        m->sync_file_index = m->file_index;
2558
        m->sync_stream_index = m->stream_index;
2559
    }
2560
}
2561

    
2562
static void opt_map_meta_data(const char *arg)
2563
{
2564
    AVMetaDataMap *m;
2565
    const char *p;
2566

    
2567
    p = arg;
2568
    m = &meta_data_maps[nb_meta_data_maps++];
2569

    
2570
    m->out_file = strtol(arg, (char **)&p, 0);
2571
    if (*p)
2572
        p++;
2573

    
2574
    m->in_file = strtol(p, (char **)&p, 0);
2575
}
2576

    
2577
static void opt_recording_time(const char *arg)
2578
{
2579
    recording_time = parse_date(arg, 1);
2580
}
2581

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

    
2587
static void opt_rec_timestamp(const char *arg)
2588
{
2589
    rec_timestamp = parse_date(arg, 0) / 1000000;
2590
}
2591

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

    
2597
static void opt_input_file(const char *filename)
2598
{
2599
    AVFormatContext *ic;
2600
    AVFormatParameters params, *ap = &params;
2601
    int err, i, ret, rfps, rfps_base;
2602
    int64_t timestamp;
2603

    
2604
    if (!strcmp(filename, "-"))
2605
        filename = "pipe:";
2606

    
2607
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2608
                   !strcmp( filename, "/dev/stdin" );
2609

    
2610
    /* get default parameters from command line */
2611
    ic = av_alloc_format_context();
2612

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

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

    
2644
    ic->loop_input = loop_input;
2645

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

    
2654
    timestamp = start_time;
2655
    /* add the stream start time */
2656
    if (ic->start_time != AV_NOPTS_VALUE)
2657
        timestamp += ic->start_time;
2658

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

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

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

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

    
2716
                    (float)rfps / rfps_base, rfps, rfps_base);
2717
            }
2718
            /* update the current frame rate to match the stream frame rate */
2719
            frame_rate      = rfps;
2720
            frame_rate_base = rfps_base;
2721

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

    
2739
    input_files[nb_input_files] = ic;
2740
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2741
    /* dump the file content */
2742
    if (verbose >= 0)
2743
        dump_format(ic, nb_input_files, filename, 0);
2744

    
2745
    nb_input_files++;
2746
    file_iformat = NULL;
2747
    file_oformat = NULL;
2748
    image_format = NULL;
2749

    
2750
    grab_device = NULL;
2751
    video_channel = 0;
2752

    
2753
    rate_emu = 0;
2754
}
2755

    
2756
static void opt_grab(const char *arg)
2757
{
2758
    file_iformat = av_find_input_format(arg);
2759
    opt_input_file("");
2760
}
2761

    
2762
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2763
{
2764
    int has_video, has_audio, i, j;
2765
    AVFormatContext *ic;
2766

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

    
2793
static void new_video_stream(AVFormatContext *oc)
2794
{
2795
    AVStream *st;
2796
    AVCodecContext *video_enc;
2797
    int codec_id;
2798

    
2799
    st = av_new_stream(oc, oc->nb_streams);
2800
    if (!st) {
2801
        fprintf(stderr, "Could not alloc stream\n");
2802
        exit(1);
2803
    }
2804
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2805
    video_bitstream_filters= NULL;
2806

    
2807
#if defined(HAVE_THREADS)
2808
    if(thread_count>1)
2809
        avcodec_thread_init(st->codec, thread_count);
2810
#endif
2811

    
2812
    video_enc = st->codec;
2813

    
2814
    if(video_codec_tag)
2815
        video_enc->codec_tag= video_codec_tag;
2816

    
2817
    if(   (video_global_header&1)
2818
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2819
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2820
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2821
    }
2822
    if(video_global_header&2){
2823
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2824
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2825
    }
2826

    
2827
    if (video_stream_copy) {
2828
        st->stream_copy = 1;
2829
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2830
    } else {
2831
        char *p;
2832
        int i;
2833
        AVCodec *codec;
2834

    
2835
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2836
        if (video_codec_id != CODEC_ID_NONE)
2837
            codec_id = video_codec_id;
2838

    
2839
        video_enc->codec_id = codec_id;
2840
        codec = avcodec_find_encoder(codec_id);
2841

    
2842
        for(i=0; i<opt_name_count; i++){
2843
             AVOption *opt;
2844
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2845
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2846
                 av_set_double(video_enc, opt_names[i], d);
2847
        }
2848

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

    
2868
        video_enc->width = frame_width + frame_padright + frame_padleft;
2869
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2870
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2871
        video_enc->pix_fmt = frame_pix_fmt;
2872

    
2873
        if(codec && codec->pix_fmts){
2874
            const enum PixelFormat *p= codec->pix_fmts;
2875
            for(; *p!=-1; p++){
2876
                if(*p == video_enc->pix_fmt)
2877
                    break;
2878
            }
2879
            if(*p == -1)
2880
                video_enc->pix_fmt = codec->pix_fmts[0];
2881
        }
2882

    
2883
        if (intra_only)
2884
            video_enc->gop_size = 0;
2885
        if (video_qscale || same_quality) {
2886
            video_enc->flags |= CODEC_FLAG_QSCALE;
2887
            video_enc->global_quality=
2888
                st->quality = FF_QP2LAMBDA * video_qscale;
2889
        }
2890

    
2891
        if(intra_matrix)
2892
            video_enc->intra_matrix = intra_matrix;
2893
        if(inter_matrix)
2894
            video_enc->inter_matrix = inter_matrix;
2895

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

    
2933
        if(packet_size){
2934
            video_enc->rtp_mode= 1;
2935
            video_enc->rtp_payload_size= packet_size;
2936
        }
2937

    
2938
        if (do_psnr)
2939
            video_enc->flags|= CODEC_FLAG_PSNR;
2940

    
2941
        video_enc->me_method = me_method;
2942

    
2943
        /* two pass mode */
2944
        if (do_pass) {
2945
            if (do_pass == 1) {
2946
                video_enc->flags |= CODEC_FLAG_PASS1;
2947
            } else {
2948
                video_enc->flags |= CODEC_FLAG_PASS2;
2949
            }
2950
        }
2951
    }
2952

    
2953
    /* reset some key parameters */
2954
    video_disable = 0;
2955
    video_codec_id = CODEC_ID_NONE;
2956
    video_stream_copy = 0;
2957
}
2958

    
2959
static void new_audio_stream(AVFormatContext *oc)
2960
{
2961
    AVStream *st;
2962
    AVCodecContext *audio_enc;
2963
    int codec_id, i;
2964

    
2965
    st = av_new_stream(oc, oc->nb_streams);
2966
    if (!st) {
2967
        fprintf(stderr, "Could not alloc stream\n");
2968
        exit(1);
2969
    }
2970

    
2971
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2972
    audio_bitstream_filters= NULL;
2973

    
2974
#if defined(HAVE_THREADS)
2975
    if(thread_count>1)
2976
        avcodec_thread_init(st->codec, thread_count);
2977
#endif
2978

    
2979
    audio_enc = st->codec;
2980
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2981

    
2982
    if(audio_codec_tag)
2983
        audio_enc->codec_tag= audio_codec_tag;
2984

    
2985
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2986
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2987
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2988
    }
2989
    if (audio_stream_copy) {
2990
        st->stream_copy = 1;
2991
        audio_enc->channels = audio_channels;
2992
    } else {
2993
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2994

    
2995
        for(i=0; i<opt_name_count; i++){
2996
            AVOption *opt;
2997
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
2998
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2999
                av_set_double(audio_enc, opt_names[i], d);
3000
        }
3001

    
3002
        if (audio_codec_id != CODEC_ID_NONE)
3003
            codec_id = audio_codec_id;
3004
        audio_enc->codec_id = codec_id;
3005

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

    
3029
    /* reset some key parameters */
3030
    audio_disable = 0;
3031
    audio_codec_id = CODEC_ID_NONE;
3032
    audio_stream_copy = 0;
3033
}
3034

    
3035
static void opt_new_subtitle_stream(void)
3036
{
3037
    AVFormatContext *oc;
3038
    AVStream *st;
3039
    AVCodecContext *subtitle_enc;
3040
    int i;
3041

    
3042
    if (nb_output_files <= 0) {
3043
        fprintf(stderr, "At least one output file must be specified\n");
3044
        exit(1);
3045
    }
3046
    oc = output_files[nb_output_files - 1];
3047

    
3048
    st = av_new_stream(oc, oc->nb_streams);
3049
    if (!st) {
3050
        fprintf(stderr, "Could not alloc stream\n");
3051
        exit(1);
3052
    }
3053

    
3054
    subtitle_enc = st->codec;
3055
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3056
    if (subtitle_stream_copy) {
3057
        st->stream_copy = 1;
3058
    } else {
3059
        for(i=0; i<opt_name_count; i++){
3060
             AVOption *opt;
3061
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3062
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3063
                 av_set_double(subtitle_enc, opt_names[i], d);
3064
        }
3065
        subtitle_enc->codec_id = subtitle_codec_id;
3066
    }
3067

    
3068
    if (subtitle_language) {
3069
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3070
        av_free(subtitle_language);
3071
        subtitle_language = NULL;
3072
    }
3073

    
3074
    subtitle_codec_id = CODEC_ID_NONE;
3075
    subtitle_stream_copy = 0;
3076
}
3077

    
3078
static void opt_new_audio_stream(void)
3079
{
3080
    AVFormatContext *oc;
3081
    if (nb_output_files <= 0) {
3082
        fprintf(stderr, "At least one output file must be specified\n");
3083
        exit(1);
3084
    }
3085
    oc = output_files[nb_output_files - 1];
3086
    new_audio_stream(oc);
3087
}
3088

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

    
3100
static void opt_output_file(const char *filename)
3101
{
3102
    AVFormatContext *oc;
3103
    int use_video, use_audio, input_has_video, input_has_audio, i;
3104
    AVFormatParameters params, *ap = &params;
3105

    
3106
    if (!strcmp(filename, "-"))
3107
        filename = "pipe:";
3108

    
3109
    oc = av_alloc_format_context();
3110

    
3111
    if (!file_oformat) {
3112
        file_oformat = guess_format(NULL, filename, NULL);
3113
        if (!file_oformat) {
3114
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3115
                    filename);
3116
            exit(1);
3117
        }
3118
    }
3119

    
3120
    oc->oformat = file_oformat;
3121
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3122

    
3123
    if (!strcmp(file_oformat->name, "ffm") &&
3124
        strstart(filename, "http:", NULL)) {
3125
        /* special case for files sent to ffserver: we get the stream
3126
           parameters from ffserver */
3127
        if (read_ffserver_streams(oc, filename) < 0) {
3128
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3129
            exit(1);
3130
        }
3131
    } else {
3132
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3133
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3134

    
3135
        /* disable if no corresponding type found and at least one
3136
           input file */
3137
        if (nb_input_files > 0) {
3138
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3139
            if (!input_has_video)
3140
                use_video = 0;
3141
            if (!input_has_audio)
3142
                use_audio = 0;
3143
        }
3144

    
3145
        /* manual disable */
3146
        if (audio_disable) {
3147
            use_audio = 0;
3148
        }
3149
        if (video_disable) {
3150
            use_video = 0;
3151
        }
3152

    
3153
        if (use_video) {
3154
            new_video_stream(oc);
3155
        }
3156

    
3157
        if (use_audio) {
3158
            new_audio_stream(oc);
3159
        }
3160

    
3161
        if (!oc->nb_streams) {
3162
            fprintf(stderr, "No audio or video streams available\n");
3163
            exit(1);
3164
        }
3165

    
3166
        oc->timestamp = rec_timestamp;
3167

    
3168
        if (str_title)
3169
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3170
        if (str_author)
3171
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3172
        if (str_copyright)
3173
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3174
        if (str_comment)
3175
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3176
        if (str_album)
3177
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3178
    }
3179

    
3180
    output_files[nb_output_files++] = oc;
3181

    
3182
    /* check filename in case of an image number is expected */
3183
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3184
        if (!av_filename_number_test(oc->filename)) {
3185
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3186
            exit(1);
3187
        }
3188
    }
3189

    
3190
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3191
        /* test if it already exists to avoid loosing precious files */
3192
        if (!file_overwrite &&
3193
            (strchr(filename, ':') == NULL ||
3194
             strstart(filename, "file:", NULL))) {
3195
            if (url_exist(filename)) {
3196
                int c;
3197

    
3198
                if ( !using_stdin ) {
3199
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3200
                    fflush(stderr);
3201
                    c = getchar();
3202
                    if (toupper(c) != 'Y') {
3203
                        fprintf(stderr, "Not overwriting - exiting\n");
3204
                        exit(1);
3205
                    }
3206
                                }
3207
                                else {
3208
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3209
                    exit(1);
3210
                                }
3211
            }
3212
        }
3213

    
3214
        /* open the file */
3215
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3216
            fprintf(stderr, "Could not open '%s'\n", filename);
3217
            exit(1);
3218
        }
3219
    }
3220

    
3221
    memset(ap, 0, sizeof(*ap));
3222
    ap->image_format = image_format;
3223
    if (av_set_parameters(oc, ap) < 0) {
3224
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3225
                oc->filename);
3226
        exit(1);
3227
    }
3228

    
3229
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3230
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3231
    oc->loop_output = loop_output;
3232

    
3233
    for(i=0; i<opt_name_count; i++){
3234
        AVOption *opt;
3235
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3236
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3237
            av_set_double(oc, opt_names[i], d);
3238
    }
3239

    
3240
    /* reset some options */
3241
    file_oformat = NULL;
3242
    file_iformat = NULL;
3243
    image_format = NULL;
3244
}
3245

    
3246
/* prepare dummy protocols for grab */
3247
static void prepare_grab(void)
3248
{
3249
    int has_video, has_audio, i, j;
3250
    AVFormatContext *oc;
3251
    AVFormatContext *ic;
3252
    AVFormatParameters vp1, *vp = &vp1;
3253
    AVFormatParameters ap1, *ap = &ap1;
3254

    
3255
    /* see if audio/video inputs are needed */
3256
    has_video = 0;
3257
    has_audio = 0;
3258
    memset(ap, 0, sizeof(*ap));
3259
    memset(vp, 0, sizeof(*vp));
3260
    vp->time_base.num= 1;
3261
    for(j=0;j<nb_output_files;j++) {
3262
        oc = output_files[j];
3263
        for(i=0;i<oc->nb_streams;i++) {
3264
            AVCodecContext *enc = oc->streams[i]->codec;
3265
            switch(enc->codec_type) {
3266
            case CODEC_TYPE_AUDIO:
3267
                if (enc->sample_rate > ap->sample_rate)
3268
                    ap->sample_rate = enc->sample_rate;
3269
                if (enc->channels > ap->channels)
3270
                    ap->channels = enc->channels;
3271
                has_audio = 1;
3272
                break;
3273
            case CODEC_TYPE_VIDEO:
3274
                if (enc->width > vp->width)
3275
                    vp->width = enc->width;
3276
                if (enc->height > vp->height)
3277
                    vp->height = enc->height;
3278

    
3279
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3280
                    vp->time_base = enc->time_base;
3281
                    vp->width += frame_leftBand + frame_rightBand;
3282
                    vp->width -= (frame_padleft + frame_padright);
3283
                    vp->height += frame_topBand + frame_bottomBand;
3284
                    vp->height -= (frame_padtop + frame_padbottom);
3285
                }
3286
                has_video = 1;
3287
                break;
3288
            default:
3289
                av_abort();
3290
            }
3291
        }
3292
    }
3293

    
3294
    if (has_video == 0 && has_audio == 0) {
3295
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3296
        exit(1);
3297
    }
3298

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

    
3321
        if (verbose >= 0)
3322
            dump_format(ic, nb_input_files, "", 0);
3323

    
3324
        nb_input_files++;
3325
    }
3326
    if (has_audio && audio_grab_format) {
3327
        AVInputFormat *fmt1;
3328
        fmt1 = av_find_input_format(audio_grab_format);
3329
        ap->device = audio_device;
3330
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3331
            fprintf(stderr, "Could not find audio grab device\n");
3332
            exit(1);
3333
        }
3334
        input_files[nb_input_files] = ic;
3335

    
3336
        if (verbose >= 0)
3337
            dump_format(ic, nb_input_files, "", 0);
3338

    
3339
        nb_input_files++;
3340
    }
3341
}
3342

    
3343
/* same option as mencoder */
3344
static void opt_pass(const char *pass_str)
3345
{
3346
    int pass;
3347
    pass = atoi(pass_str);
3348
    if (pass != 1 && pass != 2) {
3349
        fprintf(stderr, "pass number can be only 1 or 2\n");
3350
        exit(1);
3351
    }
3352
    do_pass = pass;
3353
}
3354

    
3355
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3356
static int64_t getutime(void)
3357
{
3358
  return av_gettime();
3359
}
3360
#else
3361
static int64_t getutime(void)
3362
{
3363
    struct rusage rusage;
3364

    
3365
    getrusage(RUSAGE_SELF, &rusage);
3366
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3367
}
3368
#endif
3369

    
3370
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3371
extern int ffm_nopts;
3372
#endif
3373

    
3374
static void show_formats(void)
3375
{
3376
    AVInputFormat *ifmt;
3377
    AVOutputFormat *ofmt;
3378
    AVImageFormat *image_fmt;
3379
    URLProtocol *up;
3380
    AVCodec *p, *p2;
3381
    const char **pp, *last_name;
3382

    
3383
    printf("File formats:\n");
3384
    last_name= "000";
3385
    for(;;){
3386
        int decode=0;
3387
        int encode=0;
3388
        const char *name=NULL;
3389
        const char *long_name=NULL;
3390

    
3391
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3392
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3393
                strcmp(ofmt->name, last_name)>0){
3394
                name= ofmt->name;
3395
                long_name= ofmt->long_name;
3396
                encode=1;
3397
            }
3398
        }
3399
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3400
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3401
                strcmp(ifmt->name, last_name)>0){
3402
                name= ifmt->name;
3403
                long_name= ifmt->long_name;
3404
                encode=0;
3405
            }
3406
            if(name && strcmp(ifmt->name, name)==0)
3407
                decode=1;
3408
        }
3409
        if(name==NULL)
3410
            break;
3411
        last_name= name;
3412

    
3413
        printf(
3414
            " %s%s %-15s %s\n",
3415
            decode ? "D":" ",
3416
            encode ? "E":" ",
3417
            name,
3418
            long_name ? long_name:" ");
3419
    }
3420
    printf("\n");
3421

    
3422
    printf("Image formats (filename extensions, if any, follow):\n");
3423
    for(image_fmt = first_image_format; image_fmt != NULL;
3424
        image_fmt = image_fmt->next) {
3425
        printf(
3426
            " %s%s %-6s %s\n",
3427
            image_fmt->img_read  ? "D":" ",
3428
            image_fmt->img_write ? "E":" ",
3429
            image_fmt->name,
3430
            image_fmt->extensions ? image_fmt->extensions:" ");
3431
    }
3432
    printf("\n");
3433

    
3434
    printf("Codecs:\n");
3435
    last_name= "000";
3436
    for(;;){
3437
        int decode=0;
3438
        int encode=0;
3439
        int cap=0;
3440
        const char *type_str;
3441

    
3442
        p2=NULL;
3443
        for(p = first_avcodec; p != NULL; p = p->next) {
3444
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3445
                strcmp(p->name, last_name)>0){
3446
                p2= p;
3447
                decode= encode= cap=0;
3448
            }
3449
            if(p2 && strcmp(p->name, p2->name)==0){
3450
                if(p->decode) decode=1;
3451
                if(p->encode) encode=1;
3452
                cap |= p->capabilities;
3453
            }
3454
        }
3455
        if(p2==NULL)
3456
            break;
3457
        last_name= p2->name;
3458

    
3459
        switch(p2->type) {
3460
        case CODEC_TYPE_VIDEO:
3461
            type_str = "V";
3462
            break;
3463
        case CODEC_TYPE_AUDIO:
3464
            type_str = "A";
3465
            break;
3466
        case CODEC_TYPE_SUBTITLE:
3467
            type_str = "S";
3468
            break;
3469
        default:
3470
            type_str = "?";
3471
            break;
3472
        }
3473
        printf(
3474
            " %s%s%s%s%s%s %s",
3475
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3476
            encode ? "E":" ",
3477
            type_str,
3478
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3479
            cap & CODEC_CAP_DR1 ? "D":" ",
3480
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3481
            p2->name);
3482
       /* if(p2->decoder && decode==0)
3483
            printf(" use %s for decoding", p2->decoder->name);*/
3484
        printf("\n");
3485
    }
3486
    printf("\n");
3487

    
3488
    printf("Supported file protocols:\n");
3489
    for(up = first_protocol; up != NULL; up = up->next)
3490
        printf(" %s:", up->name);
3491
    printf("\n");
3492

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

    
3516
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3517
{
3518
    int i;
3519
    const char *p = str;
3520
    for(i = 0;; i++) {
3521
        dest[i] = atoi(p);
3522
        if(i == 63)
3523
            break;
3524
        p = strchr(p, ',');
3525
        if(!p) {
3526
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3527
            exit(1);
3528
        }
3529
        p++;
3530
    }
3531
}
3532

    
3533
static void opt_inter_matrix(const char *arg)
3534
{
3535
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3536
    parse_matrix_coeffs(inter_matrix, arg);
3537
}
3538

    
3539
static void opt_intra_matrix(const char *arg)
3540
{
3541
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3542
    parse_matrix_coeffs(intra_matrix, arg);
3543
}
3544

    
3545
static void opt_target(const char *arg)
3546
{
3547
    int norm = -1;
3548
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3549

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

    
3594
    if(norm < 0) {
3595
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3596
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3597
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3598
        exit(1);
3599
    }
3600

    
3601
    if(!strcmp(arg, "vcd")) {
3602

    
3603
        opt_video_codec("mpeg1video");
3604
        opt_audio_codec("mp2");
3605
        opt_format("vcd");
3606

    
3607
        opt_frame_size(norm ? "352x240" : "352x288");
3608
        opt_frame_rate(frame_rates[norm]);
3609
        opt_default("gop", norm ? "18" : "15");
3610

    
3611
        opt_default("b", "1150000");
3612
        opt_default("maxrate", "1150000");
3613
        opt_default("minrate", "1150000");
3614
        opt_default("bufsize", "327680"); // 40*1024*8;
3615

    
3616
        audio_bit_rate = 224000;
3617
        audio_sample_rate = 44100;
3618

    
3619
        opt_default("packetsize", "2324");
3620
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3621

    
3622
        /* We have to offset the PTS, so that it is consistent with the SCR.
3623
           SCR starts at 36000, but the first two packs contain only padding
3624
           and the first pack from the other stream, respectively, may also have
3625
           been written before.
3626
           So the real data starts at SCR 36000+3*1200. */
3627
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3628
    } else if(!strcmp(arg, "svcd")) {
3629

    
3630
        opt_video_codec("mpeg2video");
3631
        opt_audio_codec("mp2");
3632
        opt_format("svcd");
3633

    
3634
        opt_frame_size(norm ? "480x480" : "480x576");
3635
        opt_frame_rate(frame_rates[norm]);
3636
        opt_default("gop", norm ? "18" : "15");
3637

    
3638
        opt_default("b", "2040000");
3639
        opt_default("maxrate", "2516000");
3640
        opt_default("minrate", "0"); //1145000;
3641
        opt_default("bufsize", "1835008"); //224*1024*8;
3642
        opt_default("flags", "+SCAN_OFFSET");
3643

    
3644

    
3645
        audio_bit_rate = 224000;
3646
        audio_sample_rate = 44100;
3647

    
3648
        opt_default("packetsize", "2324");
3649

    
3650
    } else if(!strcmp(arg, "dvd")) {
3651

    
3652
        opt_video_codec("mpeg2video");
3653
        opt_audio_codec("ac3");
3654
        opt_format("dvd");
3655

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

    
3660
        opt_default("b", "6000000");
3661
        opt_default("maxrate", "9000000");
3662
        opt_default("minrate", "0"); //1500000;
3663
        opt_default("bufsize", "1835008"); //224*1024*8;
3664

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

    
3668
        audio_bit_rate = 448000;
3669
        audio_sample_rate = 48000;
3670

    
3671
    } else if(!strncmp(arg, "dv", 2)) {
3672

    
3673
        opt_format("dv");
3674

    
3675
        opt_frame_size(norm ? "720x480" : "720x576");
3676
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3677
                                             (norm ? "yuv411p" : "yuv420p"));
3678
        opt_frame_rate(frame_rates[norm]);
3679

    
3680
        audio_sample_rate = 48000;
3681
        audio_channels = 2;
3682

    
3683
    } else {
3684
        fprintf(stderr, "Unknown target: %s\n", arg);
3685
        exit(1);
3686
    }
3687
}
3688

    
3689
static void opt_video_bsf(const char *arg)
3690
{
3691
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3692
    AVBitStreamFilterContext **bsfp;
3693

    
3694
    if(!bsfc){
3695
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3696
        exit(1);
3697
    }
3698

    
3699
    bsfp= &video_bitstream_filters;
3700
    while(*bsfp)
3701
        bsfp= &(*bsfp)->next;
3702

    
3703
    *bsfp= bsfc;
3704
}
3705

    
3706
//FIXME avoid audio - video code duplication
3707
static void opt_audio_bsf(const char *arg)
3708
{
3709
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3710
    AVBitStreamFilterContext **bsfp;
3711

    
3712
    if(!bsfc){
3713
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3714
        exit(1);
3715
    }
3716

    
3717
    bsfp= &audio_bitstream_filters;
3718
    while(*bsfp)
3719
        bsfp= &(*bsfp)->next;
3720

    
3721
    *bsfp= bsfc;
3722
}
3723

    
3724
static void show_version(void)
3725
{
3726
    /* TODO: add function interface to avutil and avformat */
3727
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3728
           "libavutil   %d\n"
3729
           "libavcodec  %d\n"
3730
           "libavformat %d\n",
3731
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3732
    exit(1);
3733
}
3734

    
3735
static int opt_default(const char *opt, const char *arg){
3736
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3737
    if(!o)
3738
        o = av_set_string(avformat_opts, opt, arg);
3739
    if(!o)
3740
        return -1;
3741

    
3742
//    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));
3743

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

    
3748
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3749
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3750
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3751
        ffm_nopts = 1;
3752
#endif
3753

    
3754
    if(avctx_opts->debug)
3755
        av_log_set_level(AV_LOG_DEBUG);
3756
    return 0;
3757
}
3758

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

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

    
3851
    /* audio options */
3852
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3853
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3854
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3855
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3856
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3857
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3858
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3859
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3860
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3861
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3862

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

    
3868
    /* grab options */
3869
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3870
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3871
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3872
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3873

    
3874
    /* G.2 grab options */
3875
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3876
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3877

    
3878
    /* muxer options */
3879
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3880
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3881

    
3882
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3883
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3884

    
3885
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3886
    { NULL, },
3887
};
3888

    
3889
static void show_banner(void)
3890
{
3891
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3892
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3893
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3894
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3895
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3896
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3897
#ifdef __GNUC__
3898
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3899
#else
3900
    fprintf(stderr, ", using a non-gcc compiler\n");
3901
#endif
3902
}
3903

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

    
3943
static void show_help(void)
3944
{
3945
    show_banner();
3946
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3947
           "Hyper fast Audio and Video encoder\n");
3948
    printf("\n");
3949
    show_help_options(options, "Main options:\n",
3950
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3951
    show_help_options(options, "\nVideo options:\n",
3952
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3953
                      OPT_VIDEO);
3954
    show_help_options(options, "\nAdvanced Video options:\n",
3955
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3956
                      OPT_VIDEO | OPT_EXPERT);
3957
    show_help_options(options, "\nAudio options:\n",
3958
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3959
                      OPT_AUDIO);
3960
    show_help_options(options, "\nAdvanced Audio options:\n",
3961
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3962
                      OPT_AUDIO | OPT_EXPERT);
3963
    show_help_options(options, "\nSubtitle options:\n",
3964
                      OPT_SUBTITLE | OPT_GRAB,
3965
                      OPT_SUBTITLE);
3966
    show_help_options(options, "\nAudio/Video grab options:\n",
3967
                      OPT_GRAB,
3968
                      OPT_GRAB);
3969
    show_help_options(options, "\nAdvanced options:\n",
3970
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3971
                      OPT_EXPERT);
3972
    av_opt_show(avctx_opts, NULL);
3973
    av_opt_show(avformat_opts, NULL);
3974

    
3975
    exit(1);
3976
}
3977

    
3978
void parse_arg_file(const char *filename)
3979
{
3980
    opt_output_file(filename);
3981
}
3982

    
3983
int main(int argc, char **argv)
3984
{
3985
    int i;
3986
    int64_t ti;
3987

    
3988
    av_register_all();
3989

    
3990
    avctx_opts= avcodec_alloc_context();
3991
    avformat_opts = av_alloc_format_context();
3992

    
3993
    if (argc <= 1)
3994
        show_help();
3995
    else
3996
        show_banner();
3997

    
3998
    /* parse options */
3999
    parse_options(argc, argv, options);
4000

    
4001
    /* file converter / grab */
4002
    if (nb_output_files <= 0) {
4003
        fprintf(stderr, "Must supply at least one output file\n");
4004
        exit(1);
4005
    }
4006

    
4007
    if (nb_input_files == 0) {
4008
        input_sync = 1;
4009
        prepare_grab();
4010
    }
4011

    
4012
    ti = getutime();
4013
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
4014
              stream_maps, nb_stream_maps);
4015
    ti = getutime() - ti;
4016
    if (do_benchmark) {
4017
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4018
    }
4019

    
4020
    /* close files */
4021
    for(i=0;i<nb_output_files;i++) {
4022
        /* maybe av_close_output_file ??? */
4023
        AVFormatContext *s = output_files[i];
4024
        int j;
4025
        if (!(s->oformat->flags & AVFMT_NOFILE))
4026
            url_fclose(&s->pb);
4027
        for(j=0;j<s->nb_streams;j++)
4028
            av_free(s->streams[j]);
4029
        av_free(s);
4030
    }
4031
    for(i=0;i<nb_input_files;i++)
4032
        av_close_input_file(input_files[i]);
4033

    
4034
    av_free_static();
4035

    
4036
    if(intra_matrix)
4037
        av_free(intra_matrix);
4038
    if(inter_matrix)
4039
        av_free(inter_matrix);
4040

    
4041
#ifdef POWERPC_PERFORMANCE_REPORT
4042
    extern void powerpc_display_perf_report(void);
4043
    powerpc_display_perf_report();
4044
#endif /* POWERPC_PERFORMANCE_REPORT */
4045

    
4046
#ifndef __MINGW32__
4047
    if (received_sigterm) {
4048
        fprintf(stderr,
4049
            "Received signal %d: terminating.\n",
4050
            (int) received_sigterm);
4051
        exit (255);
4052
    }
4053
#endif
4054
    exit(0); /* not all OS-es handle main() return value */
4055
    return 0;
4056
}