Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ebde2a2c

History | View | Annotate | Download (136 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) {0,0};
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 const 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
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
800
            pkt.flags |= PKT_FLAG_KEY;
801

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

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

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

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

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

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

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

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

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

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

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

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

    
934

    
935
    oc = output_files[0];
936

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

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

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

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

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

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

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

    
1014
        fflush(stderr);
1015
    }
1016

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

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

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

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

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

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

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

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

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

    
1176
            ist->frame++;
1177
        }
1178

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

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

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

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

    
1234
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1235
                            continue;
1236

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1357
    return 0;
1358
 fail_decode:
1359
    return -1;
1360
}
1361

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

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

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

    
1393
    return -1;
1394
}
1395

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1575
        codec = ost->st->codec;
1576
        icodec = ist->st->codec;
1577

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

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

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

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

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

    
1740
    if (!bit_buffer)
1741
        bit_buffer = av_malloc(bit_buffer_size);
1742
    if (!bit_buffer)
1743
        goto fail;
1744

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

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

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

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

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

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

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

    
1840
        out_file = output_files[out_file_index];
1841
        in_file = input_files[in_file_index];
1842

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

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

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

    
1875
    key = -1;
1876
    timer_start = av_gettime();
1877

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

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

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

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

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

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

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

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

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

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

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

    
1986
            av_free_packet(&pkt);
1987
            goto redo;
1988
        }
1989

    
1990
    discard_packet:
1991
        av_free_packet(&pkt);
1992

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

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

    
2005
    term_exit();
2006

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

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

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

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

    
2033
    /* finished ! */
2034

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

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

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

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

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

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

    
2113
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2114
extern int ffm_nopts;
2115
#endif
2116

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

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

    
2142
//    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));
2143

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

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

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

    
2159
static void opt_video_rc_override_string(const char *arg)
2160
{
2161
    video_rc_override_string = arg;
2162
}
2163

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

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

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

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

    
2187
    opt_default(opt, arg);
2188

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

    
2192
    return 0;
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

    
2666
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2667
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2668
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2669

    
2670
    /* open the input file with generic libav function */
2671
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2672
    if (err < 0) {
2673
        print_error(filename, err);
2674
        exit(1);
2675
    }
2676
    if(opt_programid) {
2677
        int i;
2678
        for(i=0; i<ic->nb_programs; i++)
2679
            if(ic->programs[i]->id != opt_programid)
2680
                ic->programs[i]->discard = AVDISCARD_ALL;
2681
    }
2682

    
2683
    ic->loop_input = loop_input;
2684

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

    
2693
    timestamp = start_time;
2694
    /* add the stream start time */
2695
    if (ic->start_time != AV_NOPTS_VALUE)
2696
        timestamp += ic->start_time;
2697

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

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

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

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

    
2755
                    (float)rfps / rfps_base, rfps, rfps_base);
2756
            }
2757
            /* update the current frame rate to match the stream frame rate */
2758
            frame_rate.num = rfps;
2759
            frame_rate.den = rfps_base;
2760

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

    
2780
    input_files[nb_input_files] = ic;
2781
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2782
    /* dump the file content */
2783
    if (verbose >= 0)
2784
        dump_format(ic, nb_input_files, filename, 0);
2785

    
2786
    nb_input_files++;
2787
    file_iformat = NULL;
2788
    file_oformat = NULL;
2789

    
2790
    video_channel = 0;
2791

    
2792
    rate_emu = 0;
2793
    av_freep(&video_codec_name);
2794
    av_freep(&audio_codec_name);
2795
    av_freep(&subtitle_codec_name);
2796
}
2797

    
2798
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2799
                                         int *has_subtitle_ptr)
2800
{
2801
    int has_video, has_audio, has_subtitle, i, j;
2802
    AVFormatContext *ic;
2803

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

    
2834
static void new_video_stream(AVFormatContext *oc)
2835
{
2836
    AVStream *st;
2837
    AVCodecContext *video_enc;
2838
    int codec_id;
2839

    
2840
    st = av_new_stream(oc, oc->nb_streams);
2841
    if (!st) {
2842
        fprintf(stderr, "Could not alloc stream\n");
2843
        exit(1);
2844
    }
2845
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2846
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2847
    video_bitstream_filters= NULL;
2848

    
2849
    if(thread_count>1)
2850
        avcodec_thread_init(st->codec, thread_count);
2851

    
2852
    video_enc = st->codec;
2853

    
2854
    if(video_codec_tag)
2855
        video_enc->codec_tag= video_codec_tag;
2856

    
2857
    if(   (video_global_header&1)
2858
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2859
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2860
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2861
    }
2862
    if(video_global_header&2){
2863
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2864
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2865
    }
2866

    
2867
    if (video_stream_copy) {
2868
        st->stream_copy = 1;
2869
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2870
    } else {
2871
        const char *p;
2872
        int i;
2873
        AVCodec *codec;
2874
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2875

    
2876
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2877
        if (video_codec_name)
2878
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2879

    
2880
        video_enc->codec_id = codec_id;
2881
        codec = avcodec_find_encoder(codec_id);
2882

    
2883
        for(i=0; i<opt_name_count; i++){
2884
            char buf[256];
2885
            const AVOption *opt;
2886
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2887
            if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2888
                av_set_string(video_enc, opt_names[i], str);
2889
        }
2890

    
2891
        video_enc->time_base.den = fps.num;
2892
        video_enc->time_base.num = fps.den;
2893
        if(codec && codec->supported_framerates){
2894
            const AVRational *p= codec->supported_framerates;
2895
            const AVRational *best=NULL;
2896
            AVRational best_error= (AVRational){INT_MAX, 1};
2897
            for(; p->den!=0; p++){
2898
                AVRational error= av_sub_q(fps, *p);
2899
                if(error.num <0) error.num *= -1;
2900
                if(av_cmp_q(error, best_error) < 0){
2901
                    best_error= error;
2902
                    best= p;
2903
                }
2904
            }
2905
            video_enc->time_base.den= best->num;
2906
            video_enc->time_base.num= best->den;
2907
        }
2908

    
2909
        video_enc->width = frame_width + frame_padright + frame_padleft;
2910
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2911
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2912
        video_enc->pix_fmt = frame_pix_fmt;
2913

    
2914
        if(codec && codec->pix_fmts){
2915
            const enum PixelFormat *p= codec->pix_fmts;
2916
            for(; *p!=-1; p++){
2917
                if(*p == video_enc->pix_fmt)
2918
                    break;
2919
            }
2920
            if(*p == -1)
2921
                video_enc->pix_fmt = codec->pix_fmts[0];
2922
        }
2923

    
2924
        if (intra_only)
2925
            video_enc->gop_size = 0;
2926
        if (video_qscale || same_quality) {
2927
            video_enc->flags |= CODEC_FLAG_QSCALE;
2928
            video_enc->global_quality=
2929
                st->quality = FF_QP2LAMBDA * video_qscale;
2930
        }
2931

    
2932
        if(intra_matrix)
2933
            video_enc->intra_matrix = intra_matrix;
2934
        if(inter_matrix)
2935
            video_enc->inter_matrix = inter_matrix;
2936

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

    
2970
        if (do_psnr)
2971
            video_enc->flags|= CODEC_FLAG_PSNR;
2972

    
2973
        /* two pass mode */
2974
        if (do_pass) {
2975
            if (do_pass == 1) {
2976
                video_enc->flags |= CODEC_FLAG_PASS1;
2977
            } else {
2978
                video_enc->flags |= CODEC_FLAG_PASS2;
2979
            }
2980
        }
2981
    }
2982

    
2983
    /* reset some key parameters */
2984
    video_disable = 0;
2985
    av_freep(&video_codec_name);
2986
    video_stream_copy = 0;
2987
}
2988

    
2989
static void new_audio_stream(AVFormatContext *oc)
2990
{
2991
    AVStream *st;
2992
    AVCodecContext *audio_enc;
2993
    int codec_id, i;
2994

    
2995
    st = av_new_stream(oc, oc->nb_streams);
2996
    if (!st) {
2997
        fprintf(stderr, "Could not alloc stream\n");
2998
        exit(1);
2999
    }
3000
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3001

    
3002
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3003
    audio_bitstream_filters= NULL;
3004

    
3005
    if(thread_count>1)
3006
        avcodec_thread_init(st->codec, thread_count);
3007

    
3008
    audio_enc = st->codec;
3009
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3010
    audio_enc->strict_std_compliance = strict;
3011

    
3012
    if(audio_codec_tag)
3013
        audio_enc->codec_tag= audio_codec_tag;
3014

    
3015
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3016
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3017
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3018
    }
3019
    if (audio_stream_copy) {
3020
        st->stream_copy = 1;
3021
        audio_enc->channels = audio_channels;
3022
    } else {
3023
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3024

    
3025
        for(i=0; i<opt_name_count; i++){
3026
            char buf[256];
3027
            const AVOption *opt;
3028
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3029
            if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3030
                av_set_string(audio_enc, opt_names[i], str);
3031
        }
3032

    
3033
        if (audio_codec_name)
3034
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3035
        audio_enc->codec_id = codec_id;
3036

    
3037
        if (audio_qscale > QSCALE_NONE) {
3038
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3039
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3040
        }
3041
        audio_enc->thread_count = thread_count;
3042
        audio_enc->channels = audio_channels;
3043
    }
3044
    audio_enc->sample_rate = audio_sample_rate;
3045
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3046
    if (audio_language) {
3047
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3048
        av_free(audio_language);
3049
        audio_language = NULL;
3050
    }
3051

    
3052
    /* reset some key parameters */
3053
    audio_disable = 0;
3054
    av_freep(&audio_codec_name);
3055
    audio_stream_copy = 0;
3056
}
3057

    
3058
static void new_subtitle_stream(AVFormatContext *oc)
3059
{
3060
    AVStream *st;
3061
    AVCodecContext *subtitle_enc;
3062
    int i;
3063

    
3064
    st = av_new_stream(oc, oc->nb_streams);
3065
    if (!st) {
3066
        fprintf(stderr, "Could not alloc stream\n");
3067
        exit(1);
3068
    }
3069
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3070

    
3071
    subtitle_enc = st->codec;
3072
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3073
    if (subtitle_stream_copy) {
3074
        st->stream_copy = 1;
3075
    } else {
3076
        for(i=0; i<opt_name_count; i++){
3077
            char buf[256];
3078
            const AVOption *opt;
3079
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3080
            if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3081
                av_set_string(subtitle_enc, opt_names[i], str);
3082
        }
3083
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3084
    }
3085

    
3086
    if (subtitle_language) {
3087
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3088
        av_free(subtitle_language);
3089
        subtitle_language = NULL;
3090
    }
3091

    
3092
    subtitle_disable = 0;
3093
    av_freep(&subtitle_codec_name);
3094
    subtitle_stream_copy = 0;
3095
}
3096

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

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

    
3119
static void opt_new_subtitle_stream(void)
3120
{
3121
    AVFormatContext *oc;
3122
    if (nb_output_files <= 0) {
3123
        fprintf(stderr, "At least one output file must be specified\n");
3124
        exit(1);
3125
    }
3126
    oc = output_files[nb_output_files - 1];
3127
    new_subtitle_stream(oc);
3128
}
3129

    
3130
static void opt_output_file(const char *filename)
3131
{
3132
    AVFormatContext *oc;
3133
    int use_video, use_audio, use_subtitle;
3134
    int input_has_video, input_has_audio, input_has_subtitle, i;
3135
    AVFormatParameters params, *ap = &params;
3136

    
3137
    if (!strcmp(filename, "-"))
3138
        filename = "pipe:";
3139

    
3140
    oc = av_alloc_format_context();
3141

    
3142
    if (!file_oformat) {
3143
        file_oformat = guess_format(NULL, filename, NULL);
3144
        if (!file_oformat) {
3145
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3146
                    filename);
3147
            exit(1);
3148
        }
3149
    }
3150

    
3151
    oc->oformat = file_oformat;
3152
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3153

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

    
3167
        /* disable if no corresponding type found and at least one
3168
           input file */
3169
        if (nb_input_files > 0) {
3170
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3171
                                         &input_has_subtitle);
3172
            if (!input_has_video)
3173
                use_video = 0;
3174
            if (!input_has_audio)
3175
                use_audio = 0;
3176
            if (!input_has_subtitle)
3177
                use_subtitle = 0;
3178
        }
3179

    
3180
        /* manual disable */
3181
        if (audio_disable) {
3182
            use_audio = 0;
3183
        }
3184
        if (video_disable) {
3185
            use_video = 0;
3186
        }
3187
        if (subtitle_disable) {
3188
            use_subtitle = 0;
3189
        }
3190

    
3191
        if (use_video) {
3192
            new_video_stream(oc);
3193
        }
3194

    
3195
        if (use_audio) {
3196
            new_audio_stream(oc);
3197
        }
3198

    
3199
        if (use_subtitle) {
3200
            new_subtitle_stream(oc);
3201
        }
3202

    
3203
        oc->timestamp = rec_timestamp;
3204

    
3205
        if (str_title)
3206
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3207
        if (str_author)
3208
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3209
        if (str_copyright)
3210
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3211
        if (str_comment)
3212
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3213
        if (str_album)
3214
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3215
    }
3216

    
3217
    output_files[nb_output_files++] = oc;
3218

    
3219
    /* check filename in case of an image number is expected */
3220
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3221
        if (!av_filename_number_test(oc->filename)) {
3222
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3223
            exit(1);
3224
        }
3225
    }
3226

    
3227
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3228
        /* test if it already exists to avoid loosing precious files */
3229
        if (!file_overwrite &&
3230
            (strchr(filename, ':') == NULL ||
3231
             filename[1] == ':' ||
3232
             av_strstart(filename, "file:", NULL))) {
3233
            if (url_exist(filename)) {
3234
                int c;
3235

    
3236
                if ( !using_stdin ) {
3237
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3238
                    fflush(stderr);
3239
                    c = getchar();
3240
                    if (toupper(c) != 'Y') {
3241
                        fprintf(stderr, "Not overwriting - exiting\n");
3242
                        exit(1);
3243
                    }
3244
                                }
3245
                                else {
3246
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3247
                    exit(1);
3248
                                }
3249
            }
3250
        }
3251

    
3252
        /* open the file */
3253
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3254
            fprintf(stderr, "Could not open '%s'\n", filename);
3255
            exit(1);
3256
        }
3257
    }
3258

    
3259
    memset(ap, 0, sizeof(*ap));
3260
    if (av_set_parameters(oc, ap) < 0) {
3261
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3262
                oc->filename);
3263
        exit(1);
3264
    }
3265

    
3266
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3267
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3268
    oc->loop_output = loop_output;
3269

    
3270
    for(i=0; i<opt_name_count; i++){
3271
        char buf[256];
3272
        const AVOption *opt;
3273
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3274
        if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3275
            av_set_string(oc, opt_names[i], str);
3276
    }
3277

    
3278
    /* reset some options */
3279
    file_oformat = NULL;
3280
    file_iformat = NULL;
3281
}
3282

    
3283
/* same option as mencoder */
3284
static void opt_pass(const char *pass_str)
3285
{
3286
    int pass;
3287
    pass = atoi(pass_str);
3288
    if (pass != 1 && pass != 2) {
3289
        fprintf(stderr, "pass number can be only 1 or 2\n");
3290
        exit(1);
3291
    }
3292
    do_pass = pass;
3293
}
3294

    
3295
static int64_t getutime(void)
3296
{
3297
#ifdef HAVE_GETRUSAGE
3298
    struct rusage rusage;
3299

    
3300
    getrusage(RUSAGE_SELF, &rusage);
3301
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3302
#elif defined(HAVE_GETPROCESSTIMES)
3303
    HANDLE proc;
3304
    FILETIME c, e, k, u;
3305
    proc = GetCurrentProcess();
3306
    GetProcessTimes(proc, &c, &e, &k, &u);
3307
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3308
#else
3309
    return av_gettime();
3310
#endif
3311
}
3312

    
3313
static void opt_show_formats(void)
3314
{
3315
    AVInputFormat *ifmt=NULL;
3316
    AVOutputFormat *ofmt=NULL;
3317
    URLProtocol *up=NULL;
3318
    AVCodec *p=NULL, *p2;
3319
    AVBitStreamFilter *bsf=NULL;
3320
    const char *last_name;
3321

    
3322
    printf("File formats:\n");
3323
    last_name= "000";
3324
    for(;;){
3325
        int decode=0;
3326
        int encode=0;
3327
        const char *name=NULL;
3328
        const char *long_name=NULL;
3329

    
3330
        while((ofmt= av_oformat_next(ofmt))) {
3331
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3332
                strcmp(ofmt->name, last_name)>0){
3333
                name= ofmt->name;
3334
                long_name= ofmt->long_name;
3335
                encode=1;
3336
            }
3337
        }
3338
        while((ifmt= av_iformat_next(ifmt))) {
3339
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3340
                strcmp(ifmt->name, last_name)>0){
3341
                name= ifmt->name;
3342
                long_name= ifmt->long_name;
3343
                encode=0;
3344
            }
3345
            if(name && strcmp(ifmt->name, name)==0)
3346
                decode=1;
3347
        }
3348
        if(name==NULL)
3349
            break;
3350
        last_name= name;
3351

    
3352
        printf(
3353
            " %s%s %-15s %s\n",
3354
            decode ? "D":" ",
3355
            encode ? "E":" ",
3356
            name,
3357
            long_name ? long_name:" ");
3358
    }
3359
    printf("\n");
3360

    
3361
    printf("Codecs:\n");
3362
    last_name= "000";
3363
    for(;;){
3364
        int decode=0;
3365
        int encode=0;
3366
        int cap=0;
3367
        const char *type_str;
3368

    
3369
        p2=NULL;
3370
        while((p= av_codec_next(p))) {
3371
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3372
                strcmp(p->name, last_name)>0){
3373
                p2= p;
3374
                decode= encode= cap=0;
3375
            }
3376
            if(p2 && strcmp(p->name, p2->name)==0){
3377
                if(p->decode) decode=1;
3378
                if(p->encode) encode=1;
3379
                cap |= p->capabilities;
3380
            }
3381
        }
3382
        if(p2==NULL)
3383
            break;
3384
        last_name= p2->name;
3385

    
3386
        switch(p2->type) {
3387
        case CODEC_TYPE_VIDEO:
3388
            type_str = "V";
3389
            break;
3390
        case CODEC_TYPE_AUDIO:
3391
            type_str = "A";
3392
            break;
3393
        case CODEC_TYPE_SUBTITLE:
3394
            type_str = "S";
3395
            break;
3396
        default:
3397
            type_str = "?";
3398
            break;
3399
        }
3400
        printf(
3401
            " %s%s%s%s%s%s %s",
3402
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3403
            encode ? "E":" ",
3404
            type_str,
3405
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3406
            cap & CODEC_CAP_DR1 ? "D":" ",
3407
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3408
            p2->name);
3409
       /* if(p2->decoder && decode==0)
3410
            printf(" use %s for decoding", p2->decoder->name);*/
3411
        printf("\n");
3412
    }
3413
    printf("\n");
3414

    
3415
    printf("Bitstream filters:\n");
3416
    while((bsf = av_bitstream_filter_next(bsf)))
3417
        printf(" %s", bsf->name);
3418
    printf("\n");
3419

    
3420
    printf("Supported file protocols:\n");
3421
    while((up = av_protocol_next(up)))
3422
        printf(" %s:", up->name);
3423
    printf("\n");
3424

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

    
3436
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3437
{
3438
    int i;
3439
    const char *p = str;
3440
    for(i = 0;; i++) {
3441
        dest[i] = atoi(p);
3442
        if(i == 63)
3443
            break;
3444
        p = strchr(p, ',');
3445
        if(!p) {
3446
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3447
            exit(1);
3448
        }
3449
        p++;
3450
    }
3451
}
3452

    
3453
static void opt_inter_matrix(const char *arg)
3454
{
3455
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3456
    parse_matrix_coeffs(inter_matrix, arg);
3457
}
3458

    
3459
static void opt_intra_matrix(const char *arg)
3460
{
3461
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3462
    parse_matrix_coeffs(intra_matrix, arg);
3463
}
3464

    
3465
/**
3466
 * Trivial log callback.
3467
 * Only suitable for show_help and similar since it lacks prefix handling.
3468
 */
3469
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3470
{
3471
    vfprintf(stdout, fmt, vl);
3472
}
3473

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

    
3508
static void opt_show_help(void)
3509
{
3510
    show_help();
3511
    exit(0);
3512
}
3513

    
3514
static void opt_target(const char *arg)
3515
{
3516
    int norm = -1;
3517
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3518

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

    
3563
    if(norm < 0) {
3564
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3565
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3566
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3567
        exit(1);
3568
    }
3569

    
3570
    if(!strcmp(arg, "vcd")) {
3571

    
3572
        opt_video_codec("mpeg1video");
3573
        opt_audio_codec("mp2");
3574
        opt_format("vcd");
3575

    
3576
        opt_frame_size(norm ? "352x240" : "352x288");
3577
        opt_frame_rate(frame_rates[norm]);
3578
        opt_default("gop", norm ? "18" : "15");
3579

    
3580
        opt_default("b", "1150000");
3581
        opt_default("maxrate", "1150000");
3582
        opt_default("minrate", "1150000");
3583
        opt_default("bufsize", "327680"); // 40*1024*8;
3584

    
3585
        opt_default("ab", "224000");
3586
        audio_sample_rate = 44100;
3587
        audio_channels = 2;
3588

    
3589
        opt_default("packetsize", "2324");
3590
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3591

    
3592
        /* We have to offset the PTS, so that it is consistent with the SCR.
3593
           SCR starts at 36000, but the first two packs contain only padding
3594
           and the first pack from the other stream, respectively, may also have
3595
           been written before.
3596
           So the real data starts at SCR 36000+3*1200. */
3597
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3598
    } else if(!strcmp(arg, "svcd")) {
3599

    
3600
        opt_video_codec("mpeg2video");
3601
        opt_audio_codec("mp2");
3602
        opt_format("svcd");
3603

    
3604
        opt_frame_size(norm ? "480x480" : "480x576");
3605
        opt_frame_rate(frame_rates[norm]);
3606
        opt_default("gop", norm ? "18" : "15");
3607

    
3608
        opt_default("b", "2040000");
3609
        opt_default("maxrate", "2516000");
3610
        opt_default("minrate", "0"); //1145000;
3611
        opt_default("bufsize", "1835008"); //224*1024*8;
3612
        opt_default("flags", "+SCAN_OFFSET");
3613

    
3614

    
3615
        opt_default("ab", "224000");
3616
        audio_sample_rate = 44100;
3617

    
3618
        opt_default("packetsize", "2324");
3619

    
3620
    } else if(!strcmp(arg, "dvd")) {
3621

    
3622
        opt_video_codec("mpeg2video");
3623
        opt_audio_codec("ac3");
3624
        opt_format("dvd");
3625

    
3626
        opt_frame_size(norm ? "720x480" : "720x576");
3627
        opt_frame_rate(frame_rates[norm]);
3628
        opt_default("gop", norm ? "18" : "15");
3629

    
3630
        opt_default("b", "6000000");
3631
        opt_default("maxrate", "9000000");
3632
        opt_default("minrate", "0"); //1500000;
3633
        opt_default("bufsize", "1835008"); //224*1024*8;
3634

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

    
3638
        opt_default("ab", "448000");
3639
        audio_sample_rate = 48000;
3640

    
3641
    } else if(!strncmp(arg, "dv", 2)) {
3642

    
3643
        opt_format("dv");
3644

    
3645
        opt_frame_size(norm ? "720x480" : "720x576");
3646
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3647
                                             (norm ? "yuv411p" : "yuv420p"));
3648
        opt_frame_rate(frame_rates[norm]);
3649

    
3650
        audio_sample_rate = 48000;
3651
        audio_channels = 2;
3652

    
3653
    } else {
3654
        fprintf(stderr, "Unknown target: %s\n", arg);
3655
        exit(1);
3656
    }
3657
}
3658

    
3659
static void opt_vstats_file (const char *arg)
3660
{
3661
    av_free (vstats_filename);
3662
    vstats_filename=av_strdup (arg);
3663
}
3664

    
3665
static void opt_vstats (void)
3666
{
3667
    char filename[40];
3668
    time_t today2 = time(NULL);
3669
    struct tm *today = localtime(&today2);
3670

    
3671
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3672
             today->tm_sec);
3673
    opt_vstats_file(filename);
3674
}
3675

    
3676
static int opt_bsf(const char *opt, const char *arg)
3677
{
3678
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3679
    AVBitStreamFilterContext **bsfp;
3680

    
3681
    if(!bsfc){
3682
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3683
        exit(1);
3684
    }
3685

    
3686
    bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3687
    while(*bsfp)
3688
        bsfp= &(*bsfp)->next;
3689

    
3690
    *bsfp= bsfc;
3691

    
3692
    return 0;
3693
}
3694

    
3695
static void opt_show_license(void)
3696
{
3697
    show_license();
3698
    exit(0);
3699
}
3700

    
3701
static void opt_show_version(void)
3702
{
3703
    show_version(program_name);
3704
    exit(0);
3705
}
3706

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

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

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

    
3809
    /* subtitle options */
3810
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3811
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3812
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3813
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3814

    
3815
    /* grab options */
3816
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3817
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3818
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3819

    
3820
    /* muxer options */
3821
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3822
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3823

    
3824
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3825
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3826

    
3827
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3828
    { NULL, },
3829
};
3830

    
3831
static int av_exit()
3832
{
3833
    int i;
3834

    
3835
    /* close files */
3836
    for(i=0;i<nb_output_files;i++) {
3837
        /* maybe av_close_output_file ??? */
3838
        AVFormatContext *s = output_files[i];
3839
        int j;
3840
        if (!(s->oformat->flags & AVFMT_NOFILE))
3841
            url_fclose(s->pb);
3842
        for(j=0;j<s->nb_streams;j++) {
3843
            av_free(s->streams[j]->codec);
3844
            av_free(s->streams[j]);
3845
        }
3846
        av_free(s);
3847
    }
3848
    for(i=0;i<nb_input_files;i++)
3849
        av_close_input_file(input_files[i]);
3850

    
3851
    av_free_static();
3852

    
3853
    av_free(intra_matrix);
3854
    av_free(inter_matrix);
3855

    
3856
    if (vstats_file)
3857
        fclose(vstats_file);
3858
    av_free(vstats_filename);
3859

    
3860
    av_free(opt_names);
3861

    
3862
    av_free(video_codec_name);
3863
    av_free(audio_codec_name);
3864
    av_free(subtitle_codec_name);
3865

    
3866
    av_free(video_standard);
3867

    
3868
#ifdef CONFIG_POWERPC_PERF
3869
    extern void powerpc_display_perf_report(void);
3870
    powerpc_display_perf_report();
3871
#endif /* CONFIG_POWERPC_PERF */
3872

    
3873
    if (received_sigterm) {
3874
        fprintf(stderr,
3875
            "Received signal %d: terminating.\n",
3876
            (int) received_sigterm);
3877
        exit (255);
3878
    }
3879

    
3880
    exit(0); /* not all OS-es handle main() return value */
3881
    return 0;
3882
}
3883

    
3884
int main(int argc, char **argv)
3885
{
3886
    int i;
3887
    int64_t ti;
3888

    
3889
    avcodec_register_all();
3890
    avdevice_register_all();
3891
    av_register_all();
3892

    
3893
    for(i=0; i<CODEC_TYPE_NB; i++){
3894
        avctx_opts[i]= avcodec_alloc_context2(i);
3895
    }
3896
    avformat_opts = av_alloc_format_context();
3897
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3898

    
3899
    show_banner(program_name, program_birth_year);
3900
    if (argc <= 1) {
3901
        show_help();
3902
        exit(1);
3903
    }
3904

    
3905
    /* parse options */
3906
    parse_options(argc, argv, options, opt_output_file);
3907

    
3908
    /* file converter / grab */
3909
    if (nb_output_files <= 0) {
3910
        fprintf(stderr, "Must supply at least one output file\n");
3911
        exit(1);
3912
    }
3913

    
3914
    if (nb_input_files == 0) {
3915
        fprintf(stderr, "Must supply at least one input file\n");
3916
        exit(1);
3917
    }
3918

    
3919
    ti = getutime();
3920
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3921
              stream_maps, nb_stream_maps);
3922
    ti = getutime() - ti;
3923
    if (do_benchmark) {
3924
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3925
    }
3926

    
3927
    return av_exit();
3928
}