Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 3a74415d

History | View | Annotate | Download (132 KB)

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

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

    
48
#include "version.h"
49
#include "cmdutils.h"
50

    
51
#undef NDEBUG
52
#include <assert.h>
53

    
54
#if !defined(INFINITY) && defined(HUGE_VAL)
55
#define INFINITY HUGE_VAL
56
#endif
57

    
58
#undef exit
59

    
60
/* select an input stream for an output stream */
61
typedef struct AVStreamMap {
62
    int file_index;
63
    int stream_index;
64
    int sync_file_index;
65
    int sync_stream_index;
66
} AVStreamMap;
67

    
68
/** select an input file for an output file */
69
typedef struct AVMetaDataMap {
70
    int out_file;
71
    int in_file;
72
} AVMetaDataMap;
73

    
74
extern const OptionDef options[];
75

    
76
static void show_help(void);
77
static void show_license(void);
78
static int opt_default(const char *opt, const char *arg);
79

    
80
#define MAX_FILES 20
81

    
82
static AVFormatContext *input_files[MAX_FILES];
83
static int64_t input_files_ts_offset[MAX_FILES];
84
static int nb_input_files = 0;
85

    
86
static AVFormatContext *output_files[MAX_FILES];
87
static int nb_output_files = 0;
88

    
89
static AVStreamMap stream_maps[MAX_FILES];
90
static int nb_stream_maps;
91

    
92
static AVMetaDataMap meta_data_maps[MAX_FILES];
93
static int nb_meta_data_maps;
94

    
95
static AVInputFormat *file_iformat;
96
static AVOutputFormat *file_oformat;
97
static int frame_width  = 0;
98
static int frame_height = 0;
99
static float frame_aspect_ratio = 0;
100
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
101
static int frame_padtop  = 0;
102
static int frame_padbottom = 0;
103
static int frame_padleft  = 0;
104
static int frame_padright = 0;
105
static int padcolor[3] = {16,128,128}; /* default to black */
106
static int frame_topBand  = 0;
107
static int frame_bottomBand = 0;
108
static int frame_leftBand  = 0;
109
static int frame_rightBand = 0;
110
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
111
static int frame_rate = 25;
112
static int frame_rate_base = 1;
113
static float video_qscale = 0;
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 strict = 0;
132
static int top_field_first = -1;
133
static int me_threshold = 0;
134
static int intra_dc_precision = 8;
135
static int loop_input = 0;
136
static int loop_output = AVFMT_NOOUTPUTLOOP;
137
static int qp_hist = 0;
138

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

    
149
static int subtitle_codec_id = CODEC_ID_NONE;
150
static char *subtitle_language = NULL;
151

    
152
static float mux_preload= 0.5;
153
static float mux_max_delay= 0.7;
154

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

    
181
static int rate_emu = 0;
182

    
183
static int  video_channel = 0;
184
static char *video_standard = "ntsc";
185

    
186
static int audio_volume = 256;
187

    
188
static int using_stdin = 0;
189
static int using_vhook = 0;
190
static int verbose = 1;
191
static int thread_count= 1;
192
static int q_pressed = 0;
193
static int64_t video_size = 0;
194
static int64_t audio_size = 0;
195
static int64_t extra_size = 0;
196
static int nb_frames_dup = 0;
197
static int nb_frames_drop = 0;
198
static int input_sync;
199
static uint64_t limit_filesize = 0; //
200

    
201
static int pgmyuv_compatibility_hack=0;
202
static int dts_delta_threshold = 10;
203

    
204
static int sws_flags = SWS_BICUBIC;
205

    
206
const char **opt_names=NULL;
207
int opt_name_count=0;
208
AVCodecContext *avctx_opts[CODEC_TYPE_NB];
209
AVFormatContext *avformat_opts;
210
static int64_t timer_start = 0;
211

    
212
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
213
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
214
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
215

    
216
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
217

    
218
struct AVInputStream;
219

    
220
typedef struct AVOutputStream {
221
    int file_index;          /* file index */
222
    int index;               /* stream index in the output file */
223
    int source_index;        /* AVInputStream index */
224
    AVStream *st;            /* stream in the output file */
225
    int encoding_needed;     /* true if encoding needed for this stream */
226
    int frame_number;
227
    /* input pts and corresponding output pts
228
       for A/V sync */
229
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
230
    struct AVInputStream *sync_ist; /* input stream to sync against */
231
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
232
    /* video only */
233
    int video_resample;
234
    AVFrame pict_tmp;      /* temporary image for resampling */
235
    struct SwsContext *img_resample_ctx; /* for image resampling */
236
    int resample_height;
237

    
238
    int video_crop;
239
    int topBand;             /* cropping area sizes */
240
    int leftBand;
241

    
242
    int video_pad;
243
    int padtop;              /* padding area sizes */
244
    int padbottom;
245
    int padleft;
246
    int padright;
247

    
248
    /* audio only */
249
    int audio_resample;
250
    ReSampleContext *resample; /* for audio resampling */
251
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
252
    FILE *logfile;
253
} AVOutputStream;
254

    
255
typedef struct AVInputStream {
256
    int file_index;
257
    int index;
258
    AVStream *st;
259
    int discard;             /* true if stream data should be discarded */
260
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
261
    int64_t sample_index;      /* current sample */
262

    
263
    int64_t       start;     /* time when read started */
264
    unsigned long frame;     /* current frame */
265
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
266
                                is not defined */
267
    int64_t       pts;       /* current pts */
268
    int is_start;            /* is 1 at the start and after a discontinuity */
269
} AVInputStream;
270

    
271
typedef struct AVInputFile {
272
    int eof_reached;      /* true if eof reached */
273
    int ist_index;        /* index of first stream in ist_table */
274
    int buffer_size;      /* current total buffer size */
275
    int nb_streams;       /* nb streams we are aware of */
276
} AVInputFile;
277

    
278
#ifndef __MINGW32__
279

    
280
/* init terminal so that we can grab keys */
281
static struct termios oldtty;
282
#endif
283

    
284
static void term_exit(void)
285
{
286
#ifndef __MINGW32__
287
    tcsetattr (0, TCSANOW, &oldtty);
288
#endif
289
}
290

    
291
static volatile sig_atomic_t received_sigterm = 0;
292

    
293
static void
294
sigterm_handler(int sig)
295
{
296
    received_sigterm = sig;
297
    term_exit();
298
}
299

    
300
static void term_init(void)
301
{
302
#ifndef __MINGW32__
303
    struct termios tty;
304

    
305
    tcgetattr (0, &tty);
306
    oldtty = tty;
307

    
308
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
309
                          |INLCR|IGNCR|ICRNL|IXON);
310
    tty.c_oflag |= OPOST;
311
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
312
    tty.c_cflag &= ~(CSIZE|PARENB);
313
    tty.c_cflag |= CS8;
314
    tty.c_cc[VMIN] = 1;
315
    tty.c_cc[VTIME] = 0;
316

    
317
    tcsetattr (0, TCSANOW, &tty);
318
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
319
#endif
320

    
321
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
322
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
323
    /*
324
    register a function to be called at normal program termination
325
    */
326
    atexit(term_exit);
327
#ifdef CONFIG_BEOS_NETSERVER
328
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
329
#endif
330
}
331

    
332
/* read a key without blocking */
333
static int read_key(void)
334
{
335
#ifdef __MINGW32__
336
    if(kbhit())
337
        return(getch());
338
#else
339
    int n = 1;
340
    unsigned char ch;
341
#ifndef CONFIG_BEOS_NETSERVER
342
    struct timeval tv;
343
    fd_set rfds;
344

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

    
356
        return n;
357
    }
358
#endif
359
    return -1;
360
}
361

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

    
367
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
368
{
369
    int i, err;
370
    AVFormatContext *ic;
371

    
372
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
373
    if (err < 0)
374
        return err;
375
    /* copy stream format */
376
    s->nb_streams = ic->nb_streams;
377
    for(i=0;i<ic->nb_streams;i++) {
378
        AVStream *st;
379

    
380
        // FIXME: a more elegant solution is needed
381
        st = av_mallocz(sizeof(AVStream));
382
        memcpy(st, ic->streams[i], sizeof(AVStream));
383
        st->codec = avcodec_alloc_context();
384
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
385
        s->streams[i] = st;
386
    }
387

    
388
    av_close_input_file(ic);
389
    return 0;
390
}
391

    
392
static double
393
get_sync_ipts(const AVOutputStream *ost)
394
{
395
    const AVInputStream *ist = ost->sync_ist;
396
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
397
}
398

    
399
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
400
    while(bsfc){
401
        AVPacket new_pkt= *pkt;
402
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
403
                                          &new_pkt.data, &new_pkt.size,
404
                                          pkt->data, pkt->size,
405
                                          pkt->flags & PKT_FLAG_KEY);
406
        if(a){
407
            av_free_packet(pkt);
408
            new_pkt.destruct= av_destruct_packet;
409
        }
410
        *pkt= new_pkt;
411

    
412
        bsfc= bsfc->next;
413
    }
414

    
415
    av_interleaved_write_frame(s, pkt);
416
}
417

    
418
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
419

    
420
static void do_audio_out(AVFormatContext *s,
421
                         AVOutputStream *ost,
422
                         AVInputStream *ist,
423
                         unsigned char *buf, int size)
424
{
425
    uint8_t *buftmp;
426
    static uint8_t *audio_buf = NULL;
427
    static uint8_t *audio_out = NULL;
428
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
429

    
430
    int size_out, frame_bytes, ret;
431
    AVCodecContext *enc= ost->st->codec;
432

    
433
    /* SC: dynamic allocation of buffers */
434
    if (!audio_buf)
435
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
436
    if (!audio_out)
437
        audio_out = av_malloc(audio_out_size);
438
    if (!audio_buf || !audio_out)
439
        return;               /* Should signal an error ! */
440

    
441
    if(audio_sync_method){
442
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
443
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
444
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
445
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
446

    
447
        //FIXME resample delay
448
        if(fabs(delta) > 50){
449
            if(ist->is_start){
450
                if(byte_delta < 0){
451
                    byte_delta= FFMAX(byte_delta, -size);
452
                    size += byte_delta;
453
                    buf  -= byte_delta;
454
                    if(verbose > 2)
455
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
456
                    if(!size)
457
                        return;
458
                    ist->is_start=0;
459
                }else{
460
                    static uint8_t *input_tmp= NULL;
461
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
462

    
463
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
464
                        ist->is_start=0;
465
                    else
466
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
467

    
468
                    memset(input_tmp, 0, byte_delta);
469
                    memcpy(input_tmp + byte_delta, buf, size);
470
                    buf= input_tmp;
471
                    size += byte_delta;
472
                    if(verbose > 2)
473
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
474
                }
475
            }else if(audio_sync_method>1){
476
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
477
                assert(ost->audio_resample);
478
                if(verbose > 2)
479
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
480
//                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" 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));
481
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
482
            }
483
        }
484
    }else
485
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
486
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
487

    
488
    if (ost->audio_resample) {
489
        buftmp = audio_buf;
490
        size_out = audio_resample(ost->resample,
491
                                  (short *)buftmp, (short *)buf,
492
                                  size / (ist->st->codec->channels * 2));
493
        size_out = size_out * enc->channels * 2;
494
    } else {
495
        buftmp = buf;
496
        size_out = size;
497
    }
498

    
499
    /* now encode as many frames as possible */
500
    if (enc->frame_size > 1) {
501
        /* output resampled raw samples */
502
        av_fifo_write(&ost->fifo, buftmp, size_out);
503

    
504
        frame_bytes = enc->frame_size * 2 * enc->channels;
505

    
506
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
507
            AVPacket pkt;
508
            av_init_packet(&pkt);
509

    
510
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
511
                                       (short *)audio_buf);
512
            audio_size += ret;
513
            pkt.stream_index= ost->index;
514
            pkt.data= audio_out;
515
            pkt.size= ret;
516
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
517
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
518
            pkt.flags |= PKT_FLAG_KEY;
519
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
520

    
521
            ost->sync_opts += enc->frame_size;
522
        }
523
    } else {
524
        AVPacket pkt;
525
        av_init_packet(&pkt);
526

    
527
        ost->sync_opts += size_out / (2 * enc->channels);
528

    
529
        /* output a pcm frame */
530
        /* XXX: change encoding codec API to avoid this ? */
531
        switch(enc->codec->id) {
532
        case CODEC_ID_PCM_S32LE:
533
        case CODEC_ID_PCM_S32BE:
534
        case CODEC_ID_PCM_U32LE:
535
        case CODEC_ID_PCM_U32BE:
536
            size_out = size_out << 1;
537
            break;
538
        case CODEC_ID_PCM_S24LE:
539
        case CODEC_ID_PCM_S24BE:
540
        case CODEC_ID_PCM_U24LE:
541
        case CODEC_ID_PCM_U24BE:
542
        case CODEC_ID_PCM_S24DAUD:
543
            size_out = size_out / 2 * 3;
544
            break;
545
        case CODEC_ID_PCM_S16LE:
546
        case CODEC_ID_PCM_S16BE:
547
        case CODEC_ID_PCM_U16LE:
548
        case CODEC_ID_PCM_U16BE:
549
            break;
550
        default:
551
            size_out = size_out >> 1;
552
            break;
553
        }
554
        ret = avcodec_encode_audio(enc, audio_out, size_out,
555
                                   (short *)buftmp);
556
        audio_size += ret;
557
        pkt.stream_index= ost->index;
558
        pkt.data= audio_out;
559
        pkt.size= ret;
560
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
561
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
562
        pkt.flags |= PKT_FLAG_KEY;
563
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
564
    }
565
}
566

    
567
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
568
{
569
    AVCodecContext *dec;
570
    AVPicture *picture2;
571
    AVPicture picture_tmp;
572
    uint8_t *buf = 0;
573

    
574
    dec = ist->st->codec;
575

    
576
    /* deinterlace : must be done before any resize */
577
    if (do_deinterlace || using_vhook) {
578
        int size;
579

    
580
        /* create temporary picture */
581
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
582
        buf = av_malloc(size);
583
        if (!buf)
584
            return;
585

    
586
        picture2 = &picture_tmp;
587
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
588

    
589
        if (do_deinterlace){
590
            if(avpicture_deinterlace(picture2, picture,
591
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
592
                /* if error, do not deinterlace */
593
                av_free(buf);
594
                buf = NULL;
595
                picture2 = picture;
596
            }
597
        } else {
598
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
599
        }
600
    } else {
601
        picture2 = picture;
602
    }
603

    
604
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
605
                       1000000 * ist->pts / AV_TIME_BASE);
606

    
607
    if (picture != picture2)
608
        *picture = *picture2;
609
    *bufp = buf;
610
}
611

    
612
/* we begin to correct av delay at this threshold */
613
#define AV_DELAY_MAX 0.100
614

    
615
static void do_subtitle_out(AVFormatContext *s,
616
                            AVOutputStream *ost,
617
                            AVInputStream *ist,
618
                            AVSubtitle *sub,
619
                            int64_t pts)
620
{
621
    static uint8_t *subtitle_out = NULL;
622
    int subtitle_out_max_size = 65536;
623
    int subtitle_out_size, nb, i;
624
    AVCodecContext *enc;
625
    AVPacket pkt;
626

    
627
    if (pts == AV_NOPTS_VALUE) {
628
        fprintf(stderr, "Subtitle packets must have a pts\n");
629
        return;
630
    }
631

    
632
    enc = ost->st->codec;
633

    
634
    if (!subtitle_out) {
635
        subtitle_out = av_malloc(subtitle_out_max_size);
636
    }
637

    
638
    /* Note: DVB subtitle need one packet to draw them and one other
639
       packet to clear them */
640
    /* XXX: signal it in the codec context ? */
641
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
642
        nb = 2;
643
    else
644
        nb = 1;
645

    
646
    for(i = 0; i < nb; i++) {
647
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
648
                                                    subtitle_out_max_size, sub);
649

    
650
        av_init_packet(&pkt);
651
        pkt.stream_index = ost->index;
652
        pkt.data = subtitle_out;
653
        pkt.size = subtitle_out_size;
654
        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);
655
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
656
            /* XXX: the pts correction is handled here. Maybe handling
657
               it in the codec would be better */
658
            if (i == 0)
659
                pkt.pts += 90 * sub->start_display_time;
660
            else
661
                pkt.pts += 90 * sub->end_display_time;
662
        }
663
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
664
    }
665
}
666

    
667
static int bit_buffer_size= 1024*256;
668
static uint8_t *bit_buffer= NULL;
669

    
670
static void do_video_out(AVFormatContext *s,
671
                         AVOutputStream *ost,
672
                         AVInputStream *ist,
673
                         AVFrame *in_picture,
674
                         int *frame_size)
675
{
676
    int nb_frames, i, ret;
677
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
678
    AVFrame picture_crop_temp, picture_pad_temp;
679
    AVCodecContext *enc, *dec;
680

    
681
    avcodec_get_frame_defaults(&picture_crop_temp);
682
    avcodec_get_frame_defaults(&picture_pad_temp);
683

    
684
    enc = ost->st->codec;
685
    dec = ist->st->codec;
686

    
687
    /* by default, we output a single frame */
688
    nb_frames = 1;
689

    
690
    *frame_size = 0;
691

    
692
    if(video_sync_method){
693
        double vdelta;
694
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
695
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
696
        if (vdelta < -1.1)
697
            nb_frames = 0;
698
        else if (vdelta > 1.1)
699
            nb_frames = lrintf(vdelta);
700
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
701
        if (nb_frames == 0){
702
            ++nb_frames_drop;
703
            if (verbose>2)
704
                fprintf(stderr, "*** drop!\n");
705
        }else if (nb_frames > 1) {
706
            nb_frames_dup += nb_frames;
707
            if (verbose>2)
708
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
709
        }
710
    }else
711
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
712

    
713
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
714
    if (nb_frames <= 0)
715
        return;
716

    
717
    if (ost->video_crop) {
718
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
719
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
720
            return;
721
        }
722
        formatted_picture = &picture_crop_temp;
723
    } else {
724
        formatted_picture = in_picture;
725
    }
726

    
727
    final_picture = formatted_picture;
728
    padding_src = formatted_picture;
729
    resampling_dst = &ost->pict_tmp;
730
    if (ost->video_pad) {
731
        final_picture = &ost->pict_tmp;
732
        if (ost->video_resample) {
733
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
734
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
735
                return;
736
            }
737
            resampling_dst = &picture_pad_temp;
738
        }
739
    }
740

    
741
    if (ost->video_resample) {
742
        padding_src = NULL;
743
        final_picture = &ost->pict_tmp;
744
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
745
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
746
    }
747

    
748
    if (ost->video_pad) {
749
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
750
                enc->height, enc->width, enc->pix_fmt,
751
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
752
    }
753

    
754
    /* duplicates frame if needed */
755
    for(i=0;i<nb_frames;i++) {
756
        AVPacket pkt;
757
        av_init_packet(&pkt);
758
        pkt.stream_index= ost->index;
759

    
760
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
761
            /* raw pictures are written as AVPicture structure to
762
               avoid any copies. We support temorarily the older
763
               method. */
764
            AVFrame* old_frame = enc->coded_frame;
765
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
766
            pkt.data= (uint8_t *)final_picture;
767
            pkt.size=  sizeof(AVPicture);
768
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
769
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
770
            if(dec->coded_frame && dec->coded_frame->key_frame)
771
                pkt.flags |= PKT_FLAG_KEY;
772

    
773
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
774
            enc->coded_frame = old_frame;
775
        } else {
776
            AVFrame big_picture;
777

    
778
            big_picture= *final_picture;
779
            /* better than nothing: use input picture interlaced
780
               settings */
781
            big_picture.interlaced_frame = in_picture->interlaced_frame;
782
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
783
                if(top_field_first == -1)
784
                    big_picture.top_field_first = in_picture->top_field_first;
785
                else
786
                    big_picture.top_field_first = top_field_first;
787
            }
788

    
789
            /* handles sameq here. This is not correct because it may
790
               not be a global option */
791
            if (same_quality) {
792
                big_picture.quality = ist->st->quality;
793
            }else
794
                big_picture.quality = ost->st->quality;
795
            if(!me_threshold)
796
                big_picture.pict_type = 0;
797
//            big_picture.pts = AV_NOPTS_VALUE;
798
            big_picture.pts= ost->sync_opts;
799
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
800
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
801
            ret = avcodec_encode_video(enc,
802
                                       bit_buffer, bit_buffer_size,
803
                                       &big_picture);
804
            if (ret == -1) {
805
                fprintf(stderr, "Video encoding failed\n");
806
                exit(1);
807
            }
808
            //enc->frame_number = enc->real_pict_num;
809
            if(ret>0){
810
                pkt.data= bit_buffer;
811
                pkt.size= ret;
812
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
813
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
814
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
815
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
816
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
817

    
818
                if(enc->coded_frame && enc->coded_frame->key_frame)
819
                    pkt.flags |= PKT_FLAG_KEY;
820
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
821
                *frame_size = ret;
822
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
823
                //        enc->frame_number-1, enc->real_pict_num, ret,
824
                //        enc->pict_type);
825
                /* if two pass, output log */
826
                if (ost->logfile && enc->stats_out) {
827
                    fprintf(ost->logfile, "%s", enc->stats_out);
828
                }
829
            }
830
        }
831
        ost->sync_opts++;
832
        ost->frame_number++;
833
    }
834
}
835

    
836
static double psnr(double d){
837
    if(d==0) return INFINITY;
838
    return -10.0*log(d)/log(10.0);
839
}
840

    
841
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
842
                           int frame_size)
843
{
844
    static FILE *fvstats=NULL;
845
    char filename[40];
846
    time_t today2;
847
    struct tm *today;
848
    AVCodecContext *enc;
849
    int frame_number;
850
    int64_t ti;
851
    double ti1, bitrate, avg_bitrate;
852

    
853
    if (!fvstats) {
854
        today2 = time(NULL);
855
        today = localtime(&today2);
856
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
857
                                               today->tm_min,
858
                                               today->tm_sec);
859
        fvstats = fopen(filename,"w");
860
        if (!fvstats) {
861
            perror("fopen");
862
            exit(1);
863
        }
864
    }
865

    
866
    ti = INT64_MAX;
867
    enc = ost->st->codec;
868
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
869
        frame_number = ost->frame_number;
870
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
871
        if (enc->flags&CODEC_FLAG_PSNR)
872
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
873

    
874
        fprintf(fvstats,"f_size= %6d ", frame_size);
875
        /* compute pts value */
876
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
877
        if (ti1 < 0.01)
878
            ti1 = 0.01;
879

    
880
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
881
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
882
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
883
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
884
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
885
    }
886
}
887

    
888
static void print_report(AVFormatContext **output_files,
889
                         AVOutputStream **ost_table, int nb_ostreams,
890
                         int is_last_report)
891
{
892
    char buf[1024];
893
    AVOutputStream *ost;
894
    AVFormatContext *oc, *os;
895
    int64_t total_size;
896
    AVCodecContext *enc;
897
    int frame_number, vid, i;
898
    double bitrate, ti1, pts;
899
    static int64_t last_time = -1;
900
    static int qp_histogram[52];
901

    
902
    if (!is_last_report) {
903
        int64_t cur_time;
904
        /* display the report every 0.5 seconds */
905
        cur_time = av_gettime();
906
        if (last_time == -1) {
907
            last_time = cur_time;
908
            return;
909
        }
910
        if ((cur_time - last_time) < 500000)
911
            return;
912
        last_time = cur_time;
913
    }
914

    
915

    
916
    oc = output_files[0];
917

    
918
    total_size = url_ftell(&oc->pb);
919

    
920
    buf[0] = '\0';
921
    ti1 = 1e10;
922
    vid = 0;
923
    for(i=0;i<nb_ostreams;i++) {
924
        ost = ost_table[i];
925
        os = output_files[ost->file_index];
926
        enc = ost->st->codec;
927
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
928
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
929
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
930
        }
931
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
932
            float t = (av_gettime()-timer_start) / 1000000.0;
933

    
934
            frame_number = ost->frame_number;
935
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
936
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
937
                     enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
938
            if(is_last_report)
939
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
940
            if(qp_hist && enc->coded_frame){
941
                int j;
942
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
943
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
944
                    qp_histogram[qp]++;
945
                for(j=0; j<32; j++)
946
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
947
            }
948
            if (enc->flags&CODEC_FLAG_PSNR){
949
                int j;
950
                double error, error_sum=0;
951
                double scale, scale_sum=0;
952
                char type[3]= {'Y','U','V'};
953
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
954
                for(j=0; j<3; j++){
955
                    if(is_last_report){
956
                        error= enc->error[j];
957
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
958
                    }else{
959
                        error= enc->coded_frame->error[j];
960
                        scale= enc->width*enc->height*255.0*255.0;
961
                    }
962
                    if(j) scale/=4;
963
                    error_sum += error;
964
                    scale_sum += scale;
965
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
966
                }
967
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
968
            }
969
            vid = 1;
970
        }
971
        /* compute min output value */
972
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
973
        if ((pts < ti1) && (pts > 0))
974
            ti1 = pts;
975
    }
976
    if (ti1 < 0.01)
977
        ti1 = 0.01;
978

    
979
    if (verbose || is_last_report) {
980
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
981

    
982
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
983
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
984
            (double)total_size / 1024, ti1, bitrate);
985

    
986
        if (verbose > 1)
987
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
988
                  nb_frames_dup, nb_frames_drop);
989

    
990
        if (verbose >= 0)
991
            fprintf(stderr, "%s    \r", buf);
992

    
993
        fflush(stderr);
994
    }
995

    
996
    if (is_last_report && verbose >= 0){
997
        int64_t raw= audio_size + video_size + extra_size;
998
        fprintf(stderr, "\n");
999
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1000
                video_size/1024.0,
1001
                audio_size/1024.0,
1002
                extra_size/1024.0,
1003
                100.0*(total_size - raw)/raw
1004
        );
1005
    }
1006
}
1007

    
1008
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1009
static int output_packet(AVInputStream *ist, int ist_index,
1010
                         AVOutputStream **ost_table, int nb_ostreams,
1011
                         const AVPacket *pkt)
1012
{
1013
    AVFormatContext *os;
1014
    AVOutputStream *ost;
1015
    uint8_t *ptr;
1016
    int len, ret, i;
1017
    uint8_t *data_buf;
1018
    int data_size, got_picture;
1019
    AVFrame picture;
1020
    void *buffer_to_free;
1021
    static unsigned int samples_size= 0;
1022
    static short *samples= NULL;
1023
    AVSubtitle subtitle, *subtitle_to_free;
1024
    int got_subtitle;
1025

    
1026
    if(!pkt){
1027
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1028
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1029
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1030
    } else {
1031
//        assert(ist->pts == ist->next_pts);
1032
    }
1033

    
1034
    if (pkt == NULL) {
1035
        /* EOF handling */
1036
        ptr = NULL;
1037
        len = 0;
1038
        goto handle_eof;
1039
    }
1040

    
1041
    len = pkt->size;
1042
    ptr = pkt->data;
1043
    while (len > 0) {
1044
    handle_eof:
1045
        /* decode the packet if needed */
1046
        data_buf = NULL; /* fail safe */
1047
        data_size = 0;
1048
        subtitle_to_free = NULL;
1049
        if (ist->decoding_needed) {
1050
            switch(ist->st->codec->codec_type) {
1051
            case CODEC_TYPE_AUDIO:{
1052
                if(pkt)
1053
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1054
                data_size= samples_size;
1055
                    /* XXX: could avoid copy if PCM 16 bits with same
1056
                       endianness as CPU */
1057
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1058
                                           ptr, len);
1059
                if (ret < 0)
1060
                    goto fail_decode;
1061
                ptr += ret;
1062
                len -= ret;
1063
                /* Some bug in mpeg audio decoder gives */
1064
                /* data_size < 0, it seems they are overflows */
1065
                if (data_size <= 0) {
1066
                    /* no audio frame */
1067
                    continue;
1068
                }
1069
                data_buf = (uint8_t *)samples;
1070
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1071
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1072
                break;}
1073
            case CODEC_TYPE_VIDEO:
1074
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1075
                    /* XXX: allocate picture correctly */
1076
                    avcodec_get_frame_defaults(&picture);
1077

    
1078
                    ret = avcodec_decode_video(ist->st->codec,
1079
                                               &picture, &got_picture, ptr, len);
1080
                    ist->st->quality= picture.quality;
1081
                    if (ret < 0)
1082
                        goto fail_decode;
1083
                    if (!got_picture) {
1084
                        /* no picture yet */
1085
                        goto discard_packet;
1086
                    }
1087
                    if (ist->st->codec->time_base.num != 0) {
1088
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1089
                                          ist->st->codec->time_base.num) /
1090
                            ist->st->codec->time_base.den;
1091
                    }
1092
                    len = 0;
1093
                    break;
1094
            case CODEC_TYPE_SUBTITLE:
1095
                ret = avcodec_decode_subtitle(ist->st->codec,
1096
                                              &subtitle, &got_subtitle, ptr, len);
1097
                if (ret < 0)
1098
                    goto fail_decode;
1099
                if (!got_subtitle) {
1100
                    goto discard_packet;
1101
                }
1102
                subtitle_to_free = &subtitle;
1103
                len = 0;
1104
                break;
1105
            default:
1106
                goto fail_decode;
1107
            }
1108
        } else {
1109
            switch(ist->st->codec->codec_type) {
1110
            case CODEC_TYPE_AUDIO:
1111
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1112
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1113
                break;
1114
            case CODEC_TYPE_VIDEO:
1115
                if (ist->st->codec->time_base.num != 0) {
1116
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1117
                                      ist->st->codec->time_base.num) /
1118
                        ist->st->codec->time_base.den;
1119
                }
1120
                break;
1121
            }
1122
            data_buf = ptr;
1123
            data_size = len;
1124
            ret = len;
1125
            len = 0;
1126
        }
1127

    
1128
        buffer_to_free = NULL;
1129
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1130
            pre_process_video_frame(ist, (AVPicture *)&picture,
1131
                                    &buffer_to_free);
1132
        }
1133

    
1134
        // preprocess audio (volume)
1135
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1136
            if (audio_volume != 256) {
1137
                short *volp;
1138
                volp = samples;
1139
                for(i=0;i<(data_size / sizeof(short));i++) {
1140
                    int v = ((*volp) * audio_volume + 128) >> 8;
1141
                    if (v < -32768) v = -32768;
1142
                    if (v >  32767) v = 32767;
1143
                    *volp++ = v;
1144
                }
1145
            }
1146
        }
1147

    
1148
        /* frame rate emulation */
1149
        if (ist->st->codec->rate_emu) {
1150
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1151
            int64_t now = av_gettime() - ist->start;
1152
            if (pts > now)
1153
                usleep(pts - now);
1154

    
1155
            ist->frame++;
1156
        }
1157

    
1158
#if 0
1159
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1160
           is the one of the next displayed one */
1161
        /* XXX: add mpeg4 too ? */
1162
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1163
            if (ist->st->codec->pict_type != B_TYPE) {
1164
                int64_t tmp;
1165
                tmp = ist->last_ip_pts;
1166
                ist->last_ip_pts  = ist->frac_pts.val;
1167
                ist->frac_pts.val = tmp;
1168
            }
1169
        }
1170
#endif
1171
        /* if output time reached then transcode raw format,
1172
           encode packets and output them */
1173
        if (start_time == 0 || ist->pts >= start_time)
1174
            for(i=0;i<nb_ostreams;i++) {
1175
                int frame_size;
1176

    
1177
                ost = ost_table[i];
1178
                if (ost->source_index == ist_index) {
1179
                    os = output_files[ost->file_index];
1180

    
1181
#if 0
1182
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1183
                           (double)pkt->pts / AV_TIME_BASE,
1184
                           ((double)ist->pts / AV_TIME_BASE) -
1185
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1186
#endif
1187
                    /* set the input output pts pairs */
1188
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1189

    
1190
                    if (ost->encoding_needed) {
1191
                        switch(ost->st->codec->codec_type) {
1192
                        case CODEC_TYPE_AUDIO:
1193
                            do_audio_out(os, ost, ist, data_buf, data_size);
1194
                            break;
1195
                        case CODEC_TYPE_VIDEO:
1196
                            do_video_out(os, ost, ist, &picture, &frame_size);
1197
                            video_size += frame_size;
1198
                            if (do_vstats && frame_size)
1199
                                do_video_stats(os, ost, frame_size);
1200
                            break;
1201
                        case CODEC_TYPE_SUBTITLE:
1202
                            do_subtitle_out(os, ost, ist, &subtitle,
1203
                                            pkt->pts);
1204
                            break;
1205
                        default:
1206
                            av_abort();
1207
                        }
1208
                    } else {
1209
                        AVFrame avframe; //FIXME/XXX remove this
1210
                        AVPacket opkt;
1211
                        av_init_packet(&opkt);
1212

    
1213
                        /* no reencoding needed : output the packet directly */
1214
                        /* force the input stream PTS */
1215

    
1216
                        avcodec_get_frame_defaults(&avframe);
1217
                        ost->st->codec->coded_frame= &avframe;
1218
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1219

    
1220
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1221
                            audio_size += data_size;
1222
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1223
                            video_size += data_size;
1224
                            ost->sync_opts++;
1225
                        }
1226

    
1227
                        opkt.stream_index= ost->index;
1228
                        if(pkt->pts != AV_NOPTS_VALUE)
1229
                            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);
1230
                        else
1231
                            opkt.pts= AV_NOPTS_VALUE;
1232

    
1233
                        {
1234
                            int64_t dts;
1235
                            if (pkt->dts == AV_NOPTS_VALUE)
1236
                                dts = ist->next_pts;
1237
                            else
1238
                                dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1239
                            opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1240
                        }
1241
                        opkt.flags= pkt->flags;
1242

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

    
1247
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1248
                        ost->st->codec->frame_number++;
1249
                        ost->frame_number++;
1250
                        av_free_packet(&opkt);
1251
                    }
1252
                }
1253
            }
1254
        av_free(buffer_to_free);
1255
        /* XXX: allocate the subtitles in the codec ? */
1256
        if (subtitle_to_free) {
1257
            if (subtitle_to_free->rects != NULL) {
1258
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1259
                    av_free(subtitle_to_free->rects[i].bitmap);
1260
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1261
                }
1262
                av_freep(&subtitle_to_free->rects);
1263
            }
1264
            subtitle_to_free->num_rects = 0;
1265
            subtitle_to_free = NULL;
1266
        }
1267
    }
1268
 discard_packet:
1269
    if (pkt == NULL) {
1270
        /* EOF handling */
1271

    
1272
        for(i=0;i<nb_ostreams;i++) {
1273
            ost = ost_table[i];
1274
            if (ost->source_index == ist_index) {
1275
                AVCodecContext *enc= ost->st->codec;
1276
                os = output_files[ost->file_index];
1277

    
1278
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1279
                    continue;
1280
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1281
                    continue;
1282

    
1283
                if (ost->encoding_needed) {
1284
                    for(;;) {
1285
                        AVPacket pkt;
1286
                        int fifo_bytes;
1287
                        av_init_packet(&pkt);
1288
                        pkt.stream_index= ost->index;
1289

    
1290
                        switch(ost->st->codec->codec_type) {
1291
                        case CODEC_TYPE_AUDIO:
1292
                            fifo_bytes = av_fifo_size(&ost->fifo);
1293
                            ret = 0;
1294
                            /* encode any samples remaining in fifo */
1295
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1296
                                int fs_tmp = enc->frame_size;
1297
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1298
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1299
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1300
                                }
1301
                                enc->frame_size = fs_tmp;
1302
                            }
1303
                            if(ret <= 0) {
1304
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1305
                            }
1306
                            audio_size += ret;
1307
                            pkt.flags |= PKT_FLAG_KEY;
1308
                            break;
1309
                        case CODEC_TYPE_VIDEO:
1310
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1311
                            video_size += ret;
1312
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1313
                                pkt.flags |= PKT_FLAG_KEY;
1314
                            if (ost->logfile && enc->stats_out) {
1315
                                fprintf(ost->logfile, "%s", enc->stats_out);
1316
                            }
1317
                            break;
1318
                        default:
1319
                            ret=-1;
1320
                        }
1321

    
1322
                        if(ret<=0)
1323
                            break;
1324
                        pkt.data= bit_buffer;
1325
                        pkt.size= ret;
1326
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1327
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1328
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1329
                    }
1330
                }
1331
            }
1332
        }
1333
    }
1334

    
1335
    return 0;
1336
 fail_decode:
1337
    return -1;
1338
}
1339

    
1340

    
1341
/*
1342
 * The following code is the main loop of the file converter
1343
 */
1344
static int av_encode(AVFormatContext **output_files,
1345
                     int nb_output_files,
1346
                     AVFormatContext **input_files,
1347
                     int nb_input_files,
1348
                     AVStreamMap *stream_maps, int nb_stream_maps)
1349
{
1350
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1351
    AVFormatContext *is, *os;
1352
    AVCodecContext *codec, *icodec;
1353
    AVOutputStream *ost, **ost_table = NULL;
1354
    AVInputStream *ist, **ist_table = NULL;
1355
    AVInputFile *file_table;
1356
    int key;
1357

    
1358
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1359
    if (!file_table)
1360
        goto fail;
1361

    
1362
    /* input stream init */
1363
    j = 0;
1364
    for(i=0;i<nb_input_files;i++) {
1365
        is = input_files[i];
1366
        file_table[i].ist_index = j;
1367
        file_table[i].nb_streams = is->nb_streams;
1368
        j += is->nb_streams;
1369
    }
1370
    nb_istreams = j;
1371

    
1372
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1373
    if (!ist_table)
1374
        goto fail;
1375

    
1376
    for(i=0;i<nb_istreams;i++) {
1377
        ist = av_mallocz(sizeof(AVInputStream));
1378
        if (!ist)
1379
            goto fail;
1380
        ist_table[i] = ist;
1381
    }
1382
    j = 0;
1383
    for(i=0;i<nb_input_files;i++) {
1384
        is = input_files[i];
1385
        for(k=0;k<is->nb_streams;k++) {
1386
            ist = ist_table[j++];
1387
            ist->st = is->streams[k];
1388
            ist->file_index = i;
1389
            ist->index = k;
1390
            ist->discard = 1; /* the stream is discarded by default
1391
                                 (changed later) */
1392

    
1393
            if (ist->st->codec->rate_emu) {
1394
                ist->start = av_gettime();
1395
                ist->frame = 0;
1396
            }
1397
        }
1398
    }
1399

    
1400
    /* output stream init */
1401
    nb_ostreams = 0;
1402
    for(i=0;i<nb_output_files;i++) {
1403
        os = output_files[i];
1404
        if (!os->nb_streams) {
1405
            fprintf(stderr, "Output file does not contain any stream\n");
1406
            exit(1);
1407
        }
1408
        nb_ostreams += os->nb_streams;
1409
    }
1410
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1411
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1412
        exit(1);
1413
    }
1414

    
1415
    /* Sanity check the mapping args -- do the input files & streams exist? */
1416
    for(i=0;i<nb_stream_maps;i++) {
1417
        int fi = stream_maps[i].file_index;
1418
        int si = stream_maps[i].stream_index;
1419

    
1420
        if (fi < 0 || fi > nb_input_files - 1 ||
1421
            si < 0 || si > file_table[fi].nb_streams - 1) {
1422
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1423
            exit(1);
1424
        }
1425
        fi = stream_maps[i].sync_file_index;
1426
        si = stream_maps[i].sync_stream_index;
1427
        if (fi < 0 || fi > nb_input_files - 1 ||
1428
            si < 0 || si > file_table[fi].nb_streams - 1) {
1429
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1430
            exit(1);
1431
        }
1432
    }
1433

    
1434
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1435
    if (!ost_table)
1436
        goto fail;
1437
    for(i=0;i<nb_ostreams;i++) {
1438
        ost = av_mallocz(sizeof(AVOutputStream));
1439
        if (!ost)
1440
            goto fail;
1441
        ost_table[i] = ost;
1442
    }
1443

    
1444
    n = 0;
1445
    for(k=0;k<nb_output_files;k++) {
1446
        os = output_files[k];
1447
        for(i=0;i<os->nb_streams;i++) {
1448
            int found;
1449
            ost = ost_table[n++];
1450
            ost->file_index = k;
1451
            ost->index = i;
1452
            ost->st = os->streams[i];
1453
            if (nb_stream_maps > 0) {
1454
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1455
                    stream_maps[n-1].stream_index;
1456

    
1457
                /* Sanity check that the stream types match */
1458
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1459
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1460
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1461
                        ost->file_index, ost->index);
1462
                    exit(1);
1463
                }
1464

    
1465
            } else {
1466
                /* get corresponding input stream index : we select the first one with the right type */
1467
                found = 0;
1468
                for(j=0;j<nb_istreams;j++) {
1469
                    ist = ist_table[j];
1470
                    if (ist->discard &&
1471
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1472
                        ost->source_index = j;
1473
                        found = 1;
1474
                        break;
1475
                    }
1476
                }
1477

    
1478
                if (!found) {
1479
                    /* try again and reuse existing stream */
1480
                    for(j=0;j<nb_istreams;j++) {
1481
                        ist = ist_table[j];
1482
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1483
                            ost->source_index = j;
1484
                            found = 1;
1485
                        }
1486
                    }
1487
                    if (!found) {
1488
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1489
                                ost->file_index, ost->index);
1490
                        exit(1);
1491
                    }
1492
                }
1493
            }
1494
            ist = ist_table[ost->source_index];
1495
            ist->discard = 0;
1496
            ost->sync_ist = (nb_stream_maps > 0) ?
1497
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1498
                         stream_maps[n-1].sync_stream_index] : ist;
1499
        }
1500
    }
1501

    
1502
    /* for each output stream, we compute the right encoding parameters */
1503
    for(i=0;i<nb_ostreams;i++) {
1504
        ost = ost_table[i];
1505
        ist = ist_table[ost->source_index];
1506

    
1507
        codec = ost->st->codec;
1508
        icodec = ist->st->codec;
1509

    
1510
        if (ost->st->stream_copy) {
1511
            /* if stream_copy is selected, no need to decode or encode */
1512
            codec->codec_id = icodec->codec_id;
1513
            codec->codec_type = icodec->codec_type;
1514
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1515
            codec->bit_rate = icodec->bit_rate;
1516
            codec->extradata= icodec->extradata;
1517
            codec->extradata_size= icodec->extradata_size;
1518
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1519
                codec->time_base = icodec->time_base;
1520
            else
1521
                codec->time_base = ist->st->time_base;
1522
            switch(codec->codec_type) {
1523
            case CODEC_TYPE_AUDIO:
1524
                codec->sample_rate = icodec->sample_rate;
1525
                codec->channels = icodec->channels;
1526
                codec->frame_size = icodec->frame_size;
1527
                codec->block_align= icodec->block_align;
1528
                break;
1529
            case CODEC_TYPE_VIDEO:
1530
                if(using_vhook) {
1531
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1532
                    exit(1);
1533
                }
1534
                codec->pix_fmt = icodec->pix_fmt;
1535
                codec->width = icodec->width;
1536
                codec->height = icodec->height;
1537
                codec->has_b_frames = icodec->has_b_frames;
1538
                break;
1539
            case CODEC_TYPE_SUBTITLE:
1540
                break;
1541
            default:
1542
                av_abort();
1543
            }
1544
        } else {
1545
            switch(codec->codec_type) {
1546
            case CODEC_TYPE_AUDIO:
1547
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1548
                    goto fail;
1549

    
1550
                if (codec->channels == icodec->channels &&
1551
                    codec->sample_rate == icodec->sample_rate) {
1552
                    ost->audio_resample = 0;
1553
                } else {
1554
                    if (codec->channels != icodec->channels &&
1555
                        (icodec->codec_id == CODEC_ID_AC3 ||
1556
                         icodec->codec_id == CODEC_ID_DTS)) {
1557
                        /* Special case for 5:1 AC3 and DTS input */
1558
                        /* and mono or stereo output      */
1559
                        /* Request specific number of channels */
1560
                        icodec->channels = codec->channels;
1561
                        if (codec->sample_rate == icodec->sample_rate)
1562
                            ost->audio_resample = 0;
1563
                        else {
1564
                            ost->audio_resample = 1;
1565
                        }
1566
                    } else {
1567
                        ost->audio_resample = 1;
1568
                    }
1569
                }
1570
                if(audio_sync_method>1)
1571
                    ost->audio_resample = 1;
1572

    
1573
                if(ost->audio_resample){
1574
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1575
                                                    codec->sample_rate, icodec->sample_rate);
1576
                    if(!ost->resample){
1577
                        printf("Can't resample.  Aborting.\n");
1578
                        av_abort();
1579
                    }
1580
                }
1581
                ist->decoding_needed = 1;
1582
                ost->encoding_needed = 1;
1583
                break;
1584
            case CODEC_TYPE_VIDEO:
1585
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1586
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1587
                ost->video_resample = ((codec->width != icodec->width -
1588
                                (frame_leftBand + frame_rightBand) +
1589
                                (frame_padleft + frame_padright)) ||
1590
                        (codec->height != icodec->height -
1591
                                (frame_topBand  + frame_bottomBand) +
1592
                                (frame_padtop + frame_padbottom)) ||
1593
                        (codec->pix_fmt != icodec->pix_fmt));
1594
                if (ost->video_crop) {
1595
                    ost->topBand = frame_topBand;
1596
                    ost->leftBand = frame_leftBand;
1597
                }
1598
                if (ost->video_pad) {
1599
                    ost->padtop = frame_padtop;
1600
                    ost->padleft = frame_padleft;
1601
                    ost->padbottom = frame_padbottom;
1602
                    ost->padright = frame_padright;
1603
                    if (!ost->video_resample) {
1604
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1605
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1606
                                         codec->width, codec->height ) )
1607
                            goto fail;
1608
                    }
1609
                }
1610
                if (ost->video_resample) {
1611
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1612
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1613
                                         codec->width, codec->height ) ) {
1614
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1615
                        exit(1);
1616
                    }
1617
                    ost->img_resample_ctx = sws_getContext(
1618
                            icodec->width - (frame_leftBand + frame_rightBand),
1619
                            icodec->height - (frame_topBand + frame_bottomBand),
1620
                            icodec->pix_fmt,
1621
                            codec->width - (frame_padleft + frame_padright),
1622
                            codec->height - (frame_padtop + frame_padbottom),
1623
                            codec->pix_fmt,
1624
                            sws_flags, NULL, NULL, NULL);
1625
                    if (ost->img_resample_ctx == NULL) {
1626
                        fprintf(stderr, "Cannot get resampling context\n");
1627
                        exit(1);
1628
                    }
1629
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1630
                }
1631
                ost->encoding_needed = 1;
1632
                ist->decoding_needed = 1;
1633
                break;
1634
            case CODEC_TYPE_SUBTITLE:
1635
                ost->encoding_needed = 1;
1636
                ist->decoding_needed = 1;
1637
                break;
1638
            default:
1639
                av_abort();
1640
                break;
1641
            }
1642
            /* two pass mode */
1643
            if (ost->encoding_needed &&
1644
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1645
                char logfilename[1024];
1646
                FILE *f;
1647
                int size;
1648
                char *logbuffer;
1649

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

    
1688
    if (!bit_buffer)
1689
        bit_buffer = av_malloc(bit_buffer_size);
1690
    if (!bit_buffer)
1691
        goto fail;
1692

    
1693
    /* dump the file output parameters - cannot be done before in case
1694
       of stream copy */
1695
    for(i=0;i<nb_output_files;i++) {
1696
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1697
    }
1698

    
1699
    /* dump the stream mapping */
1700
    if (verbose >= 0) {
1701
        fprintf(stderr, "Stream mapping:\n");
1702
        for(i=0;i<nb_ostreams;i++) {
1703
            ost = ost_table[i];
1704
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1705
                    ist_table[ost->source_index]->file_index,
1706
                    ist_table[ost->source_index]->index,
1707
                    ost->file_index,
1708
                    ost->index);
1709
            if (ost->sync_ist != ist_table[ost->source_index])
1710
                fprintf(stderr, " [sync #%d.%d]",
1711
                        ost->sync_ist->file_index,
1712
                        ost->sync_ist->index);
1713
            fprintf(stderr, "\n");
1714
        }
1715
    }
1716

    
1717
    /* open each encoder */
1718
    for(i=0;i<nb_ostreams;i++) {
1719
        ost = ost_table[i];
1720
        if (ost->encoding_needed) {
1721
            AVCodec *codec;
1722
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1723
            if (!codec) {
1724
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1725
                        ost->file_index, ost->index);
1726
                exit(1);
1727
            }
1728
            if (avcodec_open(ost->st->codec, codec) < 0) {
1729
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1730
                        ost->file_index, ost->index);
1731
                exit(1);
1732
            }
1733
            extra_size += ost->st->codec->extradata_size;
1734
        }
1735
    }
1736

    
1737
    /* open each decoder */
1738
    for(i=0;i<nb_istreams;i++) {
1739
        ist = ist_table[i];
1740
        if (ist->decoding_needed) {
1741
            AVCodec *codec;
1742
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1743
            if (!codec) {
1744
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1745
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1746
                exit(1);
1747
            }
1748
            if (avcodec_open(ist->st->codec, codec) < 0) {
1749
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1750
                        ist->file_index, ist->index);
1751
                exit(1);
1752
            }
1753
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1754
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1755
        }
1756
    }
1757

    
1758
    /* init pts */
1759
    for(i=0;i<nb_istreams;i++) {
1760
        ist = ist_table[i];
1761
        is = input_files[ist->file_index];
1762
        ist->pts = 0;
1763
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1764
        if(ist->st->start_time == AV_NOPTS_VALUE)
1765
            ist->next_pts=0;
1766
        if(input_files_ts_offset[ist->file_index])
1767
            ist->next_pts= AV_NOPTS_VALUE;
1768
        ist->is_start = 1;
1769
    }
1770

    
1771
    /* set meta data information from input file if required */
1772
    for (i=0;i<nb_meta_data_maps;i++) {
1773
        AVFormatContext *out_file;
1774
        AVFormatContext *in_file;
1775

    
1776
        int out_file_index = meta_data_maps[i].out_file;
1777
        int in_file_index = meta_data_maps[i].in_file;
1778
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1779
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1780
            ret = AVERROR(EINVAL);
1781
            goto fail;
1782
        }
1783
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1784
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1785
            ret = AVERROR(EINVAL);
1786
            goto fail;
1787
        }
1788

    
1789
        out_file = output_files[out_file_index];
1790
        in_file = input_files[in_file_index];
1791

    
1792
        strcpy(out_file->title, in_file->title);
1793
        strcpy(out_file->author, in_file->author);
1794
        strcpy(out_file->copyright, in_file->copyright);
1795
        strcpy(out_file->comment, in_file->comment);
1796
        strcpy(out_file->album, in_file->album);
1797
        out_file->year = in_file->year;
1798
        out_file->track = in_file->track;
1799
        strcpy(out_file->genre, in_file->genre);
1800
    }
1801

    
1802
    /* open files and write file headers */
1803
    for(i=0;i<nb_output_files;i++) {
1804
        os = output_files[i];
1805
        if (av_write_header(os) < 0) {
1806
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1807
            ret = AVERROR(EINVAL);
1808
            goto fail;
1809
        }
1810
    }
1811

    
1812
    if ( !using_stdin && verbose >= 0) {
1813
        fprintf(stderr, "Press [q] to stop encoding\n");
1814
        url_set_interrupt_cb(decode_interrupt_cb);
1815
    }
1816
    term_init();
1817

    
1818
    key = -1;
1819
    timer_start = av_gettime();
1820

    
1821
    for(; received_sigterm == 0;) {
1822
        int file_index, ist_index;
1823
        AVPacket pkt;
1824
        double ipts_min;
1825
        double opts_min;
1826

    
1827
    redo:
1828
        ipts_min= 1e100;
1829
        opts_min= 1e100;
1830
        /* if 'q' pressed, exits */
1831
        if (!using_stdin) {
1832
            if (q_pressed)
1833
                break;
1834
            /* read_key() returns 0 on EOF */
1835
            key = read_key();
1836
            if (key == 'q')
1837
                break;
1838
        }
1839

    
1840
        /* select the stream that we must read now by looking at the
1841
           smallest output pts */
1842
        file_index = -1;
1843
        for(i=0;i<nb_ostreams;i++) {
1844
            double ipts, opts;
1845
            ost = ost_table[i];
1846
            os = output_files[ost->file_index];
1847
            ist = ist_table[ost->source_index];
1848
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1849
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1850
            else
1851
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1852
            ipts = (double)ist->pts;
1853
            if (!file_table[ist->file_index].eof_reached){
1854
                if(ipts < ipts_min) {
1855
                    ipts_min = ipts;
1856
                    if(input_sync ) file_index = ist->file_index;
1857
                }
1858
                if(opts < opts_min) {
1859
                    opts_min = opts;
1860
                    if(!input_sync) file_index = ist->file_index;
1861
                }
1862
            }
1863
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1864
                file_index= -1;
1865
                break;
1866
            }
1867
        }
1868
        /* if none, if is finished */
1869
        if (file_index < 0) {
1870
            break;
1871
        }
1872

    
1873
        /* finish if recording time exhausted */
1874
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1875
            break;
1876

    
1877
        /* finish if limit size exhausted */
1878
        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1879
            break;
1880

    
1881
        /* read a frame from it and output it in the fifo */
1882
        is = input_files[file_index];
1883
        if (av_read_frame(is, &pkt) < 0) {
1884
            file_table[file_index].eof_reached = 1;
1885
            if (opt_shortest) break; else continue; //
1886
        }
1887

    
1888
        if (do_pkt_dump) {
1889
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1890
        }
1891
        /* the following test is needed in case new streams appear
1892
           dynamically in stream : we ignore them */
1893
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1894
            goto discard_packet;
1895
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1896
        ist = ist_table[ist_index];
1897
        if (ist->discard)
1898
            goto discard_packet;
1899

    
1900
//        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1901
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1902
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1903
            if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1904
                input_files_ts_offset[ist->file_index]-= delta;
1905
                if (verbose > 2)
1906
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1907
                for(i=0; i<file_table[file_index].nb_streams; i++){
1908
                    int index= file_table[file_index].ist_index + i;
1909
                    ist_table[index]->next_pts += delta;
1910
                    ist_table[index]->is_start=1;
1911
                }
1912
            }
1913
        }
1914

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

    
1918
            if (verbose >= 0)
1919
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1920
                        ist->file_index, ist->index);
1921

    
1922
            av_free_packet(&pkt);
1923
            goto redo;
1924
        }
1925

    
1926
    discard_packet:
1927
        av_free_packet(&pkt);
1928

    
1929
        /* dump report by using the output first video and audio streams */
1930
        print_report(output_files, ost_table, nb_ostreams, 0);
1931
    }
1932

    
1933
    /* at the end of stream, we must flush the decoder buffers */
1934
    for(i=0;i<nb_istreams;i++) {
1935
        ist = ist_table[i];
1936
        if (ist->decoding_needed) {
1937
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1938
        }
1939
    }
1940

    
1941
    term_exit();
1942

    
1943
    /* write the trailer if needed and close file */
1944
    for(i=0;i<nb_output_files;i++) {
1945
        os = output_files[i];
1946
        av_write_trailer(os);
1947
    }
1948

    
1949
    /* dump report by using the first video and audio streams */
1950
    print_report(output_files, ost_table, nb_ostreams, 1);
1951

    
1952
    /* close each encoder */
1953
    for(i=0;i<nb_ostreams;i++) {
1954
        ost = ost_table[i];
1955
        if (ost->encoding_needed) {
1956
            av_freep(&ost->st->codec->stats_in);
1957
            avcodec_close(ost->st->codec);
1958
        }
1959
    }
1960

    
1961
    /* close each decoder */
1962
    for(i=0;i<nb_istreams;i++) {
1963
        ist = ist_table[i];
1964
        if (ist->decoding_needed) {
1965
            avcodec_close(ist->st->codec);
1966
        }
1967
    }
1968

    
1969
    /* finished ! */
1970

    
1971
    ret = 0;
1972
 fail1:
1973
    av_freep(&bit_buffer);
1974
    av_free(file_table);
1975

    
1976
    if (ist_table) {
1977
        for(i=0;i<nb_istreams;i++) {
1978
            ist = ist_table[i];
1979
            av_free(ist);
1980
        }
1981
        av_free(ist_table);
1982
    }
1983
    if (ost_table) {
1984
        for(i=0;i<nb_ostreams;i++) {
1985
            ost = ost_table[i];
1986
            if (ost) {
1987
                if (ost->logfile) {
1988
                    fclose(ost->logfile);
1989
                    ost->logfile = NULL;
1990
                }
1991
                av_fifo_free(&ost->fifo); /* works even if fifo is not
1992
                                             initialized but set to zero */
1993
                av_free(ost->pict_tmp.data[0]);
1994
                if (ost->video_resample)
1995
                    sws_freeContext(ost->img_resample_ctx);
1996
                if (ost->audio_resample)
1997
                    audio_resample_close(ost->resample);
1998
                av_free(ost);
1999
            }
2000
        }
2001
        av_free(ost_table);
2002
    }
2003
    return ret;
2004
 fail:
2005
    ret = AVERROR(ENOMEM);
2006
    goto fail1;
2007
}
2008

    
2009
#if 0
2010
int file_read(const char *filename)
2011
{
2012
    URLContext *h;
2013
    unsigned char buffer[1024];
2014
    int len, i;
2015

2016
    if (url_open(&h, filename, O_RDONLY) < 0) {
2017
        printf("could not open '%s'\n", filename);
2018
        return -1;
2019
    }
2020
    for(;;) {
2021
        len = url_read(h, buffer, sizeof(buffer));
2022
        if (len <= 0)
2023
            break;
2024
        for(i=0;i<len;i++) putchar(buffer[i]);
2025
    }
2026
    url_close(h);
2027
    return 0;
2028
}
2029
#endif
2030

    
2031
static void opt_format(const char *arg)
2032
{
2033
    /* compatibility stuff for pgmyuv */
2034
    if (!strcmp(arg, "pgmyuv")) {
2035
        pgmyuv_compatibility_hack=1;
2036
//        opt_image_format(arg);
2037
        arg = "image2";
2038
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2039
    }
2040

    
2041
    file_iformat = av_find_input_format(arg);
2042
    file_oformat = guess_format(arg, NULL, NULL);
2043
    if (!file_iformat && !file_oformat) {
2044
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2045
        exit(1);
2046
    }
2047
}
2048

    
2049
static void opt_video_rc_eq(char *arg)
2050
{
2051
    video_rc_eq = arg;
2052
}
2053

    
2054
static void opt_video_rc_override_string(char *arg)
2055
{
2056
    video_rc_override_string = arg;
2057
}
2058

    
2059
static void opt_me_threshold(const char *arg)
2060
{
2061
    me_threshold = atoi(arg);
2062
}
2063

    
2064
static void opt_verbose(const char *arg)
2065
{
2066
    verbose = atoi(arg);
2067
    av_log_level = atoi(arg);
2068
}
2069

    
2070
static void opt_frame_rate(const char *arg)
2071
{
2072
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2073
        fprintf(stderr, "Incorrect frame rate\n");
2074
        exit(1);
2075
    }
2076
}
2077

    
2078
static void opt_frame_crop_top(const char *arg)
2079
{
2080
    frame_topBand = atoi(arg);
2081
    if (frame_topBand < 0) {
2082
        fprintf(stderr, "Incorrect top crop size\n");
2083
        exit(1);
2084
    }
2085
    if ((frame_topBand % 2) != 0) {
2086
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2087
        exit(1);
2088
    }
2089
    if ((frame_topBand) >= frame_height){
2090
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2091
        exit(1);
2092
    }
2093
    frame_height -= frame_topBand;
2094
}
2095

    
2096
static void opt_frame_crop_bottom(const char *arg)
2097
{
2098
    frame_bottomBand = atoi(arg);
2099
    if (frame_bottomBand < 0) {
2100
        fprintf(stderr, "Incorrect bottom crop size\n");
2101
        exit(1);
2102
    }
2103
    if ((frame_bottomBand % 2) != 0) {
2104
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2105
        exit(1);
2106
    }
2107
    if ((frame_bottomBand) >= frame_height){
2108
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2109
        exit(1);
2110
    }
2111
    frame_height -= frame_bottomBand;
2112
}
2113

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

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

    
2150
static void opt_frame_size(const char *arg)
2151
{
2152
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2153
        fprintf(stderr, "Incorrect frame size\n");
2154
        exit(1);
2155
    }
2156
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2157
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2158
        exit(1);
2159
    }
2160
}
2161

    
2162

    
2163
#define SCALEBITS 10
2164
#define ONE_HALF  (1 << (SCALEBITS - 1))
2165
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2166

    
2167
#define RGB_TO_Y(r, g, b) \
2168
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2169
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2170

    
2171
#define RGB_TO_U(r1, g1, b1, shift)\
2172
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2173
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2174

    
2175
#define RGB_TO_V(r1, g1, b1, shift)\
2176
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2177
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2178

    
2179
static void opt_pad_color(const char *arg) {
2180
    /* Input is expected to be six hex digits similar to
2181
       how colors are expressed in html tags (but without the #) */
2182
    int rgb = strtol(arg, NULL, 16);
2183
    int r,g,b;
2184

    
2185
    r = (rgb >> 16);
2186
    g = ((rgb >> 8) & 255);
2187
    b = (rgb & 255);
2188

    
2189
    padcolor[0] = RGB_TO_Y(r,g,b);
2190
    padcolor[1] = RGB_TO_U(r,g,b,0);
2191
    padcolor[2] = RGB_TO_V(r,g,b,0);
2192
}
2193

    
2194
static void opt_frame_pad_top(const char *arg)
2195
{
2196
    frame_padtop = atoi(arg);
2197
    if (frame_padtop < 0) {
2198
        fprintf(stderr, "Incorrect top pad size\n");
2199
        exit(1);
2200
    }
2201
    if ((frame_padtop % 2) != 0) {
2202
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2203
        exit(1);
2204
    }
2205
}
2206

    
2207
static void opt_frame_pad_bottom(const char *arg)
2208
{
2209
    frame_padbottom = atoi(arg);
2210
    if (frame_padbottom < 0) {
2211
        fprintf(stderr, "Incorrect bottom pad size\n");
2212
        exit(1);
2213
    }
2214
    if ((frame_padbottom % 2) != 0) {
2215
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2216
        exit(1);
2217
    }
2218
}
2219

    
2220

    
2221
static void opt_frame_pad_left(const char *arg)
2222
{
2223
    frame_padleft = atoi(arg);
2224
    if (frame_padleft < 0) {
2225
        fprintf(stderr, "Incorrect left pad size\n");
2226
        exit(1);
2227
    }
2228
    if ((frame_padleft % 2) != 0) {
2229
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2230
        exit(1);
2231
    }
2232
}
2233

    
2234

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

    
2248

    
2249
static void opt_frame_pix_fmt(const char *arg)
2250
{
2251
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2252
}
2253

    
2254
static void opt_frame_aspect_ratio(const char *arg)
2255
{
2256
    int x = 0, y = 0;
2257
    double ar = 0;
2258
    const char *p;
2259

    
2260
    p = strchr(arg, ':');
2261
    if (p) {
2262
        x = strtol(arg, (char **)&arg, 10);
2263
        if (arg == p)
2264
            y = strtol(arg+1, (char **)&arg, 10);
2265
        if (x > 0 && y > 0)
2266
            ar = (double)x / (double)y;
2267
    } else
2268
        ar = strtod(arg, (char **)&arg);
2269

    
2270
    if (!ar) {
2271
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2272
        exit(1);
2273
    }
2274
    frame_aspect_ratio = ar;
2275
}
2276

    
2277
static void opt_qscale(const char *arg)
2278
{
2279
    video_qscale = atof(arg);
2280
    if (video_qscale <= 0 ||
2281
        video_qscale > 255) {
2282
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2283
        exit(1);
2284
    }
2285
}
2286

    
2287
static void opt_qdiff(const char *arg)
2288
{
2289
    video_qdiff = atoi(arg);
2290
    if (video_qdiff < 0 ||
2291
        video_qdiff > 31) {
2292
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2293
        exit(1);
2294
    }
2295
}
2296

    
2297
static void opt_strict(const char *arg)
2298
{
2299
    strict= atoi(arg);
2300
}
2301

    
2302
static void opt_top_field_first(const char *arg)
2303
{
2304
    top_field_first= atoi(arg);
2305
}
2306

    
2307
static void opt_thread_count(const char *arg)
2308
{
2309
    thread_count= atoi(arg);
2310
#if !defined(HAVE_THREADS)
2311
    if (verbose >= 0)
2312
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2313
#endif
2314
}
2315

    
2316
static void opt_audio_rate(const char *arg)
2317
{
2318
    audio_sample_rate = atoi(arg);
2319
}
2320

    
2321
static void opt_audio_channels(const char *arg)
2322
{
2323
    audio_channels = atoi(arg);
2324
}
2325

    
2326
static void opt_video_channel(const char *arg)
2327
{
2328
    video_channel = strtol(arg, NULL, 0);
2329
}
2330

    
2331
static void opt_video_standard(const char *arg)
2332
{
2333
    video_standard = av_strdup(arg);
2334
}
2335

    
2336
static void opt_codec(int *pstream_copy, int *pcodec_id,
2337
                      int codec_type, const char *arg)
2338
{
2339
    AVCodec *p;
2340

    
2341
    if (!strcmp(arg, "copy")) {
2342
        *pstream_copy = 1;
2343
    } else {
2344
        p = first_avcodec;
2345
        while (p) {
2346
            if (!strcmp(p->name, arg) && p->type == codec_type)
2347
                break;
2348
            p = p->next;
2349
        }
2350
        if (p == NULL) {
2351
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2352
            exit(1);
2353
        } else {
2354
            *pcodec_id = p->id;
2355
        }
2356
    }
2357
}
2358

    
2359
static void opt_audio_codec(const char *arg)
2360
{
2361
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2362
}
2363

    
2364
static void opt_audio_tag(const char *arg)
2365
{
2366
    char *tail;
2367
    audio_codec_tag= strtol(arg, &tail, 0);
2368

    
2369
    if(!tail || *tail)
2370
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2371
}
2372

    
2373
static void opt_video_tag(const char *arg)
2374
{
2375
    char *tail;
2376
    video_codec_tag= strtol(arg, &tail, 0);
2377

    
2378
    if(!tail || *tail)
2379
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2380
}
2381

    
2382
static void add_frame_hooker(const char *arg)
2383
{
2384
    int argc = 0;
2385
    char *argv[64];
2386
    int i;
2387
    char *args = av_strdup(arg);
2388

    
2389
    using_vhook = 1;
2390

    
2391
    argv[0] = strtok(args, " ");
2392
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2393
    }
2394

    
2395
    i = frame_hook_add(argc, argv);
2396

    
2397
    if (i != 0) {
2398
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2399
        exit(1);
2400
    }
2401
}
2402

    
2403
const char *motion_str[] = {
2404
    "zero",
2405
    "full",
2406
    "log",
2407
    "phods",
2408
    "epzs",
2409
    "x1",
2410
    "hex",
2411
    "umh",
2412
    "iter",
2413
    NULL,
2414
};
2415

    
2416
static void opt_motion_estimation(const char *arg)
2417
{
2418
    const char **p;
2419
    p = motion_str;
2420
    for(;;) {
2421
        if (!*p) {
2422
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2423
            exit(1);
2424
        }
2425
        if (!strcmp(*p, arg))
2426
            break;
2427
        p++;
2428
    }
2429
    me_method = (p - motion_str) + 1;
2430
}
2431

    
2432
static void opt_video_codec(const char *arg)
2433
{
2434
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2435
}
2436

    
2437
static void opt_subtitle_codec(const char *arg)
2438
{
2439
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2440
}
2441

    
2442
static void opt_map(const char *arg)
2443
{
2444
    AVStreamMap *m;
2445
    const char *p;
2446

    
2447
    p = arg;
2448
    m = &stream_maps[nb_stream_maps++];
2449

    
2450
    m->file_index = strtol(arg, (char **)&p, 0);
2451
    if (*p)
2452
        p++;
2453

    
2454
    m->stream_index = strtol(p, (char **)&p, 0);
2455
    if (*p) {
2456
        p++;
2457
        m->sync_file_index = strtol(p, (char **)&p, 0);
2458
        if (*p)
2459
            p++;
2460
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2461
    } else {
2462
        m->sync_file_index = m->file_index;
2463
        m->sync_stream_index = m->stream_index;
2464
    }
2465
}
2466

    
2467
static void opt_map_meta_data(const char *arg)
2468
{
2469
    AVMetaDataMap *m;
2470
    const char *p;
2471

    
2472
    p = arg;
2473
    m = &meta_data_maps[nb_meta_data_maps++];
2474

    
2475
    m->out_file = strtol(arg, (char **)&p, 0);
2476
    if (*p)
2477
        p++;
2478

    
2479
    m->in_file = strtol(p, (char **)&p, 0);
2480
}
2481

    
2482
static void opt_recording_time(const char *arg)
2483
{
2484
    recording_time = parse_date(arg, 1);
2485
}
2486

    
2487
static void opt_start_time(const char *arg)
2488
{
2489
    start_time = parse_date(arg, 1);
2490
}
2491

    
2492
static void opt_rec_timestamp(const char *arg)
2493
{
2494
    rec_timestamp = parse_date(arg, 0) / 1000000;
2495
}
2496

    
2497
static void opt_input_ts_offset(const char *arg)
2498
{
2499
    input_ts_offset = parse_date(arg, 1);
2500
}
2501

    
2502
static void opt_input_file(const char *filename)
2503
{
2504
    AVFormatContext *ic;
2505
    AVFormatParameters params, *ap = &params;
2506
    int err, i, ret, rfps, rfps_base;
2507
    int64_t timestamp;
2508

    
2509
    if (!strcmp(filename, "-"))
2510
        filename = "pipe:";
2511

    
2512
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2513
                   !strcmp( filename, "/dev/stdin" );
2514

    
2515
    /* get default parameters from command line */
2516
    ic = av_alloc_format_context();
2517

    
2518
    memset(ap, 0, sizeof(*ap));
2519
    ap->prealloced_context = 1;
2520
    ap->sample_rate = audio_sample_rate;
2521
    ap->channels = audio_channels;
2522
    ap->time_base.den = frame_rate;
2523
    ap->time_base.num = frame_rate_base;
2524
    ap->width = frame_width + frame_padleft + frame_padright;
2525
    ap->height = frame_height + frame_padtop + frame_padbottom;
2526
    ap->pix_fmt = frame_pix_fmt;
2527
    ap->channel = video_channel;
2528
    ap->standard = video_standard;
2529
    ap->video_codec_id = video_codec_id;
2530
    ap->audio_codec_id = audio_codec_id;
2531
    if(pgmyuv_compatibility_hack)
2532
        ap->video_codec_id= CODEC_ID_PGMYUV;
2533

    
2534
    for(i=0; i<opt_name_count; i++){
2535
        const AVOption *opt;
2536
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2537
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2538
            av_set_double(ic, opt_names[i], d);
2539
    }
2540
    /* open the input file with generic libav function */
2541
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2542
    if (err < 0) {
2543
        print_error(filename, err);
2544
        exit(1);
2545
    }
2546

    
2547
    ic->loop_input = loop_input;
2548

    
2549
    /* If not enough info to get the stream parameters, we decode the
2550
       first frames to get it. (used in mpeg case for example) */
2551
    ret = av_find_stream_info(ic);
2552
    if (ret < 0 && verbose >= 0) {
2553
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2554
        exit(1);
2555
    }
2556

    
2557
    timestamp = start_time;
2558
    /* add the stream start time */
2559
    if (ic->start_time != AV_NOPTS_VALUE)
2560
        timestamp += ic->start_time;
2561

    
2562
    /* if seeking requested, we execute it */
2563
    if (start_time != 0) {
2564
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2565
        if (ret < 0) {
2566
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2567
                    filename, (double)timestamp / AV_TIME_BASE);
2568
        }
2569
        /* reset seek info */
2570
        start_time = 0;
2571
    }
2572

    
2573
    /* update the current parameters so that they match the one of the input stream */
2574
    for(i=0;i<ic->nb_streams;i++) {
2575
        int j;
2576
        AVCodecContext *enc = ic->streams[i]->codec;
2577
        if(thread_count>1)
2578
            avcodec_thread_init(enc, thread_count);
2579
        enc->thread_count= thread_count;
2580
        switch(enc->codec_type) {
2581
        case CODEC_TYPE_AUDIO:
2582
            for(j=0; j<opt_name_count; j++){
2583
                const AVOption *opt;
2584
                double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2585
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2586
                    av_set_double(enc, opt_names[j], d);
2587
            }
2588
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2589
            audio_channels = enc->channels;
2590
            audio_sample_rate = enc->sample_rate;
2591
            if(audio_disable)
2592
                ic->streams[i]->discard= AVDISCARD_ALL;
2593
            break;
2594
        case CODEC_TYPE_VIDEO:
2595
            for(j=0; j<opt_name_count; j++){
2596
                const AVOption *opt;
2597
                double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2598
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2599
                    av_set_double(enc, opt_names[j], d);
2600
            }
2601
            frame_height = enc->height;
2602
            frame_width = enc->width;
2603
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2604
            frame_pix_fmt = enc->pix_fmt;
2605
            rfps      = ic->streams[i]->r_frame_rate.num;
2606
            rfps_base = ic->streams[i]->r_frame_rate.den;
2607
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2608
            if(me_threshold)
2609
                enc->debug |= FF_DEBUG_MV;
2610

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

    
2613
                if (verbose >= 0)
2614
                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2615
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2616

    
2617
                    (float)rfps / rfps_base, rfps, rfps_base);
2618
            }
2619
            /* update the current frame rate to match the stream frame rate */
2620
            frame_rate      = rfps;
2621
            frame_rate_base = rfps_base;
2622

    
2623
            enc->rate_emu = rate_emu;
2624
            if(video_disable)
2625
                ic->streams[i]->discard= AVDISCARD_ALL;
2626
            else if(video_discard)
2627
                ic->streams[i]->discard= video_discard;
2628
            break;
2629
        case CODEC_TYPE_DATA:
2630
            break;
2631
        case CODEC_TYPE_SUBTITLE:
2632
            break;
2633
        case CODEC_TYPE_UNKNOWN:
2634
            break;
2635
        default:
2636
            av_abort();
2637
        }
2638
    }
2639

    
2640
    input_files[nb_input_files] = ic;
2641
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2642
    /* dump the file content */
2643
    if (verbose >= 0)
2644
        dump_format(ic, nb_input_files, filename, 0);
2645

    
2646
    nb_input_files++;
2647
    file_iformat = NULL;
2648
    file_oformat = NULL;
2649

    
2650
    video_channel = 0;
2651

    
2652
    rate_emu = 0;
2653
}
2654

    
2655
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2656
{
2657
    int has_video, has_audio, i, j;
2658
    AVFormatContext *ic;
2659

    
2660
    has_video = 0;
2661
    has_audio = 0;
2662
    for(j=0;j<nb_input_files;j++) {
2663
        ic = input_files[j];
2664
        for(i=0;i<ic->nb_streams;i++) {
2665
            AVCodecContext *enc = ic->streams[i]->codec;
2666
            switch(enc->codec_type) {
2667
            case CODEC_TYPE_AUDIO:
2668
                has_audio = 1;
2669
                break;
2670
            case CODEC_TYPE_VIDEO:
2671
                has_video = 1;
2672
                break;
2673
            case CODEC_TYPE_DATA:
2674
            case CODEC_TYPE_UNKNOWN:
2675
            case CODEC_TYPE_SUBTITLE:
2676
                break;
2677
            default:
2678
                av_abort();
2679
            }
2680
        }
2681
    }
2682
    *has_video_ptr = has_video;
2683
    *has_audio_ptr = has_audio;
2684
}
2685

    
2686
static void new_video_stream(AVFormatContext *oc)
2687
{
2688
    AVStream *st;
2689
    AVCodecContext *video_enc;
2690
    int codec_id;
2691

    
2692
    st = av_new_stream(oc, oc->nb_streams);
2693
    if (!st) {
2694
        fprintf(stderr, "Could not alloc stream\n");
2695
        exit(1);
2696
    }
2697
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2698
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2699
    video_bitstream_filters= NULL;
2700

    
2701
    if(thread_count>1)
2702
        avcodec_thread_init(st->codec, thread_count);
2703

    
2704
    video_enc = st->codec;
2705

    
2706
    if(video_codec_tag)
2707
        video_enc->codec_tag= video_codec_tag;
2708

    
2709
    if(   (video_global_header&1)
2710
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2711
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2712
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2713
    }
2714
    if(video_global_header&2){
2715
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2716
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2717
    }
2718

    
2719
    if (video_stream_copy) {
2720
        st->stream_copy = 1;
2721
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2722
    } else {
2723
        char *p;
2724
        int i;
2725
        AVCodec *codec;
2726

    
2727
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2728
        if (video_codec_id != CODEC_ID_NONE)
2729
            codec_id = video_codec_id;
2730

    
2731
        video_enc->codec_id = codec_id;
2732
        codec = avcodec_find_encoder(codec_id);
2733

    
2734
        for(i=0; i<opt_name_count; i++){
2735
             const AVOption *opt;
2736
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2737
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2738
                 av_set_double(video_enc, opt_names[i], d);
2739
        }
2740

    
2741
        video_enc->time_base.den = frame_rate;
2742
        video_enc->time_base.num = frame_rate_base;
2743
        if(codec && codec->supported_framerates){
2744
            const AVRational *p= codec->supported_framerates;
2745
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2746
            const AVRational *best=NULL;
2747
            AVRational best_error= (AVRational){INT_MAX, 1};
2748
            for(; p->den!=0; p++){
2749
                AVRational error= av_sub_q(req, *p);
2750
                if(error.num <0) error.num *= -1;
2751
                if(av_cmp_q(error, best_error) < 0){
2752
                    best_error= error;
2753
                    best= p;
2754
                }
2755
            }
2756
            video_enc->time_base.den= best->num;
2757
            video_enc->time_base.num= best->den;
2758
        }
2759

    
2760
        video_enc->width = frame_width + frame_padright + frame_padleft;
2761
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2762
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2763
        video_enc->pix_fmt = frame_pix_fmt;
2764

    
2765
        if(codec && codec->pix_fmts){
2766
            const enum PixelFormat *p= codec->pix_fmts;
2767
            for(; *p!=-1; p++){
2768
                if(*p == video_enc->pix_fmt)
2769
                    break;
2770
            }
2771
            if(*p == -1)
2772
                video_enc->pix_fmt = codec->pix_fmts[0];
2773
        }
2774

    
2775
        if (intra_only)
2776
            video_enc->gop_size = 0;
2777
        if (video_qscale || same_quality) {
2778
            video_enc->flags |= CODEC_FLAG_QSCALE;
2779
            video_enc->global_quality=
2780
                st->quality = FF_QP2LAMBDA * video_qscale;
2781
        }
2782

    
2783
        if(intra_matrix)
2784
            video_enc->intra_matrix = intra_matrix;
2785
        if(inter_matrix)
2786
            video_enc->inter_matrix = inter_matrix;
2787

    
2788
        video_enc->max_qdiff = video_qdiff;
2789
        video_enc->rc_eq = video_rc_eq;
2790
        video_enc->thread_count = thread_count;
2791
        p= video_rc_override_string;
2792
        for(i=0; p; i++){
2793
            int start, end, q;
2794
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2795
            if(e!=3){
2796
                fprintf(stderr, "error parsing rc_override\n");
2797
                exit(1);
2798
            }
2799
            video_enc->rc_override=
2800
                av_realloc(video_enc->rc_override,
2801
                           sizeof(RcOverride)*(i+1));
2802
            video_enc->rc_override[i].start_frame= start;
2803
            video_enc->rc_override[i].end_frame  = end;
2804
            if(q>0){
2805
                video_enc->rc_override[i].qscale= q;
2806
                video_enc->rc_override[i].quality_factor= 1.0;
2807
            }
2808
            else{
2809
                video_enc->rc_override[i].qscale= 0;
2810
                video_enc->rc_override[i].quality_factor= -q/100.0;
2811
            }
2812
            p= strchr(p, '/');
2813
            if(p) p++;
2814
        }
2815
        video_enc->rc_override_count=i;
2816
        if (!video_enc->rc_initial_buffer_occupancy)
2817
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2818
        video_enc->me_threshold= me_threshold;
2819
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2820
        video_enc->strict_std_compliance = strict;
2821

    
2822
        if (do_psnr)
2823
            video_enc->flags|= CODEC_FLAG_PSNR;
2824

    
2825
        video_enc->me_method = me_method;
2826

    
2827
        /* two pass mode */
2828
        if (do_pass) {
2829
            if (do_pass == 1) {
2830
                video_enc->flags |= CODEC_FLAG_PASS1;
2831
            } else {
2832
                video_enc->flags |= CODEC_FLAG_PASS2;
2833
            }
2834
        }
2835
    }
2836

    
2837
    /* reset some key parameters */
2838
    video_disable = 0;
2839
    video_codec_id = CODEC_ID_NONE;
2840
    video_stream_copy = 0;
2841
}
2842

    
2843
static void new_audio_stream(AVFormatContext *oc)
2844
{
2845
    AVStream *st;
2846
    AVCodecContext *audio_enc;
2847
    int codec_id, i;
2848

    
2849
    st = av_new_stream(oc, oc->nb_streams);
2850
    if (!st) {
2851
        fprintf(stderr, "Could not alloc stream\n");
2852
        exit(1);
2853
    }
2854
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2855

    
2856
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2857
    audio_bitstream_filters= NULL;
2858

    
2859
    if(thread_count>1)
2860
        avcodec_thread_init(st->codec, thread_count);
2861

    
2862
    audio_enc = st->codec;
2863
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2864
    audio_enc->strict_std_compliance = strict;
2865

    
2866
    if(audio_codec_tag)
2867
        audio_enc->codec_tag= audio_codec_tag;
2868

    
2869
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2870
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2871
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2872
    }
2873
    if (audio_stream_copy) {
2874
        st->stream_copy = 1;
2875
        audio_enc->channels = audio_channels;
2876
    } else {
2877
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2878

    
2879
        for(i=0; i<opt_name_count; i++){
2880
            const AVOption *opt;
2881
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2882
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2883
                av_set_double(audio_enc, opt_names[i], d);
2884
        }
2885

    
2886
        if (audio_codec_id != CODEC_ID_NONE)
2887
            codec_id = audio_codec_id;
2888
        audio_enc->codec_id = codec_id;
2889

    
2890
        if (audio_qscale > QSCALE_NONE) {
2891
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2892
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2893
        }
2894
        audio_enc->thread_count = thread_count;
2895
        audio_enc->channels = audio_channels;
2896
    }
2897
    audio_enc->sample_rate = audio_sample_rate;
2898
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2899
    if (audio_language) {
2900
        pstrcpy(st->language, sizeof(st->language), audio_language);
2901
        av_free(audio_language);
2902
        audio_language = NULL;
2903
    }
2904

    
2905
    /* reset some key parameters */
2906
    audio_disable = 0;
2907
    audio_codec_id = CODEC_ID_NONE;
2908
    audio_stream_copy = 0;
2909
}
2910

    
2911
static void opt_new_subtitle_stream(void)
2912
{
2913
    AVFormatContext *oc;
2914
    AVStream *st;
2915
    AVCodecContext *subtitle_enc;
2916
    int i;
2917

    
2918
    if (nb_output_files <= 0) {
2919
        fprintf(stderr, "At least one output file must be specified\n");
2920
        exit(1);
2921
    }
2922
    oc = output_files[nb_output_files - 1];
2923

    
2924
    st = av_new_stream(oc, oc->nb_streams);
2925
    if (!st) {
2926
        fprintf(stderr, "Could not alloc stream\n");
2927
        exit(1);
2928
    }
2929
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2930

    
2931
    subtitle_enc = st->codec;
2932
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2933
    if (subtitle_stream_copy) {
2934
        st->stream_copy = 1;
2935
    } else {
2936
        for(i=0; i<opt_name_count; i++){
2937
             const AVOption *opt;
2938
             double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2939
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2940
                 av_set_double(subtitle_enc, opt_names[i], d);
2941
        }
2942
        subtitle_enc->codec_id = subtitle_codec_id;
2943
    }
2944

    
2945
    if (subtitle_language) {
2946
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
2947
        av_free(subtitle_language);
2948
        subtitle_language = NULL;
2949
    }
2950

    
2951
    subtitle_codec_id = CODEC_ID_NONE;
2952
    subtitle_stream_copy = 0;
2953
}
2954

    
2955
static void opt_new_audio_stream(void)
2956
{
2957
    AVFormatContext *oc;
2958
    if (nb_output_files <= 0) {
2959
        fprintf(stderr, "At least one output file must be specified\n");
2960
        exit(1);
2961
    }
2962
    oc = output_files[nb_output_files - 1];
2963
    new_audio_stream(oc);
2964
}
2965

    
2966
static void opt_new_video_stream(void)
2967
{
2968
    AVFormatContext *oc;
2969
    if (nb_output_files <= 0) {
2970
        fprintf(stderr, "At least one output file must be specified\n");
2971
        exit(1);
2972
    }
2973
    oc = output_files[nb_output_files - 1];
2974
    new_video_stream(oc);
2975
}
2976

    
2977
static void opt_output_file(const char *filename)
2978
{
2979
    AVFormatContext *oc;
2980
    int use_video, use_audio, input_has_video, input_has_audio, i;
2981
    AVFormatParameters params, *ap = &params;
2982

    
2983
    if (!strcmp(filename, "-"))
2984
        filename = "pipe:";
2985

    
2986
    oc = av_alloc_format_context();
2987

    
2988
    if (!file_oformat) {
2989
        file_oformat = guess_format(NULL, filename, NULL);
2990
        if (!file_oformat) {
2991
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2992
                    filename);
2993
            exit(1);
2994
        }
2995
    }
2996

    
2997
    oc->oformat = file_oformat;
2998
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
2999

    
3000
    if (!strcmp(file_oformat->name, "ffm") &&
3001
        strstart(filename, "http:", NULL)) {
3002
        /* special case for files sent to ffserver: we get the stream
3003
           parameters from ffserver */
3004
        if (read_ffserver_streams(oc, filename) < 0) {
3005
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3006
            exit(1);
3007
        }
3008
    } else {
3009
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3010
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3011

    
3012
        /* disable if no corresponding type found and at least one
3013
           input file */
3014
        if (nb_input_files > 0) {
3015
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3016
            if (!input_has_video)
3017
                use_video = 0;
3018
            if (!input_has_audio)
3019
                use_audio = 0;
3020
        }
3021

    
3022
        /* manual disable */
3023
        if (audio_disable) {
3024
            use_audio = 0;
3025
        }
3026
        if (video_disable) {
3027
            use_video = 0;
3028
        }
3029

    
3030
        if (use_video) {
3031
            new_video_stream(oc);
3032
        }
3033

    
3034
        if (use_audio) {
3035
            new_audio_stream(oc);
3036
        }
3037

    
3038
        oc->timestamp = rec_timestamp;
3039

    
3040
        if (str_title)
3041
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3042
        if (str_author)
3043
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3044
        if (str_copyright)
3045
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3046
        if (str_comment)
3047
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3048
        if (str_album)
3049
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3050
    }
3051

    
3052
    output_files[nb_output_files++] = oc;
3053

    
3054
    /* check filename in case of an image number is expected */
3055
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3056
        if (!av_filename_number_test(oc->filename)) {
3057
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3058
            exit(1);
3059
        }
3060
    }
3061

    
3062
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3063
        /* test if it already exists to avoid loosing precious files */
3064
        if (!file_overwrite &&
3065
            (strchr(filename, ':') == NULL ||
3066
             strstart(filename, "file:", NULL))) {
3067
            if (url_exist(filename)) {
3068
                int c;
3069

    
3070
                if ( !using_stdin ) {
3071
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3072
                    fflush(stderr);
3073
                    c = getchar();
3074
                    if (toupper(c) != 'Y') {
3075
                        fprintf(stderr, "Not overwriting - exiting\n");
3076
                        exit(1);
3077
                    }
3078
                                }
3079
                                else {
3080
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3081
                    exit(1);
3082
                                }
3083
            }
3084
        }
3085

    
3086
        /* open the file */
3087
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3088
            fprintf(stderr, "Could not open '%s'\n", filename);
3089
            exit(1);
3090
        }
3091
    }
3092

    
3093
    memset(ap, 0, sizeof(*ap));
3094
    if (av_set_parameters(oc, ap) < 0) {
3095
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3096
                oc->filename);
3097
        exit(1);
3098
    }
3099

    
3100
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3101
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3102
    oc->loop_output = loop_output;
3103

    
3104
    for(i=0; i<opt_name_count; i++){
3105
        const AVOption *opt;
3106
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3107
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3108
            av_set_double(oc, opt_names[i], d);
3109
    }
3110

    
3111
    /* reset some options */
3112
    file_oformat = NULL;
3113
    file_iformat = NULL;
3114
}
3115

    
3116
/* same option as mencoder */
3117
static void opt_pass(const char *pass_str)
3118
{
3119
    int pass;
3120
    pass = atoi(pass_str);
3121
    if (pass != 1 && pass != 2) {
3122
        fprintf(stderr, "pass number can be only 1 or 2\n");
3123
        exit(1);
3124
    }
3125
    do_pass = pass;
3126
}
3127

    
3128
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3129
static int64_t getutime(void)
3130
{
3131
  return av_gettime();
3132
}
3133
#else
3134
static int64_t getutime(void)
3135
{
3136
    struct rusage rusage;
3137

    
3138
    getrusage(RUSAGE_SELF, &rusage);
3139
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3140
}
3141
#endif
3142

    
3143
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3144
extern int ffm_nopts;
3145
#endif
3146

    
3147
static void show_formats(void)
3148
{
3149
    AVInputFormat *ifmt;
3150
    AVOutputFormat *ofmt;
3151
    URLProtocol *up;
3152
    AVCodec *p, *p2;
3153
    const char **pp, *last_name;
3154

    
3155
    printf("File formats:\n");
3156
    last_name= "000";
3157
    for(;;){
3158
        int decode=0;
3159
        int encode=0;
3160
        const char *name=NULL;
3161
        const char *long_name=NULL;
3162

    
3163
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3164
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3165
                strcmp(ofmt->name, last_name)>0){
3166
                name= ofmt->name;
3167
                long_name= ofmt->long_name;
3168
                encode=1;
3169
            }
3170
        }
3171
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3172
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3173
                strcmp(ifmt->name, last_name)>0){
3174
                name= ifmt->name;
3175
                long_name= ifmt->long_name;
3176
                encode=0;
3177
            }
3178
            if(name && strcmp(ifmt->name, name)==0)
3179
                decode=1;
3180
        }
3181
        if(name==NULL)
3182
            break;
3183
        last_name= name;
3184

    
3185
        printf(
3186
            " %s%s %-15s %s\n",
3187
            decode ? "D":" ",
3188
            encode ? "E":" ",
3189
            name,
3190
            long_name ? long_name:" ");
3191
    }
3192
    printf("\n");
3193

    
3194
    printf("Codecs:\n");
3195
    last_name= "000";
3196
    for(;;){
3197
        int decode=0;
3198
        int encode=0;
3199
        int cap=0;
3200
        const char *type_str;
3201

    
3202
        p2=NULL;
3203
        for(p = first_avcodec; p != NULL; p = p->next) {
3204
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3205
                strcmp(p->name, last_name)>0){
3206
                p2= p;
3207
                decode= encode= cap=0;
3208
            }
3209
            if(p2 && strcmp(p->name, p2->name)==0){
3210
                if(p->decode) decode=1;
3211
                if(p->encode) encode=1;
3212
                cap |= p->capabilities;
3213
            }
3214
        }
3215
        if(p2==NULL)
3216
            break;
3217
        last_name= p2->name;
3218

    
3219
        switch(p2->type) {
3220
        case CODEC_TYPE_VIDEO:
3221
            type_str = "V";
3222
            break;
3223
        case CODEC_TYPE_AUDIO:
3224
            type_str = "A";
3225
            break;
3226
        case CODEC_TYPE_SUBTITLE:
3227
            type_str = "S";
3228
            break;
3229
        default:
3230
            type_str = "?";
3231
            break;
3232
        }
3233
        printf(
3234
            " %s%s%s%s%s%s %s",
3235
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3236
            encode ? "E":" ",
3237
            type_str,
3238
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3239
            cap & CODEC_CAP_DR1 ? "D":" ",
3240
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3241
            p2->name);
3242
       /* if(p2->decoder && decode==0)
3243
            printf(" use %s for decoding", p2->decoder->name);*/
3244
        printf("\n");
3245
    }
3246
    printf("\n");
3247

    
3248
    printf("Supported file protocols:\n");
3249
    for(up = first_protocol; up != NULL; up = up->next)
3250
        printf(" %s:", up->name);
3251
    printf("\n");
3252

    
3253
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3254
    printf("Motion estimation methods:\n");
3255
    pp = motion_str;
3256
    while (*pp) {
3257
        printf(" %s", *pp);
3258
        if ((pp - motion_str + 1) == ME_ZERO)
3259
            printf("(fastest)");
3260
        else if ((pp - motion_str + 1) == ME_FULL)
3261
            printf("(slowest)");
3262
        else if ((pp - motion_str + 1) == ME_EPZS)
3263
            printf("(default)");
3264
        pp++;
3265
    }
3266
    printf("\n\n");
3267
    printf(
3268
"Note, the names of encoders and decoders dont always match, so there are\n"
3269
"several cases where the above table shows encoder only or decoder only entries\n"
3270
"even though both encoding and decoding are supported for example, the h263\n"
3271
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3272
"worse\n");
3273
    exit(1);
3274
}
3275

    
3276
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3277
{
3278
    int i;
3279
    const char *p = str;
3280
    for(i = 0;; i++) {
3281
        dest[i] = atoi(p);
3282
        if(i == 63)
3283
            break;
3284
        p = strchr(p, ',');
3285
        if(!p) {
3286
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3287
            exit(1);
3288
        }
3289
        p++;
3290
    }
3291
}
3292

    
3293
static void opt_inter_matrix(const char *arg)
3294
{
3295
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3296
    parse_matrix_coeffs(inter_matrix, arg);
3297
}
3298

    
3299
static void opt_intra_matrix(const char *arg)
3300
{
3301
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3302
    parse_matrix_coeffs(intra_matrix, arg);
3303
}
3304

    
3305
static void opt_target(const char *arg)
3306
{
3307
    int norm = -1;
3308
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3309

    
3310
    if(!strncmp(arg, "pal-", 4)) {
3311
        norm = 0;
3312
        arg += 4;
3313
    } else if(!strncmp(arg, "ntsc-", 5)) {
3314
        norm = 1;
3315
        arg += 5;
3316
    } else if(!strncmp(arg, "film-", 5)) {
3317
        norm = 2;
3318
        arg += 5;
3319
    } else {
3320
        int fr;
3321
        /* Calculate FR via float to avoid int overflow */
3322
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3323
        if(fr == 25000) {
3324
            norm = 0;
3325
        } else if((fr == 29970) || (fr == 23976)) {
3326
            norm = 1;
3327
        } else {
3328
            /* Try to determine PAL/NTSC by peeking in the input files */
3329
            if(nb_input_files) {
3330
                int i, j;
3331
                for(j = 0; j < nb_input_files; j++) {
3332
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3333
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3334
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3335
                            continue;
3336
                        fr = c->time_base.den * 1000 / c->time_base.num;
3337
                        if(fr == 25000) {
3338
                            norm = 0;
3339
                            break;
3340
                        } else if((fr == 29970) || (fr == 23976)) {
3341
                            norm = 1;
3342
                            break;
3343
                        }
3344
                    }
3345
                    if(norm >= 0)
3346
                        break;
3347
                }
3348
            }
3349
        }
3350
        if(verbose && norm >= 0)
3351
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3352
    }
3353

    
3354
    if(norm < 0) {
3355
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3356
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3357
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3358
        exit(1);
3359
    }
3360

    
3361
    if(!strcmp(arg, "vcd")) {
3362

    
3363
        opt_video_codec("mpeg1video");
3364
        opt_audio_codec("mp2");
3365
        opt_format("vcd");
3366

    
3367
        opt_frame_size(norm ? "352x240" : "352x288");
3368
        opt_frame_rate(frame_rates[norm]);
3369
        opt_default("gop", norm ? "18" : "15");
3370

    
3371
        opt_default("b", "1150000");
3372
        opt_default("maxrate", "1150000");
3373
        opt_default("minrate", "1150000");
3374
        opt_default("bufsize", "327680"); // 40*1024*8;
3375

    
3376
        opt_default("ab", "224000");
3377
        audio_sample_rate = 44100;
3378
        audio_channels = 2;
3379

    
3380
        opt_default("packetsize", "2324");
3381
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3382

    
3383
        /* We have to offset the PTS, so that it is consistent with the SCR.
3384
           SCR starts at 36000, but the first two packs contain only padding
3385
           and the first pack from the other stream, respectively, may also have
3386
           been written before.
3387
           So the real data starts at SCR 36000+3*1200. */
3388
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3389
    } else if(!strcmp(arg, "svcd")) {
3390

    
3391
        opt_video_codec("mpeg2video");
3392
        opt_audio_codec("mp2");
3393
        opt_format("svcd");
3394

    
3395
        opt_frame_size(norm ? "480x480" : "480x576");
3396
        opt_frame_rate(frame_rates[norm]);
3397
        opt_default("gop", norm ? "18" : "15");
3398

    
3399
        opt_default("b", "2040000");
3400
        opt_default("maxrate", "2516000");
3401
        opt_default("minrate", "0"); //1145000;
3402
        opt_default("bufsize", "1835008"); //224*1024*8;
3403
        opt_default("flags", "+SCAN_OFFSET");
3404

    
3405

    
3406
        opt_default("ab", "224000");
3407
        audio_sample_rate = 44100;
3408

    
3409
        opt_default("packetsize", "2324");
3410

    
3411
    } else if(!strcmp(arg, "dvd")) {
3412

    
3413
        opt_video_codec("mpeg2video");
3414
        opt_audio_codec("ac3");
3415
        opt_format("dvd");
3416

    
3417
        opt_frame_size(norm ? "720x480" : "720x576");
3418
        opt_frame_rate(frame_rates[norm]);
3419
        opt_default("gop", norm ? "18" : "15");
3420

    
3421
        opt_default("b", "6000000");
3422
        opt_default("maxrate", "9000000");
3423
        opt_default("minrate", "0"); //1500000;
3424
        opt_default("bufsize", "1835008"); //224*1024*8;
3425

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

    
3429
        opt_default("ab", "448000");
3430
        audio_sample_rate = 48000;
3431

    
3432
    } else if(!strncmp(arg, "dv", 2)) {
3433

    
3434
        opt_format("dv");
3435

    
3436
        opt_frame_size(norm ? "720x480" : "720x576");
3437
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3438
                                             (norm ? "yuv411p" : "yuv420p"));
3439
        opt_frame_rate(frame_rates[norm]);
3440

    
3441
        audio_sample_rate = 48000;
3442
        audio_channels = 2;
3443

    
3444
    } else {
3445
        fprintf(stderr, "Unknown target: %s\n", arg);
3446
        exit(1);
3447
    }
3448
}
3449

    
3450
static void opt_video_bsf(const char *arg)
3451
{
3452
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3453
    AVBitStreamFilterContext **bsfp;
3454

    
3455
    if(!bsfc){
3456
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3457
        exit(1);
3458
    }
3459

    
3460
    bsfp= &video_bitstream_filters;
3461
    while(*bsfp)
3462
        bsfp= &(*bsfp)->next;
3463

    
3464
    *bsfp= bsfc;
3465
}
3466

    
3467
//FIXME avoid audio - video code duplication
3468
static void opt_audio_bsf(const char *arg)
3469
{
3470
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3471
    AVBitStreamFilterContext **bsfp;
3472

    
3473
    if(!bsfc){
3474
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3475
        exit(1);
3476
    }
3477

    
3478
    bsfp= &audio_bitstream_filters;
3479
    while(*bsfp)
3480
        bsfp= &(*bsfp)->next;
3481

    
3482
    *bsfp= bsfc;
3483
}
3484

    
3485
static void show_version(void)
3486
{
3487
    /* TODO: add function interface to avutil and avformat */
3488
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3489
           "libavutil   %d\n"
3490
           "libavcodec  %d\n"
3491
           "libavformat %d\n",
3492
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3493
    exit(1);
3494
}
3495

    
3496
static int opt_default(const char *opt, const char *arg){
3497
    int type;
3498
    const AVOption *o= NULL;
3499
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3500

    
3501
    for(type=0; type<CODEC_TYPE_NB; type++){
3502
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3503
        if(o2)
3504
            o = av_set_string(avctx_opts[type], opt, arg);
3505
    }
3506
    if(!o)
3507
        o = av_set_string(avformat_opts, opt, arg);
3508
    if(!o){
3509
        if(opt[0] == 'a')
3510
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3511
        else if(opt[0] == 'v')
3512
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3513
        else if(opt[0] == 's')
3514
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3515
    }
3516
    if(!o)
3517
        return -1;
3518

    
3519
//    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));
3520

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

    
3525
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3526
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3527
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3528
        ffm_nopts = 1;
3529
#endif
3530

    
3531
    if(avctx_opts[0]->debug)
3532
        av_log_level = AV_LOG_DEBUG;
3533
    return 0;
3534
}
3535

    
3536
const OptionDef options[] = {
3537
    /* main options */
3538
    { "L", 0, {(void*)show_license}, "show license" },
3539
    { "h", 0, {(void*)show_help}, "show help" },
3540
    { "version", 0, {(void*)show_version}, "show version" },
3541
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3542
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3543
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3544
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3545
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3546
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3547
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3548
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3549
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3550
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3551
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3552
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3553
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3554
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3555
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3556
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3557
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3558
      "add timings for benchmarking" },
3559
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3560
      "dump each input packet" },
3561
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3562
      "when dumping packets, also dump the payload" },
3563
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3564
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3565
    { "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)", "" },
3566
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3567
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3568
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3569
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3570
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3571
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3572
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3573
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3574
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3575

    
3576
    /* video options */
3577
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3578
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3579
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3580
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3581
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3582
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3583
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3584
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3585
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3586
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3587
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3588
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3589
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3590
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3591
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3592
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3593
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3594
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3595
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3596
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3597
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3598
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3599
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3600
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3601
      "method" },
3602
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3603
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3604
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3605
      "use same video quality as source (implies VBR)" },
3606
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3607
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3608
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3609
      "deinterlace pictures" },
3610
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3611
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3612
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3613
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3614
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3615
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3616
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3617
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3618
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3619
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3620

    
3621
    /* audio options */
3622
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3623
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3624
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3625
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3626
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3627
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3628
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3629
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3630
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3631
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3632

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

    
3638
    /* grab options */
3639
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3640
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3641
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3642

    
3643
    /* muxer options */
3644
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3645
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3646

    
3647
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3648
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3649

    
3650
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3651
    { NULL, },
3652
};
3653

    
3654
static void show_banner(void)
3655
{
3656
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3657
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3658
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3659
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3660
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3661
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3662
#ifdef __GNUC__
3663
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3664
#else
3665
    fprintf(stderr, ", using a non-gcc compiler\n");
3666
#endif
3667
}
3668

    
3669
static void show_license(void)
3670
{
3671
    show_banner();
3672
#ifdef CONFIG_GPL
3673
    printf(
3674
    "FFmpeg is free software; you can redistribute it and/or modify\n"
3675
    "it under the terms of the GNU General Public License as published by\n"
3676
    "the Free Software Foundation; either version 2 of the License, or\n"
3677
    "(at your option) any later version.\n"
3678
    "\n"
3679
    "FFmpeg is distributed in the hope that it will be useful,\n"
3680
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3681
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3682
    "GNU General Public License for more details.\n"
3683
    "\n"
3684
    "You should have received a copy of the GNU General Public License\n"
3685
    "along with FFmpeg; if not, write to the Free Software\n"
3686
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3687
    );
3688
#else
3689
    printf(
3690
    "FFmpeg is free software; you can redistribute it and/or\n"
3691
    "modify it under the terms of the GNU Lesser General Public\n"
3692
    "License as published by the Free Software Foundation; either\n"
3693
    "version 2.1 of the License, or (at your option) any later version.\n"
3694
    "\n"
3695
    "FFmpeg is distributed in the hope that it will be useful,\n"
3696
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3697
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3698
    "Lesser General Public License for more details.\n"
3699
    "\n"
3700
    "You should have received a copy of the GNU Lesser General Public\n"
3701
    "License along with FFmpeg; if not, write to the Free Software\n"
3702
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3703
    );
3704
#endif
3705
    exit(1);
3706
}
3707

    
3708
static void show_help(void)
3709
{
3710
    show_banner();
3711
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3712
           "Hyper fast Audio and Video encoder\n");
3713
    printf("\n");
3714
    show_help_options(options, "Main options:\n",
3715
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3716
    show_help_options(options, "\nVideo options:\n",
3717
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3718
                      OPT_VIDEO);
3719
    show_help_options(options, "\nAdvanced Video options:\n",
3720
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3721
                      OPT_VIDEO | OPT_EXPERT);
3722
    show_help_options(options, "\nAudio options:\n",
3723
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3724
                      OPT_AUDIO);
3725
    show_help_options(options, "\nAdvanced Audio options:\n",
3726
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3727
                      OPT_AUDIO | OPT_EXPERT);
3728
    show_help_options(options, "\nSubtitle options:\n",
3729
                      OPT_SUBTITLE | OPT_GRAB,
3730
                      OPT_SUBTITLE);
3731
    show_help_options(options, "\nAudio/Video grab options:\n",
3732
                      OPT_GRAB,
3733
                      OPT_GRAB);
3734
    show_help_options(options, "\nAdvanced options:\n",
3735
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3736
                      OPT_EXPERT);
3737
    av_opt_show(avctx_opts[0], NULL);
3738
    av_opt_show(avformat_opts, NULL);
3739

    
3740
    exit(1);
3741
}
3742

    
3743
void parse_arg_file(const char *filename)
3744
{
3745
    opt_output_file(filename);
3746
}
3747

    
3748
int main(int argc, char **argv)
3749
{
3750
    int i;
3751
    int64_t ti;
3752

    
3753
    av_register_all();
3754

    
3755
    for(i=0; i<CODEC_TYPE_NB; i++){
3756
        avctx_opts[i]= avcodec_alloc_context2(i);
3757
    }
3758
    avformat_opts = av_alloc_format_context();
3759

    
3760
    if (argc <= 1)
3761
        show_help();
3762
    else
3763
        show_banner();
3764

    
3765
    /* parse options */
3766
    parse_options(argc, argv, options);
3767

    
3768
    /* file converter / grab */
3769
    if (nb_output_files <= 0) {
3770
        fprintf(stderr, "Must supply at least one output file\n");
3771
        exit(1);
3772
    }
3773

    
3774
    if (nb_input_files == 0) {
3775
        fprintf(stderr, "Must supply at least one input file\n");
3776
        exit(1);
3777
    }
3778

    
3779
    ti = getutime();
3780
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3781
              stream_maps, nb_stream_maps);
3782
    ti = getutime() - ti;
3783
    if (do_benchmark) {
3784
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3785
    }
3786

    
3787
    /* close files */
3788
    for(i=0;i<nb_output_files;i++) {
3789
        /* maybe av_close_output_file ??? */
3790
        AVFormatContext *s = output_files[i];
3791
        int j;
3792
        if (!(s->oformat->flags & AVFMT_NOFILE))
3793
            url_fclose(&s->pb);
3794
        for(j=0;j<s->nb_streams;j++) {
3795
            av_free(s->streams[j]->codec);
3796
            av_free(s->streams[j]);
3797
        }
3798
        av_free(s);
3799
    }
3800
    for(i=0;i<nb_input_files;i++)
3801
        av_close_input_file(input_files[i]);
3802

    
3803
    av_free_static();
3804

    
3805
    av_free(intra_matrix);
3806
    av_free(inter_matrix);
3807
    av_free(opt_names);
3808

    
3809
#ifdef CONFIG_POWERPC_PERF
3810
    extern void powerpc_display_perf_report(void);
3811
    powerpc_display_perf_report();
3812
#endif /* CONFIG_POWERPC_PERF */
3813

    
3814
    if (received_sigterm) {
3815
        fprintf(stderr,
3816
            "Received signal %d: terminating.\n",
3817
            (int) received_sigterm);
3818
        exit (255);
3819
    }
3820

    
3821
    exit(0); /* not all OS-es handle main() return value */
3822
    return 0;
3823
}