Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ f5eb2b65

History | View | Annotate | Download (133 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_pass = 0;
170
static char *pass_logfilename = NULL;
171
static int audio_stream_copy = 0;
172
static int video_stream_copy = 0;
173
static int subtitle_stream_copy = 0;
174
static int video_sync_method= 1;
175
static int audio_sync_method= 0;
176
static int copy_ts= 0;
177
static int opt_shortest = 0; //
178
static int video_global_header = 0;
179
static FILE *fvstats= NULL;
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
    AVCodecContext *enc;
845
    int frame_number;
846
    int64_t ti;
847
    double ti1, bitrate, avg_bitrate;
848

    
849
    ti = INT64_MAX;
850
    enc = ost->st->codec;
851
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
852
        frame_number = ost->frame_number;
853
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
854
        if (enc->flags&CODEC_FLAG_PSNR)
855
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
856

    
857
        fprintf(fvstats,"f_size= %6d ", frame_size);
858
        /* compute pts value */
859
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
860
        if (ti1 < 0.01)
861
            ti1 = 0.01;
862

    
863
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
864
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
865
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
866
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
867
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
868
    }
869
}
870

    
871
static void print_report(AVFormatContext **output_files,
872
                         AVOutputStream **ost_table, int nb_ostreams,
873
                         int is_last_report)
874
{
875
    char buf[1024];
876
    AVOutputStream *ost;
877
    AVFormatContext *oc, *os;
878
    int64_t total_size;
879
    AVCodecContext *enc;
880
    int frame_number, vid, i;
881
    double bitrate, ti1, pts;
882
    static int64_t last_time = -1;
883
    static int qp_histogram[52];
884

    
885
    if (!is_last_report) {
886
        int64_t cur_time;
887
        /* display the report every 0.5 seconds */
888
        cur_time = av_gettime();
889
        if (last_time == -1) {
890
            last_time = cur_time;
891
            return;
892
        }
893
        if ((cur_time - last_time) < 500000)
894
            return;
895
        last_time = cur_time;
896
    }
897

    
898

    
899
    oc = output_files[0];
900

    
901
    total_size = url_fsize(&oc->pb);
902
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
903
        total_size= url_ftell(&oc->pb);
904

    
905
    buf[0] = '\0';
906
    ti1 = 1e10;
907
    vid = 0;
908
    for(i=0;i<nb_ostreams;i++) {
909
        ost = ost_table[i];
910
        os = output_files[ost->file_index];
911
        enc = ost->st->codec;
912
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
913
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
914
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
915
        }
916
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
917
            float t = (av_gettime()-timer_start) / 1000000.0;
918

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

    
964
    if (verbose || is_last_report) {
965
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
966

    
967
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
968
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
969
            (double)total_size / 1024, ti1, bitrate);
970

    
971
        if (verbose > 1)
972
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
973
                  nb_frames_dup, nb_frames_drop);
974

    
975
        if (verbose >= 0)
976
            fprintf(stderr, "%s    \r", buf);
977

    
978
        fflush(stderr);
979
    }
980

    
981
    if (is_last_report && verbose >= 0){
982
        int64_t raw= audio_size + video_size + extra_size;
983
        fprintf(stderr, "\n");
984
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
985
                video_size/1024.0,
986
                audio_size/1024.0,
987
                extra_size/1024.0,
988
                100.0*(total_size - raw)/raw
989
        );
990
    }
991
}
992

    
993
/* pkt = NULL means EOF (needed to flush decoder buffers) */
994
static int output_packet(AVInputStream *ist, int ist_index,
995
                         AVOutputStream **ost_table, int nb_ostreams,
996
                         const AVPacket *pkt)
997
{
998
    AVFormatContext *os;
999
    AVOutputStream *ost;
1000
    uint8_t *ptr;
1001
    int len, ret, i;
1002
    uint8_t *data_buf;
1003
    int data_size, got_picture;
1004
    AVFrame picture;
1005
    void *buffer_to_free;
1006
    static unsigned int samples_size= 0;
1007
    static short *samples= NULL;
1008
    AVSubtitle subtitle, *subtitle_to_free;
1009
    int got_subtitle;
1010

    
1011
    if(!pkt){
1012
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1013
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1014
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1015
    } else {
1016
//        assert(ist->pts == ist->next_pts);
1017
    }
1018

    
1019
    if (pkt == NULL) {
1020
        /* EOF handling */
1021
        ptr = NULL;
1022
        len = 0;
1023
        goto handle_eof;
1024
    }
1025

    
1026
    len = pkt->size;
1027
    ptr = pkt->data;
1028
    while (len > 0) {
1029
    handle_eof:
1030
        /* decode the packet if needed */
1031
        data_buf = NULL; /* fail safe */
1032
        data_size = 0;
1033
        subtitle_to_free = NULL;
1034
        if (ist->decoding_needed) {
1035
            switch(ist->st->codec->codec_type) {
1036
            case CODEC_TYPE_AUDIO:{
1037
                if(pkt)
1038
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1039
                data_size= samples_size;
1040
                    /* XXX: could avoid copy if PCM 16 bits with same
1041
                       endianness as CPU */
1042
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1043
                                           ptr, len);
1044
                if (ret < 0)
1045
                    goto fail_decode;
1046
                ptr += ret;
1047
                len -= ret;
1048
                /* Some bug in mpeg audio decoder gives */
1049
                /* data_size < 0, it seems they are overflows */
1050
                if (data_size <= 0) {
1051
                    /* no audio frame */
1052
                    continue;
1053
                }
1054
                data_buf = (uint8_t *)samples;
1055
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1056
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1057
                break;}
1058
            case CODEC_TYPE_VIDEO:
1059
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1060
                    /* XXX: allocate picture correctly */
1061
                    avcodec_get_frame_defaults(&picture);
1062

    
1063
                    ret = avcodec_decode_video(ist->st->codec,
1064
                                               &picture, &got_picture, ptr, len);
1065
                    ist->st->quality= picture.quality;
1066
                    if (ret < 0)
1067
                        goto fail_decode;
1068
                    if (!got_picture) {
1069
                        /* no picture yet */
1070
                        goto discard_packet;
1071
                    }
1072
                    if (ist->st->codec->time_base.num != 0) {
1073
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1074
                                          ist->st->codec->time_base.num) /
1075
                            ist->st->codec->time_base.den;
1076
                    }
1077
                    len = 0;
1078
                    break;
1079
            case CODEC_TYPE_SUBTITLE:
1080
                ret = avcodec_decode_subtitle(ist->st->codec,
1081
                                              &subtitle, &got_subtitle, ptr, len);
1082
                if (ret < 0)
1083
                    goto fail_decode;
1084
                if (!got_subtitle) {
1085
                    goto discard_packet;
1086
                }
1087
                subtitle_to_free = &subtitle;
1088
                len = 0;
1089
                break;
1090
            default:
1091
                goto fail_decode;
1092
            }
1093
        } else {
1094
            switch(ist->st->codec->codec_type) {
1095
            case CODEC_TYPE_AUDIO:
1096
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1097
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1098
                break;
1099
            case CODEC_TYPE_VIDEO:
1100
                if (ist->st->codec->time_base.num != 0) {
1101
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1102
                                      ist->st->codec->time_base.num) /
1103
                        ist->st->codec->time_base.den;
1104
                }
1105
                break;
1106
            }
1107
            data_buf = ptr;
1108
            data_size = len;
1109
            ret = len;
1110
            len = 0;
1111
        }
1112

    
1113
        buffer_to_free = NULL;
1114
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1115
            pre_process_video_frame(ist, (AVPicture *)&picture,
1116
                                    &buffer_to_free);
1117
        }
1118

    
1119
        // preprocess audio (volume)
1120
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1121
            if (audio_volume != 256) {
1122
                short *volp;
1123
                volp = samples;
1124
                for(i=0;i<(data_size / sizeof(short));i++) {
1125
                    int v = ((*volp) * audio_volume + 128) >> 8;
1126
                    if (v < -32768) v = -32768;
1127
                    if (v >  32767) v = 32767;
1128
                    *volp++ = v;
1129
                }
1130
            }
1131
        }
1132

    
1133
        /* frame rate emulation */
1134
        if (ist->st->codec->rate_emu) {
1135
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1136
            int64_t now = av_gettime() - ist->start;
1137
            if (pts > now)
1138
                usleep(pts - now);
1139

    
1140
            ist->frame++;
1141
        }
1142

    
1143
#if 0
1144
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1145
           is the one of the next displayed one */
1146
        /* XXX: add mpeg4 too ? */
1147
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1148
            if (ist->st->codec->pict_type != B_TYPE) {
1149
                int64_t tmp;
1150
                tmp = ist->last_ip_pts;
1151
                ist->last_ip_pts  = ist->frac_pts.val;
1152
                ist->frac_pts.val = tmp;
1153
            }
1154
        }
1155
#endif
1156
        /* if output time reached then transcode raw format,
1157
           encode packets and output them */
1158
        if (start_time == 0 || ist->pts >= start_time)
1159
            for(i=0;i<nb_ostreams;i++) {
1160
                int frame_size;
1161

    
1162
                ost = ost_table[i];
1163
                if (ost->source_index == ist_index) {
1164
                    os = output_files[ost->file_index];
1165

    
1166
#if 0
1167
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1168
                           (double)pkt->pts / AV_TIME_BASE,
1169
                           ((double)ist->pts / AV_TIME_BASE) -
1170
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1171
#endif
1172
                    /* set the input output pts pairs */
1173
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1174

    
1175
                    if (ost->encoding_needed) {
1176
                        switch(ost->st->codec->codec_type) {
1177
                        case CODEC_TYPE_AUDIO:
1178
                            do_audio_out(os, ost, ist, data_buf, data_size);
1179
                            break;
1180
                        case CODEC_TYPE_VIDEO:
1181
                            do_video_out(os, ost, ist, &picture, &frame_size);
1182
                            video_size += frame_size;
1183
                            if (fvstats && frame_size)
1184
                                do_video_stats(os, ost, frame_size);
1185
                            break;
1186
                        case CODEC_TYPE_SUBTITLE:
1187
                            do_subtitle_out(os, ost, ist, &subtitle,
1188
                                            pkt->pts);
1189
                            break;
1190
                        default:
1191
                            av_abort();
1192
                        }
1193
                    } else {
1194
                        AVFrame avframe; //FIXME/XXX remove this
1195
                        AVPacket opkt;
1196
                        av_init_packet(&opkt);
1197

    
1198
                        /* no reencoding needed : output the packet directly */
1199
                        /* force the input stream PTS */
1200

    
1201
                        avcodec_get_frame_defaults(&avframe);
1202
                        ost->st->codec->coded_frame= &avframe;
1203
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1204

    
1205
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1206
                            audio_size += data_size;
1207
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1208
                            video_size += data_size;
1209
                            ost->sync_opts++;
1210
                        }
1211

    
1212
                        opkt.stream_index= ost->index;
1213
                        if(pkt->pts != AV_NOPTS_VALUE)
1214
                            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);
1215
                        else
1216
                            opkt.pts= AV_NOPTS_VALUE;
1217

    
1218
                        {
1219
                            int64_t dts;
1220
                            if (pkt->dts == AV_NOPTS_VALUE)
1221
                                dts = ist->next_pts;
1222
                            else
1223
                                dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1224
                            opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1225
                        }
1226
                        opkt.flags= pkt->flags;
1227

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

    
1232
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1233
                        ost->st->codec->frame_number++;
1234
                        ost->frame_number++;
1235
                        av_free_packet(&opkt);
1236
                    }
1237
                }
1238
            }
1239
        av_free(buffer_to_free);
1240
        /* XXX: allocate the subtitles in the codec ? */
1241
        if (subtitle_to_free) {
1242
            if (subtitle_to_free->rects != NULL) {
1243
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1244
                    av_free(subtitle_to_free->rects[i].bitmap);
1245
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1246
                }
1247
                av_freep(&subtitle_to_free->rects);
1248
            }
1249
            subtitle_to_free->num_rects = 0;
1250
            subtitle_to_free = NULL;
1251
        }
1252
    }
1253
 discard_packet:
1254
    if (pkt == NULL) {
1255
        /* EOF handling */
1256

    
1257
        for(i=0;i<nb_ostreams;i++) {
1258
            ost = ost_table[i];
1259
            if (ost->source_index == ist_index) {
1260
                AVCodecContext *enc= ost->st->codec;
1261
                os = output_files[ost->file_index];
1262

    
1263
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1264
                    continue;
1265
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1266
                    continue;
1267

    
1268
                if (ost->encoding_needed) {
1269
                    for(;;) {
1270
                        AVPacket pkt;
1271
                        int fifo_bytes;
1272
                        av_init_packet(&pkt);
1273
                        pkt.stream_index= ost->index;
1274

    
1275
                        switch(ost->st->codec->codec_type) {
1276
                        case CODEC_TYPE_AUDIO:
1277
                            fifo_bytes = av_fifo_size(&ost->fifo);
1278
                            ret = 0;
1279
                            /* encode any samples remaining in fifo */
1280
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1281
                                int fs_tmp = enc->frame_size;
1282
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1283
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1284
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1285
                                }
1286
                                enc->frame_size = fs_tmp;
1287
                            }
1288
                            if(ret <= 0) {
1289
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1290
                            }
1291
                            audio_size += ret;
1292
                            pkt.flags |= PKT_FLAG_KEY;
1293
                            break;
1294
                        case CODEC_TYPE_VIDEO:
1295
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1296
                            video_size += ret;
1297
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1298
                                pkt.flags |= PKT_FLAG_KEY;
1299
                            if (ost->logfile && enc->stats_out) {
1300
                                fprintf(ost->logfile, "%s", enc->stats_out);
1301
                            }
1302
                            break;
1303
                        default:
1304
                            ret=-1;
1305
                        }
1306

    
1307
                        if(ret<=0)
1308
                            break;
1309
                        pkt.data= bit_buffer;
1310
                        pkt.size= ret;
1311
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1312
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1313
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1314
                    }
1315
                }
1316
            }
1317
        }
1318
    }
1319

    
1320
    return 0;
1321
 fail_decode:
1322
    return -1;
1323
}
1324

    
1325

    
1326
/*
1327
 * The following code is the main loop of the file converter
1328
 */
1329
static int av_encode(AVFormatContext **output_files,
1330
                     int nb_output_files,
1331
                     AVFormatContext **input_files,
1332
                     int nb_input_files,
1333
                     AVStreamMap *stream_maps, int nb_stream_maps)
1334
{
1335
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1336
    AVFormatContext *is, *os;
1337
    AVCodecContext *codec, *icodec;
1338
    AVOutputStream *ost, **ost_table = NULL;
1339
    AVInputStream *ist, **ist_table = NULL;
1340
    AVInputFile *file_table;
1341
    int key;
1342

    
1343
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1344
    if (!file_table)
1345
        goto fail;
1346

    
1347
    /* input stream init */
1348
    j = 0;
1349
    for(i=0;i<nb_input_files;i++) {
1350
        is = input_files[i];
1351
        file_table[i].ist_index = j;
1352
        file_table[i].nb_streams = is->nb_streams;
1353
        j += is->nb_streams;
1354
    }
1355
    nb_istreams = j;
1356

    
1357
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1358
    if (!ist_table)
1359
        goto fail;
1360

    
1361
    for(i=0;i<nb_istreams;i++) {
1362
        ist = av_mallocz(sizeof(AVInputStream));
1363
        if (!ist)
1364
            goto fail;
1365
        ist_table[i] = ist;
1366
    }
1367
    j = 0;
1368
    for(i=0;i<nb_input_files;i++) {
1369
        is = input_files[i];
1370
        for(k=0;k<is->nb_streams;k++) {
1371
            ist = ist_table[j++];
1372
            ist->st = is->streams[k];
1373
            ist->file_index = i;
1374
            ist->index = k;
1375
            ist->discard = 1; /* the stream is discarded by default
1376
                                 (changed later) */
1377

    
1378
            if (ist->st->codec->rate_emu) {
1379
                ist->start = av_gettime();
1380
                ist->frame = 0;
1381
            }
1382
        }
1383
    }
1384

    
1385
    /* output stream init */
1386
    nb_ostreams = 0;
1387
    for(i=0;i<nb_output_files;i++) {
1388
        os = output_files[i];
1389
        if (!os->nb_streams) {
1390
            fprintf(stderr, "Output file does not contain any stream\n");
1391
            exit(1);
1392
        }
1393
        nb_ostreams += os->nb_streams;
1394
    }
1395
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1396
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1397
        exit(1);
1398
    }
1399

    
1400
    /* Sanity check the mapping args -- do the input files & streams exist? */
1401
    for(i=0;i<nb_stream_maps;i++) {
1402
        int fi = stream_maps[i].file_index;
1403
        int si = stream_maps[i].stream_index;
1404

    
1405
        if (fi < 0 || fi > nb_input_files - 1 ||
1406
            si < 0 || si > file_table[fi].nb_streams - 1) {
1407
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1408
            exit(1);
1409
        }
1410
        fi = stream_maps[i].sync_file_index;
1411
        si = stream_maps[i].sync_stream_index;
1412
        if (fi < 0 || fi > nb_input_files - 1 ||
1413
            si < 0 || si > file_table[fi].nb_streams - 1) {
1414
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1415
            exit(1);
1416
        }
1417
    }
1418

    
1419
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1420
    if (!ost_table)
1421
        goto fail;
1422
    for(i=0;i<nb_ostreams;i++) {
1423
        ost = av_mallocz(sizeof(AVOutputStream));
1424
        if (!ost)
1425
            goto fail;
1426
        ost_table[i] = ost;
1427
    }
1428

    
1429
    n = 0;
1430
    for(k=0;k<nb_output_files;k++) {
1431
        os = output_files[k];
1432
        for(i=0;i<os->nb_streams;i++) {
1433
            int found;
1434
            ost = ost_table[n++];
1435
            ost->file_index = k;
1436
            ost->index = i;
1437
            ost->st = os->streams[i];
1438
            if (nb_stream_maps > 0) {
1439
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1440
                    stream_maps[n-1].stream_index;
1441

    
1442
                /* Sanity check that the stream types match */
1443
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1444
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1445
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1446
                        ost->file_index, ost->index);
1447
                    exit(1);
1448
                }
1449

    
1450
            } else {
1451
                /* get corresponding input stream index : we select the first one with the right type */
1452
                found = 0;
1453
                for(j=0;j<nb_istreams;j++) {
1454
                    ist = ist_table[j];
1455
                    if (ist->discard &&
1456
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1457
                        ost->source_index = j;
1458
                        found = 1;
1459
                        break;
1460
                    }
1461
                }
1462

    
1463
                if (!found) {
1464
                    /* try again and reuse existing stream */
1465
                    for(j=0;j<nb_istreams;j++) {
1466
                        ist = ist_table[j];
1467
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1468
                            ost->source_index = j;
1469
                            found = 1;
1470
                        }
1471
                    }
1472
                    if (!found) {
1473
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1474
                                ost->file_index, ost->index);
1475
                        exit(1);
1476
                    }
1477
                }
1478
            }
1479
            ist = ist_table[ost->source_index];
1480
            ist->discard = 0;
1481
            ost->sync_ist = (nb_stream_maps > 0) ?
1482
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1483
                         stream_maps[n-1].sync_stream_index] : ist;
1484
        }
1485
    }
1486

    
1487
    /* for each output stream, we compute the right encoding parameters */
1488
    for(i=0;i<nb_ostreams;i++) {
1489
        ost = ost_table[i];
1490
        ist = ist_table[ost->source_index];
1491

    
1492
        codec = ost->st->codec;
1493
        icodec = ist->st->codec;
1494

    
1495
        if (ost->st->stream_copy) {
1496
            /* if stream_copy is selected, no need to decode or encode */
1497
            codec->codec_id = icodec->codec_id;
1498
            codec->codec_type = icodec->codec_type;
1499
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1500
            codec->bit_rate = icodec->bit_rate;
1501
            codec->extradata= icodec->extradata;
1502
            codec->extradata_size= icodec->extradata_size;
1503
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1504
                codec->time_base = icodec->time_base;
1505
            else
1506
                codec->time_base = ist->st->time_base;
1507
            switch(codec->codec_type) {
1508
            case CODEC_TYPE_AUDIO:
1509
                codec->sample_rate = icodec->sample_rate;
1510
                codec->channels = icodec->channels;
1511
                codec->frame_size = icodec->frame_size;
1512
                codec->block_align= icodec->block_align;
1513
                break;
1514
            case CODEC_TYPE_VIDEO:
1515
                if(using_vhook) {
1516
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1517
                    exit(1);
1518
                }
1519
                codec->pix_fmt = icodec->pix_fmt;
1520
                codec->width = icodec->width;
1521
                codec->height = icodec->height;
1522
                codec->has_b_frames = icodec->has_b_frames;
1523
                break;
1524
            case CODEC_TYPE_SUBTITLE:
1525
                break;
1526
            default:
1527
                av_abort();
1528
            }
1529
        } else {
1530
            switch(codec->codec_type) {
1531
            case CODEC_TYPE_AUDIO:
1532
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1533
                    goto fail;
1534

    
1535
                if (codec->channels == icodec->channels &&
1536
                    codec->sample_rate == icodec->sample_rate) {
1537
                    ost->audio_resample = 0;
1538
                } else {
1539
                    if (codec->channels != icodec->channels &&
1540
                        (icodec->codec_id == CODEC_ID_AC3 ||
1541
                         icodec->codec_id == CODEC_ID_DTS)) {
1542
                        /* Special case for 5:1 AC3 and DTS input */
1543
                        /* and mono or stereo output      */
1544
                        /* Request specific number of channels */
1545
                        icodec->channels = codec->channels;
1546
                        if (codec->sample_rate == icodec->sample_rate)
1547
                            ost->audio_resample = 0;
1548
                        else {
1549
                            ost->audio_resample = 1;
1550
                        }
1551
                    } else {
1552
                        ost->audio_resample = 1;
1553
                    }
1554
                }
1555
                if(audio_sync_method>1)
1556
                    ost->audio_resample = 1;
1557

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

    
1635
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1636
                         pass_logfilename ?
1637
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1638
                if (codec->flags & CODEC_FLAG_PASS1) {
1639
                    f = fopen(logfilename, "w");
1640
                    if (!f) {
1641
                        perror(logfilename);
1642
                        exit(1);
1643
                    }
1644
                    ost->logfile = f;
1645
                } else {
1646
                    /* read the log file */
1647
                    f = fopen(logfilename, "r");
1648
                    if (!f) {
1649
                        perror(logfilename);
1650
                        exit(1);
1651
                    }
1652
                    fseek(f, 0, SEEK_END);
1653
                    size = ftell(f);
1654
                    fseek(f, 0, SEEK_SET);
1655
                    logbuffer = av_malloc(size + 1);
1656
                    if (!logbuffer) {
1657
                        fprintf(stderr, "Could not allocate log buffer\n");
1658
                        exit(1);
1659
                    }
1660
                    size = fread(logbuffer, 1, size, f);
1661
                    fclose(f);
1662
                    logbuffer[size] = '\0';
1663
                    codec->stats_in = logbuffer;
1664
                }
1665
            }
1666
        }
1667
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1668
            int size= codec->width * codec->height;
1669
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1670
        }
1671
    }
1672

    
1673
    if (!bit_buffer)
1674
        bit_buffer = av_malloc(bit_buffer_size);
1675
    if (!bit_buffer)
1676
        goto fail;
1677

    
1678
    /* dump the file output parameters - cannot be done before in case
1679
       of stream copy */
1680
    for(i=0;i<nb_output_files;i++) {
1681
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1682
    }
1683

    
1684
    /* dump the stream mapping */
1685
    if (verbose >= 0) {
1686
        fprintf(stderr, "Stream mapping:\n");
1687
        for(i=0;i<nb_ostreams;i++) {
1688
            ost = ost_table[i];
1689
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1690
                    ist_table[ost->source_index]->file_index,
1691
                    ist_table[ost->source_index]->index,
1692
                    ost->file_index,
1693
                    ost->index);
1694
            if (ost->sync_ist != ist_table[ost->source_index])
1695
                fprintf(stderr, " [sync #%d.%d]",
1696
                        ost->sync_ist->file_index,
1697
                        ost->sync_ist->index);
1698
            fprintf(stderr, "\n");
1699
        }
1700
    }
1701

    
1702
    /* open each encoder */
1703
    for(i=0;i<nb_ostreams;i++) {
1704
        ost = ost_table[i];
1705
        if (ost->encoding_needed) {
1706
            AVCodec *codec;
1707
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1708
            if (!codec) {
1709
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1710
                        ost->file_index, ost->index);
1711
                exit(1);
1712
            }
1713
            if (avcodec_open(ost->st->codec, codec) < 0) {
1714
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1715
                        ost->file_index, ost->index);
1716
                exit(1);
1717
            }
1718
            extra_size += ost->st->codec->extradata_size;
1719
        }
1720
    }
1721

    
1722
    /* open each decoder */
1723
    for(i=0;i<nb_istreams;i++) {
1724
        ist = ist_table[i];
1725
        if (ist->decoding_needed) {
1726
            AVCodec *codec;
1727
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1728
            if (!codec) {
1729
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1730
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1731
                exit(1);
1732
            }
1733
            if (avcodec_open(ist->st->codec, codec) < 0) {
1734
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1735
                        ist->file_index, ist->index);
1736
                exit(1);
1737
            }
1738
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1739
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1740
        }
1741
    }
1742

    
1743
    /* init pts */
1744
    for(i=0;i<nb_istreams;i++) {
1745
        ist = ist_table[i];
1746
        is = input_files[ist->file_index];
1747
        ist->pts = 0;
1748
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1749
        if(ist->st->start_time == AV_NOPTS_VALUE)
1750
            ist->next_pts=0;
1751
        if(input_files_ts_offset[ist->file_index])
1752
            ist->next_pts= AV_NOPTS_VALUE;
1753
        ist->is_start = 1;
1754
    }
1755

    
1756
    /* set meta data information from input file if required */
1757
    for (i=0;i<nb_meta_data_maps;i++) {
1758
        AVFormatContext *out_file;
1759
        AVFormatContext *in_file;
1760

    
1761
        int out_file_index = meta_data_maps[i].out_file;
1762
        int in_file_index = meta_data_maps[i].in_file;
1763
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1764
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1765
            ret = AVERROR(EINVAL);
1766
            goto fail;
1767
        }
1768
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1769
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1770
            ret = AVERROR(EINVAL);
1771
            goto fail;
1772
        }
1773

    
1774
        out_file = output_files[out_file_index];
1775
        in_file = input_files[in_file_index];
1776

    
1777
        strcpy(out_file->title, in_file->title);
1778
        strcpy(out_file->author, in_file->author);
1779
        strcpy(out_file->copyright, in_file->copyright);
1780
        strcpy(out_file->comment, in_file->comment);
1781
        strcpy(out_file->album, in_file->album);
1782
        out_file->year = in_file->year;
1783
        out_file->track = in_file->track;
1784
        strcpy(out_file->genre, in_file->genre);
1785
    }
1786

    
1787
    /* open files and write file headers */
1788
    for(i=0;i<nb_output_files;i++) {
1789
        os = output_files[i];
1790
        if (av_write_header(os) < 0) {
1791
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1792
            ret = AVERROR(EINVAL);
1793
            goto fail;
1794
        }
1795
    }
1796

    
1797
    if ( !using_stdin && verbose >= 0) {
1798
        fprintf(stderr, "Press [q] to stop encoding\n");
1799
        url_set_interrupt_cb(decode_interrupt_cb);
1800
    }
1801
    term_init();
1802

    
1803
    key = -1;
1804
    timer_start = av_gettime();
1805

    
1806
    for(; received_sigterm == 0;) {
1807
        int file_index, ist_index;
1808
        AVPacket pkt;
1809
        double ipts_min;
1810
        double opts_min;
1811

    
1812
    redo:
1813
        ipts_min= 1e100;
1814
        opts_min= 1e100;
1815
        /* if 'q' pressed, exits */
1816
        if (!using_stdin) {
1817
            if (q_pressed)
1818
                break;
1819
            /* read_key() returns 0 on EOF */
1820
            key = read_key();
1821
            if (key == 'q')
1822
                break;
1823
        }
1824

    
1825
        /* select the stream that we must read now by looking at the
1826
           smallest output pts */
1827
        file_index = -1;
1828
        for(i=0;i<nb_ostreams;i++) {
1829
            double ipts, opts;
1830
            ost = ost_table[i];
1831
            os = output_files[ost->file_index];
1832
            ist = ist_table[ost->source_index];
1833
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1834
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1835
            else
1836
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1837
            ipts = (double)ist->pts;
1838
            if (!file_table[ist->file_index].eof_reached){
1839
                if(ipts < ipts_min) {
1840
                    ipts_min = ipts;
1841
                    if(input_sync ) file_index = ist->file_index;
1842
                }
1843
                if(opts < opts_min) {
1844
                    opts_min = opts;
1845
                    if(!input_sync) file_index = ist->file_index;
1846
                }
1847
            }
1848
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1849
                file_index= -1;
1850
                break;
1851
            }
1852
        }
1853
        /* if none, if is finished */
1854
        if (file_index < 0) {
1855
            break;
1856
        }
1857

    
1858
        /* finish if recording time exhausted */
1859
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1860
            break;
1861

    
1862
        /* finish if limit size exhausted */
1863
        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1864
            break;
1865

    
1866
        /* read a frame from it and output it in the fifo */
1867
        is = input_files[file_index];
1868
        if (av_read_frame(is, &pkt) < 0) {
1869
            file_table[file_index].eof_reached = 1;
1870
            if (opt_shortest) break; else continue; //
1871
        }
1872

    
1873
        if (do_pkt_dump) {
1874
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1875
        }
1876
        /* the following test is needed in case new streams appear
1877
           dynamically in stream : we ignore them */
1878
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1879
            goto discard_packet;
1880
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1881
        ist = ist_table[ist_index];
1882
        if (ist->discard)
1883
            goto discard_packet;
1884

    
1885
//        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);
1886
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1887
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1888
            if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1889
                input_files_ts_offset[ist->file_index]-= delta;
1890
                if (verbose > 2)
1891
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1892
                for(i=0; i<file_table[file_index].nb_streams; i++){
1893
                    int index= file_table[file_index].ist_index + i;
1894
                    ist_table[index]->next_pts += delta;
1895
                    ist_table[index]->is_start=1;
1896
                }
1897
            }
1898
        }
1899

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

    
1903
            if (verbose >= 0)
1904
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1905
                        ist->file_index, ist->index);
1906

    
1907
            av_free_packet(&pkt);
1908
            goto redo;
1909
        }
1910

    
1911
    discard_packet:
1912
        av_free_packet(&pkt);
1913

    
1914
        /* dump report by using the output first video and audio streams */
1915
        print_report(output_files, ost_table, nb_ostreams, 0);
1916
    }
1917

    
1918
    /* at the end of stream, we must flush the decoder buffers */
1919
    for(i=0;i<nb_istreams;i++) {
1920
        ist = ist_table[i];
1921
        if (ist->decoding_needed) {
1922
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1923
        }
1924
    }
1925

    
1926
    term_exit();
1927

    
1928
    /* write the trailer if needed and close file */
1929
    for(i=0;i<nb_output_files;i++) {
1930
        os = output_files[i];
1931
        av_write_trailer(os);
1932
    }
1933

    
1934
    /* dump report by using the first video and audio streams */
1935
    print_report(output_files, ost_table, nb_ostreams, 1);
1936

    
1937
    /* close each encoder */
1938
    for(i=0;i<nb_ostreams;i++) {
1939
        ost = ost_table[i];
1940
        if (ost->encoding_needed) {
1941
            av_freep(&ost->st->codec->stats_in);
1942
            avcodec_close(ost->st->codec);
1943
        }
1944
    }
1945

    
1946
    /* close each decoder */
1947
    for(i=0;i<nb_istreams;i++) {
1948
        ist = ist_table[i];
1949
        if (ist->decoding_needed) {
1950
            avcodec_close(ist->st->codec);
1951
        }
1952
    }
1953

    
1954
    /* finished ! */
1955

    
1956
    ret = 0;
1957
 fail1:
1958
    av_freep(&bit_buffer);
1959
    av_free(file_table);
1960

    
1961
    if (ist_table) {
1962
        for(i=0;i<nb_istreams;i++) {
1963
            ist = ist_table[i];
1964
            av_free(ist);
1965
        }
1966
        av_free(ist_table);
1967
    }
1968
    if (ost_table) {
1969
        for(i=0;i<nb_ostreams;i++) {
1970
            ost = ost_table[i];
1971
            if (ost) {
1972
                if (ost->logfile) {
1973
                    fclose(ost->logfile);
1974
                    ost->logfile = NULL;
1975
                }
1976
                av_fifo_free(&ost->fifo); /* works even if fifo is not
1977
                                             initialized but set to zero */
1978
                av_free(ost->pict_tmp.data[0]);
1979
                if (ost->video_resample)
1980
                    sws_freeContext(ost->img_resample_ctx);
1981
                if (ost->audio_resample)
1982
                    audio_resample_close(ost->resample);
1983
                av_free(ost);
1984
            }
1985
        }
1986
        av_free(ost_table);
1987
    }
1988
    return ret;
1989
 fail:
1990
    ret = AVERROR(ENOMEM);
1991
    goto fail1;
1992
}
1993

    
1994
#if 0
1995
int file_read(const char *filename)
1996
{
1997
    URLContext *h;
1998
    unsigned char buffer[1024];
1999
    int len, i;
2000

2001
    if (url_open(&h, filename, O_RDONLY) < 0) {
2002
        printf("could not open '%s'\n", filename);
2003
        return -1;
2004
    }
2005
    for(;;) {
2006
        len = url_read(h, buffer, sizeof(buffer));
2007
        if (len <= 0)
2008
            break;
2009
        for(i=0;i<len;i++) putchar(buffer[i]);
2010
    }
2011
    url_close(h);
2012
    return 0;
2013
}
2014
#endif
2015

    
2016
static void opt_format(const char *arg)
2017
{
2018
    /* compatibility stuff for pgmyuv */
2019
    if (!strcmp(arg, "pgmyuv")) {
2020
        pgmyuv_compatibility_hack=1;
2021
//        opt_image_format(arg);
2022
        arg = "image2";
2023
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2024
    }
2025

    
2026
    file_iformat = av_find_input_format(arg);
2027
    file_oformat = guess_format(arg, NULL, NULL);
2028
    if (!file_iformat && !file_oformat) {
2029
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2030
        exit(1);
2031
    }
2032
}
2033

    
2034
static void opt_video_rc_eq(char *arg)
2035
{
2036
    video_rc_eq = arg;
2037
}
2038

    
2039
static void opt_video_rc_override_string(char *arg)
2040
{
2041
    video_rc_override_string = arg;
2042
}
2043

    
2044
static void opt_me_threshold(const char *arg)
2045
{
2046
    me_threshold = atoi(arg);
2047
}
2048

    
2049
static void opt_verbose(const char *arg)
2050
{
2051
    verbose = atoi(arg);
2052
    av_log_level = atoi(arg);
2053
}
2054

    
2055
static void opt_frame_rate(const char *arg)
2056
{
2057
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2058
        fprintf(stderr, "Incorrect frame rate\n");
2059
        exit(1);
2060
    }
2061
}
2062

    
2063
static void opt_frame_crop_top(const char *arg)
2064
{
2065
    frame_topBand = atoi(arg);
2066
    if (frame_topBand < 0) {
2067
        fprintf(stderr, "Incorrect top crop size\n");
2068
        exit(1);
2069
    }
2070
    if ((frame_topBand % 2) != 0) {
2071
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2072
        exit(1);
2073
    }
2074
    if ((frame_topBand) >= frame_height){
2075
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2076
        exit(1);
2077
    }
2078
    frame_height -= frame_topBand;
2079
}
2080

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

    
2099
static void opt_frame_crop_left(const char *arg)
2100
{
2101
    frame_leftBand = atoi(arg);
2102
    if (frame_leftBand < 0) {
2103
        fprintf(stderr, "Incorrect left crop size\n");
2104
        exit(1);
2105
    }
2106
    if ((frame_leftBand % 2) != 0) {
2107
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2108
        exit(1);
2109
    }
2110
    if ((frame_leftBand) >= frame_width){
2111
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2112
        exit(1);
2113
    }
2114
    frame_width -= frame_leftBand;
2115
}
2116

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

    
2135
static void opt_frame_size(const char *arg)
2136
{
2137
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2138
        fprintf(stderr, "Incorrect frame size\n");
2139
        exit(1);
2140
    }
2141
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2142
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2143
        exit(1);
2144
    }
2145
}
2146

    
2147

    
2148
#define SCALEBITS 10
2149
#define ONE_HALF  (1 << (SCALEBITS - 1))
2150
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2151

    
2152
#define RGB_TO_Y(r, g, b) \
2153
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2154
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2155

    
2156
#define RGB_TO_U(r1, g1, b1, shift)\
2157
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2158
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2159

    
2160
#define RGB_TO_V(r1, g1, b1, shift)\
2161
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2162
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2163

    
2164
static void opt_pad_color(const char *arg) {
2165
    /* Input is expected to be six hex digits similar to
2166
       how colors are expressed in html tags (but without the #) */
2167
    int rgb = strtol(arg, NULL, 16);
2168
    int r,g,b;
2169

    
2170
    r = (rgb >> 16);
2171
    g = ((rgb >> 8) & 255);
2172
    b = (rgb & 255);
2173

    
2174
    padcolor[0] = RGB_TO_Y(r,g,b);
2175
    padcolor[1] = RGB_TO_U(r,g,b,0);
2176
    padcolor[2] = RGB_TO_V(r,g,b,0);
2177
}
2178

    
2179
static void opt_frame_pad_top(const char *arg)
2180
{
2181
    frame_padtop = atoi(arg);
2182
    if (frame_padtop < 0) {
2183
        fprintf(stderr, "Incorrect top pad size\n");
2184
        exit(1);
2185
    }
2186
    if ((frame_padtop % 2) != 0) {
2187
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2188
        exit(1);
2189
    }
2190
}
2191

    
2192
static void opt_frame_pad_bottom(const char *arg)
2193
{
2194
    frame_padbottom = atoi(arg);
2195
    if (frame_padbottom < 0) {
2196
        fprintf(stderr, "Incorrect bottom pad size\n");
2197
        exit(1);
2198
    }
2199
    if ((frame_padbottom % 2) != 0) {
2200
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2201
        exit(1);
2202
    }
2203
}
2204

    
2205

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

    
2219

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

    
2233

    
2234
static void opt_frame_pix_fmt(const char *arg)
2235
{
2236
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2237
}
2238

    
2239
static void opt_frame_aspect_ratio(const char *arg)
2240
{
2241
    int x = 0, y = 0;
2242
    double ar = 0;
2243
    const char *p;
2244

    
2245
    p = strchr(arg, ':');
2246
    if (p) {
2247
        x = strtol(arg, (char **)&arg, 10);
2248
        if (arg == p)
2249
            y = strtol(arg+1, (char **)&arg, 10);
2250
        if (x > 0 && y > 0)
2251
            ar = (double)x / (double)y;
2252
    } else
2253
        ar = strtod(arg, (char **)&arg);
2254

    
2255
    if (!ar) {
2256
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2257
        exit(1);
2258
    }
2259
    frame_aspect_ratio = ar;
2260
}
2261

    
2262
static void opt_qscale(const char *arg)
2263
{
2264
    video_qscale = atof(arg);
2265
    if (video_qscale <= 0 ||
2266
        video_qscale > 255) {
2267
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2268
        exit(1);
2269
    }
2270
}
2271

    
2272
static void opt_qdiff(const char *arg)
2273
{
2274
    video_qdiff = atoi(arg);
2275
    if (video_qdiff < 0 ||
2276
        video_qdiff > 31) {
2277
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2278
        exit(1);
2279
    }
2280
}
2281

    
2282
static void opt_strict(const char *arg)
2283
{
2284
    strict= atoi(arg);
2285
}
2286

    
2287
static void opt_top_field_first(const char *arg)
2288
{
2289
    top_field_first= atoi(arg);
2290
}
2291

    
2292
static void opt_thread_count(const char *arg)
2293
{
2294
    thread_count= atoi(arg);
2295
#if !defined(HAVE_THREADS)
2296
    if (verbose >= 0)
2297
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2298
#endif
2299
}
2300

    
2301
static void opt_audio_rate(const char *arg)
2302
{
2303
    audio_sample_rate = atoi(arg);
2304
}
2305

    
2306
static void opt_audio_channels(const char *arg)
2307
{
2308
    audio_channels = atoi(arg);
2309
}
2310

    
2311
static void opt_video_channel(const char *arg)
2312
{
2313
    video_channel = strtol(arg, NULL, 0);
2314
}
2315

    
2316
static void opt_video_standard(const char *arg)
2317
{
2318
    video_standard = av_strdup(arg);
2319
}
2320

    
2321
static void opt_codec(int *pstream_copy, int *pcodec_id,
2322
                      int codec_type, const char *arg)
2323
{
2324
    AVCodec *p;
2325

    
2326
    if (!strcmp(arg, "copy")) {
2327
        *pstream_copy = 1;
2328
    } else {
2329
        p = first_avcodec;
2330
        while (p) {
2331
            if (!strcmp(p->name, arg) && p->type == codec_type)
2332
                break;
2333
            p = p->next;
2334
        }
2335
        if (p == NULL) {
2336
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2337
            exit(1);
2338
        } else {
2339
            *pcodec_id = p->id;
2340
        }
2341
    }
2342
}
2343

    
2344
static void opt_audio_codec(const char *arg)
2345
{
2346
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2347
}
2348

    
2349
static void opt_audio_tag(const char *arg)
2350
{
2351
    char *tail;
2352
    audio_codec_tag= strtol(arg, &tail, 0);
2353

    
2354
    if(!tail || *tail)
2355
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2356
}
2357

    
2358
static void opt_video_tag(const char *arg)
2359
{
2360
    char *tail;
2361
    video_codec_tag= strtol(arg, &tail, 0);
2362

    
2363
    if(!tail || *tail)
2364
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2365
}
2366

    
2367
static void add_frame_hooker(const char *arg)
2368
{
2369
    int argc = 0;
2370
    char *argv[64];
2371
    int i;
2372
    char *args = av_strdup(arg);
2373

    
2374
    using_vhook = 1;
2375

    
2376
    argv[0] = strtok(args, " ");
2377
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2378
    }
2379

    
2380
    i = frame_hook_add(argc, argv);
2381

    
2382
    if (i != 0) {
2383
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2384
        exit(1);
2385
    }
2386
}
2387

    
2388
const char *motion_str[] = {
2389
    "zero",
2390
    "full",
2391
    "log",
2392
    "phods",
2393
    "epzs",
2394
    "x1",
2395
    "hex",
2396
    "umh",
2397
    "iter",
2398
    NULL,
2399
};
2400

    
2401
static void opt_motion_estimation(const char *arg)
2402
{
2403
    const char **p;
2404
    p = motion_str;
2405
    for(;;) {
2406
        if (!*p) {
2407
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2408
            exit(1);
2409
        }
2410
        if (!strcmp(*p, arg))
2411
            break;
2412
        p++;
2413
    }
2414
    me_method = (p - motion_str) + 1;
2415
}
2416

    
2417
static void opt_video_codec(const char *arg)
2418
{
2419
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2420
}
2421

    
2422
static void opt_subtitle_codec(const char *arg)
2423
{
2424
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2425
}
2426

    
2427
static void opt_map(const char *arg)
2428
{
2429
    AVStreamMap *m;
2430
    const char *p;
2431

    
2432
    p = arg;
2433
    m = &stream_maps[nb_stream_maps++];
2434

    
2435
    m->file_index = strtol(arg, (char **)&p, 0);
2436
    if (*p)
2437
        p++;
2438

    
2439
    m->stream_index = strtol(p, (char **)&p, 0);
2440
    if (*p) {
2441
        p++;
2442
        m->sync_file_index = strtol(p, (char **)&p, 0);
2443
        if (*p)
2444
            p++;
2445
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2446
    } else {
2447
        m->sync_file_index = m->file_index;
2448
        m->sync_stream_index = m->stream_index;
2449
    }
2450
}
2451

    
2452
static void opt_map_meta_data(const char *arg)
2453
{
2454
    AVMetaDataMap *m;
2455
    const char *p;
2456

    
2457
    p = arg;
2458
    m = &meta_data_maps[nb_meta_data_maps++];
2459

    
2460
    m->out_file = strtol(arg, (char **)&p, 0);
2461
    if (*p)
2462
        p++;
2463

    
2464
    m->in_file = strtol(p, (char **)&p, 0);
2465
}
2466

    
2467
static void opt_recording_time(const char *arg)
2468
{
2469
    recording_time = parse_date(arg, 1);
2470
}
2471

    
2472
static void opt_start_time(const char *arg)
2473
{
2474
    start_time = parse_date(arg, 1);
2475
}
2476

    
2477
static void opt_rec_timestamp(const char *arg)
2478
{
2479
    rec_timestamp = parse_date(arg, 0) / 1000000;
2480
}
2481

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

    
2487
static void opt_input_file(const char *filename)
2488
{
2489
    AVFormatContext *ic;
2490
    AVFormatParameters params, *ap = &params;
2491
    int err, i, ret, rfps, rfps_base;
2492
    int64_t timestamp;
2493

    
2494
    if (!strcmp(filename, "-"))
2495
        filename = "pipe:";
2496

    
2497
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2498
                   !strcmp( filename, "/dev/stdin" );
2499

    
2500
    /* get default parameters from command line */
2501
    ic = av_alloc_format_context();
2502

    
2503
    memset(ap, 0, sizeof(*ap));
2504
    ap->prealloced_context = 1;
2505
    ap->sample_rate = audio_sample_rate;
2506
    ap->channels = audio_channels;
2507
    ap->time_base.den = frame_rate;
2508
    ap->time_base.num = frame_rate_base;
2509
    ap->width = frame_width + frame_padleft + frame_padright;
2510
    ap->height = frame_height + frame_padtop + frame_padbottom;
2511
    ap->pix_fmt = frame_pix_fmt;
2512
    ap->channel = video_channel;
2513
    ap->standard = video_standard;
2514
    ap->video_codec_id = video_codec_id;
2515
    ap->audio_codec_id = audio_codec_id;
2516
    if(pgmyuv_compatibility_hack)
2517
        ap->video_codec_id= CODEC_ID_PGMYUV;
2518

    
2519
    for(i=0; i<opt_name_count; i++){
2520
        const AVOption *opt;
2521
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2522
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2523
            av_set_double(ic, opt_names[i], d);
2524
    }
2525
    /* open the input file with generic libav function */
2526
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2527
    if (err < 0) {
2528
        print_error(filename, err);
2529
        exit(1);
2530
    }
2531

    
2532
    ic->loop_input = loop_input;
2533

    
2534
    /* If not enough info to get the stream parameters, we decode the
2535
       first frames to get it. (used in mpeg case for example) */
2536
    ret = av_find_stream_info(ic);
2537
    if (ret < 0 && verbose >= 0) {
2538
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2539
        exit(1);
2540
    }
2541

    
2542
    timestamp = start_time;
2543
    /* add the stream start time */
2544
    if (ic->start_time != AV_NOPTS_VALUE)
2545
        timestamp += ic->start_time;
2546

    
2547
    /* if seeking requested, we execute it */
2548
    if (start_time != 0) {
2549
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2550
        if (ret < 0) {
2551
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2552
                    filename, (double)timestamp / AV_TIME_BASE);
2553
        }
2554
        /* reset seek info */
2555
        start_time = 0;
2556
    }
2557

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

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

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

    
2602
                    (float)rfps / rfps_base, rfps, rfps_base);
2603
            }
2604
            /* update the current frame rate to match the stream frame rate */
2605
            frame_rate      = rfps;
2606
            frame_rate_base = rfps_base;
2607

    
2608
            enc->rate_emu = rate_emu;
2609
            if(video_disable)
2610
                ic->streams[i]->discard= AVDISCARD_ALL;
2611
            else if(video_discard)
2612
                ic->streams[i]->discard= video_discard;
2613
            break;
2614
        case CODEC_TYPE_DATA:
2615
            break;
2616
        case CODEC_TYPE_SUBTITLE:
2617
            break;
2618
        case CODEC_TYPE_UNKNOWN:
2619
            break;
2620
        default:
2621
            av_abort();
2622
        }
2623
    }
2624

    
2625
    input_files[nb_input_files] = ic;
2626
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2627
    /* dump the file content */
2628
    if (verbose >= 0)
2629
        dump_format(ic, nb_input_files, filename, 0);
2630

    
2631
    nb_input_files++;
2632
    file_iformat = NULL;
2633
    file_oformat = NULL;
2634

    
2635
    video_channel = 0;
2636

    
2637
    rate_emu = 0;
2638
}
2639

    
2640
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2641
{
2642
    int has_video, has_audio, i, j;
2643
    AVFormatContext *ic;
2644

    
2645
    has_video = 0;
2646
    has_audio = 0;
2647
    for(j=0;j<nb_input_files;j++) {
2648
        ic = input_files[j];
2649
        for(i=0;i<ic->nb_streams;i++) {
2650
            AVCodecContext *enc = ic->streams[i]->codec;
2651
            switch(enc->codec_type) {
2652
            case CODEC_TYPE_AUDIO:
2653
                has_audio = 1;
2654
                break;
2655
            case CODEC_TYPE_VIDEO:
2656
                has_video = 1;
2657
                break;
2658
            case CODEC_TYPE_DATA:
2659
            case CODEC_TYPE_UNKNOWN:
2660
            case CODEC_TYPE_SUBTITLE:
2661
                break;
2662
            default:
2663
                av_abort();
2664
            }
2665
        }
2666
    }
2667
    *has_video_ptr = has_video;
2668
    *has_audio_ptr = has_audio;
2669
}
2670

    
2671
static void new_video_stream(AVFormatContext *oc)
2672
{
2673
    AVStream *st;
2674
    AVCodecContext *video_enc;
2675
    int codec_id;
2676

    
2677
    st = av_new_stream(oc, oc->nb_streams);
2678
    if (!st) {
2679
        fprintf(stderr, "Could not alloc stream\n");
2680
        exit(1);
2681
    }
2682
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2683
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2684
    video_bitstream_filters= NULL;
2685

    
2686
    if(thread_count>1)
2687
        avcodec_thread_init(st->codec, thread_count);
2688

    
2689
    video_enc = st->codec;
2690

    
2691
    if(video_codec_tag)
2692
        video_enc->codec_tag= video_codec_tag;
2693

    
2694
    if(   (video_global_header&1)
2695
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2696
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2697
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2698
    }
2699
    if(video_global_header&2){
2700
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2701
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2702
    }
2703

    
2704
    if (video_stream_copy) {
2705
        st->stream_copy = 1;
2706
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2707
    } else {
2708
        char *p;
2709
        int i;
2710
        AVCodec *codec;
2711

    
2712
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2713
        if (video_codec_id != CODEC_ID_NONE)
2714
            codec_id = video_codec_id;
2715

    
2716
        video_enc->codec_id = codec_id;
2717
        codec = avcodec_find_encoder(codec_id);
2718

    
2719
        for(i=0; i<opt_name_count; i++){
2720
             const AVOption *opt;
2721
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2722
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2723
                 av_set_double(video_enc, opt_names[i], d);
2724
        }
2725

    
2726
        video_enc->time_base.den = frame_rate;
2727
        video_enc->time_base.num = frame_rate_base;
2728
        if(codec && codec->supported_framerates){
2729
            const AVRational *p= codec->supported_framerates;
2730
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2731
            const AVRational *best=NULL;
2732
            AVRational best_error= (AVRational){INT_MAX, 1};
2733
            for(; p->den!=0; p++){
2734
                AVRational error= av_sub_q(req, *p);
2735
                if(error.num <0) error.num *= -1;
2736
                if(av_cmp_q(error, best_error) < 0){
2737
                    best_error= error;
2738
                    best= p;
2739
                }
2740
            }
2741
            video_enc->time_base.den= best->num;
2742
            video_enc->time_base.num= best->den;
2743
        }
2744

    
2745
        video_enc->width = frame_width + frame_padright + frame_padleft;
2746
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2747
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2748
        video_enc->pix_fmt = frame_pix_fmt;
2749

    
2750
        if(codec && codec->pix_fmts){
2751
            const enum PixelFormat *p= codec->pix_fmts;
2752
            for(; *p!=-1; p++){
2753
                if(*p == video_enc->pix_fmt)
2754
                    break;
2755
            }
2756
            if(*p == -1)
2757
                video_enc->pix_fmt = codec->pix_fmts[0];
2758
        }
2759

    
2760
        if (intra_only)
2761
            video_enc->gop_size = 0;
2762
        if (video_qscale || same_quality) {
2763
            video_enc->flags |= CODEC_FLAG_QSCALE;
2764
            video_enc->global_quality=
2765
                st->quality = FF_QP2LAMBDA * video_qscale;
2766
        }
2767

    
2768
        if(intra_matrix)
2769
            video_enc->intra_matrix = intra_matrix;
2770
        if(inter_matrix)
2771
            video_enc->inter_matrix = inter_matrix;
2772

    
2773
        video_enc->max_qdiff = video_qdiff;
2774
        video_enc->rc_eq = video_rc_eq;
2775
        video_enc->thread_count = thread_count;
2776
        p= video_rc_override_string;
2777
        for(i=0; p; i++){
2778
            int start, end, q;
2779
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2780
            if(e!=3){
2781
                fprintf(stderr, "error parsing rc_override\n");
2782
                exit(1);
2783
            }
2784
            video_enc->rc_override=
2785
                av_realloc(video_enc->rc_override,
2786
                           sizeof(RcOverride)*(i+1));
2787
            video_enc->rc_override[i].start_frame= start;
2788
            video_enc->rc_override[i].end_frame  = end;
2789
            if(q>0){
2790
                video_enc->rc_override[i].qscale= q;
2791
                video_enc->rc_override[i].quality_factor= 1.0;
2792
            }
2793
            else{
2794
                video_enc->rc_override[i].qscale= 0;
2795
                video_enc->rc_override[i].quality_factor= -q/100.0;
2796
            }
2797
            p= strchr(p, '/');
2798
            if(p) p++;
2799
        }
2800
        video_enc->rc_override_count=i;
2801
        if (!video_enc->rc_initial_buffer_occupancy)
2802
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2803
        video_enc->me_threshold= me_threshold;
2804
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2805
        video_enc->strict_std_compliance = strict;
2806

    
2807
        if (do_psnr)
2808
            video_enc->flags|= CODEC_FLAG_PSNR;
2809

    
2810
        video_enc->me_method = me_method;
2811

    
2812
        /* two pass mode */
2813
        if (do_pass) {
2814
            if (do_pass == 1) {
2815
                video_enc->flags |= CODEC_FLAG_PASS1;
2816
            } else {
2817
                video_enc->flags |= CODEC_FLAG_PASS2;
2818
            }
2819
        }
2820
    }
2821

    
2822
    /* reset some key parameters */
2823
    video_disable = 0;
2824
    video_codec_id = CODEC_ID_NONE;
2825
    video_stream_copy = 0;
2826
}
2827

    
2828
static void new_audio_stream(AVFormatContext *oc)
2829
{
2830
    AVStream *st;
2831
    AVCodecContext *audio_enc;
2832
    int codec_id, i;
2833

    
2834
    st = av_new_stream(oc, oc->nb_streams);
2835
    if (!st) {
2836
        fprintf(stderr, "Could not alloc stream\n");
2837
        exit(1);
2838
    }
2839
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2840

    
2841
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2842
    audio_bitstream_filters= NULL;
2843

    
2844
    if(thread_count>1)
2845
        avcodec_thread_init(st->codec, thread_count);
2846

    
2847
    audio_enc = st->codec;
2848
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2849
    audio_enc->strict_std_compliance = strict;
2850

    
2851
    if(audio_codec_tag)
2852
        audio_enc->codec_tag= audio_codec_tag;
2853

    
2854
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2855
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2856
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2857
    }
2858
    if (audio_stream_copy) {
2859
        st->stream_copy = 1;
2860
        audio_enc->channels = audio_channels;
2861
    } else {
2862
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2863

    
2864
        for(i=0; i<opt_name_count; i++){
2865
            const AVOption *opt;
2866
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2867
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2868
                av_set_double(audio_enc, opt_names[i], d);
2869
        }
2870

    
2871
        if (audio_codec_id != CODEC_ID_NONE)
2872
            codec_id = audio_codec_id;
2873
        audio_enc->codec_id = codec_id;
2874

    
2875
        if (audio_qscale > QSCALE_NONE) {
2876
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2877
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2878
        }
2879
        audio_enc->thread_count = thread_count;
2880
        audio_enc->channels = audio_channels;
2881
    }
2882
    audio_enc->sample_rate = audio_sample_rate;
2883
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2884
    if (audio_language) {
2885
        pstrcpy(st->language, sizeof(st->language), audio_language);
2886
        av_free(audio_language);
2887
        audio_language = NULL;
2888
    }
2889

    
2890
    /* reset some key parameters */
2891
    audio_disable = 0;
2892
    audio_codec_id = CODEC_ID_NONE;
2893
    audio_stream_copy = 0;
2894
}
2895

    
2896
static void opt_new_subtitle_stream(void)
2897
{
2898
    AVFormatContext *oc;
2899
    AVStream *st;
2900
    AVCodecContext *subtitle_enc;
2901
    int i;
2902

    
2903
    if (nb_output_files <= 0) {
2904
        fprintf(stderr, "At least one output file must be specified\n");
2905
        exit(1);
2906
    }
2907
    oc = output_files[nb_output_files - 1];
2908

    
2909
    st = av_new_stream(oc, oc->nb_streams);
2910
    if (!st) {
2911
        fprintf(stderr, "Could not alloc stream\n");
2912
        exit(1);
2913
    }
2914
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2915

    
2916
    subtitle_enc = st->codec;
2917
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2918
    if (subtitle_stream_copy) {
2919
        st->stream_copy = 1;
2920
    } else {
2921
        for(i=0; i<opt_name_count; i++){
2922
             const AVOption *opt;
2923
             double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2924
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2925
                 av_set_double(subtitle_enc, opt_names[i], d);
2926
        }
2927
        subtitle_enc->codec_id = subtitle_codec_id;
2928
    }
2929

    
2930
    if (subtitle_language) {
2931
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
2932
        av_free(subtitle_language);
2933
        subtitle_language = NULL;
2934
    }
2935

    
2936
    subtitle_codec_id = CODEC_ID_NONE;
2937
    subtitle_stream_copy = 0;
2938
}
2939

    
2940
static void opt_new_audio_stream(void)
2941
{
2942
    AVFormatContext *oc;
2943
    if (nb_output_files <= 0) {
2944
        fprintf(stderr, "At least one output file must be specified\n");
2945
        exit(1);
2946
    }
2947
    oc = output_files[nb_output_files - 1];
2948
    new_audio_stream(oc);
2949
}
2950

    
2951
static void opt_new_video_stream(void)
2952
{
2953
    AVFormatContext *oc;
2954
    if (nb_output_files <= 0) {
2955
        fprintf(stderr, "At least one output file must be specified\n");
2956
        exit(1);
2957
    }
2958
    oc = output_files[nb_output_files - 1];
2959
    new_video_stream(oc);
2960
}
2961

    
2962
static void opt_output_file(const char *filename)
2963
{
2964
    AVFormatContext *oc;
2965
    int use_video, use_audio, input_has_video, input_has_audio, i;
2966
    AVFormatParameters params, *ap = &params;
2967

    
2968
    if (!strcmp(filename, "-"))
2969
        filename = "pipe:";
2970

    
2971
    oc = av_alloc_format_context();
2972

    
2973
    if (!file_oformat) {
2974
        file_oformat = guess_format(NULL, filename, NULL);
2975
        if (!file_oformat) {
2976
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2977
                    filename);
2978
            exit(1);
2979
        }
2980
    }
2981

    
2982
    oc->oformat = file_oformat;
2983
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
2984

    
2985
    if (!strcmp(file_oformat->name, "ffm") &&
2986
        strstart(filename, "http:", NULL)) {
2987
        /* special case for files sent to ffserver: we get the stream
2988
           parameters from ffserver */
2989
        if (read_ffserver_streams(oc, filename) < 0) {
2990
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2991
            exit(1);
2992
        }
2993
    } else {
2994
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
2995
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
2996

    
2997
        /* disable if no corresponding type found and at least one
2998
           input file */
2999
        if (nb_input_files > 0) {
3000
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3001
            if (!input_has_video)
3002
                use_video = 0;
3003
            if (!input_has_audio)
3004
                use_audio = 0;
3005
        }
3006

    
3007
        /* manual disable */
3008
        if (audio_disable) {
3009
            use_audio = 0;
3010
        }
3011
        if (video_disable) {
3012
            use_video = 0;
3013
        }
3014

    
3015
        if (use_video) {
3016
            new_video_stream(oc);
3017
        }
3018

    
3019
        if (use_audio) {
3020
            new_audio_stream(oc);
3021
        }
3022

    
3023
        oc->timestamp = rec_timestamp;
3024

    
3025
        if (str_title)
3026
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3027
        if (str_author)
3028
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3029
        if (str_copyright)
3030
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3031
        if (str_comment)
3032
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3033
        if (str_album)
3034
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3035
    }
3036

    
3037
    output_files[nb_output_files++] = oc;
3038

    
3039
    /* check filename in case of an image number is expected */
3040
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3041
        if (!av_filename_number_test(oc->filename)) {
3042
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3043
            exit(1);
3044
        }
3045
    }
3046

    
3047
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3048
        /* test if it already exists to avoid loosing precious files */
3049
        if (!file_overwrite &&
3050
            (strchr(filename, ':') == NULL ||
3051
             strstart(filename, "file:", NULL))) {
3052
            if (url_exist(filename)) {
3053
                int c;
3054

    
3055
                if ( !using_stdin ) {
3056
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3057
                    fflush(stderr);
3058
                    c = getchar();
3059
                    if (toupper(c) != 'Y') {
3060
                        fprintf(stderr, "Not overwriting - exiting\n");
3061
                        exit(1);
3062
                    }
3063
                                }
3064
                                else {
3065
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3066
                    exit(1);
3067
                                }
3068
            }
3069
        }
3070

    
3071
        /* open the file */
3072
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3073
            fprintf(stderr, "Could not open '%s'\n", filename);
3074
            exit(1);
3075
        }
3076
    }
3077

    
3078
    memset(ap, 0, sizeof(*ap));
3079
    if (av_set_parameters(oc, ap) < 0) {
3080
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3081
                oc->filename);
3082
        exit(1);
3083
    }
3084

    
3085
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3086
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3087
    oc->loop_output = loop_output;
3088

    
3089
    for(i=0; i<opt_name_count; i++){
3090
        const AVOption *opt;
3091
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3092
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3093
            av_set_double(oc, opt_names[i], d);
3094
    }
3095

    
3096
    /* reset some options */
3097
    file_oformat = NULL;
3098
    file_iformat = NULL;
3099
}
3100

    
3101
/* same option as mencoder */
3102
static void opt_pass(const char *pass_str)
3103
{
3104
    int pass;
3105
    pass = atoi(pass_str);
3106
    if (pass != 1 && pass != 2) {
3107
        fprintf(stderr, "pass number can be only 1 or 2\n");
3108
        exit(1);
3109
    }
3110
    do_pass = pass;
3111
}
3112

    
3113
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3114
static int64_t getutime(void)
3115
{
3116
  return av_gettime();
3117
}
3118
#else
3119
static int64_t getutime(void)
3120
{
3121
    struct rusage rusage;
3122

    
3123
    getrusage(RUSAGE_SELF, &rusage);
3124
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3125
}
3126
#endif
3127

    
3128
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3129
extern int ffm_nopts;
3130
#endif
3131

    
3132
static void show_formats(void)
3133
{
3134
    AVInputFormat *ifmt;
3135
    AVOutputFormat *ofmt;
3136
    URLProtocol *up;
3137
    AVCodec *p, *p2;
3138
    const char **pp, *last_name;
3139

    
3140
    printf("File formats:\n");
3141
    last_name= "000";
3142
    for(;;){
3143
        int decode=0;
3144
        int encode=0;
3145
        const char *name=NULL;
3146
        const char *long_name=NULL;
3147

    
3148
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3149
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3150
                strcmp(ofmt->name, last_name)>0){
3151
                name= ofmt->name;
3152
                long_name= ofmt->long_name;
3153
                encode=1;
3154
            }
3155
        }
3156
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3157
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3158
                strcmp(ifmt->name, last_name)>0){
3159
                name= ifmt->name;
3160
                long_name= ifmt->long_name;
3161
                encode=0;
3162
            }
3163
            if(name && strcmp(ifmt->name, name)==0)
3164
                decode=1;
3165
        }
3166
        if(name==NULL)
3167
            break;
3168
        last_name= name;
3169

    
3170
        printf(
3171
            " %s%s %-15s %s\n",
3172
            decode ? "D":" ",
3173
            encode ? "E":" ",
3174
            name,
3175
            long_name ? long_name:" ");
3176
    }
3177
    printf("\n");
3178

    
3179
    printf("Codecs:\n");
3180
    last_name= "000";
3181
    for(;;){
3182
        int decode=0;
3183
        int encode=0;
3184
        int cap=0;
3185
        const char *type_str;
3186

    
3187
        p2=NULL;
3188
        for(p = first_avcodec; p != NULL; p = p->next) {
3189
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3190
                strcmp(p->name, last_name)>0){
3191
                p2= p;
3192
                decode= encode= cap=0;
3193
            }
3194
            if(p2 && strcmp(p->name, p2->name)==0){
3195
                if(p->decode) decode=1;
3196
                if(p->encode) encode=1;
3197
                cap |= p->capabilities;
3198
            }
3199
        }
3200
        if(p2==NULL)
3201
            break;
3202
        last_name= p2->name;
3203

    
3204
        switch(p2->type) {
3205
        case CODEC_TYPE_VIDEO:
3206
            type_str = "V";
3207
            break;
3208
        case CODEC_TYPE_AUDIO:
3209
            type_str = "A";
3210
            break;
3211
        case CODEC_TYPE_SUBTITLE:
3212
            type_str = "S";
3213
            break;
3214
        default:
3215
            type_str = "?";
3216
            break;
3217
        }
3218
        printf(
3219
            " %s%s%s%s%s%s %s",
3220
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3221
            encode ? "E":" ",
3222
            type_str,
3223
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3224
            cap & CODEC_CAP_DR1 ? "D":" ",
3225
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3226
            p2->name);
3227
       /* if(p2->decoder && decode==0)
3228
            printf(" use %s for decoding", p2->decoder->name);*/
3229
        printf("\n");
3230
    }
3231
    printf("\n");
3232

    
3233
    printf("Supported file protocols:\n");
3234
    for(up = first_protocol; up != NULL; up = up->next)
3235
        printf(" %s:", up->name);
3236
    printf("\n");
3237

    
3238
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3239
    printf("Motion estimation methods:\n");
3240
    pp = motion_str;
3241
    while (*pp) {
3242
        printf(" %s", *pp);
3243
        if ((pp - motion_str + 1) == ME_ZERO)
3244
            printf("(fastest)");
3245
        else if ((pp - motion_str + 1) == ME_FULL)
3246
            printf("(slowest)");
3247
        else if ((pp - motion_str + 1) == ME_EPZS)
3248
            printf("(default)");
3249
        pp++;
3250
    }
3251
    printf("\n\n");
3252
    printf(
3253
"Note, the names of encoders and decoders dont always match, so there are\n"
3254
"several cases where the above table shows encoder only or decoder only entries\n"
3255
"even though both encoding and decoding are supported for example, the h263\n"
3256
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3257
"worse\n");
3258
    exit(1);
3259
}
3260

    
3261
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3262
{
3263
    int i;
3264
    const char *p = str;
3265
    for(i = 0;; i++) {
3266
        dest[i] = atoi(p);
3267
        if(i == 63)
3268
            break;
3269
        p = strchr(p, ',');
3270
        if(!p) {
3271
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3272
            exit(1);
3273
        }
3274
        p++;
3275
    }
3276
}
3277

    
3278
static void opt_inter_matrix(const char *arg)
3279
{
3280
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3281
    parse_matrix_coeffs(inter_matrix, arg);
3282
}
3283

    
3284
static void opt_intra_matrix(const char *arg)
3285
{
3286
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3287
    parse_matrix_coeffs(intra_matrix, arg);
3288
}
3289

    
3290
static void opt_target(const char *arg)
3291
{
3292
    int norm = -1;
3293
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3294

    
3295
    if(!strncmp(arg, "pal-", 4)) {
3296
        norm = 0;
3297
        arg += 4;
3298
    } else if(!strncmp(arg, "ntsc-", 5)) {
3299
        norm = 1;
3300
        arg += 5;
3301
    } else if(!strncmp(arg, "film-", 5)) {
3302
        norm = 2;
3303
        arg += 5;
3304
    } else {
3305
        int fr;
3306
        /* Calculate FR via float to avoid int overflow */
3307
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3308
        if(fr == 25000) {
3309
            norm = 0;
3310
        } else if((fr == 29970) || (fr == 23976)) {
3311
            norm = 1;
3312
        } else {
3313
            /* Try to determine PAL/NTSC by peeking in the input files */
3314
            if(nb_input_files) {
3315
                int i, j;
3316
                for(j = 0; j < nb_input_files; j++) {
3317
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3318
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3319
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3320
                            continue;
3321
                        fr = c->time_base.den * 1000 / c->time_base.num;
3322
                        if(fr == 25000) {
3323
                            norm = 0;
3324
                            break;
3325
                        } else if((fr == 29970) || (fr == 23976)) {
3326
                            norm = 1;
3327
                            break;
3328
                        }
3329
                    }
3330
                    if(norm >= 0)
3331
                        break;
3332
                }
3333
            }
3334
        }
3335
        if(verbose && norm >= 0)
3336
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3337
    }
3338

    
3339
    if(norm < 0) {
3340
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3341
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3342
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3343
        exit(1);
3344
    }
3345

    
3346
    if(!strcmp(arg, "vcd")) {
3347

    
3348
        opt_video_codec("mpeg1video");
3349
        opt_audio_codec("mp2");
3350
        opt_format("vcd");
3351

    
3352
        opt_frame_size(norm ? "352x240" : "352x288");
3353
        opt_frame_rate(frame_rates[norm]);
3354
        opt_default("gop", norm ? "18" : "15");
3355

    
3356
        opt_default("b", "1150000");
3357
        opt_default("maxrate", "1150000");
3358
        opt_default("minrate", "1150000");
3359
        opt_default("bufsize", "327680"); // 40*1024*8;
3360

    
3361
        opt_default("ab", "224000");
3362
        audio_sample_rate = 44100;
3363
        audio_channels = 2;
3364

    
3365
        opt_default("packetsize", "2324");
3366
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3367

    
3368
        /* We have to offset the PTS, so that it is consistent with the SCR.
3369
           SCR starts at 36000, but the first two packs contain only padding
3370
           and the first pack from the other stream, respectively, may also have
3371
           been written before.
3372
           So the real data starts at SCR 36000+3*1200. */
3373
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3374
    } else if(!strcmp(arg, "svcd")) {
3375

    
3376
        opt_video_codec("mpeg2video");
3377
        opt_audio_codec("mp2");
3378
        opt_format("svcd");
3379

    
3380
        opt_frame_size(norm ? "480x480" : "480x576");
3381
        opt_frame_rate(frame_rates[norm]);
3382
        opt_default("gop", norm ? "18" : "15");
3383

    
3384
        opt_default("b", "2040000");
3385
        opt_default("maxrate", "2516000");
3386
        opt_default("minrate", "0"); //1145000;
3387
        opt_default("bufsize", "1835008"); //224*1024*8;
3388
        opt_default("flags", "+SCAN_OFFSET");
3389

    
3390

    
3391
        opt_default("ab", "224000");
3392
        audio_sample_rate = 44100;
3393

    
3394
        opt_default("packetsize", "2324");
3395

    
3396
    } else if(!strcmp(arg, "dvd")) {
3397

    
3398
        opt_video_codec("mpeg2video");
3399
        opt_audio_codec("ac3");
3400
        opt_format("dvd");
3401

    
3402
        opt_frame_size(norm ? "720x480" : "720x576");
3403
        opt_frame_rate(frame_rates[norm]);
3404
        opt_default("gop", norm ? "18" : "15");
3405

    
3406
        opt_default("b", "6000000");
3407
        opt_default("maxrate", "9000000");
3408
        opt_default("minrate", "0"); //1500000;
3409
        opt_default("bufsize", "1835008"); //224*1024*8;
3410

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

    
3414
        opt_default("ab", "448000");
3415
        audio_sample_rate = 48000;
3416

    
3417
    } else if(!strncmp(arg, "dv", 2)) {
3418

    
3419
        opt_format("dv");
3420

    
3421
        opt_frame_size(norm ? "720x480" : "720x576");
3422
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3423
                                             (norm ? "yuv411p" : "yuv420p"));
3424
        opt_frame_rate(frame_rates[norm]);
3425

    
3426
        audio_sample_rate = 48000;
3427
        audio_channels = 2;
3428

    
3429
    } else {
3430
        fprintf(stderr, "Unknown target: %s\n", arg);
3431
        exit(1);
3432
    }
3433
}
3434

    
3435
static void opt_vstats_file (const char *arg)
3436
{
3437
    if (!fvstats)
3438
    {
3439
        fvstats = fopen(arg ,"w");
3440
        if (!fvstats) {
3441
            perror("fopen");
3442
            exit(1);
3443
        }
3444
    }
3445
}
3446

    
3447
static void opt_vstats (void)
3448
{
3449
    if (!fvstats) {
3450
        char filename[40];
3451
        time_t today2 = time(NULL);
3452
        struct tm *today = localtime(&today2);
3453

    
3454
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
3455
                                               today->tm_min,
3456
                                               today->tm_sec);
3457
        opt_vstats_file(filename);
3458
    }
3459
}
3460

    
3461
static void opt_video_bsf(const char *arg)
3462
{
3463
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3464
    AVBitStreamFilterContext **bsfp;
3465

    
3466
    if(!bsfc){
3467
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3468
        exit(1);
3469
    }
3470

    
3471
    bsfp= &video_bitstream_filters;
3472
    while(*bsfp)
3473
        bsfp= &(*bsfp)->next;
3474

    
3475
    *bsfp= bsfc;
3476
}
3477

    
3478
//FIXME avoid audio - video code duplication
3479
static void opt_audio_bsf(const char *arg)
3480
{
3481
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3482
    AVBitStreamFilterContext **bsfp;
3483

    
3484
    if(!bsfc){
3485
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3486
        exit(1);
3487
    }
3488

    
3489
    bsfp= &audio_bitstream_filters;
3490
    while(*bsfp)
3491
        bsfp= &(*bsfp)->next;
3492

    
3493
    *bsfp= bsfc;
3494
}
3495

    
3496
static void show_version(void)
3497
{
3498
    /* TODO: add function interface to avutil and avformat */
3499
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3500
           "libavutil   %d\n"
3501
           "libavcodec  %d\n"
3502
           "libavformat %d\n",
3503
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3504
    exit(1);
3505
}
3506

    
3507
static int opt_default(const char *opt, const char *arg){
3508
    int type;
3509
    const AVOption *o= NULL;
3510
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3511

    
3512
    for(type=0; type<CODEC_TYPE_NB; type++){
3513
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3514
        if(o2)
3515
            o = av_set_string(avctx_opts[type], opt, arg);
3516
    }
3517
    if(!o)
3518
        o = av_set_string(avformat_opts, opt, arg);
3519
    if(!o){
3520
        if(opt[0] == 'a')
3521
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3522
        else if(opt[0] == 'v')
3523
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3524
        else if(opt[0] == 's')
3525
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3526
    }
3527
    if(!o)
3528
        return -1;
3529

    
3530
//    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));
3531

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

    
3536
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3537
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3538
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3539
        ffm_nopts = 1;
3540
#endif
3541

    
3542
    if(avctx_opts[0]->debug)
3543
        av_log_level = AV_LOG_DEBUG;
3544
    return 0;
3545
}
3546

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

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

    
3633
    /* audio options */
3634
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3635
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3636
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3637
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3638
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3639
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3640
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3641
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3642
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3643
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3644

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

    
3650
    /* grab options */
3651
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3652
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3653
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3654

    
3655
    /* muxer options */
3656
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3657
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3658

    
3659
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3660
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3661

    
3662
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3663
    { NULL, },
3664
};
3665

    
3666
static void show_banner(void)
3667
{
3668
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3669
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3670
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3671
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3672
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3673
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3674
#ifdef __GNUC__
3675
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3676
#else
3677
    fprintf(stderr, ", using a non-gcc compiler\n");
3678
#endif
3679
}
3680

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

    
3720
static void show_help(void)
3721
{
3722
    show_banner();
3723
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3724
           "Hyper fast Audio and Video encoder\n");
3725
    printf("\n");
3726
    show_help_options(options, "Main options:\n",
3727
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3728
    show_help_options(options, "\nVideo options:\n",
3729
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3730
                      OPT_VIDEO);
3731
    show_help_options(options, "\nAdvanced Video options:\n",
3732
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3733
                      OPT_VIDEO | OPT_EXPERT);
3734
    show_help_options(options, "\nAudio options:\n",
3735
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3736
                      OPT_AUDIO);
3737
    show_help_options(options, "\nAdvanced Audio options:\n",
3738
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3739
                      OPT_AUDIO | OPT_EXPERT);
3740
    show_help_options(options, "\nSubtitle options:\n",
3741
                      OPT_SUBTITLE | OPT_GRAB,
3742
                      OPT_SUBTITLE);
3743
    show_help_options(options, "\nAudio/Video grab options:\n",
3744
                      OPT_GRAB,
3745
                      OPT_GRAB);
3746
    show_help_options(options, "\nAdvanced options:\n",
3747
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3748
                      OPT_EXPERT);
3749
    av_opt_show(avctx_opts[0], NULL);
3750
    av_opt_show(avformat_opts, NULL);
3751

    
3752
    exit(1);
3753
}
3754

    
3755
void parse_arg_file(const char *filename)
3756
{
3757
    opt_output_file(filename);
3758
}
3759

    
3760
int main(int argc, char **argv)
3761
{
3762
    int i;
3763
    int64_t ti;
3764

    
3765
    av_register_all();
3766

    
3767
    for(i=0; i<CODEC_TYPE_NB; i++){
3768
        avctx_opts[i]= avcodec_alloc_context2(i);
3769
    }
3770
    avformat_opts = av_alloc_format_context();
3771

    
3772
    if (argc <= 1)
3773
        show_help();
3774
    else
3775
        show_banner();
3776

    
3777
    /* parse options */
3778
    parse_options(argc, argv, options);
3779

    
3780
    /* file converter / grab */
3781
    if (nb_output_files <= 0) {
3782
        fprintf(stderr, "Must supply at least one output file\n");
3783
        exit(1);
3784
    }
3785

    
3786
    if (nb_input_files == 0) {
3787
        fprintf(stderr, "Must supply at least one input file\n");
3788
        exit(1);
3789
    }
3790

    
3791
    ti = getutime();
3792
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3793
              stream_maps, nb_stream_maps);
3794
    ti = getutime() - ti;
3795
    if (do_benchmark) {
3796
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3797
    }
3798

    
3799
    /* close files */
3800
    for(i=0;i<nb_output_files;i++) {
3801
        /* maybe av_close_output_file ??? */
3802
        AVFormatContext *s = output_files[i];
3803
        int j;
3804
        if (!(s->oformat->flags & AVFMT_NOFILE))
3805
            url_fclose(&s->pb);
3806
        for(j=0;j<s->nb_streams;j++) {
3807
            av_free(s->streams[j]->codec);
3808
            av_free(s->streams[j]);
3809
        }
3810
        av_free(s);
3811
    }
3812
    for(i=0;i<nb_input_files;i++)
3813
        av_close_input_file(input_files[i]);
3814

    
3815
    av_free_static();
3816

    
3817
    av_free(intra_matrix);
3818
    av_free(inter_matrix);
3819

    
3820
    if (fvstats)
3821
        fclose(fvstats);
3822
    av_free(vstats_filename);
3823

    
3824
    av_free(opt_names);
3825

    
3826
#ifdef CONFIG_POWERPC_PERF
3827
    extern void powerpc_display_perf_report(void);
3828
    powerpc_display_perf_report();
3829
#endif /* CONFIG_POWERPC_PERF */
3830

    
3831
    if (received_sigterm) {
3832
        fprintf(stderr,
3833
            "Received signal %d: terminating.\n",
3834
            (int) received_sigterm);
3835
        exit (255);
3836
    }
3837

    
3838
    exit(0); /* not all OS-es handle main() return value */
3839
    return 0;
3840
}