Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 25e4f8aa

History | View | Annotate | Download (133 KB)

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

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

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

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

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

    
58
#undef exit
59

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

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

    
74
extern const OptionDef options[];
75

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

    
80
#define MAX_FILES 20
81

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

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

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

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

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

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

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

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

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

    
182
static int rate_emu = 0;
183

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

    
187
static int audio_volume = 256;
188

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

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

    
205
static int sws_flags = SWS_BICUBIC;
206

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

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

    
217
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
218

    
219
struct AVInputStream;
220

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

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

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

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

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

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

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

    
279
#ifndef __MINGW32__
280

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

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

    
292
static volatile sig_atomic_t received_sigterm = 0;
293

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
413
        bsfc= bsfc->next;
414
    }
415

    
416
    av_interleaved_write_frame(s, pkt);
417
}
418

    
419
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
420

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
691
    *frame_size = 0;
692

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

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

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

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

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

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

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

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

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

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

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

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

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

    
842
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
843
                           int frame_size)
844
{
845
    AVCodecContext *enc;
846
    int frame_number;
847
    int64_t ti;
848
    double ti1, bitrate, avg_bitrate;
849

    
850
    /* this is executed just the first time do_video_stats is called */
851
    if (!fvstats) {
852
        fvstats = fopen(vstats_filename, "w");
853
        if (!fvstats) {
854
            perror("fopen");
855
            exit(1);
856
        }
857
    }
858

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

    
867
        fprintf(fvstats,"f_size= %6d ", frame_size);
868
        /* compute pts value */
869
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
870
        if (ti1 < 0.01)
871
            ti1 = 0.01;
872

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

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

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

    
908

    
909
    oc = output_files[0];
910

    
911
    total_size = url_fsize(&oc->pb);
912
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
913
        total_size= url_ftell(&oc->pb);
914

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

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

    
974
    if (verbose || is_last_report) {
975
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
976

    
977
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
978
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
979
            (double)total_size / 1024, ti1, bitrate);
980

    
981
        if (verbose > 1)
982
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
983
                  nb_frames_dup, nb_frames_drop);
984

    
985
        if (verbose >= 0)
986
            fprintf(stderr, "%s    \r", buf);
987

    
988
        fflush(stderr);
989
    }
990

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

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

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

    
1029
    if (pkt == NULL) {
1030
        /* EOF handling */
1031
        ptr = NULL;
1032
        len = 0;
1033
        goto handle_eof;
1034
    }
1035

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

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

    
1123
        buffer_to_free = NULL;
1124
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1125
            pre_process_video_frame(ist, (AVPicture *)&picture,
1126
                                    &buffer_to_free);
1127
        }
1128

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

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

    
1150
            ist->frame++;
1151
        }
1152

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

    
1172
                ost = ost_table[i];
1173
                if (ost->source_index == ist_index) {
1174
                    os = output_files[ost->file_index];
1175

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

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

    
1208
                        /* no reencoding needed : output the packet directly */
1209
                        /* force the input stream PTS */
1210

    
1211
                        avcodec_get_frame_defaults(&avframe);
1212
                        ost->st->codec->coded_frame= &avframe;
1213
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1214

    
1215
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1216
                            audio_size += data_size;
1217
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1218
                            video_size += data_size;
1219
                            ost->sync_opts++;
1220
                        }
1221

    
1222
                        opkt.stream_index= ost->index;
1223
                        if(pkt->pts != AV_NOPTS_VALUE)
1224
                            opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1225
                        else
1226
                            opkt.pts= AV_NOPTS_VALUE;
1227

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

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

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

    
1267
        for(i=0;i<nb_ostreams;i++) {
1268
            ost = ost_table[i];
1269
            if (ost->source_index == ist_index) {
1270
                AVCodecContext *enc= ost->st->codec;
1271
                os = output_files[ost->file_index];
1272

    
1273
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1274
                    continue;
1275
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1276
                    continue;
1277

    
1278
                if (ost->encoding_needed) {
1279
                    for(;;) {
1280
                        AVPacket pkt;
1281
                        int fifo_bytes;
1282
                        av_init_packet(&pkt);
1283
                        pkt.stream_index= ost->index;
1284

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

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

    
1330
    return 0;
1331
 fail_decode:
1332
    return -1;
1333
}
1334

    
1335

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

    
1353
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1354
    if (!file_table)
1355
        goto fail;
1356

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

    
1367
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1368
    if (!ist_table)
1369
        goto fail;
1370

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

    
1388
            if (ist->st->codec->rate_emu) {
1389
                ist->start = av_gettime();
1390
                ist->frame = 0;
1391
            }
1392
        }
1393
    }
1394

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

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

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

    
1429
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1430
    if (!ost_table)
1431
        goto fail;
1432
    for(i=0;i<nb_ostreams;i++) {
1433
        ost = av_mallocz(sizeof(AVOutputStream));
1434
        if (!ost)
1435
            goto fail;
1436
        ost_table[i] = ost;
1437
    }
1438

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

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

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

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

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

    
1502
        codec = ost->st->codec;
1503
        icodec = ist->st->codec;
1504

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

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

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

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

    
1683
    if (!bit_buffer)
1684
        bit_buffer = av_malloc(bit_buffer_size);
1685
    if (!bit_buffer)
1686
        goto fail;
1687

    
1688
    /* dump the file output parameters - cannot be done before in case
1689
       of stream copy */
1690
    for(i=0;i<nb_output_files;i++) {
1691
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1692
    }
1693

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

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

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

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

    
1766
    /* set meta data information from input file if required */
1767
    for (i=0;i<nb_meta_data_maps;i++) {
1768
        AVFormatContext *out_file;
1769
        AVFormatContext *in_file;
1770

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

    
1784
        out_file = output_files[out_file_index];
1785
        in_file = input_files[in_file_index];
1786

    
1787
        strcpy(out_file->title, in_file->title);
1788
        strcpy(out_file->author, in_file->author);
1789
        strcpy(out_file->copyright, in_file->copyright);
1790
        strcpy(out_file->comment, in_file->comment);
1791
        strcpy(out_file->album, in_file->album);
1792
        out_file->year = in_file->year;
1793
        out_file->track = in_file->track;
1794
        strcpy(out_file->genre, in_file->genre);
1795
    }
1796

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

    
1807
    if ( !using_stdin && verbose >= 0) {
1808
        fprintf(stderr, "Press [q] to stop encoding\n");
1809
        url_set_interrupt_cb(decode_interrupt_cb);
1810
    }
1811
    term_init();
1812

    
1813
    key = -1;
1814
    timer_start = av_gettime();
1815

    
1816
    for(; received_sigterm == 0;) {
1817
        int file_index, ist_index;
1818
        AVPacket pkt;
1819
        double ipts_min;
1820
        double opts_min;
1821

    
1822
    redo:
1823
        ipts_min= 1e100;
1824
        opts_min= 1e100;
1825
        /* if 'q' pressed, exits */
1826
        if (!using_stdin) {
1827
            if (q_pressed)
1828
                break;
1829
            /* read_key() returns 0 on EOF */
1830
            key = read_key();
1831
            if (key == 'q')
1832
                break;
1833
        }
1834

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

    
1868
        /* finish if recording time exhausted */
1869
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1870
            break;
1871

    
1872
        /* finish if limit size exhausted */
1873
        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1874
            break;
1875

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

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

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

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

    
1913
            if (verbose >= 0)
1914
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1915
                        ist->file_index, ist->index);
1916

    
1917
            av_free_packet(&pkt);
1918
            goto redo;
1919
        }
1920

    
1921
    discard_packet:
1922
        av_free_packet(&pkt);
1923

    
1924
        /* dump report by using the output first video and audio streams */
1925
        print_report(output_files, ost_table, nb_ostreams, 0);
1926
    }
1927

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

    
1936
    term_exit();
1937

    
1938
    /* write the trailer if needed and close file */
1939
    for(i=0;i<nb_output_files;i++) {
1940
        os = output_files[i];
1941
        av_write_trailer(os);
1942
    }
1943

    
1944
    /* dump report by using the first video and audio streams */
1945
    print_report(output_files, ost_table, nb_ostreams, 1);
1946

    
1947
    /* close each encoder */
1948
    for(i=0;i<nb_ostreams;i++) {
1949
        ost = ost_table[i];
1950
        if (ost->encoding_needed) {
1951
            av_freep(&ost->st->codec->stats_in);
1952
            avcodec_close(ost->st->codec);
1953
        }
1954
    }
1955

    
1956
    /* close each decoder */
1957
    for(i=0;i<nb_istreams;i++) {
1958
        ist = ist_table[i];
1959
        if (ist->decoding_needed) {
1960
            avcodec_close(ist->st->codec);
1961
        }
1962
    }
1963

    
1964
    /* finished ! */
1965

    
1966
    ret = 0;
1967
 fail1:
1968
    av_freep(&bit_buffer);
1969
    av_free(file_table);
1970

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

    
2004
#if 0
2005
int file_read(const char *filename)
2006
{
2007
    URLContext *h;
2008
    unsigned char buffer[1024];
2009
    int len, i;
2010

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

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

    
2036
    file_iformat = av_find_input_format(arg);
2037
    file_oformat = guess_format(arg, NULL, NULL);
2038
    if (!file_iformat && !file_oformat) {
2039
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2040
        exit(1);
2041
    }
2042
}
2043

    
2044
static void opt_video_rc_eq(char *arg)
2045
{
2046
    video_rc_eq = arg;
2047
}
2048

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

    
2054
static void opt_me_threshold(const char *arg)
2055
{
2056
    me_threshold = atoi(arg);
2057
}
2058

    
2059
static void opt_verbose(const char *arg)
2060
{
2061
    verbose = atoi(arg);
2062
    av_log_level = atoi(arg);
2063
}
2064

    
2065
static void opt_frame_rate(const char *arg)
2066
{
2067
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2068
        fprintf(stderr, "Incorrect frame rate\n");
2069
        exit(1);
2070
    }
2071
}
2072

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

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

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

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

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

    
2157

    
2158
#define SCALEBITS 10
2159
#define ONE_HALF  (1 << (SCALEBITS - 1))
2160
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2161

    
2162
#define RGB_TO_Y(r, g, b) \
2163
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2164
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2165

    
2166
#define RGB_TO_U(r1, g1, b1, shift)\
2167
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2168
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2169

    
2170
#define RGB_TO_V(r1, g1, b1, shift)\
2171
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2172
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2173

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

    
2180
    r = (rgb >> 16);
2181
    g = ((rgb >> 8) & 255);
2182
    b = (rgb & 255);
2183

    
2184
    padcolor[0] = RGB_TO_Y(r,g,b);
2185
    padcolor[1] = RGB_TO_U(r,g,b,0);
2186
    padcolor[2] = RGB_TO_V(r,g,b,0);
2187
}
2188

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

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

    
2215

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

    
2229

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

    
2243

    
2244
static void opt_frame_pix_fmt(const char *arg)
2245
{
2246
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2247
}
2248

    
2249
static void opt_frame_aspect_ratio(const char *arg)
2250
{
2251
    int x = 0, y = 0;
2252
    double ar = 0;
2253
    const char *p;
2254

    
2255
    p = strchr(arg, ':');
2256
    if (p) {
2257
        x = strtol(arg, (char **)&arg, 10);
2258
        if (arg == p)
2259
            y = strtol(arg+1, (char **)&arg, 10);
2260
        if (x > 0 && y > 0)
2261
            ar = (double)x / (double)y;
2262
    } else
2263
        ar = strtod(arg, (char **)&arg);
2264

    
2265
    if (!ar) {
2266
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2267
        exit(1);
2268
    }
2269
    frame_aspect_ratio = ar;
2270
}
2271

    
2272
static void opt_qscale(const char *arg)
2273
{
2274
    video_qscale = atof(arg);
2275
    if (video_qscale <= 0 ||
2276
        video_qscale > 255) {
2277
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2278
        exit(1);
2279
    }
2280
}
2281

    
2282
static void opt_qdiff(const char *arg)
2283
{
2284
    video_qdiff = atoi(arg);
2285
    if (video_qdiff < 0 ||
2286
        video_qdiff > 31) {
2287
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2288
        exit(1);
2289
    }
2290
}
2291

    
2292
static void opt_strict(const char *arg)
2293
{
2294
    strict= atoi(arg);
2295
}
2296

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

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

    
2311
static void opt_audio_rate(const char *arg)
2312
{
2313
    audio_sample_rate = atoi(arg);
2314
}
2315

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

    
2321
static void opt_video_channel(const char *arg)
2322
{
2323
    video_channel = strtol(arg, NULL, 0);
2324
}
2325

    
2326
static void opt_video_standard(const char *arg)
2327
{
2328
    video_standard = av_strdup(arg);
2329
}
2330

    
2331
static void opt_codec(int *pstream_copy, int *pcodec_id,
2332
                      int codec_type, const char *arg)
2333
{
2334
    AVCodec *p;
2335

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

    
2354
static void opt_audio_codec(const char *arg)
2355
{
2356
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2357
}
2358

    
2359
static void opt_audio_tag(const char *arg)
2360
{
2361
    char *tail;
2362
    audio_codec_tag= strtol(arg, &tail, 0);
2363

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

    
2368
static void opt_video_tag(const char *arg)
2369
{
2370
    char *tail;
2371
    video_codec_tag= strtol(arg, &tail, 0);
2372

    
2373
    if(!tail || *tail)
2374
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2375
}
2376

    
2377
static void add_frame_hooker(const char *arg)
2378
{
2379
    int argc = 0;
2380
    char *argv[64];
2381
    int i;
2382
    char *args = av_strdup(arg);
2383

    
2384
    using_vhook = 1;
2385

    
2386
    argv[0] = strtok(args, " ");
2387
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2388
    }
2389

    
2390
    i = frame_hook_add(argc, argv);
2391

    
2392
    if (i != 0) {
2393
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2394
        exit(1);
2395
    }
2396
}
2397

    
2398
const char *motion_str[] = {
2399
    "zero",
2400
    "full",
2401
    "log",
2402
    "phods",
2403
    "epzs",
2404
    "x1",
2405
    "hex",
2406
    "umh",
2407
    "iter",
2408
    NULL,
2409
};
2410

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

    
2427
static void opt_video_codec(const char *arg)
2428
{
2429
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2430
}
2431

    
2432
static void opt_subtitle_codec(const char *arg)
2433
{
2434
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2435
}
2436

    
2437
static void opt_map(const char *arg)
2438
{
2439
    AVStreamMap *m;
2440
    const char *p;
2441

    
2442
    p = arg;
2443
    m = &stream_maps[nb_stream_maps++];
2444

    
2445
    m->file_index = strtol(arg, (char **)&p, 0);
2446
    if (*p)
2447
        p++;
2448

    
2449
    m->stream_index = strtol(p, (char **)&p, 0);
2450
    if (*p) {
2451
        p++;
2452
        m->sync_file_index = strtol(p, (char **)&p, 0);
2453
        if (*p)
2454
            p++;
2455
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2456
    } else {
2457
        m->sync_file_index = m->file_index;
2458
        m->sync_stream_index = m->stream_index;
2459
    }
2460
}
2461

    
2462
static void opt_map_meta_data(const char *arg)
2463
{
2464
    AVMetaDataMap *m;
2465
    const char *p;
2466

    
2467
    p = arg;
2468
    m = &meta_data_maps[nb_meta_data_maps++];
2469

    
2470
    m->out_file = strtol(arg, (char **)&p, 0);
2471
    if (*p)
2472
        p++;
2473

    
2474
    m->in_file = strtol(p, (char **)&p, 0);
2475
}
2476

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

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

    
2487
static void opt_rec_timestamp(const char *arg)
2488
{
2489
    rec_timestamp = parse_date(arg, 0) / 1000000;
2490
}
2491

    
2492
static void opt_input_ts_offset(const char *arg)
2493
{
2494
    input_ts_offset = parse_date(arg, 1);
2495
}
2496

    
2497
static void opt_input_file(const char *filename)
2498
{
2499
    AVFormatContext *ic;
2500
    AVFormatParameters params, *ap = &params;
2501
    int err, i, ret, rfps, rfps_base;
2502
    int64_t timestamp;
2503

    
2504
    if (!strcmp(filename, "-"))
2505
        filename = "pipe:";
2506

    
2507
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2508
                   !strcmp( filename, "/dev/stdin" );
2509

    
2510
    /* get default parameters from command line */
2511
    ic = av_alloc_format_context();
2512

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

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

    
2542
    ic->loop_input = loop_input;
2543

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

    
2552
    timestamp = start_time;
2553
    /* add the stream start time */
2554
    if (ic->start_time != AV_NOPTS_VALUE)
2555
        timestamp += ic->start_time;
2556

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

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

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

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

    
2612
                    (float)rfps / rfps_base, rfps, rfps_base);
2613
            }
2614
            /* update the current frame rate to match the stream frame rate */
2615
            frame_rate      = rfps;
2616
            frame_rate_base = rfps_base;
2617

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

    
2635
    input_files[nb_input_files] = ic;
2636
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2637
    /* dump the file content */
2638
    if (verbose >= 0)
2639
        dump_format(ic, nb_input_files, filename, 0);
2640

    
2641
    nb_input_files++;
2642
    file_iformat = NULL;
2643
    file_oformat = NULL;
2644

    
2645
    video_channel = 0;
2646

    
2647
    rate_emu = 0;
2648
}
2649

    
2650
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2651
{
2652
    int has_video, has_audio, i, j;
2653
    AVFormatContext *ic;
2654

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

    
2681
static void new_video_stream(AVFormatContext *oc)
2682
{
2683
    AVStream *st;
2684
    AVCodecContext *video_enc;
2685
    int codec_id;
2686

    
2687
    st = av_new_stream(oc, oc->nb_streams);
2688
    if (!st) {
2689
        fprintf(stderr, "Could not alloc stream\n");
2690
        exit(1);
2691
    }
2692
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2693
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2694
    video_bitstream_filters= NULL;
2695

    
2696
    if(thread_count>1)
2697
        avcodec_thread_init(st->codec, thread_count);
2698

    
2699
    video_enc = st->codec;
2700

    
2701
    if(video_codec_tag)
2702
        video_enc->codec_tag= video_codec_tag;
2703

    
2704
    if(   (video_global_header&1)
2705
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2706
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2707
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2708
    }
2709
    if(video_global_header&2){
2710
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2711
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2712
    }
2713

    
2714
    if (video_stream_copy) {
2715
        st->stream_copy = 1;
2716
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2717
    } else {
2718
        char *p;
2719
        int i;
2720
        AVCodec *codec;
2721

    
2722
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2723
        if (video_codec_id != CODEC_ID_NONE)
2724
            codec_id = video_codec_id;
2725

    
2726
        video_enc->codec_id = codec_id;
2727
        codec = avcodec_find_encoder(codec_id);
2728

    
2729
        for(i=0; i<opt_name_count; i++){
2730
             const AVOption *opt;
2731
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2732
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2733
                 av_set_double(video_enc, opt_names[i], d);
2734
        }
2735

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

    
2755
        video_enc->width = frame_width + frame_padright + frame_padleft;
2756
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2757
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2758
        video_enc->pix_fmt = frame_pix_fmt;
2759

    
2760
        if(codec && codec->pix_fmts){
2761
            const enum PixelFormat *p= codec->pix_fmts;
2762
            for(; *p!=-1; p++){
2763
                if(*p == video_enc->pix_fmt)
2764
                    break;
2765
            }
2766
            if(*p == -1)
2767
                video_enc->pix_fmt = codec->pix_fmts[0];
2768
        }
2769

    
2770
        if (intra_only)
2771
            video_enc->gop_size = 0;
2772
        if (video_qscale || same_quality) {
2773
            video_enc->flags |= CODEC_FLAG_QSCALE;
2774
            video_enc->global_quality=
2775
                st->quality = FF_QP2LAMBDA * video_qscale;
2776
        }
2777

    
2778
        if(intra_matrix)
2779
            video_enc->intra_matrix = intra_matrix;
2780
        if(inter_matrix)
2781
            video_enc->inter_matrix = inter_matrix;
2782

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

    
2817
        if (do_psnr)
2818
            video_enc->flags|= CODEC_FLAG_PSNR;
2819

    
2820
        video_enc->me_method = me_method;
2821

    
2822
        /* two pass mode */
2823
        if (do_pass) {
2824
            if (do_pass == 1) {
2825
                video_enc->flags |= CODEC_FLAG_PASS1;
2826
            } else {
2827
                video_enc->flags |= CODEC_FLAG_PASS2;
2828
            }
2829
        }
2830
    }
2831

    
2832
    /* reset some key parameters */
2833
    video_disable = 0;
2834
    video_codec_id = CODEC_ID_NONE;
2835
    video_stream_copy = 0;
2836
}
2837

    
2838
static void new_audio_stream(AVFormatContext *oc)
2839
{
2840
    AVStream *st;
2841
    AVCodecContext *audio_enc;
2842
    int codec_id, i;
2843

    
2844
    st = av_new_stream(oc, oc->nb_streams);
2845
    if (!st) {
2846
        fprintf(stderr, "Could not alloc stream\n");
2847
        exit(1);
2848
    }
2849
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2850

    
2851
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2852
    audio_bitstream_filters= NULL;
2853

    
2854
    if(thread_count>1)
2855
        avcodec_thread_init(st->codec, thread_count);
2856

    
2857
    audio_enc = st->codec;
2858
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2859
    audio_enc->strict_std_compliance = strict;
2860

    
2861
    if(audio_codec_tag)
2862
        audio_enc->codec_tag= audio_codec_tag;
2863

    
2864
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2865
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2866
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2867
    }
2868
    if (audio_stream_copy) {
2869
        st->stream_copy = 1;
2870
        audio_enc->channels = audio_channels;
2871
    } else {
2872
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2873

    
2874
        for(i=0; i<opt_name_count; i++){
2875
            const AVOption *opt;
2876
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2877
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2878
                av_set_double(audio_enc, opt_names[i], d);
2879
        }
2880

    
2881
        if (audio_codec_id != CODEC_ID_NONE)
2882
            codec_id = audio_codec_id;
2883
        audio_enc->codec_id = codec_id;
2884

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

    
2900
    /* reset some key parameters */
2901
    audio_disable = 0;
2902
    audio_codec_id = CODEC_ID_NONE;
2903
    audio_stream_copy = 0;
2904
}
2905

    
2906
static void opt_new_subtitle_stream(void)
2907
{
2908
    AVFormatContext *oc;
2909
    AVStream *st;
2910
    AVCodecContext *subtitle_enc;
2911
    int i;
2912

    
2913
    if (nb_output_files <= 0) {
2914
        fprintf(stderr, "At least one output file must be specified\n");
2915
        exit(1);
2916
    }
2917
    oc = output_files[nb_output_files - 1];
2918

    
2919
    st = av_new_stream(oc, oc->nb_streams);
2920
    if (!st) {
2921
        fprintf(stderr, "Could not alloc stream\n");
2922
        exit(1);
2923
    }
2924
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2925

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

    
2940
    if (subtitle_language) {
2941
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
2942
        av_free(subtitle_language);
2943
        subtitle_language = NULL;
2944
    }
2945

    
2946
    subtitle_codec_id = CODEC_ID_NONE;
2947
    subtitle_stream_copy = 0;
2948
}
2949

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

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

    
2972
static void opt_output_file(const char *filename)
2973
{
2974
    AVFormatContext *oc;
2975
    int use_video, use_audio, input_has_video, input_has_audio, i;
2976
    AVFormatParameters params, *ap = &params;
2977

    
2978
    if (!strcmp(filename, "-"))
2979
        filename = "pipe:";
2980

    
2981
    oc = av_alloc_format_context();
2982

    
2983
    if (!file_oformat) {
2984
        file_oformat = guess_format(NULL, filename, NULL);
2985
        if (!file_oformat) {
2986
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2987
                    filename);
2988
            exit(1);
2989
        }
2990
    }
2991

    
2992
    oc->oformat = file_oformat;
2993
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
2994

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

    
3007
        /* disable if no corresponding type found and at least one
3008
           input file */
3009
        if (nb_input_files > 0) {
3010
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3011
            if (!input_has_video)
3012
                use_video = 0;
3013
            if (!input_has_audio)
3014
                use_audio = 0;
3015
        }
3016

    
3017
        /* manual disable */
3018
        if (audio_disable) {
3019
            use_audio = 0;
3020
        }
3021
        if (video_disable) {
3022
            use_video = 0;
3023
        }
3024

    
3025
        if (use_video) {
3026
            new_video_stream(oc);
3027
        }
3028

    
3029
        if (use_audio) {
3030
            new_audio_stream(oc);
3031
        }
3032

    
3033
        oc->timestamp = rec_timestamp;
3034

    
3035
        if (str_title)
3036
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3037
        if (str_author)
3038
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3039
        if (str_copyright)
3040
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3041
        if (str_comment)
3042
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3043
        if (str_album)
3044
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3045
    }
3046

    
3047
    output_files[nb_output_files++] = oc;
3048

    
3049
    /* check filename in case of an image number is expected */
3050
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3051
        if (!av_filename_number_test(oc->filename)) {
3052
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3053
            exit(1);
3054
        }
3055
    }
3056

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

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

    
3081
        /* open the file */
3082
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3083
            fprintf(stderr, "Could not open '%s'\n", filename);
3084
            exit(1);
3085
        }
3086
    }
3087

    
3088
    memset(ap, 0, sizeof(*ap));
3089
    if (av_set_parameters(oc, ap) < 0) {
3090
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3091
                oc->filename);
3092
        exit(1);
3093
    }
3094

    
3095
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3096
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3097
    oc->loop_output = loop_output;
3098

    
3099
    for(i=0; i<opt_name_count; i++){
3100
        const AVOption *opt;
3101
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3102
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3103
            av_set_double(oc, opt_names[i], d);
3104
    }
3105

    
3106
    /* reset some options */
3107
    file_oformat = NULL;
3108
    file_iformat = NULL;
3109
}
3110

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

    
3123
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3124
static int64_t getutime(void)
3125
{
3126
  return av_gettime();
3127
}
3128
#else
3129
static int64_t getutime(void)
3130
{
3131
    struct rusage rusage;
3132

    
3133
    getrusage(RUSAGE_SELF, &rusage);
3134
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3135
}
3136
#endif
3137

    
3138
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3139
extern int ffm_nopts;
3140
#endif
3141

    
3142
static void show_formats(void)
3143
{
3144
    AVInputFormat *ifmt;
3145
    AVOutputFormat *ofmt;
3146
    URLProtocol *up;
3147
    AVCodec *p, *p2;
3148
    const char **pp, *last_name;
3149

    
3150
    printf("File formats:\n");
3151
    last_name= "000";
3152
    for(;;){
3153
        int decode=0;
3154
        int encode=0;
3155
        const char *name=NULL;
3156
        const char *long_name=NULL;
3157

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

    
3180
        printf(
3181
            " %s%s %-15s %s\n",
3182
            decode ? "D":" ",
3183
            encode ? "E":" ",
3184
            name,
3185
            long_name ? long_name:" ");
3186
    }
3187
    printf("\n");
3188

    
3189
    printf("Codecs:\n");
3190
    last_name= "000";
3191
    for(;;){
3192
        int decode=0;
3193
        int encode=0;
3194
        int cap=0;
3195
        const char *type_str;
3196

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

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

    
3243
    printf("Supported file protocols:\n");
3244
    for(up = first_protocol; up != NULL; up = up->next)
3245
        printf(" %s:", up->name);
3246
    printf("\n");
3247

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

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

    
3288
static void opt_inter_matrix(const char *arg)
3289
{
3290
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3291
    parse_matrix_coeffs(inter_matrix, arg);
3292
}
3293

    
3294
static void opt_intra_matrix(const char *arg)
3295
{
3296
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3297
    parse_matrix_coeffs(intra_matrix, arg);
3298
}
3299

    
3300
static void opt_target(const char *arg)
3301
{
3302
    int norm = -1;
3303
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3304

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

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

    
3356
    if(!strcmp(arg, "vcd")) {
3357

    
3358
        opt_video_codec("mpeg1video");
3359
        opt_audio_codec("mp2");
3360
        opt_format("vcd");
3361

    
3362
        opt_frame_size(norm ? "352x240" : "352x288");
3363
        opt_frame_rate(frame_rates[norm]);
3364
        opt_default("gop", norm ? "18" : "15");
3365

    
3366
        opt_default("b", "1150000");
3367
        opt_default("maxrate", "1150000");
3368
        opt_default("minrate", "1150000");
3369
        opt_default("bufsize", "327680"); // 40*1024*8;
3370

    
3371
        opt_default("ab", "224000");
3372
        audio_sample_rate = 44100;
3373
        audio_channels = 2;
3374

    
3375
        opt_default("packetsize", "2324");
3376
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3377

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

    
3386
        opt_video_codec("mpeg2video");
3387
        opt_audio_codec("mp2");
3388
        opt_format("svcd");
3389

    
3390
        opt_frame_size(norm ? "480x480" : "480x576");
3391
        opt_frame_rate(frame_rates[norm]);
3392
        opt_default("gop", norm ? "18" : "15");
3393

    
3394
        opt_default("b", "2040000");
3395
        opt_default("maxrate", "2516000");
3396
        opt_default("minrate", "0"); //1145000;
3397
        opt_default("bufsize", "1835008"); //224*1024*8;
3398
        opt_default("flags", "+SCAN_OFFSET");
3399

    
3400

    
3401
        opt_default("ab", "224000");
3402
        audio_sample_rate = 44100;
3403

    
3404
        opt_default("packetsize", "2324");
3405

    
3406
    } else if(!strcmp(arg, "dvd")) {
3407

    
3408
        opt_video_codec("mpeg2video");
3409
        opt_audio_codec("ac3");
3410
        opt_format("dvd");
3411

    
3412
        opt_frame_size(norm ? "720x480" : "720x576");
3413
        opt_frame_rate(frame_rates[norm]);
3414
        opt_default("gop", norm ? "18" : "15");
3415

    
3416
        opt_default("b", "6000000");
3417
        opt_default("maxrate", "9000000");
3418
        opt_default("minrate", "0"); //1500000;
3419
        opt_default("bufsize", "1835008"); //224*1024*8;
3420

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

    
3424
        opt_default("ab", "448000");
3425
        audio_sample_rate = 48000;
3426

    
3427
    } else if(!strncmp(arg, "dv", 2)) {
3428

    
3429
        opt_format("dv");
3430

    
3431
        opt_frame_size(norm ? "720x480" : "720x576");
3432
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3433
                                             (norm ? "yuv411p" : "yuv420p"));
3434
        opt_frame_rate(frame_rates[norm]);
3435

    
3436
        audio_sample_rate = 48000;
3437
        audio_channels = 2;
3438

    
3439
    } else {
3440
        fprintf(stderr, "Unknown target: %s\n", arg);
3441
        exit(1);
3442
    }
3443
}
3444

    
3445
static void opt_vstats_file (const char *arg)
3446
{
3447
    av_free (vstats_filename);
3448
    vstats_filename=av_strdup (arg);
3449
}
3450

    
3451
static void opt_vstats (void)
3452
{
3453
    char filename[40];
3454
    time_t today2 = time(NULL);
3455
    struct tm *today = localtime(&today2);
3456

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

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

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

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

    
3476
    *bsfp= bsfc;
3477
}
3478

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

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

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

    
3494
    *bsfp= bsfc;
3495
}
3496

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3721
/**
3722
 * Trivial log callback.
3723
 * Only suitable for show_help and similar since it lacks prefix handling.
3724
 */
3725
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3726
{
3727
    vfprintf(stdout, fmt, vl);
3728
}
3729

    
3730
static void show_help(void)
3731
{
3732
    av_log_set_callback(log_callback_help);
3733
    show_banner();
3734
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3735
           "Hyper fast Audio and Video encoder\n");
3736
    printf("\n");
3737
    show_help_options(options, "Main options:\n",
3738
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3739
    show_help_options(options, "\nVideo options:\n",
3740
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3741
                      OPT_VIDEO);
3742
    show_help_options(options, "\nAdvanced Video options:\n",
3743
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3744
                      OPT_VIDEO | OPT_EXPERT);
3745
    show_help_options(options, "\nAudio options:\n",
3746
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3747
                      OPT_AUDIO);
3748
    show_help_options(options, "\nAdvanced Audio options:\n",
3749
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3750
                      OPT_AUDIO | OPT_EXPERT);
3751
    show_help_options(options, "\nSubtitle options:\n",
3752
                      OPT_SUBTITLE | OPT_GRAB,
3753
                      OPT_SUBTITLE);
3754
    show_help_options(options, "\nAudio/Video grab options:\n",
3755
                      OPT_GRAB,
3756
                      OPT_GRAB);
3757
    show_help_options(options, "\nAdvanced options:\n",
3758
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3759
                      OPT_EXPERT);
3760
    av_opt_show(avctx_opts[0], NULL);
3761
    av_opt_show(avformat_opts, NULL);
3762

    
3763
    exit(1);
3764
}
3765

    
3766
void parse_arg_file(const char *filename)
3767
{
3768
    opt_output_file(filename);
3769
}
3770

    
3771
int main(int argc, char **argv)
3772
{
3773
    int i;
3774
    int64_t ti;
3775

    
3776
    av_register_all();
3777

    
3778
    for(i=0; i<CODEC_TYPE_NB; i++){
3779
        avctx_opts[i]= avcodec_alloc_context2(i);
3780
    }
3781
    avformat_opts = av_alloc_format_context();
3782

    
3783
    if (argc <= 1)
3784
        show_help();
3785
    else
3786
        show_banner();
3787

    
3788
    /* parse options */
3789
    parse_options(argc, argv, options);
3790

    
3791
    /* file converter / grab */
3792
    if (nb_output_files <= 0) {
3793
        fprintf(stderr, "Must supply at least one output file\n");
3794
        exit(1);
3795
    }
3796

    
3797
    if (nb_input_files == 0) {
3798
        fprintf(stderr, "Must supply at least one input file\n");
3799
        exit(1);
3800
    }
3801

    
3802
    ti = getutime();
3803
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3804
              stream_maps, nb_stream_maps);
3805
    ti = getutime() - ti;
3806
    if (do_benchmark) {
3807
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3808
    }
3809

    
3810
    /* close files */
3811
    for(i=0;i<nb_output_files;i++) {
3812
        /* maybe av_close_output_file ??? */
3813
        AVFormatContext *s = output_files[i];
3814
        int j;
3815
        if (!(s->oformat->flags & AVFMT_NOFILE))
3816
            url_fclose(&s->pb);
3817
        for(j=0;j<s->nb_streams;j++) {
3818
            av_free(s->streams[j]->codec);
3819
            av_free(s->streams[j]);
3820
        }
3821
        av_free(s);
3822
    }
3823
    for(i=0;i<nb_input_files;i++)
3824
        av_close_input_file(input_files[i]);
3825

    
3826
    av_free_static();
3827

    
3828
    av_free(intra_matrix);
3829
    av_free(inter_matrix);
3830

    
3831
    if (fvstats)
3832
        fclose(fvstats);
3833
    av_free(vstats_filename);
3834

    
3835
    av_free(opt_names);
3836

    
3837
#ifdef CONFIG_POWERPC_PERF
3838
    extern void powerpc_display_perf_report(void);
3839
    powerpc_display_perf_report();
3840
#endif /* CONFIG_POWERPC_PERF */
3841

    
3842
    if (received_sigterm) {
3843
        fprintf(stderr,
3844
            "Received signal %d: terminating.\n",
3845
            (int) received_sigterm);
3846
        exit (255);
3847
    }
3848

    
3849
    exit(0); /* not all OS-es handle main() return value */
3850
    return 0;
3851
}