Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 6b8bcd3e

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

    
22
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include "avformat.h"
31
#include "swscale.h"
32
#include "framehook.h"
33
#include "opt.h"
34
#include "fifo.h"
35
#include "avstring.h"
36

    
37
#if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
38
#include <windows.h>
39
#endif
40

    
41
#if defined(HAVE_TERMIOS_H)
42
#include <unistd.h>
43
#include <fcntl.h>
44
#include <sys/ioctl.h>
45
#include <sys/time.h>
46
#include <termios.h>
47
#include <sys/resource.h>
48
#elif defined(HAVE_CONIO_H)
49
#include <conio.h>
50
#endif
51
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
52
#include <time.h>
53

    
54
#include "version.h"
55
#include "cmdutils.h"
56

    
57
#undef NDEBUG
58
#include <assert.h>
59

    
60
#if !defined(INFINITY) && defined(HUGE_VAL)
61
#define INFINITY HUGE_VAL
62
#endif
63

    
64
#undef exit
65

    
66
/* select an input stream for an output stream */
67
typedef struct AVStreamMap {
68
    int file_index;
69
    int stream_index;
70
    int sync_file_index;
71
    int sync_stream_index;
72
} AVStreamMap;
73

    
74
/** select an input file for an output file */
75
typedef struct AVMetaDataMap {
76
    int out_file;
77
    int in_file;
78
} AVMetaDataMap;
79

    
80
extern const OptionDef options[];
81

    
82
static void show_help(void);
83
static void show_license(void);
84
static int opt_default(const char *opt, const char *arg);
85

    
86
#define MAX_FILES 20
87

    
88
static AVFormatContext *input_files[MAX_FILES];
89
static int64_t input_files_ts_offset[MAX_FILES];
90
static int nb_input_files = 0;
91

    
92
static AVFormatContext *output_files[MAX_FILES];
93
static int nb_output_files = 0;
94

    
95
static AVStreamMap stream_maps[MAX_FILES];
96
static int nb_stream_maps;
97

    
98
static AVMetaDataMap meta_data_maps[MAX_FILES];
99
static int nb_meta_data_maps;
100

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

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

    
153
static int subtitle_codec_id = CODEC_ID_NONE;
154
static char *subtitle_language = NULL;
155

    
156
static float mux_preload= 0.5;
157
static float mux_max_delay= 0.7;
158

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

    
186
static int rate_emu = 0;
187

    
188
static int  video_channel = 0;
189
static char *video_standard;
190

    
191
static int audio_volume = 256;
192

    
193
static int using_stdin = 0;
194
static int using_vhook = 0;
195
static int verbose = 1;
196
static int thread_count= 1;
197
static int q_pressed = 0;
198
static int64_t video_size = 0;
199
static int64_t audio_size = 0;
200
static int64_t extra_size = 0;
201
static int nb_frames_dup = 0;
202
static int nb_frames_drop = 0;
203
static int input_sync;
204
static uint64_t limit_filesize = 0; //
205

    
206
static int pgmyuv_compatibility_hack=0;
207
static int dts_delta_threshold = 10;
208

    
209
static int sws_flags = SWS_BICUBIC;
210

    
211
static const char **opt_names;
212
static int opt_name_count;
213
static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
214
static AVFormatContext *avformat_opts;
215
static struct SwsContext *sws_opts;
216
static int64_t timer_start;
217

    
218
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
219
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
220
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
221

    
222
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
223

    
224
struct AVInputStream;
225

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

    
244
    int video_crop;
245
    int topBand;             /* cropping area sizes */
246
    int leftBand;
247

    
248
    int video_pad;
249
    int padtop;              /* padding area sizes */
250
    int padbottom;
251
    int padleft;
252
    int padright;
253

    
254
    /* audio only */
255
    int audio_resample;
256
    ReSampleContext *resample; /* for audio resampling */
257
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
258
    FILE *logfile;
259
} AVOutputStream;
260

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

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

    
277
typedef struct AVInputFile {
278
    int eof_reached;      /* true if eof reached */
279
    int ist_index;        /* index of first stream in ist_table */
280
    int buffer_size;      /* current total buffer size */
281
    int nb_streams;       /* nb streams we are aware of */
282
} AVInputFile;
283

    
284
#ifdef HAVE_TERMIOS_H
285

    
286
/* init terminal so that we can grab keys */
287
static struct termios oldtty;
288
#endif
289

    
290
static void term_exit(void)
291
{
292
#ifdef HAVE_TERMIOS_H
293
    tcsetattr (0, TCSANOW, &oldtty);
294
#endif
295
}
296

    
297
static volatile sig_atomic_t received_sigterm = 0;
298

    
299
static void
300
sigterm_handler(int sig)
301
{
302
    received_sigterm = sig;
303
    term_exit();
304
}
305

    
306
static void term_init(void)
307
{
308
#ifdef HAVE_TERMIOS_H
309
    struct termios tty;
310

    
311
    tcgetattr (0, &tty);
312
    oldtty = tty;
313

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

    
323
    tcsetattr (0, TCSANOW, &tty);
324
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
325
#endif
326

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

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

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

    
359
        return n;
360
    }
361
#elif defined(HAVE_CONIO_H)
362
    if(kbhit())
363
        return(getch());
364
#endif
365
    return -1;
366
}
367

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

    
373
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
374
{
375
    int i, err;
376
    AVFormatContext *ic;
377

    
378
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
379
    if (err < 0)
380
        return err;
381
    /* copy stream format */
382
    s->nb_streams = ic->nb_streams;
383
    for(i=0;i<ic->nb_streams;i++) {
384
        AVStream *st;
385

    
386
        // FIXME: a more elegant solution is needed
387
        st = av_mallocz(sizeof(AVStream));
388
        memcpy(st, ic->streams[i], sizeof(AVStream));
389
        st->codec = avcodec_alloc_context();
390
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
391
        s->streams[i] = st;
392
    }
393

    
394
    av_close_input_file(ic);
395
    return 0;
396
}
397

    
398
static double
399
get_sync_ipts(const AVOutputStream *ost)
400
{
401
    const AVInputStream *ist = ost->sync_ist;
402
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
403
}
404

    
405
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
406
    while(bsfc){
407
        AVPacket new_pkt= *pkt;
408
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
409
                                          &new_pkt.data, &new_pkt.size,
410
                                          pkt->data, pkt->size,
411
                                          pkt->flags & PKT_FLAG_KEY);
412
        if(a){
413
            av_free_packet(pkt);
414
            new_pkt.destruct= av_destruct_packet;
415
        }
416
        *pkt= new_pkt;
417

    
418
        bsfc= bsfc->next;
419
    }
420

    
421
    av_interleaved_write_frame(s, pkt);
422
}
423

    
424
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
425

    
426
static void do_audio_out(AVFormatContext *s,
427
                         AVOutputStream *ost,
428
                         AVInputStream *ist,
429
                         unsigned char *buf, int size)
430
{
431
    uint8_t *buftmp;
432
    static uint8_t *audio_buf = NULL;
433
    static uint8_t *audio_out = NULL;
434
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
435

    
436
    int size_out, frame_bytes, ret;
437
    AVCodecContext *enc= ost->st->codec;
438

    
439
    /* SC: dynamic allocation of buffers */
440
    if (!audio_buf)
441
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
442
    if (!audio_out)
443
        audio_out = av_malloc(audio_out_size);
444
    if (!audio_buf || !audio_out)
445
        return;               /* Should signal an error ! */
446

    
447
    if(audio_sync_method){
448
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
449
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
450
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
451
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
452

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

    
469
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
470
                        ist->is_start=0;
471
                    else
472
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
473

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

    
494
    if (ost->audio_resample) {
495
        buftmp = audio_buf;
496
        size_out = audio_resample(ost->resample,
497
                                  (short *)buftmp, (short *)buf,
498
                                  size / (ist->st->codec->channels * 2));
499
        size_out = size_out * enc->channels * 2;
500
    } else {
501
        buftmp = buf;
502
        size_out = size;
503
    }
504

    
505
    /* now encode as many frames as possible */
506
    if (enc->frame_size > 1) {
507
        /* output resampled raw samples */
508
        av_fifo_write(&ost->fifo, buftmp, size_out);
509

    
510
        frame_bytes = enc->frame_size * 2 * enc->channels;
511

    
512
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
513
            AVPacket pkt;
514
            av_init_packet(&pkt);
515

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

    
527
            ost->sync_opts += enc->frame_size;
528
        }
529
    } else {
530
        AVPacket pkt;
531
        av_init_packet(&pkt);
532

    
533
        ost->sync_opts += size_out / (2 * enc->channels);
534

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

    
573
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
574
{
575
    AVCodecContext *dec;
576
    AVPicture *picture2;
577
    AVPicture picture_tmp;
578
    uint8_t *buf = 0;
579

    
580
    dec = ist->st->codec;
581

    
582
    /* deinterlace : must be done before any resize */
583
    if (do_deinterlace || using_vhook) {
584
        int size;
585

    
586
        /* create temporary picture */
587
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
588
        buf = av_malloc(size);
589
        if (!buf)
590
            return;
591

    
592
        picture2 = &picture_tmp;
593
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
594

    
595
        if (do_deinterlace){
596
            if(avpicture_deinterlace(picture2, picture,
597
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
598
                /* if error, do not deinterlace */
599
                av_free(buf);
600
                buf = NULL;
601
                picture2 = picture;
602
            }
603
        } else {
604
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
605
        }
606
    } else {
607
        picture2 = picture;
608
    }
609

    
610
    if (ENABLE_VHOOK)
611
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
612
                           1000000 * ist->pts / AV_TIME_BASE);
613

    
614
    if (picture != picture2)
615
        *picture = *picture2;
616
    *bufp = buf;
617
}
618

    
619
/* we begin to correct av delay at this threshold */
620
#define AV_DELAY_MAX 0.100
621

    
622
static void do_subtitle_out(AVFormatContext *s,
623
                            AVOutputStream *ost,
624
                            AVInputStream *ist,
625
                            AVSubtitle *sub,
626
                            int64_t pts)
627
{
628
    static uint8_t *subtitle_out = NULL;
629
    int subtitle_out_max_size = 65536;
630
    int subtitle_out_size, nb, i;
631
    AVCodecContext *enc;
632
    AVPacket pkt;
633

    
634
    if (pts == AV_NOPTS_VALUE) {
635
        fprintf(stderr, "Subtitle packets must have a pts\n");
636
        return;
637
    }
638

    
639
    enc = ost->st->codec;
640

    
641
    if (!subtitle_out) {
642
        subtitle_out = av_malloc(subtitle_out_max_size);
643
    }
644

    
645
    /* Note: DVB subtitle need one packet to draw them and one other
646
       packet to clear them */
647
    /* XXX: signal it in the codec context ? */
648
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
649
        nb = 2;
650
    else
651
        nb = 1;
652

    
653
    for(i = 0; i < nb; i++) {
654
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
655
                                                    subtitle_out_max_size, sub);
656

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

    
674
static int bit_buffer_size= 1024*256;
675
static uint8_t *bit_buffer= NULL;
676

    
677
static void do_video_out(AVFormatContext *s,
678
                         AVOutputStream *ost,
679
                         AVInputStream *ist,
680
                         AVFrame *in_picture,
681
                         int *frame_size)
682
{
683
    int nb_frames, i, ret;
684
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
685
    AVFrame picture_crop_temp, picture_pad_temp;
686
    AVCodecContext *enc, *dec;
687

    
688
    avcodec_get_frame_defaults(&picture_crop_temp);
689
    avcodec_get_frame_defaults(&picture_pad_temp);
690

    
691
    enc = ost->st->codec;
692
    dec = ist->st->codec;
693

    
694
    /* by default, we output a single frame */
695
    nb_frames = 1;
696

    
697
    *frame_size = 0;
698

    
699
    if(video_sync_method){
700
        double vdelta;
701
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
702
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
703
        if (vdelta < -1.1)
704
            nb_frames = 0;
705
        else if (vdelta > 1.1)
706
            nb_frames = lrintf(vdelta);
707
//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);
708
        if (nb_frames == 0){
709
            ++nb_frames_drop;
710
            if (verbose>2)
711
                fprintf(stderr, "*** drop!\n");
712
        }else if (nb_frames > 1) {
713
            nb_frames_dup += nb_frames;
714
            if (verbose>2)
715
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
716
        }
717
    }else
718
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
719

    
720
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
721
    if (nb_frames <= 0)
722
        return;
723

    
724
    if (ost->video_crop) {
725
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
726
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
727
            return;
728
        }
729
        formatted_picture = &picture_crop_temp;
730
    } else {
731
        formatted_picture = in_picture;
732
    }
733

    
734
    final_picture = formatted_picture;
735
    padding_src = formatted_picture;
736
    resampling_dst = &ost->pict_tmp;
737
    if (ost->video_pad) {
738
        final_picture = &ost->pict_tmp;
739
        if (ost->video_resample) {
740
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
741
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
742
                return;
743
            }
744
            resampling_dst = &picture_pad_temp;
745
        }
746
    }
747

    
748
    if (ost->video_resample) {
749
        padding_src = NULL;
750
        final_picture = &ost->pict_tmp;
751
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
752
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
753
    }
754

    
755
    if (ost->video_pad) {
756
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
757
                enc->height, enc->width, enc->pix_fmt,
758
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
759
    }
760

    
761
    /* duplicates frame if needed */
762
    for(i=0;i<nb_frames;i++) {
763
        AVPacket pkt;
764
        av_init_packet(&pkt);
765
        pkt.stream_index= ost->index;
766

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

    
780
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
781
            enc->coded_frame = old_frame;
782
        } else {
783
            AVFrame big_picture;
784

    
785
            big_picture= *final_picture;
786
            /* better than nothing: use input picture interlaced
787
               settings */
788
            big_picture.interlaced_frame = in_picture->interlaced_frame;
789
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
790
                if(top_field_first == -1)
791
                    big_picture.top_field_first = in_picture->top_field_first;
792
                else
793
                    big_picture.top_field_first = top_field_first;
794
            }
795

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

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

    
843
static double psnr(double d){
844
    if(d==0) return INFINITY;
845
    return -10.0*log(d)/log(10.0);
846
}
847

    
848
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
849
                           int frame_size)
850
{
851
    AVCodecContext *enc;
852
    int frame_number;
853
    double ti1, bitrate, avg_bitrate;
854

    
855
    /* this is executed just the first time do_video_stats is called */
856
    if (!fvstats) {
857
        fvstats = fopen(vstats_filename, "w");
858
        if (!fvstats) {
859
            perror("fopen");
860
            exit(1);
861
        }
862
    }
863

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

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

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

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

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

    
912

    
913
    oc = output_files[0];
914

    
915
    total_size = url_fsize(&oc->pb);
916
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
917
        total_size= url_ftell(&oc->pb);
918

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

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

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

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

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

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

    
992
        fflush(stderr);
993
    }
994

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

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

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

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

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

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

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

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

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

    
1154
            ist->frame++;
1155
        }
1156

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1339

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1925
            av_free_packet(&pkt);
1926
            goto redo;
1927
        }
1928

    
1929
    discard_packet:
1930
        av_free_packet(&pkt);
1931

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

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

    
1944
    term_exit();
1945

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

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

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

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

    
1972
    /* finished ! */
1973

    
1974
    ret = 0;
1975
 fail1:
1976
    av_freep(&bit_buffer);
1977
    av_free(file_table);
1978

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

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

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

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

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

    
2052
static void opt_video_rc_eq(char *arg)
2053
{
2054
    video_rc_eq = arg;
2055
}
2056

    
2057
static void opt_video_rc_override_string(char *arg)
2058
{
2059
    video_rc_override_string = arg;
2060
}
2061

    
2062
static void opt_me_threshold(const char *arg)
2063
{
2064
    me_threshold = atoi(arg);
2065
}
2066

    
2067
static void opt_verbose(const char *arg)
2068
{
2069
    verbose = atoi(arg);
2070
    av_log_level = atoi(arg);
2071
}
2072

    
2073
static void opt_frame_rate(const char *arg)
2074
{
2075
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2076
        fprintf(stderr, "Incorrect frame rate\n");
2077
        exit(1);
2078
    }
2079
}
2080

    
2081
static void opt_frame_crop_top(const char *arg)
2082
{
2083
    frame_topBand = atoi(arg);
2084
    if (frame_topBand < 0) {
2085
        fprintf(stderr, "Incorrect top crop size\n");
2086
        exit(1);
2087
    }
2088
    if ((frame_topBand % 2) != 0) {
2089
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2090
        exit(1);
2091
    }
2092
    if ((frame_topBand) >= 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_topBand;
2097
}
2098

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

    
2117
static void opt_frame_crop_left(const char *arg)
2118
{
2119
    frame_leftBand = atoi(arg);
2120
    if (frame_leftBand < 0) {
2121
        fprintf(stderr, "Incorrect left crop size\n");
2122
        exit(1);
2123
    }
2124
    if ((frame_leftBand % 2) != 0) {
2125
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2126
        exit(1);
2127
    }
2128
    if ((frame_leftBand) >= 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_leftBand;
2133
}
2134

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

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

    
2165

    
2166
#define SCALEBITS 10
2167
#define ONE_HALF  (1 << (SCALEBITS - 1))
2168
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2169

    
2170
#define RGB_TO_Y(r, g, b) \
2171
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2172
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2173

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

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

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

    
2188
    r = (rgb >> 16);
2189
    g = ((rgb >> 8) & 255);
2190
    b = (rgb & 255);
2191

    
2192
    padcolor[0] = RGB_TO_Y(r,g,b);
2193
    padcolor[1] = RGB_TO_U(r,g,b,0);
2194
    padcolor[2] = RGB_TO_V(r,g,b,0);
2195
}
2196

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

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

    
2223

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

    
2237

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

    
2251
void list_pix_fmts(void)
2252
{
2253
    int i;
2254
    char pix_fmt_str[128];
2255
    for (i=-1; i < PIX_FMT_NB; i++) {
2256
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2257
        fprintf(stdout, "%s\n", pix_fmt_str);
2258
    }
2259
}
2260

    
2261
static void opt_frame_pix_fmt(const char *arg)
2262
{
2263
    if (strcmp(arg, "list"))
2264
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2265
    else {
2266
        list_pix_fmts();
2267
        exit(0);
2268
    }
2269
}
2270

    
2271
static void opt_frame_aspect_ratio(const char *arg)
2272
{
2273
    int x = 0, y = 0;
2274
    double ar = 0;
2275
    const char *p;
2276

    
2277
    p = strchr(arg, ':');
2278
    if (p) {
2279
        x = strtol(arg, (char **)&arg, 10);
2280
        if (arg == p)
2281
            y = strtol(arg+1, (char **)&arg, 10);
2282
        if (x > 0 && y > 0)
2283
            ar = (double)x / (double)y;
2284
    } else
2285
        ar = strtod(arg, (char **)&arg);
2286

    
2287
    if (!ar) {
2288
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2289
        exit(1);
2290
    }
2291
    frame_aspect_ratio = ar;
2292
}
2293

    
2294
static void opt_qscale(const char *arg)
2295
{
2296
    video_qscale = atof(arg);
2297
    if (video_qscale <= 0 ||
2298
        video_qscale > 255) {
2299
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2300
        exit(1);
2301
    }
2302
}
2303

    
2304
static void opt_qdiff(const char *arg)
2305
{
2306
    video_qdiff = atoi(arg);
2307
    if (video_qdiff < 0 ||
2308
        video_qdiff > 31) {
2309
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2310
        exit(1);
2311
    }
2312
}
2313

    
2314
static void opt_strict(const char *arg)
2315
{
2316
    strict= atoi(arg);
2317
}
2318

    
2319
static void opt_top_field_first(const char *arg)
2320
{
2321
    top_field_first= atoi(arg);
2322
}
2323

    
2324
static void opt_thread_count(const char *arg)
2325
{
2326
    thread_count= atoi(arg);
2327
#if !defined(HAVE_THREADS)
2328
    if (verbose >= 0)
2329
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2330
#endif
2331
}
2332

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

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

    
2343
static void opt_video_channel(const char *arg)
2344
{
2345
    video_channel = strtol(arg, NULL, 0);
2346
}
2347

    
2348
static void opt_video_standard(const char *arg)
2349
{
2350
    video_standard = av_strdup(arg);
2351
}
2352

    
2353
static void opt_codec(int *pstream_copy, int *pcodec_id,
2354
                      int codec_type, const char *arg)
2355
{
2356
    AVCodec *p;
2357

    
2358
    if (!strcmp(arg, "copy")) {
2359
        *pstream_copy = 1;
2360
    } else {
2361
        p = first_avcodec;
2362
        while (p) {
2363
            if (!strcmp(p->name, arg) && p->type == codec_type)
2364
                break;
2365
            p = p->next;
2366
        }
2367
        if (p == NULL) {
2368
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2369
            exit(1);
2370
        } else {
2371
            *pcodec_id = p->id;
2372
        }
2373
    }
2374
}
2375

    
2376
static void opt_audio_codec(const char *arg)
2377
{
2378
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2379
}
2380

    
2381
static void opt_audio_tag(const char *arg)
2382
{
2383
    char *tail;
2384
    audio_codec_tag= strtol(arg, &tail, 0);
2385

    
2386
    if(!tail || *tail)
2387
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2388
}
2389

    
2390
static void opt_video_tag(const char *arg)
2391
{
2392
    char *tail;
2393
    video_codec_tag= strtol(arg, &tail, 0);
2394

    
2395
    if(!tail || *tail)
2396
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2397
}
2398

    
2399
#ifdef CONFIG_VHOOK
2400
static void add_frame_hooker(const char *arg)
2401
{
2402
    int argc = 0;
2403
    char *argv[64];
2404
    int i;
2405
    char *args = av_strdup(arg);
2406

    
2407
    using_vhook = 1;
2408

    
2409
    argv[0] = strtok(args, " ");
2410
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2411
    }
2412

    
2413
    i = frame_hook_add(argc, argv);
2414

    
2415
    if (i != 0) {
2416
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2417
        exit(1);
2418
    }
2419
}
2420
#endif
2421

    
2422
static void opt_video_codec(const char *arg)
2423
{
2424
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2425
}
2426

    
2427
static void opt_subtitle_codec(const char *arg)
2428
{
2429
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2430
}
2431

    
2432
static void opt_map(const char *arg)
2433
{
2434
    AVStreamMap *m;
2435
    const char *p;
2436

    
2437
    p = arg;
2438
    m = &stream_maps[nb_stream_maps++];
2439

    
2440
    m->file_index = strtol(arg, (char **)&p, 0);
2441
    if (*p)
2442
        p++;
2443

    
2444
    m->stream_index = strtol(p, (char **)&p, 0);
2445
    if (*p) {
2446
        p++;
2447
        m->sync_file_index = strtol(p, (char **)&p, 0);
2448
        if (*p)
2449
            p++;
2450
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2451
    } else {
2452
        m->sync_file_index = m->file_index;
2453
        m->sync_stream_index = m->stream_index;
2454
    }
2455
}
2456

    
2457
static void opt_map_meta_data(const char *arg)
2458
{
2459
    AVMetaDataMap *m;
2460
    const char *p;
2461

    
2462
    p = arg;
2463
    m = &meta_data_maps[nb_meta_data_maps++];
2464

    
2465
    m->out_file = strtol(arg, (char **)&p, 0);
2466
    if (*p)
2467
        p++;
2468

    
2469
    m->in_file = strtol(p, (char **)&p, 0);
2470
}
2471

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

    
2477
static void opt_start_time(const char *arg)
2478
{
2479
    start_time = parse_date(arg, 1);
2480
}
2481

    
2482
static void opt_rec_timestamp(const char *arg)
2483
{
2484
    rec_timestamp = parse_date(arg, 0) / 1000000;
2485
}
2486

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

    
2492
static void opt_input_file(const char *filename)
2493
{
2494
    AVFormatContext *ic;
2495
    AVFormatParameters params, *ap = &params;
2496
    int err, i, ret, rfps, rfps_base;
2497
    int64_t timestamp;
2498

    
2499
    if (!strcmp(filename, "-"))
2500
        filename = "pipe:";
2501

    
2502
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2503
                   !strcmp( filename, "/dev/stdin" );
2504

    
2505
    /* get default parameters from command line */
2506
    ic = av_alloc_format_context();
2507

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

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

    
2537
    ic->loop_input = loop_input;
2538

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

    
2547
    timestamp = start_time;
2548
    /* add the stream start time */
2549
    if (ic->start_time != AV_NOPTS_VALUE)
2550
        timestamp += ic->start_time;
2551

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

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

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

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

    
2607
                    (float)rfps / rfps_base, rfps, rfps_base);
2608
            }
2609
            /* update the current frame rate to match the stream frame rate */
2610
            frame_rate.num = rfps;
2611
            frame_rate.den = rfps_base;
2612

    
2613
            enc->rate_emu = rate_emu;
2614
            if(video_disable)
2615
                ic->streams[i]->discard= AVDISCARD_ALL;
2616
            else if(video_discard)
2617
                ic->streams[i]->discard= video_discard;
2618
            break;
2619
        case CODEC_TYPE_DATA:
2620
            break;
2621
        case CODEC_TYPE_SUBTITLE:
2622
            break;
2623
        case CODEC_TYPE_UNKNOWN:
2624
            break;
2625
        default:
2626
            abort();
2627
        }
2628
    }
2629

    
2630
    input_files[nb_input_files] = ic;
2631
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2632
    /* dump the file content */
2633
    if (verbose >= 0)
2634
        dump_format(ic, nb_input_files, filename, 0);
2635

    
2636
    nb_input_files++;
2637
    file_iformat = NULL;
2638
    file_oformat = NULL;
2639

    
2640
    video_channel = 0;
2641

    
2642
    rate_emu = 0;
2643
}
2644

    
2645
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2646
{
2647
    int has_video, has_audio, i, j;
2648
    AVFormatContext *ic;
2649

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

    
2676
static void new_video_stream(AVFormatContext *oc)
2677
{
2678
    AVStream *st;
2679
    AVCodecContext *video_enc;
2680
    int codec_id;
2681

    
2682
    st = av_new_stream(oc, oc->nb_streams);
2683
    if (!st) {
2684
        fprintf(stderr, "Could not alloc stream\n");
2685
        exit(1);
2686
    }
2687
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2688
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2689
    video_bitstream_filters= NULL;
2690

    
2691
    if(thread_count>1)
2692
        avcodec_thread_init(st->codec, thread_count);
2693

    
2694
    video_enc = st->codec;
2695

    
2696
    if(video_codec_tag)
2697
        video_enc->codec_tag= video_codec_tag;
2698

    
2699
    if(   (video_global_header&1)
2700
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2701
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2702
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2703
    }
2704
    if(video_global_header&2){
2705
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2706
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2707
    }
2708

    
2709
    if (video_stream_copy) {
2710
        st->stream_copy = 1;
2711
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2712
    } else {
2713
        char *p;
2714
        int i;
2715
        AVCodec *codec;
2716

    
2717
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2718
        if (video_codec_id != CODEC_ID_NONE)
2719
            codec_id = video_codec_id;
2720

    
2721
        video_enc->codec_id = codec_id;
2722
        codec = avcodec_find_encoder(codec_id);
2723

    
2724
        for(i=0; i<opt_name_count; i++){
2725
             const AVOption *opt;
2726
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2727
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2728
                 av_set_double(video_enc, opt_names[i], d);
2729
        }
2730

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

    
2750
        video_enc->width = frame_width + frame_padright + frame_padleft;
2751
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2752
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2753
        video_enc->pix_fmt = frame_pix_fmt;
2754

    
2755
        if(codec && codec->pix_fmts){
2756
            const enum PixelFormat *p= codec->pix_fmts;
2757
            for(; *p!=-1; p++){
2758
                if(*p == video_enc->pix_fmt)
2759
                    break;
2760
            }
2761
            if(*p == -1)
2762
                video_enc->pix_fmt = codec->pix_fmts[0];
2763
        }
2764

    
2765
        if (intra_only)
2766
            video_enc->gop_size = 0;
2767
        if (video_qscale || same_quality) {
2768
            video_enc->flags |= CODEC_FLAG_QSCALE;
2769
            video_enc->global_quality=
2770
                st->quality = FF_QP2LAMBDA * video_qscale;
2771
        }
2772

    
2773
        if(intra_matrix)
2774
            video_enc->intra_matrix = intra_matrix;
2775
        if(inter_matrix)
2776
            video_enc->inter_matrix = inter_matrix;
2777

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

    
2812
        if (do_psnr)
2813
            video_enc->flags|= CODEC_FLAG_PSNR;
2814

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

    
2825
    /* reset some key parameters */
2826
    video_disable = 0;
2827
    video_codec_id = CODEC_ID_NONE;
2828
    video_stream_copy = 0;
2829
}
2830

    
2831
static void new_audio_stream(AVFormatContext *oc)
2832
{
2833
    AVStream *st;
2834
    AVCodecContext *audio_enc;
2835
    int codec_id, i;
2836

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

    
2844
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2845
    audio_bitstream_filters= NULL;
2846

    
2847
    if(thread_count>1)
2848
        avcodec_thread_init(st->codec, thread_count);
2849

    
2850
    audio_enc = st->codec;
2851
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2852
    audio_enc->strict_std_compliance = strict;
2853

    
2854
    if(audio_codec_tag)
2855
        audio_enc->codec_tag= audio_codec_tag;
2856

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

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

    
2874
        if (audio_codec_id != CODEC_ID_NONE)
2875
            codec_id = audio_codec_id;
2876
        audio_enc->codec_id = codec_id;
2877

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

    
2893
    /* reset some key parameters */
2894
    audio_disable = 0;
2895
    audio_codec_id = CODEC_ID_NONE;
2896
    audio_stream_copy = 0;
2897
}
2898

    
2899
static void opt_new_subtitle_stream(void)
2900
{
2901
    AVFormatContext *oc;
2902
    AVStream *st;
2903
    AVCodecContext *subtitle_enc;
2904
    int i;
2905

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

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

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

    
2933
    if (subtitle_language) {
2934
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2935
        av_free(subtitle_language);
2936
        subtitle_language = NULL;
2937
    }
2938

    
2939
    subtitle_codec_id = CODEC_ID_NONE;
2940
    subtitle_stream_copy = 0;
2941
}
2942

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

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

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

    
2971
    if (!strcmp(filename, "-"))
2972
        filename = "pipe:";
2973

    
2974
    oc = av_alloc_format_context();
2975

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

    
2985
    oc->oformat = file_oformat;
2986
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
2987

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

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

    
3010
        /* manual disable */
3011
        if (audio_disable) {
3012
            use_audio = 0;
3013
        }
3014
        if (video_disable) {
3015
            use_video = 0;
3016
        }
3017

    
3018
        if (use_video) {
3019
            new_video_stream(oc);
3020
        }
3021

    
3022
        if (use_audio) {
3023
            new_audio_stream(oc);
3024
        }
3025

    
3026
        oc->timestamp = rec_timestamp;
3027

    
3028
        if (str_title)
3029
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3030
        if (str_author)
3031
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3032
        if (str_copyright)
3033
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3034
        if (str_comment)
3035
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3036
        if (str_album)
3037
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3038
    }
3039

    
3040
    output_files[nb_output_files++] = oc;
3041

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

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

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

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

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

    
3088
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3089
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3090
    oc->loop_output = loop_output;
3091

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

    
3099
    /* reset some options */
3100
    file_oformat = NULL;
3101
    file_iformat = NULL;
3102
}
3103

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

    
3116
static int64_t getutime(void)
3117
{
3118
#ifdef HAVE_GETRUSAGE
3119
    struct rusage rusage;
3120

    
3121
    getrusage(RUSAGE_SELF, &rusage);
3122
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3123
#elif defined(HAVE_GETPROCESSTIMES)
3124
    HANDLE proc;
3125
    FILETIME c, e, k, u;
3126
    proc = GetCurrentProcess();
3127
    GetProcessTimes(proc, &c, &e, &k, &u);
3128
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3129
#else
3130
  return av_gettime();
3131
#endif
3132
}
3133

    
3134
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3135
extern int ffm_nopts;
3136
#endif
3137

    
3138
static void show_formats(void)
3139
{
3140
    AVInputFormat *ifmt;
3141
    AVOutputFormat *ofmt;
3142
    URLProtocol *up;
3143
    AVCodec *p, *p2;
3144
    const char *last_name;
3145

    
3146
    printf("File formats:\n");
3147
    last_name= "000";
3148
    for(;;){
3149
        int decode=0;
3150
        int encode=0;
3151
        const char *name=NULL;
3152
        const char *long_name=NULL;
3153

    
3154
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3155
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3156
                strcmp(ofmt->name, last_name)>0){
3157
                name= ofmt->name;
3158
                long_name= ofmt->long_name;
3159
                encode=1;
3160
            }
3161
        }
3162
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3163
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3164
                strcmp(ifmt->name, last_name)>0){
3165
                name= ifmt->name;
3166
                long_name= ifmt->long_name;
3167
                encode=0;
3168
            }
3169
            if(name && strcmp(ifmt->name, name)==0)
3170
                decode=1;
3171
        }
3172
        if(name==NULL)
3173
            break;
3174
        last_name= name;
3175

    
3176
        printf(
3177
            " %s%s %-15s %s\n",
3178
            decode ? "D":" ",
3179
            encode ? "E":" ",
3180
            name,
3181
            long_name ? long_name:" ");
3182
    }
3183
    printf("\n");
3184

    
3185
    printf("Codecs:\n");
3186
    last_name= "000";
3187
    for(;;){
3188
        int decode=0;
3189
        int encode=0;
3190
        int cap=0;
3191
        const char *type_str;
3192

    
3193
        p2=NULL;
3194
        for(p = first_avcodec; p != NULL; p = p->next) {
3195
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3196
                strcmp(p->name, last_name)>0){
3197
                p2= p;
3198
                decode= encode= cap=0;
3199
            }
3200
            if(p2 && strcmp(p->name, p2->name)==0){
3201
                if(p->decode) decode=1;
3202
                if(p->encode) encode=1;
3203
                cap |= p->capabilities;
3204
            }
3205
        }
3206
        if(p2==NULL)
3207
            break;
3208
        last_name= p2->name;
3209

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

    
3239
    printf("Supported file protocols:\n");
3240
    for(up = first_protocol; up != NULL; up = up->next)
3241
        printf(" %s:", up->name);
3242
    printf("\n");
3243

    
3244
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3245
    printf("\n");
3246
    printf(
3247
"Note, the names of encoders and decoders do not always match, so there are\n"
3248
"several cases where the above table shows encoder only or decoder only entries\n"
3249
"even though both encoding and decoding are supported. For example, the h263\n"
3250
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3251
"worse.\n");
3252
    exit(1);
3253
}
3254

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

    
3272
static void opt_inter_matrix(const char *arg)
3273
{
3274
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3275
    parse_matrix_coeffs(inter_matrix, arg);
3276
}
3277

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

    
3284
static void opt_target(const char *arg)
3285
{
3286
    int norm = -1;
3287
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3288

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

    
3333
    if(norm < 0) {
3334
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3335
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3336
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3337
        exit(1);
3338
    }
3339

    
3340
    if(!strcmp(arg, "vcd")) {
3341

    
3342
        opt_video_codec("mpeg1video");
3343
        opt_audio_codec("mp2");
3344
        opt_format("vcd");
3345

    
3346
        opt_frame_size(norm ? "352x240" : "352x288");
3347
        opt_frame_rate(frame_rates[norm]);
3348
        opt_default("gop", norm ? "18" : "15");
3349

    
3350
        opt_default("b", "1150000");
3351
        opt_default("maxrate", "1150000");
3352
        opt_default("minrate", "1150000");
3353
        opt_default("bufsize", "327680"); // 40*1024*8;
3354

    
3355
        opt_default("ab", "224000");
3356
        audio_sample_rate = 44100;
3357
        audio_channels = 2;
3358

    
3359
        opt_default("packetsize", "2324");
3360
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3361

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

    
3370
        opt_video_codec("mpeg2video");
3371
        opt_audio_codec("mp2");
3372
        opt_format("svcd");
3373

    
3374
        opt_frame_size(norm ? "480x480" : "480x576");
3375
        opt_frame_rate(frame_rates[norm]);
3376
        opt_default("gop", norm ? "18" : "15");
3377

    
3378
        opt_default("b", "2040000");
3379
        opt_default("maxrate", "2516000");
3380
        opt_default("minrate", "0"); //1145000;
3381
        opt_default("bufsize", "1835008"); //224*1024*8;
3382
        opt_default("flags", "+SCAN_OFFSET");
3383

    
3384

    
3385
        opt_default("ab", "224000");
3386
        audio_sample_rate = 44100;
3387

    
3388
        opt_default("packetsize", "2324");
3389

    
3390
    } else if(!strcmp(arg, "dvd")) {
3391

    
3392
        opt_video_codec("mpeg2video");
3393
        opt_audio_codec("ac3");
3394
        opt_format("dvd");
3395

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

    
3400
        opt_default("b", "6000000");
3401
        opt_default("maxrate", "9000000");
3402
        opt_default("minrate", "0"); //1500000;
3403
        opt_default("bufsize", "1835008"); //224*1024*8;
3404

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

    
3408
        opt_default("ab", "448000");
3409
        audio_sample_rate = 48000;
3410

    
3411
    } else if(!strncmp(arg, "dv", 2)) {
3412

    
3413
        opt_format("dv");
3414

    
3415
        opt_frame_size(norm ? "720x480" : "720x576");
3416
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3417
                                             (norm ? "yuv411p" : "yuv420p"));
3418
        opt_frame_rate(frame_rates[norm]);
3419

    
3420
        audio_sample_rate = 48000;
3421
        audio_channels = 2;
3422

    
3423
    } else {
3424
        fprintf(stderr, "Unknown target: %s\n", arg);
3425
        exit(1);
3426
    }
3427
}
3428

    
3429
static void opt_vstats_file (const char *arg)
3430
{
3431
    av_free (vstats_filename);
3432
    vstats_filename=av_strdup (arg);
3433
}
3434

    
3435
static void opt_vstats (void)
3436
{
3437
    char filename[40];
3438
    time_t today2 = time(NULL);
3439
    struct tm *today = localtime(&today2);
3440

    
3441
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3442
             today->tm_sec);
3443
    opt_vstats_file(filename);
3444
}
3445

    
3446
static void opt_video_bsf(const char *arg)
3447
{
3448
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3449
    AVBitStreamFilterContext **bsfp;
3450

    
3451
    if(!bsfc){
3452
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3453
        exit(1);
3454
    }
3455

    
3456
    bsfp= &video_bitstream_filters;
3457
    while(*bsfp)
3458
        bsfp= &(*bsfp)->next;
3459

    
3460
    *bsfp= bsfc;
3461
}
3462

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

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

    
3474
    bsfp= &audio_bitstream_filters;
3475
    while(*bsfp)
3476
        bsfp= &(*bsfp)->next;
3477

    
3478
    *bsfp= bsfc;
3479
}
3480

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

    
3492
static int opt_default(const char *opt, const char *arg){
3493
    int type;
3494
    const AVOption *o= NULL;
3495
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3496

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

    
3517
//    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));
3518

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3707
/**
3708
 * Trivial log callback.
3709
 * Only suitable for show_help and similar since it lacks prefix handling.
3710
 */
3711
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3712
{
3713
    vfprintf(stdout, fmt, vl);
3714
}
3715

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

    
3750
    exit(1);
3751
}
3752

    
3753
void parse_arg_file(const char *filename)
3754
{
3755
    opt_output_file(filename);
3756
}
3757

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

    
3763
    av_register_all();
3764

    
3765
    for(i=0; i<CODEC_TYPE_NB; i++){
3766
        avctx_opts[i]= avcodec_alloc_context2(i);
3767
    }
3768
    avformat_opts = av_alloc_format_context();
3769
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3770

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

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

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

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

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

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

    
3814
    av_free_static();
3815

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

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

    
3823
    av_free(opt_names);
3824

    
3825
    av_free(video_standard);
3826

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

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

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