Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 2886f311

History | View | Annotate | Download (135 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 "avdevice.h"
32
#include "swscale.h"
33
#include "framehook.h"
34
#include "opt.h"
35
#include "fifo.h"
36
#include "avstring.h"
37
#include "os_support.h"
38

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

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

    
56
#include "version.h"
57
#include "cmdutils.h"
58

    
59
#undef NDEBUG
60
#include <assert.h>
61

    
62
#if !defined(INFINITY) && defined(HUGE_VAL)
63
#define INFINITY HUGE_VAL
64
#endif
65

    
66
#undef exit
67

    
68
static const char program_name[] = "FFmpeg";
69
static const int program_birth_year = 2000;
70

    
71
/* select an input stream for an output stream */
72
typedef struct AVStreamMap {
73
    int file_index;
74
    int stream_index;
75
    int sync_file_index;
76
    int sync_stream_index;
77
} AVStreamMap;
78

    
79
/** select an input file for an output file */
80
typedef struct AVMetaDataMap {
81
    int out_file;
82
    int in_file;
83
} AVMetaDataMap;
84

    
85
extern const OptionDef options[];
86

    
87
#define MAX_FILES 20
88

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

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

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

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

    
102
static AVInputFormat *file_iformat;
103
static AVOutputFormat *file_oformat;
104
static int frame_width  = 0;
105
static int frame_height = 0;
106
static float frame_aspect_ratio = 0;
107
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
108
static int frame_padtop  = 0;
109
static int frame_padbottom = 0;
110
static int frame_padleft  = 0;
111
static int frame_padright = 0;
112
static int padcolor[3] = {16,128,128}; /* default to black */
113
static int frame_topBand  = 0;
114
static int frame_bottomBand = 0;
115
static int frame_leftBand  = 0;
116
static int frame_rightBand = 0;
117
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
118
static AVRational frame_rate = (AVRational) {25,1};
119
static float video_qscale = 0;
120
static int video_qdiff = 3;
121
static uint16_t *intra_matrix = NULL;
122
static uint16_t *inter_matrix = NULL;
123
#if 0 //experimental, (can be removed)
124
static float video_rc_qsquish=1.0;
125
static float video_rc_qmod_amp=0;
126
static int video_rc_qmod_freq=0;
127
#endif
128
static char *video_rc_override_string=NULL;
129
static int video_disable = 0;
130
static int video_discard = 0;
131
static char *video_codec_name = NULL;
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 char  *audio_codec_name = NULL;
150
static int audio_codec_tag = 0;
151
static char *audio_language = NULL;
152

    
153
static int subtitle_disable = 0;
154
static char *subtitle_codec_name = NULL;
155
static char *subtitle_language = NULL;
156

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

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

    
189
static int rate_emu = 0;
190

    
191
static int  video_channel = 0;
192
static char *video_standard;
193

    
194
static int audio_volume = 256;
195

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

    
209
static int pgmyuv_compatibility_hack=0;
210
static float dts_delta_threshold = 10;
211

    
212
static int sws_flags = SWS_BICUBIC;
213

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

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

    
225
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226

    
227
struct AVInputStream;
228

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

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

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

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

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

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

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

    
287
#ifdef HAVE_TERMIOS_H
288

    
289
/* init terminal so that we can grab keys */
290
static struct termios oldtty;
291
#endif
292

    
293
static void term_exit(void)
294
{
295
#ifdef HAVE_TERMIOS_H
296
    tcsetattr (0, TCSANOW, &oldtty);
297
#endif
298
}
299

    
300
static volatile sig_atomic_t received_sigterm = 0;
301

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

    
309
static void term_init(void)
310
{
311
#ifdef HAVE_TERMIOS_H
312
    struct termios tty;
313

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

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

    
326
    tcsetattr (0, TCSANOW, &tty);
327
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
328
#endif
329

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

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

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

    
362
        return n;
363
    }
364
#elif defined(HAVE_CONIO_H)
365
    if(kbhit())
366
        return(getch());
367
#endif
368
    return -1;
369
}
370

    
371
static int decode_interrupt_cb(void)
372
{
373
    return q_pressed || (q_pressed = read_key() == 'q');
374
}
375

    
376
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
377
{
378
    int i, err;
379
    AVFormatContext *ic;
380

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

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

    
397
    av_close_input_file(ic);
398
    return 0;
399
}
400

    
401
static double
402
get_sync_ipts(const AVOutputStream *ost)
403
{
404
    const AVInputStream *ist = ost->sync_ist;
405
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
406
}
407

    
408
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
409
    int ret;
410

    
411
    while(bsfc){
412
        AVPacket new_pkt= *pkt;
413
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
414
                                          &new_pkt.data, &new_pkt.size,
415
                                          pkt->data, pkt->size,
416
                                          pkt->flags & PKT_FLAG_KEY);
417
        if(a){
418
            av_free_packet(pkt);
419
            new_pkt.destruct= av_destruct_packet;
420
        }
421
        *pkt= new_pkt;
422

    
423
        bsfc= bsfc->next;
424
    }
425

    
426
    ret= av_interleaved_write_frame(s, pkt);
427
    if(ret < 0){
428
        print_error("av_interleaved_write_frame()", ret);
429
        exit(1);
430
    }
431
}
432

    
433
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
434

    
435
static void do_audio_out(AVFormatContext *s,
436
                         AVOutputStream *ost,
437
                         AVInputStream *ist,
438
                         unsigned char *buf, int size)
439
{
440
    uint8_t *buftmp;
441
    static uint8_t *audio_buf = NULL;
442
    static uint8_t *audio_out = NULL;
443
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
444

    
445
    int size_out, frame_bytes, ret;
446
    AVCodecContext *enc= ost->st->codec;
447
    AVCodecContext *dec= ist->st->codec;
448

    
449
    /* SC: dynamic allocation of buffers */
450
    if (!audio_buf)
451
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
452
    if (!audio_out)
453
        audio_out = av_malloc(audio_out_size);
454
    if (!audio_buf || !audio_out)
455
        return;               /* Should signal an error ! */
456

    
457
    if (enc->channels != dec->channels)
458
        ost->audio_resample = 1;
459

    
460
    if (ost->audio_resample && !ost->resample) {
461
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
462
                                            enc->sample_rate, dec->sample_rate);
463
        if (!ost->resample) {
464
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
465
                    dec->channels, dec->sample_rate,
466
                    enc->channels, enc->sample_rate);
467
            exit(1);
468
        }
469
    }
470

    
471
    if(audio_sync_method){
472
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
473
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
474
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
475
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
476

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

    
493
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
494
                        ist->is_start=0;
495
                    else
496
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
497

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

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

    
529
    /* now encode as many frames as possible */
530
    if (enc->frame_size > 1) {
531
        /* output resampled raw samples */
532
        av_fifo_write(&ost->fifo, buftmp, size_out);
533

    
534
        frame_bytes = enc->frame_size * 2 * enc->channels;
535

    
536
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
537
            AVPacket pkt;
538
            av_init_packet(&pkt);
539

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

    
551
            ost->sync_opts += enc->frame_size;
552
        }
553
    } else {
554
        AVPacket pkt;
555
        av_init_packet(&pkt);
556

    
557
        ost->sync_opts += size_out / (2 * enc->channels);
558

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

    
597
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
598
{
599
    AVCodecContext *dec;
600
    AVPicture *picture2;
601
    AVPicture picture_tmp;
602
    uint8_t *buf = 0;
603

    
604
    dec = ist->st->codec;
605

    
606
    /* deinterlace : must be done before any resize */
607
    if (do_deinterlace || using_vhook) {
608
        int size;
609

    
610
        /* create temporary picture */
611
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
612
        buf = av_malloc(size);
613
        if (!buf)
614
            return;
615

    
616
        picture2 = &picture_tmp;
617
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
618

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

    
634
    if (ENABLE_VHOOK)
635
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
636
                           1000000 * ist->pts / AV_TIME_BASE);
637

    
638
    if (picture != picture2)
639
        *picture = *picture2;
640
    *bufp = buf;
641
}
642

    
643
/* we begin to correct av delay at this threshold */
644
#define AV_DELAY_MAX 0.100
645

    
646
static void do_subtitle_out(AVFormatContext *s,
647
                            AVOutputStream *ost,
648
                            AVInputStream *ist,
649
                            AVSubtitle *sub,
650
                            int64_t pts)
651
{
652
    static uint8_t *subtitle_out = NULL;
653
    int subtitle_out_max_size = 65536;
654
    int subtitle_out_size, nb, i;
655
    AVCodecContext *enc;
656
    AVPacket pkt;
657

    
658
    if (pts == AV_NOPTS_VALUE) {
659
        fprintf(stderr, "Subtitle packets must have a pts\n");
660
        return;
661
    }
662

    
663
    enc = ost->st->codec;
664

    
665
    if (!subtitle_out) {
666
        subtitle_out = av_malloc(subtitle_out_max_size);
667
    }
668

    
669
    /* Note: DVB subtitle need one packet to draw them and one other
670
       packet to clear them */
671
    /* XXX: signal it in the codec context ? */
672
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
673
        nb = 2;
674
    else
675
        nb = 1;
676

    
677
    for(i = 0; i < nb; i++) {
678
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
679
                                                    subtitle_out_max_size, sub);
680

    
681
        av_init_packet(&pkt);
682
        pkt.stream_index = ost->index;
683
        pkt.data = subtitle_out;
684
        pkt.size = subtitle_out_size;
685
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
686
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
687
            /* XXX: the pts correction is handled here. Maybe handling
688
               it in the codec would be better */
689
            if (i == 0)
690
                pkt.pts += 90 * sub->start_display_time;
691
            else
692
                pkt.pts += 90 * sub->end_display_time;
693
        }
694
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
695
    }
696
}
697

    
698
static int bit_buffer_size= 1024*256;
699
static uint8_t *bit_buffer= NULL;
700

    
701
static void do_video_out(AVFormatContext *s,
702
                         AVOutputStream *ost,
703
                         AVInputStream *ist,
704
                         AVFrame *in_picture,
705
                         int *frame_size)
706
{
707
    int nb_frames, i, ret;
708
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
709
    AVFrame picture_crop_temp, picture_pad_temp;
710
    AVCodecContext *enc, *dec;
711

    
712
    avcodec_get_frame_defaults(&picture_crop_temp);
713
    avcodec_get_frame_defaults(&picture_pad_temp);
714

    
715
    enc = ost->st->codec;
716
    dec = ist->st->codec;
717

    
718
    /* by default, we output a single frame */
719
    nb_frames = 1;
720

    
721
    *frame_size = 0;
722

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

    
744
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
745
    if (nb_frames <= 0)
746
        return;
747

    
748
    if (ost->video_crop) {
749
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
750
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
751
            return;
752
        }
753
        formatted_picture = &picture_crop_temp;
754
    } else {
755
        formatted_picture = in_picture;
756
    }
757

    
758
    final_picture = formatted_picture;
759
    padding_src = formatted_picture;
760
    resampling_dst = &ost->pict_tmp;
761
    if (ost->video_pad) {
762
        final_picture = &ost->pict_tmp;
763
        if (ost->video_resample) {
764
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
765
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
766
                return;
767
            }
768
            resampling_dst = &picture_pad_temp;
769
        }
770
    }
771

    
772
    if (ost->video_resample) {
773
        padding_src = NULL;
774
        final_picture = &ost->pict_tmp;
775
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
776
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
777
    }
778

    
779
    if (ost->video_pad) {
780
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
781
                enc->height, enc->width, enc->pix_fmt,
782
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
783
    }
784

    
785
    /* duplicates frame if needed */
786
    for(i=0;i<nb_frames;i++) {
787
        AVPacket pkt;
788
        av_init_packet(&pkt);
789
        pkt.stream_index= ost->index;
790

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

    
804
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
805
            enc->coded_frame = old_frame;
806
        } else {
807
            AVFrame big_picture;
808

    
809
            big_picture= *final_picture;
810
            /* better than nothing: use input picture interlaced
811
               settings */
812
            big_picture.interlaced_frame = in_picture->interlaced_frame;
813
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
814
                if(top_field_first == -1)
815
                    big_picture.top_field_first = in_picture->top_field_first;
816
                else
817
                    big_picture.top_field_first = top_field_first;
818
            }
819

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

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

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

    
872
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
873
                           int frame_size)
874
{
875
    AVCodecContext *enc;
876
    int frame_number;
877
    double ti1, bitrate, avg_bitrate;
878

    
879
    /* this is executed just the first time do_video_stats is called */
880
    if (!vstats_file) {
881
        vstats_file = fopen(vstats_filename, "w");
882
        if (!vstats_file) {
883
            perror("fopen");
884
            exit(1);
885
        }
886
    }
887

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

    
895
        fprintf(vstats_file,"f_size= %6d ", frame_size);
896
        /* compute pts value */
897
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
898
        if (ti1 < 0.01)
899
            ti1 = 0.01;
900

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

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

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

    
936

    
937
    oc = output_files[0];
938

    
939
    total_size = url_fsize(oc->pb);
940
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
941
        total_size= url_ftell(oc->pb);
942

    
943
    buf[0] = '\0';
944
    ti1 = 1e10;
945
    vid = 0;
946
    for(i=0;i<nb_ostreams;i++) {
947
        ost = ost_table[i];
948
        os = output_files[ost->file_index];
949
        enc = ost->st->codec;
950
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
951
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
952
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
953
        }
954
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
955
            float t = (av_gettime()-timer_start) / 1000000.0;
956

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

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

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

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

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

    
1016
        fflush(stderr);
1017
    }
1018

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

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

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

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

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

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

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

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

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

    
1178
            ist->frame++;
1179
        }
1180

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

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

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

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

    
1236
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1237
                            continue;
1238

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

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

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

    
1253
                        opkt.stream_index= ost->index;
1254
                        if(pkt->pts != AV_NOPTS_VALUE)
1255
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1256
                        else
1257
                            opkt.pts= AV_NOPTS_VALUE;
1258

    
1259
                            if (pkt->dts == AV_NOPTS_VALUE)
1260
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1261
                            else
1262
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1263

    
1264
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1265
                        opkt.flags= pkt->flags;
1266

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

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

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

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

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

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

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

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

    
1364
static void print_sdp(AVFormatContext **avc, int n)
1365
{
1366
    char sdp[2048];
1367

    
1368
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1369
    printf("SDP:\n%s\n", sdp);
1370
}
1371

    
1372
static int stream_index_from_inputs(AVFormatContext **input_files,
1373
                                    int nb_input_files,
1374
                                    AVInputFile *file_table,
1375
                                    AVInputStream **ist_table,
1376
                                    enum CodecType type,
1377
                                    int programid)
1378
{
1379
    int p, q, z;
1380
    for(z=0; z<nb_input_files; z++) {
1381
        AVFormatContext *ic = input_files[z];
1382
        for(p=0; p<ic->nb_programs; p++) {
1383
            AVProgram *program = ic->programs[p];
1384
            if(program->id != programid)
1385
                continue;
1386
            for(q=0; q<program->nb_stream_indexes; q++) {
1387
                int sidx = program->stream_index[q];
1388
                int ris = file_table[z].ist_index + sidx;
1389
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1390
                    return ris;
1391
            }
1392
        }
1393
    }
1394

    
1395
    return -1;
1396
}
1397

    
1398
/*
1399
 * The following code is the main loop of the file converter
1400
 */
1401
static int av_encode(AVFormatContext **output_files,
1402
                     int nb_output_files,
1403
                     AVFormatContext **input_files,
1404
                     int nb_input_files,
1405
                     AVStreamMap *stream_maps, int nb_stream_maps)
1406
{
1407
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1408
    AVFormatContext *is, *os;
1409
    AVCodecContext *codec, *icodec;
1410
    AVOutputStream *ost, **ost_table = NULL;
1411
    AVInputStream *ist, **ist_table = NULL;
1412
    AVInputFile *file_table;
1413
    int key;
1414
    int want_sdp = 1;
1415

    
1416
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1417
    if (!file_table)
1418
        goto fail;
1419

    
1420
    /* input stream init */
1421
    j = 0;
1422
    for(i=0;i<nb_input_files;i++) {
1423
        is = input_files[i];
1424
        file_table[i].ist_index = j;
1425
        file_table[i].nb_streams = is->nb_streams;
1426
        j += is->nb_streams;
1427
    }
1428
    nb_istreams = j;
1429

    
1430
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1431
    if (!ist_table)
1432
        goto fail;
1433

    
1434
    for(i=0;i<nb_istreams;i++) {
1435
        ist = av_mallocz(sizeof(AVInputStream));
1436
        if (!ist)
1437
            goto fail;
1438
        ist_table[i] = ist;
1439
    }
1440
    j = 0;
1441
    for(i=0;i<nb_input_files;i++) {
1442
        is = input_files[i];
1443
        for(k=0;k<is->nb_streams;k++) {
1444
            ist = ist_table[j++];
1445
            ist->st = is->streams[k];
1446
            ist->file_index = i;
1447
            ist->index = k;
1448
            ist->discard = 1; /* the stream is discarded by default
1449
                                 (changed later) */
1450

    
1451
            if (ist->st->codec->rate_emu) {
1452
                ist->start = av_gettime();
1453
                ist->frame = 0;
1454
            }
1455
        }
1456
    }
1457

    
1458
    /* output stream init */
1459
    nb_ostreams = 0;
1460
    for(i=0;i<nb_output_files;i++) {
1461
        os = output_files[i];
1462
        if (!os->nb_streams) {
1463
            fprintf(stderr, "Output file does not contain any stream\n");
1464
            exit(1);
1465
        }
1466
        nb_ostreams += os->nb_streams;
1467
    }
1468
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1469
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1470
        exit(1);
1471
    }
1472

    
1473
    /* Sanity check the mapping args -- do the input files & streams exist? */
1474
    for(i=0;i<nb_stream_maps;i++) {
1475
        int fi = stream_maps[i].file_index;
1476
        int si = stream_maps[i].stream_index;
1477

    
1478
        if (fi < 0 || fi > nb_input_files - 1 ||
1479
            si < 0 || si > file_table[fi].nb_streams - 1) {
1480
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1481
            exit(1);
1482
        }
1483
        fi = stream_maps[i].sync_file_index;
1484
        si = stream_maps[i].sync_stream_index;
1485
        if (fi < 0 || fi > nb_input_files - 1 ||
1486
            si < 0 || si > file_table[fi].nb_streams - 1) {
1487
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1488
            exit(1);
1489
        }
1490
    }
1491

    
1492
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1493
    if (!ost_table)
1494
        goto fail;
1495
    for(i=0;i<nb_ostreams;i++) {
1496
        ost = av_mallocz(sizeof(AVOutputStream));
1497
        if (!ost)
1498
            goto fail;
1499
        ost_table[i] = ost;
1500
    }
1501

    
1502
    n = 0;
1503
    for(k=0;k<nb_output_files;k++) {
1504
        os = output_files[k];
1505
        for(i=0;i<os->nb_streams;i++) {
1506
            int found;
1507
            ost = ost_table[n++];
1508
            ost->file_index = k;
1509
            ost->index = i;
1510
            ost->st = os->streams[i];
1511
            if (nb_stream_maps > 0) {
1512
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1513
                    stream_maps[n-1].stream_index;
1514

    
1515
                /* Sanity check that the stream types match */
1516
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1517
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1518
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1519
                        ost->file_index, ost->index);
1520
                    exit(1);
1521
                }
1522

    
1523
            } else {
1524
                if(opt_programid) {
1525
                    found = 0;
1526
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1527
                    if(j != -1) {
1528
                        ost->source_index = j;
1529
                        found = 1;
1530
                    }
1531
                } else {
1532
                    /* get corresponding input stream index : we select the first one with the right type */
1533
                    found = 0;
1534
                    for(j=0;j<nb_istreams;j++) {
1535
                        ist = ist_table[j];
1536
                        if (ist->discard &&
1537
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1538
                            ost->source_index = j;
1539
                            found = 1;
1540
                            break;
1541
                        }
1542
                    }
1543
                }
1544

    
1545
                if (!found) {
1546
                    if(! opt_programid) {
1547
                        /* try again and reuse existing stream */
1548
                        for(j=0;j<nb_istreams;j++) {
1549
                            ist = ist_table[j];
1550
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1551
                                ost->source_index = j;
1552
                                found = 1;
1553
                            }
1554
                        }
1555
                    }
1556
                    if (!found) {
1557
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1558
                                ost->file_index, ost->index);
1559
                        exit(1);
1560
                    }
1561
                }
1562
            }
1563
            ist = ist_table[ost->source_index];
1564
            ist->discard = 0;
1565
            ost->sync_ist = (nb_stream_maps > 0) ?
1566
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1567
                         stream_maps[n-1].sync_stream_index] : ist;
1568
        }
1569
    }
1570

    
1571
    /* for each output stream, we compute the right encoding parameters */
1572
    for(i=0;i<nb_ostreams;i++) {
1573
        ost = ost_table[i];
1574
        os = output_files[ost->file_index];
1575
        ist = ist_table[ost->source_index];
1576

    
1577
        codec = ost->st->codec;
1578
        icodec = ist->st->codec;
1579

    
1580
        if (!ost->st->language[0])
1581
            av_strlcpy(ost->st->language, ist->st->language,
1582
                       sizeof(ost->st->language));
1583

    
1584
        if (ost->st->stream_copy) {
1585
            /* if stream_copy is selected, no need to decode or encode */
1586
            codec->codec_id = icodec->codec_id;
1587
            codec->codec_type = icodec->codec_type;
1588

    
1589
            if(!codec->codec_tag){
1590
                if(   !os->oformat->codec_tag
1591
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1592
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1593
                    codec->codec_tag = icodec->codec_tag;
1594
            }
1595

    
1596
            codec->bit_rate = icodec->bit_rate;
1597
            codec->extradata= icodec->extradata;
1598
            codec->extradata_size= icodec->extradata_size;
1599
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1600
                codec->time_base = icodec->time_base;
1601
            else
1602
                codec->time_base = ist->st->time_base;
1603
            switch(codec->codec_type) {
1604
            case CODEC_TYPE_AUDIO:
1605
                codec->sample_rate = icodec->sample_rate;
1606
                codec->channels = icodec->channels;
1607
                codec->frame_size = icodec->frame_size;
1608
                codec->block_align= icodec->block_align;
1609
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1610
                    codec->block_align= 0;
1611
                break;
1612
            case CODEC_TYPE_VIDEO:
1613
                if(using_vhook) {
1614
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1615
                    exit(1);
1616
                }
1617
                codec->pix_fmt = icodec->pix_fmt;
1618
                codec->width = icodec->width;
1619
                codec->height = icodec->height;
1620
                codec->has_b_frames = icodec->has_b_frames;
1621
                break;
1622
            case CODEC_TYPE_SUBTITLE:
1623
                break;
1624
            default:
1625
                abort();
1626
            }
1627
        } else {
1628
            switch(codec->codec_type) {
1629
            case CODEC_TYPE_AUDIO:
1630
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1631
                    goto fail;
1632
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1633
                icodec->request_channels = codec->channels;
1634
                ist->decoding_needed = 1;
1635
                ost->encoding_needed = 1;
1636
                break;
1637
            case CODEC_TYPE_VIDEO:
1638
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1639
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1640
                ost->video_resample = ((codec->width != icodec->width -
1641
                                (frame_leftBand + frame_rightBand) +
1642
                                (frame_padleft + frame_padright)) ||
1643
                        (codec->height != icodec->height -
1644
                                (frame_topBand  + frame_bottomBand) +
1645
                                (frame_padtop + frame_padbottom)) ||
1646
                        (codec->pix_fmt != icodec->pix_fmt));
1647
                if (ost->video_crop) {
1648
                    ost->topBand = frame_topBand;
1649
                    ost->leftBand = frame_leftBand;
1650
                }
1651
                if (ost->video_pad) {
1652
                    ost->padtop = frame_padtop;
1653
                    ost->padleft = frame_padleft;
1654
                    ost->padbottom = frame_padbottom;
1655
                    ost->padright = frame_padright;
1656
                    if (!ost->video_resample) {
1657
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1658
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1659
                                         codec->width, codec->height ) )
1660
                            goto fail;
1661
                    }
1662
                }
1663
                if (ost->video_resample) {
1664
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1665
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1666
                                         codec->width, codec->height ) ) {
1667
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1668
                        exit(1);
1669
                    }
1670
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1671
                    ost->img_resample_ctx = sws_getContext(
1672
                            icodec->width - (frame_leftBand + frame_rightBand),
1673
                            icodec->height - (frame_topBand + frame_bottomBand),
1674
                            icodec->pix_fmt,
1675
                            codec->width - (frame_padleft + frame_padright),
1676
                            codec->height - (frame_padtop + frame_padbottom),
1677
                            codec->pix_fmt,
1678
                            sws_flags, NULL, NULL, NULL);
1679
                    if (ost->img_resample_ctx == NULL) {
1680
                        fprintf(stderr, "Cannot get resampling context\n");
1681
                        exit(1);
1682
                    }
1683
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1684
                }
1685
                ost->encoding_needed = 1;
1686
                ist->decoding_needed = 1;
1687
                break;
1688
            case CODEC_TYPE_SUBTITLE:
1689
                ost->encoding_needed = 1;
1690
                ist->decoding_needed = 1;
1691
                break;
1692
            default:
1693
                abort();
1694
                break;
1695
            }
1696
            /* two pass mode */
1697
            if (ost->encoding_needed &&
1698
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1699
                char logfilename[1024];
1700
                FILE *f;
1701
                int size;
1702
                char *logbuffer;
1703

    
1704
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1705
                         pass_logfilename ?
1706
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1707
                if (codec->flags & CODEC_FLAG_PASS1) {
1708
                    f = fopen(logfilename, "w");
1709
                    if (!f) {
1710
                        perror(logfilename);
1711
                        exit(1);
1712
                    }
1713
                    ost->logfile = f;
1714
                } else {
1715
                    /* read the log file */
1716
                    f = fopen(logfilename, "r");
1717
                    if (!f) {
1718
                        perror(logfilename);
1719
                        exit(1);
1720
                    }
1721
                    fseek(f, 0, SEEK_END);
1722
                    size = ftell(f);
1723
                    fseek(f, 0, SEEK_SET);
1724
                    logbuffer = av_malloc(size + 1);
1725
                    if (!logbuffer) {
1726
                        fprintf(stderr, "Could not allocate log buffer\n");
1727
                        exit(1);
1728
                    }
1729
                    size = fread(logbuffer, 1, size, f);
1730
                    fclose(f);
1731
                    logbuffer[size] = '\0';
1732
                    codec->stats_in = logbuffer;
1733
                }
1734
            }
1735
        }
1736
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1737
            int size= codec->width * codec->height;
1738
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1739
        }
1740
    }
1741

    
1742
    if (!bit_buffer)
1743
        bit_buffer = av_malloc(bit_buffer_size);
1744
    if (!bit_buffer)
1745
        goto fail;
1746

    
1747
    /* dump the file output parameters - cannot be done before in case
1748
       of stream copy */
1749
    for(i=0;i<nb_output_files;i++) {
1750
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1751
    }
1752

    
1753
    /* dump the stream mapping */
1754
    if (verbose >= 0) {
1755
        fprintf(stderr, "Stream mapping:\n");
1756
        for(i=0;i<nb_ostreams;i++) {
1757
            ost = ost_table[i];
1758
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1759
                    ist_table[ost->source_index]->file_index,
1760
                    ist_table[ost->source_index]->index,
1761
                    ost->file_index,
1762
                    ost->index);
1763
            if (ost->sync_ist != ist_table[ost->source_index])
1764
                fprintf(stderr, " [sync #%d.%d]",
1765
                        ost->sync_ist->file_index,
1766
                        ost->sync_ist->index);
1767
            fprintf(stderr, "\n");
1768
        }
1769
    }
1770

    
1771
    /* open each encoder */
1772
    for(i=0;i<nb_ostreams;i++) {
1773
        ost = ost_table[i];
1774
        if (ost->encoding_needed) {
1775
            AVCodec *codec;
1776
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1777
            if (!codec) {
1778
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1779
                        ost->file_index, ost->index);
1780
                exit(1);
1781
            }
1782
            if (avcodec_open(ost->st->codec, codec) < 0) {
1783
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1784
                        ost->file_index, ost->index);
1785
                exit(1);
1786
            }
1787
            extra_size += ost->st->codec->extradata_size;
1788
        }
1789
    }
1790

    
1791
    /* open each decoder */
1792
    for(i=0;i<nb_istreams;i++) {
1793
        ist = ist_table[i];
1794
        if (ist->decoding_needed) {
1795
            AVCodec *codec;
1796
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1797
            if (!codec) {
1798
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1799
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1800
                exit(1);
1801
            }
1802
            if (avcodec_open(ist->st->codec, codec) < 0) {
1803
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1804
                        ist->file_index, ist->index);
1805
                exit(1);
1806
            }
1807
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1808
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1809
        }
1810
    }
1811

    
1812
    /* init pts */
1813
    for(i=0;i<nb_istreams;i++) {
1814
        ist = ist_table[i];
1815
        is = input_files[ist->file_index];
1816
        ist->pts = 0;
1817
        ist->next_pts=0;
1818
        if(   input_files_ts_offset[ist->file_index] != -is->start_time
1819
           && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1820
            ist->next_pts= AV_NOPTS_VALUE;
1821
        ist->is_start = 1;
1822
    }
1823

    
1824
    /* set meta data information from input file if required */
1825
    for (i=0;i<nb_meta_data_maps;i++) {
1826
        AVFormatContext *out_file;
1827
        AVFormatContext *in_file;
1828

    
1829
        int out_file_index = meta_data_maps[i].out_file;
1830
        int in_file_index = meta_data_maps[i].in_file;
1831
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1832
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1833
            ret = AVERROR(EINVAL);
1834
            goto fail;
1835
        }
1836
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1837
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1838
            ret = AVERROR(EINVAL);
1839
            goto fail;
1840
        }
1841

    
1842
        out_file = output_files[out_file_index];
1843
        in_file = input_files[in_file_index];
1844

    
1845
        strcpy(out_file->title, in_file->title);
1846
        strcpy(out_file->author, in_file->author);
1847
        strcpy(out_file->copyright, in_file->copyright);
1848
        strcpy(out_file->comment, in_file->comment);
1849
        strcpy(out_file->album, in_file->album);
1850
        out_file->year = in_file->year;
1851
        out_file->track = in_file->track;
1852
        strcpy(out_file->genre, in_file->genre);
1853
    }
1854

    
1855
    /* open files and write file headers */
1856
    for(i=0;i<nb_output_files;i++) {
1857
        os = output_files[i];
1858
        if (av_write_header(os) < 0) {
1859
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1860
            ret = AVERROR(EINVAL);
1861
            goto fail;
1862
        }
1863
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1864
            want_sdp = 0;
1865
        }
1866
    }
1867
    if (want_sdp) {
1868
        print_sdp(output_files, nb_output_files);
1869
    }
1870

    
1871
    if ( !using_stdin && verbose >= 0) {
1872
        fprintf(stderr, "Press [q] to stop encoding\n");
1873
        url_set_interrupt_cb(decode_interrupt_cb);
1874
    }
1875
    term_init();
1876

    
1877
    key = -1;
1878
    timer_start = av_gettime();
1879

    
1880
    for(; received_sigterm == 0;) {
1881
        int file_index, ist_index;
1882
        AVPacket pkt;
1883
        double ipts_min;
1884
        double opts_min;
1885

    
1886
    redo:
1887
        ipts_min= 1e100;
1888
        opts_min= 1e100;
1889
        /* if 'q' pressed, exits */
1890
        if (!using_stdin) {
1891
            if (q_pressed)
1892
                break;
1893
            /* read_key() returns 0 on EOF */
1894
            key = read_key();
1895
            if (key == 'q')
1896
                break;
1897
        }
1898

    
1899
        /* select the stream that we must read now by looking at the
1900
           smallest output pts */
1901
        file_index = -1;
1902
        for(i=0;i<nb_ostreams;i++) {
1903
            double ipts, opts;
1904
            ost = ost_table[i];
1905
            os = output_files[ost->file_index];
1906
            ist = ist_table[ost->source_index];
1907
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1908
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1909
            else
1910
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1911
            ipts = (double)ist->pts;
1912
            if (!file_table[ist->file_index].eof_reached){
1913
                if(ipts < ipts_min) {
1914
                    ipts_min = ipts;
1915
                    if(input_sync ) file_index = ist->file_index;
1916
                }
1917
                if(opts < opts_min) {
1918
                    opts_min = opts;
1919
                    if(!input_sync) file_index = ist->file_index;
1920
                }
1921
            }
1922
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1923
                file_index= -1;
1924
                break;
1925
            }
1926
        }
1927
        /* if none, if is finished */
1928
        if (file_index < 0) {
1929
            break;
1930
        }
1931

    
1932
        /* finish if recording time exhausted */
1933
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1934
            break;
1935

    
1936
        /* finish if limit size exhausted */
1937
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1938
            break;
1939

    
1940
        /* read a frame from it and output it in the fifo */
1941
        is = input_files[file_index];
1942
        if (av_read_frame(is, &pkt) < 0) {
1943
            file_table[file_index].eof_reached = 1;
1944
            if (opt_shortest)
1945
                break;
1946
            else
1947
                continue;
1948
        }
1949

    
1950
        if (do_pkt_dump) {
1951
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1952
        }
1953
        /* the following test is needed in case new streams appear
1954
           dynamically in stream : we ignore them */
1955
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1956
            goto discard_packet;
1957
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1958
        ist = ist_table[ist_index];
1959
        if (ist->discard)
1960
            goto discard_packet;
1961

    
1962
        if (pkt.dts != AV_NOPTS_VALUE)
1963
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1964
        if (pkt.pts != AV_NOPTS_VALUE)
1965
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1966

    
1967
//        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);
1968
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1969
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1970
            int64_t delta= pkt_dts - ist->next_pts;
1971
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1972
                input_files_ts_offset[ist->file_index]-= delta;
1973
                if (verbose > 2)
1974
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1975
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1976
                if(pkt.pts != AV_NOPTS_VALUE)
1977
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1978
            }
1979
        }
1980

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

    
1984
            if (verbose >= 0)
1985
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1986
                        ist->file_index, ist->index);
1987

    
1988
            av_free_packet(&pkt);
1989
            goto redo;
1990
        }
1991

    
1992
    discard_packet:
1993
        av_free_packet(&pkt);
1994

    
1995
        /* dump report by using the output first video and audio streams */
1996
        print_report(output_files, ost_table, nb_ostreams, 0);
1997
    }
1998

    
1999
    /* at the end of stream, we must flush the decoder buffers */
2000
    for(i=0;i<nb_istreams;i++) {
2001
        ist = ist_table[i];
2002
        if (ist->decoding_needed) {
2003
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2004
        }
2005
    }
2006

    
2007
    term_exit();
2008

    
2009
    /* write the trailer if needed and close file */
2010
    for(i=0;i<nb_output_files;i++) {
2011
        os = output_files[i];
2012
        av_write_trailer(os);
2013
    }
2014

    
2015
    /* dump report by using the first video and audio streams */
2016
    print_report(output_files, ost_table, nb_ostreams, 1);
2017

    
2018
    /* close each encoder */
2019
    for(i=0;i<nb_ostreams;i++) {
2020
        ost = ost_table[i];
2021
        if (ost->encoding_needed) {
2022
            av_freep(&ost->st->codec->stats_in);
2023
            avcodec_close(ost->st->codec);
2024
        }
2025
    }
2026

    
2027
    /* close each decoder */
2028
    for(i=0;i<nb_istreams;i++) {
2029
        ist = ist_table[i];
2030
        if (ist->decoding_needed) {
2031
            avcodec_close(ist->st->codec);
2032
        }
2033
    }
2034

    
2035
    /* finished ! */
2036

    
2037
    ret = 0;
2038
 fail1:
2039
    av_freep(&bit_buffer);
2040
    av_free(file_table);
2041

    
2042
    if (ist_table) {
2043
        for(i=0;i<nb_istreams;i++) {
2044
            ist = ist_table[i];
2045
            av_free(ist);
2046
        }
2047
        av_free(ist_table);
2048
    }
2049
    if (ost_table) {
2050
        for(i=0;i<nb_ostreams;i++) {
2051
            ost = ost_table[i];
2052
            if (ost) {
2053
                if (ost->logfile) {
2054
                    fclose(ost->logfile);
2055
                    ost->logfile = NULL;
2056
                }
2057
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2058
                                             initialized but set to zero */
2059
                av_free(ost->pict_tmp.data[0]);
2060
                if (ost->video_resample)
2061
                    sws_freeContext(ost->img_resample_ctx);
2062
                if (ost->audio_resample)
2063
                    audio_resample_close(ost->resample);
2064
                av_free(ost);
2065
            }
2066
        }
2067
        av_free(ost_table);
2068
    }
2069
    return ret;
2070
 fail:
2071
    ret = AVERROR(ENOMEM);
2072
    goto fail1;
2073
}
2074

    
2075
#if 0
2076
int file_read(const char *filename)
2077
{
2078
    URLContext *h;
2079
    unsigned char buffer[1024];
2080
    int len, i;
2081

2082
    if (url_open(&h, filename, O_RDONLY) < 0) {
2083
        printf("could not open '%s'\n", filename);
2084
        return -1;
2085
    }
2086
    for(;;) {
2087
        len = url_read(h, buffer, sizeof(buffer));
2088
        if (len <= 0)
2089
            break;
2090
        for(i=0;i<len;i++) putchar(buffer[i]);
2091
    }
2092
    url_close(h);
2093
    return 0;
2094
}
2095
#endif
2096

    
2097
static void opt_format(const char *arg)
2098
{
2099
    /* compatibility stuff for pgmyuv */
2100
    if (!strcmp(arg, "pgmyuv")) {
2101
        pgmyuv_compatibility_hack=1;
2102
//        opt_image_format(arg);
2103
        arg = "image2";
2104
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2105
    }
2106

    
2107
    file_iformat = av_find_input_format(arg);
2108
    file_oformat = guess_format(arg, NULL, NULL);
2109
    if (!file_iformat && !file_oformat) {
2110
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2111
        exit(1);
2112
    }
2113
}
2114

    
2115
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2116
extern int ffm_nopts;
2117
#endif
2118

    
2119
static int opt_default(const char *opt, const char *arg){
2120
    int type;
2121
    const AVOption *o= NULL;
2122
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2123

    
2124
    for(type=0; type<CODEC_TYPE_NB; type++){
2125
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2126
        if(o2)
2127
            o = av_set_string(avctx_opts[type], opt, arg);
2128
    }
2129
    if(!o)
2130
        o = av_set_string(avformat_opts, opt, arg);
2131
    if(!o)
2132
        o = av_set_string(sws_opts, opt, arg);
2133
    if(!o){
2134
        if(opt[0] == 'a')
2135
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2136
        else if(opt[0] == 'v')
2137
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2138
        else if(opt[0] == 's')
2139
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2140
    }
2141
    if(!o)
2142
        return -1;
2143

    
2144
//    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));
2145

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

    
2150
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2151
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
2152
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2153
        ffm_nopts = 1;
2154
#endif
2155

    
2156
    if(avctx_opts[0]->debug)
2157
        av_log_set_level(AV_LOG_DEBUG);
2158
    return 0;
2159
}
2160

    
2161
static void opt_video_rc_override_string(char *arg)
2162
{
2163
    video_rc_override_string = arg;
2164
}
2165

    
2166
static void opt_me_threshold(const char *arg)
2167
{
2168
    me_threshold = atoi(arg);
2169
}
2170

    
2171
static void opt_verbose(const char *arg)
2172
{
2173
    verbose = atoi(arg);
2174
    av_log_set_level(atoi(arg));
2175
}
2176

    
2177
static void opt_frame_rate(const char *arg)
2178
{
2179
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2180
        fprintf(stderr, "Incorrect frame rate\n");
2181
        exit(1);
2182
    }
2183
}
2184

    
2185
static void opt_bitrate(const char *opt, const char *arg)
2186
{
2187
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2188

    
2189
    opt_default(opt, arg);
2190

    
2191
    if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2192
        fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2193
}
2194

    
2195
static void opt_frame_crop_top(const char *arg)
2196
{
2197
    frame_topBand = atoi(arg);
2198
    if (frame_topBand < 0) {
2199
        fprintf(stderr, "Incorrect top crop size\n");
2200
        exit(1);
2201
    }
2202
    if ((frame_topBand % 2) != 0) {
2203
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2204
        exit(1);
2205
    }
2206
    if ((frame_topBand) >= frame_height){
2207
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2208
        exit(1);
2209
    }
2210
    frame_height -= frame_topBand;
2211
}
2212

    
2213
static void opt_frame_crop_bottom(const char *arg)
2214
{
2215
    frame_bottomBand = atoi(arg);
2216
    if (frame_bottomBand < 0) {
2217
        fprintf(stderr, "Incorrect bottom crop size\n");
2218
        exit(1);
2219
    }
2220
    if ((frame_bottomBand % 2) != 0) {
2221
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2222
        exit(1);
2223
    }
2224
    if ((frame_bottomBand) >= frame_height){
2225
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2226
        exit(1);
2227
    }
2228
    frame_height -= frame_bottomBand;
2229
}
2230

    
2231
static void opt_frame_crop_left(const char *arg)
2232
{
2233
    frame_leftBand = atoi(arg);
2234
    if (frame_leftBand < 0) {
2235
        fprintf(stderr, "Incorrect left crop size\n");
2236
        exit(1);
2237
    }
2238
    if ((frame_leftBand % 2) != 0) {
2239
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2240
        exit(1);
2241
    }
2242
    if ((frame_leftBand) >= frame_width){
2243
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2244
        exit(1);
2245
    }
2246
    frame_width -= frame_leftBand;
2247
}
2248

    
2249
static void opt_frame_crop_right(const char *arg)
2250
{
2251
    frame_rightBand = atoi(arg);
2252
    if (frame_rightBand < 0) {
2253
        fprintf(stderr, "Incorrect right crop size\n");
2254
        exit(1);
2255
    }
2256
    if ((frame_rightBand % 2) != 0) {
2257
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2258
        exit(1);
2259
    }
2260
    if ((frame_rightBand) >= frame_width){
2261
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2262
        exit(1);
2263
    }
2264
    frame_width -= frame_rightBand;
2265
}
2266

    
2267
static void opt_frame_size(const char *arg)
2268
{
2269
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2270
        fprintf(stderr, "Incorrect frame size\n");
2271
        exit(1);
2272
    }
2273
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2274
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2275
        exit(1);
2276
    }
2277
}
2278

    
2279

    
2280
#define SCALEBITS 10
2281
#define ONE_HALF  (1 << (SCALEBITS - 1))
2282
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2283

    
2284
#define RGB_TO_Y(r, g, b) \
2285
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2286
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2287

    
2288
#define RGB_TO_U(r1, g1, b1, shift)\
2289
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2290
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2291

    
2292
#define RGB_TO_V(r1, g1, b1, shift)\
2293
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2294
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2295

    
2296
static void opt_pad_color(const char *arg) {
2297
    /* Input is expected to be six hex digits similar to
2298
       how colors are expressed in html tags (but without the #) */
2299
    int rgb = strtol(arg, NULL, 16);
2300
    int r,g,b;
2301

    
2302
    r = (rgb >> 16);
2303
    g = ((rgb >> 8) & 255);
2304
    b = (rgb & 255);
2305

    
2306
    padcolor[0] = RGB_TO_Y(r,g,b);
2307
    padcolor[1] = RGB_TO_U(r,g,b,0);
2308
    padcolor[2] = RGB_TO_V(r,g,b,0);
2309
}
2310

    
2311
static void opt_frame_pad_top(const char *arg)
2312
{
2313
    frame_padtop = atoi(arg);
2314
    if (frame_padtop < 0) {
2315
        fprintf(stderr, "Incorrect top pad size\n");
2316
        exit(1);
2317
    }
2318
    if ((frame_padtop % 2) != 0) {
2319
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2320
        exit(1);
2321
    }
2322
}
2323

    
2324
static void opt_frame_pad_bottom(const char *arg)
2325
{
2326
    frame_padbottom = atoi(arg);
2327
    if (frame_padbottom < 0) {
2328
        fprintf(stderr, "Incorrect bottom pad size\n");
2329
        exit(1);
2330
    }
2331
    if ((frame_padbottom % 2) != 0) {
2332
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2333
        exit(1);
2334
    }
2335
}
2336

    
2337

    
2338
static void opt_frame_pad_left(const char *arg)
2339
{
2340
    frame_padleft = atoi(arg);
2341
    if (frame_padleft < 0) {
2342
        fprintf(stderr, "Incorrect left pad size\n");
2343
        exit(1);
2344
    }
2345
    if ((frame_padleft % 2) != 0) {
2346
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2347
        exit(1);
2348
    }
2349
}
2350

    
2351

    
2352
static void opt_frame_pad_right(const char *arg)
2353
{
2354
    frame_padright = atoi(arg);
2355
    if (frame_padright < 0) {
2356
        fprintf(stderr, "Incorrect right pad size\n");
2357
        exit(1);
2358
    }
2359
    if ((frame_padright % 2) != 0) {
2360
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2361
        exit(1);
2362
    }
2363
}
2364

    
2365
void list_pix_fmts(void)
2366
{
2367
    int i;
2368
    char pix_fmt_str[128];
2369
    for (i=-1; i < PIX_FMT_NB; i++) {
2370
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2371
        fprintf(stdout, "%s\n", pix_fmt_str);
2372
    }
2373
}
2374

    
2375
static void opt_frame_pix_fmt(const char *arg)
2376
{
2377
    if (strcmp(arg, "list"))
2378
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2379
    else {
2380
        list_pix_fmts();
2381
        exit(0);
2382
    }
2383
}
2384

    
2385
static void opt_frame_aspect_ratio(const char *arg)
2386
{
2387
    int x = 0, y = 0;
2388
    double ar = 0;
2389
    const char *p;
2390

    
2391
    p = strchr(arg, ':');
2392
    if (p) {
2393
        x = strtol(arg, (char **)&arg, 10);
2394
        if (arg == p)
2395
            y = strtol(arg+1, (char **)&arg, 10);
2396
        if (x > 0 && y > 0)
2397
            ar = (double)x / (double)y;
2398
    } else
2399
        ar = strtod(arg, (char **)&arg);
2400

    
2401
    if (!ar) {
2402
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2403
        exit(1);
2404
    }
2405
    frame_aspect_ratio = ar;
2406
}
2407

    
2408
static void opt_qscale(const char *arg)
2409
{
2410
    video_qscale = atof(arg);
2411
    if (video_qscale <= 0 ||
2412
        video_qscale > 255) {
2413
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2414
        exit(1);
2415
    }
2416
}
2417

    
2418
static void opt_qdiff(const char *arg)
2419
{
2420
    video_qdiff = atoi(arg);
2421
    if (video_qdiff < 0 ||
2422
        video_qdiff > 31) {
2423
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2424
        exit(1);
2425
    }
2426
}
2427

    
2428
static void opt_strict(const char *arg)
2429
{
2430
    strict= atoi(arg);
2431
}
2432

    
2433
static void opt_top_field_first(const char *arg)
2434
{
2435
    top_field_first= atoi(arg);
2436
}
2437

    
2438
static void opt_thread_count(const char *arg)
2439
{
2440
    thread_count= atoi(arg);
2441
#if !defined(HAVE_THREADS)
2442
    if (verbose >= 0)
2443
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2444
#endif
2445
}
2446

    
2447
static void opt_audio_rate(const char *arg)
2448
{
2449
    audio_sample_rate = atoi(arg);
2450
}
2451

    
2452
static void opt_audio_channels(const char *arg)
2453
{
2454
    audio_channels = atoi(arg);
2455
}
2456

    
2457
static void opt_video_channel(const char *arg)
2458
{
2459
    video_channel = strtol(arg, NULL, 0);
2460
}
2461

    
2462
static void opt_video_standard(const char *arg)
2463
{
2464
    video_standard = av_strdup(arg);
2465
}
2466

    
2467
static void opt_codec(int *pstream_copy, char **pcodec_name,
2468
                      int codec_type, const char *arg)
2469
{
2470
    av_freep(pcodec_name);
2471
    if (!strcmp(arg, "copy")) {
2472
        *pstream_copy = 1;
2473
    } else {
2474
        *pcodec_name = av_strdup(arg);
2475
    }
2476
}
2477

    
2478
static void opt_audio_codec(const char *arg)
2479
{
2480
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2481
}
2482

    
2483
static void opt_audio_tag(const char *arg)
2484
{
2485
    char *tail;
2486
    audio_codec_tag= strtol(arg, &tail, 0);
2487

    
2488
    if(!tail || *tail)
2489
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2490
}
2491

    
2492
static void opt_video_tag(const char *arg)
2493
{
2494
    char *tail;
2495
    video_codec_tag= strtol(arg, &tail, 0);
2496

    
2497
    if(!tail || *tail)
2498
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2499
}
2500

    
2501
#ifdef CONFIG_VHOOK
2502
static void add_frame_hooker(const char *arg)
2503
{
2504
    int argc = 0;
2505
    char *argv[64];
2506
    int i;
2507
    char *args = av_strdup(arg);
2508

    
2509
    using_vhook = 1;
2510

    
2511
    argv[0] = strtok(args, " ");
2512
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2513
    }
2514

    
2515
    i = frame_hook_add(argc, argv);
2516

    
2517
    if (i != 0) {
2518
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2519
        exit(1);
2520
    }
2521
}
2522
#endif
2523

    
2524
static void opt_video_codec(const char *arg)
2525
{
2526
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2527
}
2528

    
2529
static void opt_subtitle_codec(const char *arg)
2530
{
2531
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2532
}
2533

    
2534
static void opt_map(const char *arg)
2535
{
2536
    AVStreamMap *m;
2537
    const char *p;
2538

    
2539
    p = arg;
2540
    m = &stream_maps[nb_stream_maps++];
2541

    
2542
    m->file_index = strtol(arg, (char **)&p, 0);
2543
    if (*p)
2544
        p++;
2545

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

    
2559
static void opt_map_meta_data(const char *arg)
2560
{
2561
    AVMetaDataMap *m;
2562
    const char *p;
2563

    
2564
    p = arg;
2565
    m = &meta_data_maps[nb_meta_data_maps++];
2566

    
2567
    m->out_file = strtol(arg, (char **)&p, 0);
2568
    if (*p)
2569
        p++;
2570

    
2571
    m->in_file = strtol(p, (char **)&p, 0);
2572
}
2573

    
2574
static int64_t parse_time_or_die(const char *timestr, int is_duration)
2575
{
2576
    int64_t us = parse_date(timestr, is_duration);
2577
    if (us == INT64_MIN) {
2578
        fprintf(stderr, "Invalid %s specification: %s\n",
2579
                is_duration ? "duration" : "date", timestr);
2580
        exit(1);
2581
    }
2582
    return us;
2583
}
2584

    
2585
static void opt_recording_time(const char *arg)
2586
{
2587
    recording_time = parse_time_or_die(arg, 1);
2588
}
2589

    
2590
static void opt_start_time(const char *arg)
2591
{
2592
    start_time = parse_time_or_die(arg, 1);
2593
}
2594

    
2595
static void opt_rec_timestamp(const char *arg)
2596
{
2597
    rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2598
}
2599

    
2600
static void opt_input_ts_offset(const char *arg)
2601
{
2602
    input_ts_offset = parse_time_or_die(arg, 1);
2603
}
2604

    
2605
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2606
{
2607
    char *codec_string = encoder ? "encoder" : "decoder";
2608
    AVCodec *codec;
2609

    
2610
    if(!name)
2611
        return CODEC_ID_NONE;
2612
    codec = encoder ?
2613
        avcodec_find_encoder_by_name(name) :
2614
        avcodec_find_decoder_by_name(name);
2615
    if(!codec) {
2616
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2617
        exit(1);
2618
    }
2619
    if(codec->type != type) {
2620
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2621
        exit(1);
2622
    }
2623
    return codec->id;
2624
}
2625

    
2626
static void opt_input_file(const char *filename)
2627
{
2628
    AVFormatContext *ic;
2629
    AVFormatParameters params, *ap = &params;
2630
    int err, i, ret, rfps, rfps_base;
2631
    int64_t timestamp;
2632

    
2633
    if (!strcmp(filename, "-"))
2634
        filename = "pipe:";
2635

    
2636
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2637
                   !strcmp( filename, "/dev/stdin" );
2638

    
2639
    /* get default parameters from command line */
2640
    ic = av_alloc_format_context();
2641

    
2642
    memset(ap, 0, sizeof(*ap));
2643
    ap->prealloced_context = 1;
2644
    ap->sample_rate = audio_sample_rate;
2645
    ap->channels = audio_channels;
2646
    ap->time_base.den = frame_rate.num;
2647
    ap->time_base.num = frame_rate.den;
2648
    ap->width = frame_width + frame_padleft + frame_padright;
2649
    ap->height = frame_height + frame_padtop + frame_padbottom;
2650
    ap->pix_fmt = frame_pix_fmt;
2651
    ap->channel = video_channel;
2652
    ap->standard = video_standard;
2653
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2654
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2655
    if(pgmyuv_compatibility_hack)
2656
        ap->video_codec_id= CODEC_ID_PGMYUV;
2657

    
2658
    for(i=0; i<opt_name_count; i++){
2659
        char buf[256];
2660
        const AVOption *opt;
2661
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2662
        if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2663
            av_set_string(ic, opt_names[i], str);
2664
    }
2665
    /* open the input file with generic libav function */
2666
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2667
    if (err < 0) {
2668
        print_error(filename, err);
2669
        exit(1);
2670
    }
2671
    if(opt_programid) {
2672
        int i;
2673
        for(i=0; i<ic->nb_programs; i++)
2674
            if(ic->programs[i]->id != opt_programid)
2675
                ic->programs[i]->discard = AVDISCARD_ALL;
2676
    }
2677

    
2678
    ic->loop_input = loop_input;
2679

    
2680
    /* If not enough info to get the stream parameters, we decode the
2681
       first frames to get it. (used in mpeg case for example) */
2682
    ret = av_find_stream_info(ic);
2683
    if (ret < 0 && verbose >= 0) {
2684
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2685
        exit(1);
2686
    }
2687

    
2688
    timestamp = start_time;
2689
    /* add the stream start time */
2690
    if (ic->start_time != AV_NOPTS_VALUE)
2691
        timestamp += ic->start_time;
2692

    
2693
    /* if seeking requested, we execute it */
2694
    if (start_time != 0) {
2695
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2696
        if (ret < 0) {
2697
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2698
                    filename, (double)timestamp / AV_TIME_BASE);
2699
        }
2700
        /* reset seek info */
2701
        start_time = 0;
2702
    }
2703

    
2704
    /* update the current parameters so that they match the one of the input stream */
2705
    for(i=0;i<ic->nb_streams;i++) {
2706
        int j;
2707
        AVCodecContext *enc = ic->streams[i]->codec;
2708
        if(thread_count>1)
2709
            avcodec_thread_init(enc, thread_count);
2710
        enc->thread_count= thread_count;
2711
        switch(enc->codec_type) {
2712
        case CODEC_TYPE_AUDIO:
2713
            for(j=0; j<opt_name_count; j++){
2714
                char buf[256];
2715
                const AVOption *opt;
2716
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2717
                if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2718
                    av_set_string(enc, opt_names[j], str);
2719
            }
2720
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2721
            audio_channels = enc->channels;
2722
            audio_sample_rate = enc->sample_rate;
2723
            if(audio_disable)
2724
                ic->streams[i]->discard= AVDISCARD_ALL;
2725
            break;
2726
        case CODEC_TYPE_VIDEO:
2727
            for(j=0; j<opt_name_count; j++){
2728
                char buf[256];
2729
                const AVOption *opt;
2730
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2731
                if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2732
                    av_set_string(enc, opt_names[j], str);
2733
            }
2734
            frame_height = enc->height;
2735
            frame_width = enc->width;
2736
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2737
            frame_pix_fmt = enc->pix_fmt;
2738
            rfps      = ic->streams[i]->r_frame_rate.num;
2739
            rfps_base = ic->streams[i]->r_frame_rate.den;
2740
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2741
            if(me_threshold)
2742
                enc->debug |= FF_DEBUG_MV;
2743

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

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

    
2750
                    (float)rfps / rfps_base, rfps, rfps_base);
2751
            }
2752
            /* update the current frame rate to match the stream frame rate */
2753
            frame_rate.num = rfps;
2754
            frame_rate.den = rfps_base;
2755

    
2756
            enc->rate_emu = rate_emu;
2757
            if(video_disable)
2758
                ic->streams[i]->discard= AVDISCARD_ALL;
2759
            else if(video_discard)
2760
                ic->streams[i]->discard= video_discard;
2761
            break;
2762
        case CODEC_TYPE_DATA:
2763
            break;
2764
        case CODEC_TYPE_SUBTITLE:
2765
            if(subtitle_disable)
2766
                ic->streams[i]->discard = AVDISCARD_ALL;
2767
            break;
2768
        case CODEC_TYPE_UNKNOWN:
2769
            break;
2770
        default:
2771
            abort();
2772
        }
2773
    }
2774

    
2775
    input_files[nb_input_files] = ic;
2776
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2777
    /* dump the file content */
2778
    if (verbose >= 0)
2779
        dump_format(ic, nb_input_files, filename, 0);
2780

    
2781
    nb_input_files++;
2782
    file_iformat = NULL;
2783
    file_oformat = NULL;
2784

    
2785
    video_channel = 0;
2786

    
2787
    rate_emu = 0;
2788
}
2789

    
2790
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2791
                                         int *has_subtitle_ptr)
2792
{
2793
    int has_video, has_audio, has_subtitle, i, j;
2794
    AVFormatContext *ic;
2795

    
2796
    has_video = 0;
2797
    has_audio = 0;
2798
    has_subtitle = 0;
2799
    for(j=0;j<nb_input_files;j++) {
2800
        ic = input_files[j];
2801
        for(i=0;i<ic->nb_streams;i++) {
2802
            AVCodecContext *enc = ic->streams[i]->codec;
2803
            switch(enc->codec_type) {
2804
            case CODEC_TYPE_AUDIO:
2805
                has_audio = 1;
2806
                break;
2807
            case CODEC_TYPE_VIDEO:
2808
                has_video = 1;
2809
                break;
2810
            case CODEC_TYPE_SUBTITLE:
2811
                has_subtitle = 1;
2812
                break;
2813
            case CODEC_TYPE_DATA:
2814
            case CODEC_TYPE_UNKNOWN:
2815
                break;
2816
            default:
2817
                abort();
2818
            }
2819
        }
2820
    }
2821
    *has_video_ptr = has_video;
2822
    *has_audio_ptr = has_audio;
2823
    *has_subtitle_ptr = has_subtitle;
2824
}
2825

    
2826
static void new_video_stream(AVFormatContext *oc)
2827
{
2828
    AVStream *st;
2829
    AVCodecContext *video_enc;
2830
    int codec_id;
2831

    
2832
    st = av_new_stream(oc, oc->nb_streams);
2833
    if (!st) {
2834
        fprintf(stderr, "Could not alloc stream\n");
2835
        exit(1);
2836
    }
2837
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2838
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2839
    video_bitstream_filters= NULL;
2840

    
2841
    if(thread_count>1)
2842
        avcodec_thread_init(st->codec, thread_count);
2843

    
2844
    video_enc = st->codec;
2845

    
2846
    if(video_codec_tag)
2847
        video_enc->codec_tag= video_codec_tag;
2848

    
2849
    if(   (video_global_header&1)
2850
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2851
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2852
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2853
    }
2854
    if(video_global_header&2){
2855
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2856
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2857
    }
2858

    
2859
    if (video_stream_copy) {
2860
        st->stream_copy = 1;
2861
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2862
    } else {
2863
        char *p;
2864
        int i;
2865
        AVCodec *codec;
2866

    
2867
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2868
        if (video_codec_name)
2869
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2870

    
2871
        video_enc->codec_id = codec_id;
2872
        codec = avcodec_find_encoder(codec_id);
2873

    
2874
        for(i=0; i<opt_name_count; i++){
2875
            char buf[256];
2876
            const AVOption *opt;
2877
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2878
            if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2879
                av_set_string(video_enc, opt_names[i], str);
2880
        }
2881

    
2882
        video_enc->time_base.den = frame_rate.num;
2883
        video_enc->time_base.num = frame_rate.den;
2884
        if(codec && codec->supported_framerates){
2885
            const AVRational *p= codec->supported_framerates;
2886
            AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2887
            const AVRational *best=NULL;
2888
            AVRational best_error= (AVRational){INT_MAX, 1};
2889
            for(; p->den!=0; p++){
2890
                AVRational error= av_sub_q(req, *p);
2891
                if(error.num <0) error.num *= -1;
2892
                if(av_cmp_q(error, best_error) < 0){
2893
                    best_error= error;
2894
                    best= p;
2895
                }
2896
            }
2897
            video_enc->time_base.den= best->num;
2898
            video_enc->time_base.num= best->den;
2899
        }
2900

    
2901
        video_enc->width = frame_width + frame_padright + frame_padleft;
2902
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2903
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2904
        video_enc->pix_fmt = frame_pix_fmt;
2905

    
2906
        if(codec && codec->pix_fmts){
2907
            const enum PixelFormat *p= codec->pix_fmts;
2908
            for(; *p!=-1; p++){
2909
                if(*p == video_enc->pix_fmt)
2910
                    break;
2911
            }
2912
            if(*p == -1)
2913
                video_enc->pix_fmt = codec->pix_fmts[0];
2914
        }
2915

    
2916
        if (intra_only)
2917
            video_enc->gop_size = 0;
2918
        if (video_qscale || same_quality) {
2919
            video_enc->flags |= CODEC_FLAG_QSCALE;
2920
            video_enc->global_quality=
2921
                st->quality = FF_QP2LAMBDA * video_qscale;
2922
        }
2923

    
2924
        if(intra_matrix)
2925
            video_enc->intra_matrix = intra_matrix;
2926
        if(inter_matrix)
2927
            video_enc->inter_matrix = inter_matrix;
2928

    
2929
        video_enc->max_qdiff = video_qdiff;
2930
        video_enc->thread_count = thread_count;
2931
        p= video_rc_override_string;
2932
        for(i=0; p; i++){
2933
            int start, end, q;
2934
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2935
            if(e!=3){
2936
                fprintf(stderr, "error parsing rc_override\n");
2937
                exit(1);
2938
            }
2939
            video_enc->rc_override=
2940
                av_realloc(video_enc->rc_override,
2941
                           sizeof(RcOverride)*(i+1));
2942
            video_enc->rc_override[i].start_frame= start;
2943
            video_enc->rc_override[i].end_frame  = end;
2944
            if(q>0){
2945
                video_enc->rc_override[i].qscale= q;
2946
                video_enc->rc_override[i].quality_factor= 1.0;
2947
            }
2948
            else{
2949
                video_enc->rc_override[i].qscale= 0;
2950
                video_enc->rc_override[i].quality_factor= -q/100.0;
2951
            }
2952
            p= strchr(p, '/');
2953
            if(p) p++;
2954
        }
2955
        video_enc->rc_override_count=i;
2956
        if (!video_enc->rc_initial_buffer_occupancy)
2957
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2958
        video_enc->me_threshold= me_threshold;
2959
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2960
        video_enc->strict_std_compliance = strict;
2961

    
2962
        if (do_psnr)
2963
            video_enc->flags|= CODEC_FLAG_PSNR;
2964

    
2965
        /* two pass mode */
2966
        if (do_pass) {
2967
            if (do_pass == 1) {
2968
                video_enc->flags |= CODEC_FLAG_PASS1;
2969
            } else {
2970
                video_enc->flags |= CODEC_FLAG_PASS2;
2971
            }
2972
        }
2973
    }
2974

    
2975
    /* reset some key parameters */
2976
    video_disable = 0;
2977
    av_freep(&video_codec_name);
2978
    video_stream_copy = 0;
2979
}
2980

    
2981
static void new_audio_stream(AVFormatContext *oc)
2982
{
2983
    AVStream *st;
2984
    AVCodecContext *audio_enc;
2985
    int codec_id, i;
2986

    
2987
    st = av_new_stream(oc, oc->nb_streams);
2988
    if (!st) {
2989
        fprintf(stderr, "Could not alloc stream\n");
2990
        exit(1);
2991
    }
2992
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2993

    
2994
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2995
    audio_bitstream_filters= NULL;
2996

    
2997
    if(thread_count>1)
2998
        avcodec_thread_init(st->codec, thread_count);
2999

    
3000
    audio_enc = st->codec;
3001
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3002
    audio_enc->strict_std_compliance = strict;
3003

    
3004
    if(audio_codec_tag)
3005
        audio_enc->codec_tag= audio_codec_tag;
3006

    
3007
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3008
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3009
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3010
    }
3011
    if (audio_stream_copy) {
3012
        st->stream_copy = 1;
3013
        audio_enc->channels = audio_channels;
3014
    } else {
3015
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3016

    
3017
        for(i=0; i<opt_name_count; i++){
3018
            char buf[256];
3019
            const AVOption *opt;
3020
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3021
            if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3022
                av_set_string(audio_enc, opt_names[i], str);
3023
        }
3024

    
3025
        if (audio_codec_name)
3026
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3027
        audio_enc->codec_id = codec_id;
3028

    
3029
        if (audio_qscale > QSCALE_NONE) {
3030
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3031
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3032
        }
3033
        audio_enc->thread_count = thread_count;
3034
        audio_enc->channels = audio_channels;
3035
    }
3036
    audio_enc->sample_rate = audio_sample_rate;
3037
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3038
    if (audio_language) {
3039
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3040
        av_free(audio_language);
3041
        audio_language = NULL;
3042
    }
3043

    
3044
    /* reset some key parameters */
3045
    audio_disable = 0;
3046
    av_freep(&audio_codec_name);
3047
    audio_stream_copy = 0;
3048
}
3049

    
3050
static void new_subtitle_stream(AVFormatContext *oc)
3051
{
3052
    AVStream *st;
3053
    AVCodecContext *subtitle_enc;
3054
    int i;
3055

    
3056
    st = av_new_stream(oc, oc->nb_streams);
3057
    if (!st) {
3058
        fprintf(stderr, "Could not alloc stream\n");
3059
        exit(1);
3060
    }
3061
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3062

    
3063
    subtitle_enc = st->codec;
3064
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3065
    if (subtitle_stream_copy) {
3066
        st->stream_copy = 1;
3067
    } else {
3068
        for(i=0; i<opt_name_count; i++){
3069
            char buf[256];
3070
            const AVOption *opt;
3071
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3072
            if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3073
                av_set_string(subtitle_enc, opt_names[i], str);
3074
        }
3075
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3076
    }
3077

    
3078
    if (subtitle_language) {
3079
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3080
        av_free(subtitle_language);
3081
        subtitle_language = NULL;
3082
    }
3083

    
3084
    subtitle_disable = 0;
3085
    av_freep(&subtitle_codec_name);
3086
    subtitle_stream_copy = 0;
3087
}
3088

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

    
3100
static void opt_new_video_stream(void)
3101
{
3102
    AVFormatContext *oc;
3103
    if (nb_output_files <= 0) {
3104
        fprintf(stderr, "At least one output file must be specified\n");
3105
        exit(1);
3106
    }
3107
    oc = output_files[nb_output_files - 1];
3108
    new_video_stream(oc);
3109
}
3110

    
3111
static void opt_new_subtitle_stream(void)
3112
{
3113
    AVFormatContext *oc;
3114
    if (nb_output_files <= 0) {
3115
        fprintf(stderr, "At least one output file must be specified\n");
3116
        exit(1);
3117
    }
3118
    oc = output_files[nb_output_files - 1];
3119
    new_subtitle_stream(oc);
3120
}
3121

    
3122
static void opt_output_file(const char *filename)
3123
{
3124
    AVFormatContext *oc;
3125
    int use_video, use_audio, use_subtitle;
3126
    int input_has_video, input_has_audio, input_has_subtitle, i;
3127
    AVFormatParameters params, *ap = &params;
3128

    
3129
    if (!strcmp(filename, "-"))
3130
        filename = "pipe:";
3131

    
3132
    oc = av_alloc_format_context();
3133

    
3134
    if (!file_oformat) {
3135
        file_oformat = guess_format(NULL, filename, NULL);
3136
        if (!file_oformat) {
3137
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3138
                    filename);
3139
            exit(1);
3140
        }
3141
    }
3142

    
3143
    oc->oformat = file_oformat;
3144
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3145

    
3146
    if (!strcmp(file_oformat->name, "ffm") &&
3147
        av_strstart(filename, "http:", NULL)) {
3148
        /* special case for files sent to ffserver: we get the stream
3149
           parameters from ffserver */
3150
        if (read_ffserver_streams(oc, filename) < 0) {
3151
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3152
            exit(1);
3153
        }
3154
    } else {
3155
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3156
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3157
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3158

    
3159
        /* disable if no corresponding type found and at least one
3160
           input file */
3161
        if (nb_input_files > 0) {
3162
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3163
                                         &input_has_subtitle);
3164
            if (!input_has_video)
3165
                use_video = 0;
3166
            if (!input_has_audio)
3167
                use_audio = 0;
3168
            if (!input_has_subtitle)
3169
                use_subtitle = 0;
3170
        }
3171

    
3172
        /* manual disable */
3173
        if (audio_disable) {
3174
            use_audio = 0;
3175
        }
3176
        if (video_disable) {
3177
            use_video = 0;
3178
        }
3179
        if (subtitle_disable) {
3180
            use_subtitle = 0;
3181
        }
3182

    
3183
        if (use_video) {
3184
            new_video_stream(oc);
3185
        }
3186

    
3187
        if (use_audio) {
3188
            new_audio_stream(oc);
3189
        }
3190

    
3191
        if (use_subtitle) {
3192
            new_subtitle_stream(oc);
3193
        }
3194

    
3195
        oc->timestamp = rec_timestamp;
3196

    
3197
        if (str_title)
3198
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3199
        if (str_author)
3200
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3201
        if (str_copyright)
3202
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3203
        if (str_comment)
3204
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3205
        if (str_album)
3206
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3207
    }
3208

    
3209
    output_files[nb_output_files++] = oc;
3210

    
3211
    /* check filename in case of an image number is expected */
3212
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3213
        if (!av_filename_number_test(oc->filename)) {
3214
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3215
            exit(1);
3216
        }
3217
    }
3218

    
3219
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3220
        /* test if it already exists to avoid loosing precious files */
3221
        if (!file_overwrite &&
3222
            (strchr(filename, ':') == NULL ||
3223
             av_strstart(filename, "file:", NULL))) {
3224
            if (url_exist(filename)) {
3225
                int c;
3226

    
3227
                if ( !using_stdin ) {
3228
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3229
                    fflush(stderr);
3230
                    c = getchar();
3231
                    if (toupper(c) != 'Y') {
3232
                        fprintf(stderr, "Not overwriting - exiting\n");
3233
                        exit(1);
3234
                    }
3235
                                }
3236
                                else {
3237
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3238
                    exit(1);
3239
                                }
3240
            }
3241
        }
3242

    
3243
        /* open the file */
3244
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3245
            fprintf(stderr, "Could not open '%s'\n", filename);
3246
            exit(1);
3247
        }
3248
    }
3249

    
3250
    memset(ap, 0, sizeof(*ap));
3251
    if (av_set_parameters(oc, ap) < 0) {
3252
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3253
                oc->filename);
3254
        exit(1);
3255
    }
3256

    
3257
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3258
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3259
    oc->loop_output = loop_output;
3260

    
3261
    for(i=0; i<opt_name_count; i++){
3262
        char buf[256];
3263
        const AVOption *opt;
3264
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3265
        if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3266
            av_set_string(oc, opt_names[i], str);
3267
    }
3268

    
3269
    /* reset some options */
3270
    file_oformat = NULL;
3271
    file_iformat = NULL;
3272
}
3273

    
3274
/* same option as mencoder */
3275
static void opt_pass(const char *pass_str)
3276
{
3277
    int pass;
3278
    pass = atoi(pass_str);
3279
    if (pass != 1 && pass != 2) {
3280
        fprintf(stderr, "pass number can be only 1 or 2\n");
3281
        exit(1);
3282
    }
3283
    do_pass = pass;
3284
}
3285

    
3286
static int64_t getutime(void)
3287
{
3288
#ifdef HAVE_GETRUSAGE
3289
    struct rusage rusage;
3290

    
3291
    getrusage(RUSAGE_SELF, &rusage);
3292
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3293
#elif defined(HAVE_GETPROCESSTIMES)
3294
    HANDLE proc;
3295
    FILETIME c, e, k, u;
3296
    proc = GetCurrentProcess();
3297
    GetProcessTimes(proc, &c, &e, &k, &u);
3298
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3299
#else
3300
    return av_gettime();
3301
#endif
3302
}
3303

    
3304
static void opt_show_formats(void)
3305
{
3306
    AVInputFormat *ifmt=NULL;
3307
    AVOutputFormat *ofmt=NULL;
3308
    URLProtocol *up=NULL;
3309
    AVCodec *p=NULL, *p2;
3310
    AVBitStreamFilter *bsf=NULL;
3311
    const char *last_name;
3312

    
3313
    printf("File formats:\n");
3314
    last_name= "000";
3315
    for(;;){
3316
        int decode=0;
3317
        int encode=0;
3318
        const char *name=NULL;
3319
        const char *long_name=NULL;
3320

    
3321
        while(ofmt= av_oformat_next(ofmt)) {
3322
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3323
                strcmp(ofmt->name, last_name)>0){
3324
                name= ofmt->name;
3325
                long_name= ofmt->long_name;
3326
                encode=1;
3327
            }
3328
        }
3329
        while(ifmt= av_iformat_next(ifmt)) {
3330
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3331
                strcmp(ifmt->name, last_name)>0){
3332
                name= ifmt->name;
3333
                long_name= ifmt->long_name;
3334
                encode=0;
3335
            }
3336
            if(name && strcmp(ifmt->name, name)==0)
3337
                decode=1;
3338
        }
3339
        if(name==NULL)
3340
            break;
3341
        last_name= name;
3342

    
3343
        printf(
3344
            " %s%s %-15s %s\n",
3345
            decode ? "D":" ",
3346
            encode ? "E":" ",
3347
            name,
3348
            long_name ? long_name:" ");
3349
    }
3350
    printf("\n");
3351

    
3352
    printf("Codecs:\n");
3353
    last_name= "000";
3354
    for(;;){
3355
        int decode=0;
3356
        int encode=0;
3357
        int cap=0;
3358
        const char *type_str;
3359

    
3360
        p2=NULL;
3361
        while(p= av_codec_next(p)) {
3362
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3363
                strcmp(p->name, last_name)>0){
3364
                p2= p;
3365
                decode= encode= cap=0;
3366
            }
3367
            if(p2 && strcmp(p->name, p2->name)==0){
3368
                if(p->decode) decode=1;
3369
                if(p->encode) encode=1;
3370
                cap |= p->capabilities;
3371
            }
3372
        }
3373
        if(p2==NULL)
3374
            break;
3375
        last_name= p2->name;
3376

    
3377
        switch(p2->type) {
3378
        case CODEC_TYPE_VIDEO:
3379
            type_str = "V";
3380
            break;
3381
        case CODEC_TYPE_AUDIO:
3382
            type_str = "A";
3383
            break;
3384
        case CODEC_TYPE_SUBTITLE:
3385
            type_str = "S";
3386
            break;
3387
        default:
3388
            type_str = "?";
3389
            break;
3390
        }
3391
        printf(
3392
            " %s%s%s%s%s%s %s",
3393
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3394
            encode ? "E":" ",
3395
            type_str,
3396
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3397
            cap & CODEC_CAP_DR1 ? "D":" ",
3398
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3399
            p2->name);
3400
       /* if(p2->decoder && decode==0)
3401
            printf(" use %s for decoding", p2->decoder->name);*/
3402
        printf("\n");
3403
    }
3404
    printf("\n");
3405

    
3406
    printf("Bitstream filters:\n");
3407
    while(bsf = av_bitstream_filter_next(bsf))
3408
        printf(" %s", bsf->name);
3409
    printf("\n");
3410

    
3411
    printf("Supported file protocols:\n");
3412
    while(up = av_protocol_next(up))
3413
        printf(" %s:", up->name);
3414
    printf("\n");
3415

    
3416
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3417
    printf("\n");
3418
    printf(
3419
"Note, the names of encoders and decoders do not always match, so there are\n"
3420
"several cases where the above table shows encoder only or decoder only entries\n"
3421
"even though both encoding and decoding are supported. For example, the h263\n"
3422
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3423
"worse.\n");
3424
    exit(0);
3425
}
3426

    
3427
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3428
{
3429
    int i;
3430
    const char *p = str;
3431
    for(i = 0;; i++) {
3432
        dest[i] = atoi(p);
3433
        if(i == 63)
3434
            break;
3435
        p = strchr(p, ',');
3436
        if(!p) {
3437
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3438
            exit(1);
3439
        }
3440
        p++;
3441
    }
3442
}
3443

    
3444
static void opt_inter_matrix(const char *arg)
3445
{
3446
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3447
    parse_matrix_coeffs(inter_matrix, arg);
3448
}
3449

    
3450
static void opt_intra_matrix(const char *arg)
3451
{
3452
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3453
    parse_matrix_coeffs(intra_matrix, arg);
3454
}
3455

    
3456
/**
3457
 * Trivial log callback.
3458
 * Only suitable for show_help and similar since it lacks prefix handling.
3459
 */
3460
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3461
{
3462
    vfprintf(stdout, fmt, vl);
3463
}
3464

    
3465
static void show_help(void)
3466
{
3467
    av_log_set_callback(log_callback_help);
3468
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3469
           "Hyper fast Audio and Video encoder\n");
3470
    printf("\n");
3471
    show_help_options(options, "Main options:\n",
3472
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3473
    show_help_options(options, "\nVideo options:\n",
3474
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3475
                      OPT_VIDEO);
3476
    show_help_options(options, "\nAdvanced Video options:\n",
3477
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3478
                      OPT_VIDEO | OPT_EXPERT);
3479
    show_help_options(options, "\nAudio options:\n",
3480
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3481
                      OPT_AUDIO);
3482
    show_help_options(options, "\nAdvanced Audio options:\n",
3483
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3484
                      OPT_AUDIO | OPT_EXPERT);
3485
    show_help_options(options, "\nSubtitle options:\n",
3486
                      OPT_SUBTITLE | OPT_GRAB,
3487
                      OPT_SUBTITLE);
3488
    show_help_options(options, "\nAudio/Video grab options:\n",
3489
                      OPT_GRAB,
3490
                      OPT_GRAB);
3491
    show_help_options(options, "\nAdvanced options:\n",
3492
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3493
                      OPT_EXPERT);
3494
    av_opt_show(avctx_opts[0], NULL);
3495
    av_opt_show(avformat_opts, NULL);
3496
    av_opt_show(sws_opts, NULL);
3497
}
3498

    
3499
static void opt_show_help(void)
3500
{
3501
    show_help();
3502
    exit(0);
3503
}
3504

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

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

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

    
3561
    if(!strcmp(arg, "vcd")) {
3562

    
3563
        opt_video_codec("mpeg1video");
3564
        opt_audio_codec("mp2");
3565
        opt_format("vcd");
3566

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

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

    
3576
        opt_default("ab", "224000");
3577
        audio_sample_rate = 44100;
3578
        audio_channels = 2;
3579

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

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

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

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

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

    
3605

    
3606
        opt_default("ab", "224000");
3607
        audio_sample_rate = 44100;
3608

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

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

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

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

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

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

    
3629
        opt_default("ab", "448000");
3630
        audio_sample_rate = 48000;
3631

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

    
3634
        opt_format("dv");
3635

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

    
3641
        audio_sample_rate = 48000;
3642
        audio_channels = 2;
3643

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

    
3650
static void opt_vstats_file (const char *arg)
3651
{
3652
    av_free (vstats_filename);
3653
    vstats_filename=av_strdup (arg);
3654
}
3655

    
3656
static void opt_vstats (void)
3657
{
3658
    char filename[40];
3659
    time_t today2 = time(NULL);
3660
    struct tm *today = localtime(&today2);
3661

    
3662
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3663
             today->tm_sec);
3664
    opt_vstats_file(filename);
3665
}
3666

    
3667
static void opt_bsf(const char *opt, const char *arg)
3668
{
3669
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3670
    AVBitStreamFilterContext **bsfp;
3671

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

    
3677
    bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3678
    while(*bsfp)
3679
        bsfp= &(*bsfp)->next;
3680

    
3681
    *bsfp= bsfc;
3682
}
3683

    
3684
static void opt_show_license(void)
3685
{
3686
    show_license();
3687
    exit(0);
3688
}
3689

    
3690
static void opt_show_version(void)
3691
{
3692
    show_version(program_name);
3693
    exit(0);
3694
}
3695

    
3696
const OptionDef options[] = {
3697
    /* main options */
3698
    { "L", 0, {(void*)opt_show_license}, "show license" },
3699
    { "h", 0, {(void*)opt_show_help}, "show help" },
3700
    { "version", 0, {(void*)opt_show_version}, "show version" },
3701
    { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3702
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3703
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3704
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3705
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3706
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3707
    { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3708
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3709
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3710
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3711
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3712
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3713
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3714
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3715
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3716
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3717
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3718
      "add timings for benchmarking" },
3719
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3720
      "dump each input packet" },
3721
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3722
      "when dumping packets, also dump the payload" },
3723
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3724
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3725
    { "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)", "" },
3726
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3727
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3728
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3729
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3730
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3731
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3732
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3733
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3734
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3735
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3736
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3737

    
3738
    /* video options */
3739
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3740
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3741
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3742
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3743
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3744
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3745
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3746
    { "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" },
3747
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3748
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3749
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3750
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3751
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3752
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3753
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3754
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3755
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3756
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3757
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3758
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3759
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3760
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3761
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3762
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3763
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3764
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3765
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3766
      "use same video quality as source (implies VBR)" },
3767
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3768
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3769
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3770
      "deinterlace pictures" },
3771
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3772
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3773
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3774
#ifdef CONFIG_VHOOK
3775
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3776
#endif
3777
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3778
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3779
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3780
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3781
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3782
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3783
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3784

    
3785
    /* audio options */
3786
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3787
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3788
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3789
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3790
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3791
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3792
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3793
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3794
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3795
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3796
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3797

    
3798
    /* subtitle options */
3799
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3800
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3801
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3802
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3803

    
3804
    /* grab options */
3805
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3806
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3807
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3808

    
3809
    /* muxer options */
3810
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3811
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3812

    
3813
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3814
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3815

    
3816
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3817
    { NULL, },
3818
};
3819

    
3820
static int av_exit()
3821
{
3822
    int i;
3823

    
3824
    /* close files */
3825
    for(i=0;i<nb_output_files;i++) {
3826
        /* maybe av_close_output_file ??? */
3827
        AVFormatContext *s = output_files[i];
3828
        int j;
3829
        if (!(s->oformat->flags & AVFMT_NOFILE))
3830
            url_fclose(s->pb);
3831
        for(j=0;j<s->nb_streams;j++) {
3832
            av_free(s->streams[j]->codec);
3833
            av_free(s->streams[j]);
3834
        }
3835
        av_free(s);
3836
    }
3837
    for(i=0;i<nb_input_files;i++)
3838
        av_close_input_file(input_files[i]);
3839

    
3840
    av_free_static();
3841

    
3842
    av_free(intra_matrix);
3843
    av_free(inter_matrix);
3844

    
3845
    if (vstats_file)
3846
        fclose(vstats_file);
3847
    av_free(vstats_filename);
3848

    
3849
    av_free(opt_names);
3850

    
3851
    av_free(video_codec_name);
3852
    av_free(audio_codec_name);
3853
    av_free(subtitle_codec_name);
3854

    
3855
    av_free(video_standard);
3856

    
3857
#ifdef CONFIG_POWERPC_PERF
3858
    extern void powerpc_display_perf_report(void);
3859
    powerpc_display_perf_report();
3860
#endif /* CONFIG_POWERPC_PERF */
3861

    
3862
    if (received_sigterm) {
3863
        fprintf(stderr,
3864
            "Received signal %d: terminating.\n",
3865
            (int) received_sigterm);
3866
        exit (255);
3867
    }
3868

    
3869
    exit(0); /* not all OS-es handle main() return value */
3870
    return 0;
3871
}
3872

    
3873
int main(int argc, char **argv)
3874
{
3875
    int i;
3876
    int64_t ti;
3877

    
3878
    avcodec_register_all();
3879
    avdevice_register_all();
3880
    av_register_all();
3881

    
3882
    for(i=0; i<CODEC_TYPE_NB; i++){
3883
        avctx_opts[i]= avcodec_alloc_context2(i);
3884
    }
3885
    avformat_opts = av_alloc_format_context();
3886
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3887

    
3888
    show_banner(program_name, program_birth_year);
3889
    if (argc <= 1) {
3890
        show_help();
3891
        exit(1);
3892
    }
3893

    
3894
    /* parse options */
3895
    parse_options(argc, argv, options, opt_output_file);
3896

    
3897
    /* file converter / grab */
3898
    if (nb_output_files <= 0) {
3899
        fprintf(stderr, "Must supply at least one output file\n");
3900
        exit(1);
3901
    }
3902

    
3903
    if (nb_input_files == 0) {
3904
        fprintf(stderr, "Must supply at least one input file\n");
3905
        exit(1);
3906
    }
3907

    
3908
    ti = getutime();
3909
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3910
              stream_maps, nb_stream_maps);
3911
    ti = getutime() - ti;
3912
    if (do_benchmark) {
3913
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3914
    }
3915

    
3916
    return av_exit();
3917
}