Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 755bfeab

History | View | Annotate | Download (134 KB)

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

    
22
#include <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;
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
struct SwsContext *sws_opts;
212
static int64_t timer_start = 0;
213

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

    
218
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
219

    
220
struct AVInputStream;
221

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

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

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

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

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

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

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

    
280
#ifndef __MINGW32__
281

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

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

    
293
static volatile sig_atomic_t received_sigterm = 0;
294

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
414
        bsfc= bsfc->next;
415
    }
416

    
417
    av_interleaved_write_frame(s, pkt);
418
}
419

    
420
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
421

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
692
    *frame_size = 0;
693

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
909

    
910
    oc = output_files[0];
911

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

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

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

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

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

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

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

    
989
        fflush(stderr);
990
    }
991

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

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

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

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

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

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

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

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

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

    
1151
            ist->frame++;
1152
        }
1153

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1336

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1686
    if (!bit_buffer)
1687
        bit_buffer = av_malloc(bit_buffer_size);
1688
    if (!bit_buffer)
1689
        goto fail;
1690

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

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

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

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

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

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

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

    
1787
        out_file = output_files[out_file_index];
1788
        in_file = input_files[in_file_index];
1789

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

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

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

    
1816
    key = -1;
1817
    timer_start = av_gettime();
1818

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

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

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

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

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

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

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

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

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

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

    
1920
            av_free_packet(&pkt);
1921
            goto redo;
1922
        }
1923

    
1924
    discard_packet:
1925
        av_free_packet(&pkt);
1926

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

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

    
1939
    term_exit();
1940

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

    
1947
    /* dump report by using the first video and audio streams */
1948
    print_report(output_files, ost_table, nb_ostreams, 1);
1949

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

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

    
1967
    /* finished ! */
1968

    
1969
    ret = 0;
1970
 fail1:
1971
    av_freep(&bit_buffer);
1972
    av_free(file_table);
1973

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

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

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

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

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

    
2047
static void opt_video_rc_eq(char *arg)
2048
{
2049
    video_rc_eq = arg;
2050
}
2051

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

    
2057
static void opt_me_threshold(const char *arg)
2058
{
2059
    me_threshold = atoi(arg);
2060
}
2061

    
2062
static void opt_verbose(const char *arg)
2063
{
2064
    verbose = atoi(arg);
2065
    av_log_level = atoi(arg);
2066
}
2067

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

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

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

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

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

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

    
2160

    
2161
#define SCALEBITS 10
2162
#define ONE_HALF  (1 << (SCALEBITS - 1))
2163
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2164

    
2165
#define RGB_TO_Y(r, g, b) \
2166
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2167
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2168

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

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

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

    
2183
    r = (rgb >> 16);
2184
    g = ((rgb >> 8) & 255);
2185
    b = (rgb & 255);
2186

    
2187
    padcolor[0] = RGB_TO_Y(r,g,b);
2188
    padcolor[1] = RGB_TO_U(r,g,b,0);
2189
    padcolor[2] = RGB_TO_V(r,g,b,0);
2190
}
2191

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

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

    
2218

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

    
2232

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

    
2246
void list_pix_fmts(void)
2247
{
2248
    int i;
2249
    char pix_fmt_str[128];
2250
    for (i=-1; i < PIX_FMT_NB; i++) {
2251
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2252
        fprintf(stdout, "%s\n", pix_fmt_str);
2253
    }
2254
}
2255

    
2256
static void opt_frame_pix_fmt(const char *arg)
2257
{
2258
    if (strcmp(arg, "list"))
2259
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2260
    else {
2261
        list_pix_fmts();
2262
        exit(0);
2263
    }
2264
}
2265

    
2266
static void opt_frame_aspect_ratio(const char *arg)
2267
{
2268
    int x = 0, y = 0;
2269
    double ar = 0;
2270
    const char *p;
2271

    
2272
    p = strchr(arg, ':');
2273
    if (p) {
2274
        x = strtol(arg, (char **)&arg, 10);
2275
        if (arg == p)
2276
            y = strtol(arg+1, (char **)&arg, 10);
2277
        if (x > 0 && y > 0)
2278
            ar = (double)x / (double)y;
2279
    } else
2280
        ar = strtod(arg, (char **)&arg);
2281

    
2282
    if (!ar) {
2283
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2284
        exit(1);
2285
    }
2286
    frame_aspect_ratio = ar;
2287
}
2288

    
2289
static void opt_qscale(const char *arg)
2290
{
2291
    video_qscale = atof(arg);
2292
    if (video_qscale <= 0 ||
2293
        video_qscale > 255) {
2294
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2295
        exit(1);
2296
    }
2297
}
2298

    
2299
static void opt_qdiff(const char *arg)
2300
{
2301
    video_qdiff = atoi(arg);
2302
    if (video_qdiff < 0 ||
2303
        video_qdiff > 31) {
2304
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2305
        exit(1);
2306
    }
2307
}
2308

    
2309
static void opt_strict(const char *arg)
2310
{
2311
    strict= atoi(arg);
2312
}
2313

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

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

    
2328
static void opt_audio_rate(const char *arg)
2329
{
2330
    audio_sample_rate = atoi(arg);
2331
}
2332

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

    
2338
static void opt_video_channel(const char *arg)
2339
{
2340
    video_channel = strtol(arg, NULL, 0);
2341
}
2342

    
2343
static void opt_video_standard(const char *arg)
2344
{
2345
    video_standard = av_strdup(arg);
2346
}
2347

    
2348
static void opt_codec(int *pstream_copy, int *pcodec_id,
2349
                      int codec_type, const char *arg)
2350
{
2351
    AVCodec *p;
2352

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

    
2371
static void opt_audio_codec(const char *arg)
2372
{
2373
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2374
}
2375

    
2376
static void opt_audio_tag(const char *arg)
2377
{
2378
    char *tail;
2379
    audio_codec_tag= strtol(arg, &tail, 0);
2380

    
2381
    if(!tail || *tail)
2382
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2383
}
2384

    
2385
static void opt_video_tag(const char *arg)
2386
{
2387
    char *tail;
2388
    video_codec_tag= strtol(arg, &tail, 0);
2389

    
2390
    if(!tail || *tail)
2391
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2392
}
2393

    
2394
static void add_frame_hooker(const char *arg)
2395
{
2396
    int argc = 0;
2397
    char *argv[64];
2398
    int i;
2399
    char *args = av_strdup(arg);
2400

    
2401
    using_vhook = 1;
2402

    
2403
    argv[0] = strtok(args, " ");
2404
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2405
    }
2406

    
2407
    i = frame_hook_add(argc, argv);
2408

    
2409
    if (i != 0) {
2410
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2411
        exit(1);
2412
    }
2413
}
2414

    
2415
const char *motion_str[] = {
2416
    "zero",
2417
    "full",
2418
    "log",
2419
    "phods",
2420
    "epzs",
2421
    "x1",
2422
    "hex",
2423
    "umh",
2424
    "iter",
2425
    NULL,
2426
};
2427

    
2428
static void opt_motion_estimation(const char *arg)
2429
{
2430
    const char **p;
2431
    p = motion_str;
2432
    for(;;) {
2433
        if (!*p) {
2434
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2435
            exit(1);
2436
        }
2437
        if (!strcmp(*p, arg))
2438
            break;
2439
        p++;
2440
    }
2441
    me_method = (p - motion_str) + 1;
2442
}
2443

    
2444
static void opt_video_codec(const char *arg)
2445
{
2446
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2447
}
2448

    
2449
static void opt_subtitle_codec(const char *arg)
2450
{
2451
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2452
}
2453

    
2454
static void opt_map(const char *arg)
2455
{
2456
    AVStreamMap *m;
2457
    const char *p;
2458

    
2459
    p = arg;
2460
    m = &stream_maps[nb_stream_maps++];
2461

    
2462
    m->file_index = strtol(arg, (char **)&p, 0);
2463
    if (*p)
2464
        p++;
2465

    
2466
    m->stream_index = strtol(p, (char **)&p, 0);
2467
    if (*p) {
2468
        p++;
2469
        m->sync_file_index = strtol(p, (char **)&p, 0);
2470
        if (*p)
2471
            p++;
2472
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2473
    } else {
2474
        m->sync_file_index = m->file_index;
2475
        m->sync_stream_index = m->stream_index;
2476
    }
2477
}
2478

    
2479
static void opt_map_meta_data(const char *arg)
2480
{
2481
    AVMetaDataMap *m;
2482
    const char *p;
2483

    
2484
    p = arg;
2485
    m = &meta_data_maps[nb_meta_data_maps++];
2486

    
2487
    m->out_file = strtol(arg, (char **)&p, 0);
2488
    if (*p)
2489
        p++;
2490

    
2491
    m->in_file = strtol(p, (char **)&p, 0);
2492
}
2493

    
2494
static void opt_recording_time(const char *arg)
2495
{
2496
    recording_time = parse_date(arg, 1);
2497
}
2498

    
2499
static void opt_start_time(const char *arg)
2500
{
2501
    start_time = parse_date(arg, 1);
2502
}
2503

    
2504
static void opt_rec_timestamp(const char *arg)
2505
{
2506
    rec_timestamp = parse_date(arg, 0) / 1000000;
2507
}
2508

    
2509
static void opt_input_ts_offset(const char *arg)
2510
{
2511
    input_ts_offset = parse_date(arg, 1);
2512
}
2513

    
2514
static void opt_input_file(const char *filename)
2515
{
2516
    AVFormatContext *ic;
2517
    AVFormatParameters params, *ap = &params;
2518
    int err, i, ret, rfps, rfps_base;
2519
    int64_t timestamp;
2520

    
2521
    if (!strcmp(filename, "-"))
2522
        filename = "pipe:";
2523

    
2524
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2525
                   !strcmp( filename, "/dev/stdin" );
2526

    
2527
    /* get default parameters from command line */
2528
    ic = av_alloc_format_context();
2529

    
2530
    memset(ap, 0, sizeof(*ap));
2531
    ap->prealloced_context = 1;
2532
    ap->sample_rate = audio_sample_rate;
2533
    ap->channels = audio_channels;
2534
    ap->time_base.den = frame_rate;
2535
    ap->time_base.num = frame_rate_base;
2536
    ap->width = frame_width + frame_padleft + frame_padright;
2537
    ap->height = frame_height + frame_padtop + frame_padbottom;
2538
    ap->pix_fmt = frame_pix_fmt;
2539
    ap->channel = video_channel;
2540
    ap->standard = video_standard;
2541
    ap->video_codec_id = video_codec_id;
2542
    ap->audio_codec_id = audio_codec_id;
2543
    if(pgmyuv_compatibility_hack)
2544
        ap->video_codec_id= CODEC_ID_PGMYUV;
2545

    
2546
    for(i=0; i<opt_name_count; i++){
2547
        const AVOption *opt;
2548
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2549
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2550
            av_set_double(ic, opt_names[i], d);
2551
    }
2552
    /* open the input file with generic libav function */
2553
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2554
    if (err < 0) {
2555
        print_error(filename, err);
2556
        exit(1);
2557
    }
2558

    
2559
    ic->loop_input = loop_input;
2560

    
2561
    /* If not enough info to get the stream parameters, we decode the
2562
       first frames to get it. (used in mpeg case for example) */
2563
    ret = av_find_stream_info(ic);
2564
    if (ret < 0 && verbose >= 0) {
2565
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2566
        exit(1);
2567
    }
2568

    
2569
    timestamp = start_time;
2570
    /* add the stream start time */
2571
    if (ic->start_time != AV_NOPTS_VALUE)
2572
        timestamp += ic->start_time;
2573

    
2574
    /* if seeking requested, we execute it */
2575
    if (start_time != 0) {
2576
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2577
        if (ret < 0) {
2578
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2579
                    filename, (double)timestamp / AV_TIME_BASE);
2580
        }
2581
        /* reset seek info */
2582
        start_time = 0;
2583
    }
2584

    
2585
    /* update the current parameters so that they match the one of the input stream */
2586
    for(i=0;i<ic->nb_streams;i++) {
2587
        int j;
2588
        AVCodecContext *enc = ic->streams[i]->codec;
2589
        if(thread_count>1)
2590
            avcodec_thread_init(enc, thread_count);
2591
        enc->thread_count= thread_count;
2592
        switch(enc->codec_type) {
2593
        case CODEC_TYPE_AUDIO:
2594
            for(j=0; j<opt_name_count; j++){
2595
                const AVOption *opt;
2596
                double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2597
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2598
                    av_set_double(enc, opt_names[j], d);
2599
            }
2600
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2601
            audio_channels = enc->channels;
2602
            audio_sample_rate = enc->sample_rate;
2603
            if(audio_disable)
2604
                ic->streams[i]->discard= AVDISCARD_ALL;
2605
            break;
2606
        case CODEC_TYPE_VIDEO:
2607
            for(j=0; j<opt_name_count; j++){
2608
                const AVOption *opt;
2609
                double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2610
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2611
                    av_set_double(enc, opt_names[j], d);
2612
            }
2613
            frame_height = enc->height;
2614
            frame_width = enc->width;
2615
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2616
            frame_pix_fmt = enc->pix_fmt;
2617
            rfps      = ic->streams[i]->r_frame_rate.num;
2618
            rfps_base = ic->streams[i]->r_frame_rate.den;
2619
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2620
            if(me_threshold)
2621
                enc->debug |= FF_DEBUG_MV;
2622

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

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

    
2629
                    (float)rfps / rfps_base, rfps, rfps_base);
2630
            }
2631
            /* update the current frame rate to match the stream frame rate */
2632
            frame_rate      = rfps;
2633
            frame_rate_base = rfps_base;
2634

    
2635
            enc->rate_emu = rate_emu;
2636
            if(video_disable)
2637
                ic->streams[i]->discard= AVDISCARD_ALL;
2638
            else if(video_discard)
2639
                ic->streams[i]->discard= video_discard;
2640
            break;
2641
        case CODEC_TYPE_DATA:
2642
            break;
2643
        case CODEC_TYPE_SUBTITLE:
2644
            break;
2645
        case CODEC_TYPE_UNKNOWN:
2646
            break;
2647
        default:
2648
            av_abort();
2649
        }
2650
    }
2651

    
2652
    input_files[nb_input_files] = ic;
2653
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2654
    /* dump the file content */
2655
    if (verbose >= 0)
2656
        dump_format(ic, nb_input_files, filename, 0);
2657

    
2658
    nb_input_files++;
2659
    file_iformat = NULL;
2660
    file_oformat = NULL;
2661

    
2662
    video_channel = 0;
2663

    
2664
    rate_emu = 0;
2665
}
2666

    
2667
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2668
{
2669
    int has_video, has_audio, i, j;
2670
    AVFormatContext *ic;
2671

    
2672
    has_video = 0;
2673
    has_audio = 0;
2674
    for(j=0;j<nb_input_files;j++) {
2675
        ic = input_files[j];
2676
        for(i=0;i<ic->nb_streams;i++) {
2677
            AVCodecContext *enc = ic->streams[i]->codec;
2678
            switch(enc->codec_type) {
2679
            case CODEC_TYPE_AUDIO:
2680
                has_audio = 1;
2681
                break;
2682
            case CODEC_TYPE_VIDEO:
2683
                has_video = 1;
2684
                break;
2685
            case CODEC_TYPE_DATA:
2686
            case CODEC_TYPE_UNKNOWN:
2687
            case CODEC_TYPE_SUBTITLE:
2688
                break;
2689
            default:
2690
                av_abort();
2691
            }
2692
        }
2693
    }
2694
    *has_video_ptr = has_video;
2695
    *has_audio_ptr = has_audio;
2696
}
2697

    
2698
static void new_video_stream(AVFormatContext *oc)
2699
{
2700
    AVStream *st;
2701
    AVCodecContext *video_enc;
2702
    int codec_id;
2703

    
2704
    st = av_new_stream(oc, oc->nb_streams);
2705
    if (!st) {
2706
        fprintf(stderr, "Could not alloc stream\n");
2707
        exit(1);
2708
    }
2709
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2710
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2711
    video_bitstream_filters= NULL;
2712

    
2713
    if(thread_count>1)
2714
        avcodec_thread_init(st->codec, thread_count);
2715

    
2716
    video_enc = st->codec;
2717

    
2718
    if(video_codec_tag)
2719
        video_enc->codec_tag= video_codec_tag;
2720

    
2721
    if(   (video_global_header&1)
2722
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2723
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2724
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2725
    }
2726
    if(video_global_header&2){
2727
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2728
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2729
    }
2730

    
2731
    if (video_stream_copy) {
2732
        st->stream_copy = 1;
2733
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2734
    } else {
2735
        char *p;
2736
        int i;
2737
        AVCodec *codec;
2738

    
2739
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2740
        if (video_codec_id != CODEC_ID_NONE)
2741
            codec_id = video_codec_id;
2742

    
2743
        video_enc->codec_id = codec_id;
2744
        codec = avcodec_find_encoder(codec_id);
2745

    
2746
        for(i=0; i<opt_name_count; i++){
2747
             const AVOption *opt;
2748
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2749
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2750
                 av_set_double(video_enc, opt_names[i], d);
2751
        }
2752

    
2753
        video_enc->time_base.den = frame_rate;
2754
        video_enc->time_base.num = frame_rate_base;
2755
        if(codec && codec->supported_framerates){
2756
            const AVRational *p= codec->supported_framerates;
2757
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2758
            const AVRational *best=NULL;
2759
            AVRational best_error= (AVRational){INT_MAX, 1};
2760
            for(; p->den!=0; p++){
2761
                AVRational error= av_sub_q(req, *p);
2762
                if(error.num <0) error.num *= -1;
2763
                if(av_cmp_q(error, best_error) < 0){
2764
                    best_error= error;
2765
                    best= p;
2766
                }
2767
            }
2768
            video_enc->time_base.den= best->num;
2769
            video_enc->time_base.num= best->den;
2770
        }
2771

    
2772
        video_enc->width = frame_width + frame_padright + frame_padleft;
2773
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2774
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2775
        video_enc->pix_fmt = frame_pix_fmt;
2776

    
2777
        if(codec && codec->pix_fmts){
2778
            const enum PixelFormat *p= codec->pix_fmts;
2779
            for(; *p!=-1; p++){
2780
                if(*p == video_enc->pix_fmt)
2781
                    break;
2782
            }
2783
            if(*p == -1)
2784
                video_enc->pix_fmt = codec->pix_fmts[0];
2785
        }
2786

    
2787
        if (intra_only)
2788
            video_enc->gop_size = 0;
2789
        if (video_qscale || same_quality) {
2790
            video_enc->flags |= CODEC_FLAG_QSCALE;
2791
            video_enc->global_quality=
2792
                st->quality = FF_QP2LAMBDA * video_qscale;
2793
        }
2794

    
2795
        if(intra_matrix)
2796
            video_enc->intra_matrix = intra_matrix;
2797
        if(inter_matrix)
2798
            video_enc->inter_matrix = inter_matrix;
2799

    
2800
        video_enc->max_qdiff = video_qdiff;
2801
        video_enc->rc_eq = video_rc_eq;
2802
        video_enc->thread_count = thread_count;
2803
        p= video_rc_override_string;
2804
        for(i=0; p; i++){
2805
            int start, end, q;
2806
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2807
            if(e!=3){
2808
                fprintf(stderr, "error parsing rc_override\n");
2809
                exit(1);
2810
            }
2811
            video_enc->rc_override=
2812
                av_realloc(video_enc->rc_override,
2813
                           sizeof(RcOverride)*(i+1));
2814
            video_enc->rc_override[i].start_frame= start;
2815
            video_enc->rc_override[i].end_frame  = end;
2816
            if(q>0){
2817
                video_enc->rc_override[i].qscale= q;
2818
                video_enc->rc_override[i].quality_factor= 1.0;
2819
            }
2820
            else{
2821
                video_enc->rc_override[i].qscale= 0;
2822
                video_enc->rc_override[i].quality_factor= -q/100.0;
2823
            }
2824
            p= strchr(p, '/');
2825
            if(p) p++;
2826
        }
2827
        video_enc->rc_override_count=i;
2828
        if (!video_enc->rc_initial_buffer_occupancy)
2829
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2830
        video_enc->me_threshold= me_threshold;
2831
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2832
        video_enc->strict_std_compliance = strict;
2833

    
2834
        if (do_psnr)
2835
            video_enc->flags|= CODEC_FLAG_PSNR;
2836

    
2837
        video_enc->me_method = me_method;
2838

    
2839
        /* two pass mode */
2840
        if (do_pass) {
2841
            if (do_pass == 1) {
2842
                video_enc->flags |= CODEC_FLAG_PASS1;
2843
            } else {
2844
                video_enc->flags |= CODEC_FLAG_PASS2;
2845
            }
2846
        }
2847
    }
2848

    
2849
    /* reset some key parameters */
2850
    video_disable = 0;
2851
    video_codec_id = CODEC_ID_NONE;
2852
    video_stream_copy = 0;
2853
}
2854

    
2855
static void new_audio_stream(AVFormatContext *oc)
2856
{
2857
    AVStream *st;
2858
    AVCodecContext *audio_enc;
2859
    int codec_id, i;
2860

    
2861
    st = av_new_stream(oc, oc->nb_streams);
2862
    if (!st) {
2863
        fprintf(stderr, "Could not alloc stream\n");
2864
        exit(1);
2865
    }
2866
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2867

    
2868
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2869
    audio_bitstream_filters= NULL;
2870

    
2871
    if(thread_count>1)
2872
        avcodec_thread_init(st->codec, thread_count);
2873

    
2874
    audio_enc = st->codec;
2875
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2876
    audio_enc->strict_std_compliance = strict;
2877

    
2878
    if(audio_codec_tag)
2879
        audio_enc->codec_tag= audio_codec_tag;
2880

    
2881
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2882
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2883
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2884
    }
2885
    if (audio_stream_copy) {
2886
        st->stream_copy = 1;
2887
        audio_enc->channels = audio_channels;
2888
    } else {
2889
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2890

    
2891
        for(i=0; i<opt_name_count; i++){
2892
            const AVOption *opt;
2893
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2894
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2895
                av_set_double(audio_enc, opt_names[i], d);
2896
        }
2897

    
2898
        if (audio_codec_id != CODEC_ID_NONE)
2899
            codec_id = audio_codec_id;
2900
        audio_enc->codec_id = codec_id;
2901

    
2902
        if (audio_qscale > QSCALE_NONE) {
2903
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2904
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2905
        }
2906
        audio_enc->thread_count = thread_count;
2907
        audio_enc->channels = audio_channels;
2908
    }
2909
    audio_enc->sample_rate = audio_sample_rate;
2910
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2911
    if (audio_language) {
2912
        pstrcpy(st->language, sizeof(st->language), audio_language);
2913
        av_free(audio_language);
2914
        audio_language = NULL;
2915
    }
2916

    
2917
    /* reset some key parameters */
2918
    audio_disable = 0;
2919
    audio_codec_id = CODEC_ID_NONE;
2920
    audio_stream_copy = 0;
2921
}
2922

    
2923
static void opt_new_subtitle_stream(void)
2924
{
2925
    AVFormatContext *oc;
2926
    AVStream *st;
2927
    AVCodecContext *subtitle_enc;
2928
    int i;
2929

    
2930
    if (nb_output_files <= 0) {
2931
        fprintf(stderr, "At least one output file must be specified\n");
2932
        exit(1);
2933
    }
2934
    oc = output_files[nb_output_files - 1];
2935

    
2936
    st = av_new_stream(oc, oc->nb_streams);
2937
    if (!st) {
2938
        fprintf(stderr, "Could not alloc stream\n");
2939
        exit(1);
2940
    }
2941
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2942

    
2943
    subtitle_enc = st->codec;
2944
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2945
    if (subtitle_stream_copy) {
2946
        st->stream_copy = 1;
2947
    } else {
2948
        for(i=0; i<opt_name_count; i++){
2949
             const AVOption *opt;
2950
             double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2951
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2952
                 av_set_double(subtitle_enc, opt_names[i], d);
2953
        }
2954
        subtitle_enc->codec_id = subtitle_codec_id;
2955
    }
2956

    
2957
    if (subtitle_language) {
2958
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
2959
        av_free(subtitle_language);
2960
        subtitle_language = NULL;
2961
    }
2962

    
2963
    subtitle_codec_id = CODEC_ID_NONE;
2964
    subtitle_stream_copy = 0;
2965
}
2966

    
2967
static void opt_new_audio_stream(void)
2968
{
2969
    AVFormatContext *oc;
2970
    if (nb_output_files <= 0) {
2971
        fprintf(stderr, "At least one output file must be specified\n");
2972
        exit(1);
2973
    }
2974
    oc = output_files[nb_output_files - 1];
2975
    new_audio_stream(oc);
2976
}
2977

    
2978
static void opt_new_video_stream(void)
2979
{
2980
    AVFormatContext *oc;
2981
    if (nb_output_files <= 0) {
2982
        fprintf(stderr, "At least one output file must be specified\n");
2983
        exit(1);
2984
    }
2985
    oc = output_files[nb_output_files - 1];
2986
    new_video_stream(oc);
2987
}
2988

    
2989
static void opt_output_file(const char *filename)
2990
{
2991
    AVFormatContext *oc;
2992
    int use_video, use_audio, input_has_video, input_has_audio, i;
2993
    AVFormatParameters params, *ap = &params;
2994

    
2995
    if (!strcmp(filename, "-"))
2996
        filename = "pipe:";
2997

    
2998
    oc = av_alloc_format_context();
2999

    
3000
    if (!file_oformat) {
3001
        file_oformat = guess_format(NULL, filename, NULL);
3002
        if (!file_oformat) {
3003
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3004
                    filename);
3005
            exit(1);
3006
        }
3007
    }
3008

    
3009
    oc->oformat = file_oformat;
3010
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3011

    
3012
    if (!strcmp(file_oformat->name, "ffm") &&
3013
        strstart(filename, "http:", NULL)) {
3014
        /* special case for files sent to ffserver: we get the stream
3015
           parameters from ffserver */
3016
        if (read_ffserver_streams(oc, filename) < 0) {
3017
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3018
            exit(1);
3019
        }
3020
    } else {
3021
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3022
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3023

    
3024
        /* disable if no corresponding type found and at least one
3025
           input file */
3026
        if (nb_input_files > 0) {
3027
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3028
            if (!input_has_video)
3029
                use_video = 0;
3030
            if (!input_has_audio)
3031
                use_audio = 0;
3032
        }
3033

    
3034
        /* manual disable */
3035
        if (audio_disable) {
3036
            use_audio = 0;
3037
        }
3038
        if (video_disable) {
3039
            use_video = 0;
3040
        }
3041

    
3042
        if (use_video) {
3043
            new_video_stream(oc);
3044
        }
3045

    
3046
        if (use_audio) {
3047
            new_audio_stream(oc);
3048
        }
3049

    
3050
        oc->timestamp = rec_timestamp;
3051

    
3052
        if (str_title)
3053
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3054
        if (str_author)
3055
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3056
        if (str_copyright)
3057
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3058
        if (str_comment)
3059
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3060
        if (str_album)
3061
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3062
    }
3063

    
3064
    output_files[nb_output_files++] = oc;
3065

    
3066
    /* check filename in case of an image number is expected */
3067
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3068
        if (!av_filename_number_test(oc->filename)) {
3069
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3070
            exit(1);
3071
        }
3072
    }
3073

    
3074
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3075
        /* test if it already exists to avoid loosing precious files */
3076
        if (!file_overwrite &&
3077
            (strchr(filename, ':') == NULL ||
3078
             strstart(filename, "file:", NULL))) {
3079
            if (url_exist(filename)) {
3080
                int c;
3081

    
3082
                if ( !using_stdin ) {
3083
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3084
                    fflush(stderr);
3085
                    c = getchar();
3086
                    if (toupper(c) != 'Y') {
3087
                        fprintf(stderr, "Not overwriting - exiting\n");
3088
                        exit(1);
3089
                    }
3090
                                }
3091
                                else {
3092
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3093
                    exit(1);
3094
                                }
3095
            }
3096
        }
3097

    
3098
        /* open the file */
3099
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3100
            fprintf(stderr, "Could not open '%s'\n", filename);
3101
            exit(1);
3102
        }
3103
    }
3104

    
3105
    memset(ap, 0, sizeof(*ap));
3106
    if (av_set_parameters(oc, ap) < 0) {
3107
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3108
                oc->filename);
3109
        exit(1);
3110
    }
3111

    
3112
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3113
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3114
    oc->loop_output = loop_output;
3115

    
3116
    for(i=0; i<opt_name_count; i++){
3117
        const AVOption *opt;
3118
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3119
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3120
            av_set_double(oc, opt_names[i], d);
3121
    }
3122

    
3123
    /* reset some options */
3124
    file_oformat = NULL;
3125
    file_iformat = NULL;
3126
}
3127

    
3128
/* same option as mencoder */
3129
static void opt_pass(const char *pass_str)
3130
{
3131
    int pass;
3132
    pass = atoi(pass_str);
3133
    if (pass != 1 && pass != 2) {
3134
        fprintf(stderr, "pass number can be only 1 or 2\n");
3135
        exit(1);
3136
    }
3137
    do_pass = pass;
3138
}
3139

    
3140
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3141
static int64_t getutime(void)
3142
{
3143
  return av_gettime();
3144
}
3145
#else
3146
static int64_t getutime(void)
3147
{
3148
    struct rusage rusage;
3149

    
3150
    getrusage(RUSAGE_SELF, &rusage);
3151
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3152
}
3153
#endif
3154

    
3155
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3156
extern int ffm_nopts;
3157
#endif
3158

    
3159
static void show_formats(void)
3160
{
3161
    AVInputFormat *ifmt;
3162
    AVOutputFormat *ofmt;
3163
    URLProtocol *up;
3164
    AVCodec *p, *p2;
3165
    const char **pp, *last_name;
3166

    
3167
    printf("File formats:\n");
3168
    last_name= "000";
3169
    for(;;){
3170
        int decode=0;
3171
        int encode=0;
3172
        const char *name=NULL;
3173
        const char *long_name=NULL;
3174

    
3175
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3176
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3177
                strcmp(ofmt->name, last_name)>0){
3178
                name= ofmt->name;
3179
                long_name= ofmt->long_name;
3180
                encode=1;
3181
            }
3182
        }
3183
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3184
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3185
                strcmp(ifmt->name, last_name)>0){
3186
                name= ifmt->name;
3187
                long_name= ifmt->long_name;
3188
                encode=0;
3189
            }
3190
            if(name && strcmp(ifmt->name, name)==0)
3191
                decode=1;
3192
        }
3193
        if(name==NULL)
3194
            break;
3195
        last_name= name;
3196

    
3197
        printf(
3198
            " %s%s %-15s %s\n",
3199
            decode ? "D":" ",
3200
            encode ? "E":" ",
3201
            name,
3202
            long_name ? long_name:" ");
3203
    }
3204
    printf("\n");
3205

    
3206
    printf("Codecs:\n");
3207
    last_name= "000";
3208
    for(;;){
3209
        int decode=0;
3210
        int encode=0;
3211
        int cap=0;
3212
        const char *type_str;
3213

    
3214
        p2=NULL;
3215
        for(p = first_avcodec; p != NULL; p = p->next) {
3216
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3217
                strcmp(p->name, last_name)>0){
3218
                p2= p;
3219
                decode= encode= cap=0;
3220
            }
3221
            if(p2 && strcmp(p->name, p2->name)==0){
3222
                if(p->decode) decode=1;
3223
                if(p->encode) encode=1;
3224
                cap |= p->capabilities;
3225
            }
3226
        }
3227
        if(p2==NULL)
3228
            break;
3229
        last_name= p2->name;
3230

    
3231
        switch(p2->type) {
3232
        case CODEC_TYPE_VIDEO:
3233
            type_str = "V";
3234
            break;
3235
        case CODEC_TYPE_AUDIO:
3236
            type_str = "A";
3237
            break;
3238
        case CODEC_TYPE_SUBTITLE:
3239
            type_str = "S";
3240
            break;
3241
        default:
3242
            type_str = "?";
3243
            break;
3244
        }
3245
        printf(
3246
            " %s%s%s%s%s%s %s",
3247
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3248
            encode ? "E":" ",
3249
            type_str,
3250
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3251
            cap & CODEC_CAP_DR1 ? "D":" ",
3252
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3253
            p2->name);
3254
       /* if(p2->decoder && decode==0)
3255
            printf(" use %s for decoding", p2->decoder->name);*/
3256
        printf("\n");
3257
    }
3258
    printf("\n");
3259

    
3260
    printf("Supported file protocols:\n");
3261
    for(up = first_protocol; up != NULL; up = up->next)
3262
        printf(" %s:", up->name);
3263
    printf("\n");
3264

    
3265
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3266
    printf("Motion estimation methods:\n");
3267
    pp = motion_str;
3268
    while (*pp) {
3269
        printf(" %s", *pp);
3270
        if ((pp - motion_str + 1) == ME_ZERO)
3271
            printf("(fastest)");
3272
        else if ((pp - motion_str + 1) == ME_FULL)
3273
            printf("(slowest)");
3274
        else if ((pp - motion_str + 1) == ME_EPZS)
3275
            printf("(default)");
3276
        pp++;
3277
    }
3278
    printf("\n\n");
3279
    printf(
3280
"Note, the names of encoders and decoders do not always match, so there are\n"
3281
"several cases where the above table shows encoder only or decoder only entries\n"
3282
"even though both encoding and decoding are supported. For example, the h263\n"
3283
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3284
"worse.\n");
3285
    exit(1);
3286
}
3287

    
3288
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3289
{
3290
    int i;
3291
    const char *p = str;
3292
    for(i = 0;; i++) {
3293
        dest[i] = atoi(p);
3294
        if(i == 63)
3295
            break;
3296
        p = strchr(p, ',');
3297
        if(!p) {
3298
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3299
            exit(1);
3300
        }
3301
        p++;
3302
    }
3303
}
3304

    
3305
static void opt_inter_matrix(const char *arg)
3306
{
3307
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3308
    parse_matrix_coeffs(inter_matrix, arg);
3309
}
3310

    
3311
static void opt_intra_matrix(const char *arg)
3312
{
3313
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3314
    parse_matrix_coeffs(intra_matrix, arg);
3315
}
3316

    
3317
static void opt_target(const char *arg)
3318
{
3319
    int norm = -1;
3320
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3321

    
3322
    if(!strncmp(arg, "pal-", 4)) {
3323
        norm = 0;
3324
        arg += 4;
3325
    } else if(!strncmp(arg, "ntsc-", 5)) {
3326
        norm = 1;
3327
        arg += 5;
3328
    } else if(!strncmp(arg, "film-", 5)) {
3329
        norm = 2;
3330
        arg += 5;
3331
    } else {
3332
        int fr;
3333
        /* Calculate FR via float to avoid int overflow */
3334
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3335
        if(fr == 25000) {
3336
            norm = 0;
3337
        } else if((fr == 29970) || (fr == 23976)) {
3338
            norm = 1;
3339
        } else {
3340
            /* Try to determine PAL/NTSC by peeking in the input files */
3341
            if(nb_input_files) {
3342
                int i, j;
3343
                for(j = 0; j < nb_input_files; j++) {
3344
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3345
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3346
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3347
                            continue;
3348
                        fr = c->time_base.den * 1000 / c->time_base.num;
3349
                        if(fr == 25000) {
3350
                            norm = 0;
3351
                            break;
3352
                        } else if((fr == 29970) || (fr == 23976)) {
3353
                            norm = 1;
3354
                            break;
3355
                        }
3356
                    }
3357
                    if(norm >= 0)
3358
                        break;
3359
                }
3360
            }
3361
        }
3362
        if(verbose && norm >= 0)
3363
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3364
    }
3365

    
3366
    if(norm < 0) {
3367
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3368
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3369
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3370
        exit(1);
3371
    }
3372

    
3373
    if(!strcmp(arg, "vcd")) {
3374

    
3375
        opt_video_codec("mpeg1video");
3376
        opt_audio_codec("mp2");
3377
        opt_format("vcd");
3378

    
3379
        opt_frame_size(norm ? "352x240" : "352x288");
3380
        opt_frame_rate(frame_rates[norm]);
3381
        opt_default("gop", norm ? "18" : "15");
3382

    
3383
        opt_default("b", "1150000");
3384
        opt_default("maxrate", "1150000");
3385
        opt_default("minrate", "1150000");
3386
        opt_default("bufsize", "327680"); // 40*1024*8;
3387

    
3388
        opt_default("ab", "224000");
3389
        audio_sample_rate = 44100;
3390
        audio_channels = 2;
3391

    
3392
        opt_default("packetsize", "2324");
3393
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3394

    
3395
        /* We have to offset the PTS, so that it is consistent with the SCR.
3396
           SCR starts at 36000, but the first two packs contain only padding
3397
           and the first pack from the other stream, respectively, may also have
3398
           been written before.
3399
           So the real data starts at SCR 36000+3*1200. */
3400
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3401
    } else if(!strcmp(arg, "svcd")) {
3402

    
3403
        opt_video_codec("mpeg2video");
3404
        opt_audio_codec("mp2");
3405
        opt_format("svcd");
3406

    
3407
        opt_frame_size(norm ? "480x480" : "480x576");
3408
        opt_frame_rate(frame_rates[norm]);
3409
        opt_default("gop", norm ? "18" : "15");
3410

    
3411
        opt_default("b", "2040000");
3412
        opt_default("maxrate", "2516000");
3413
        opt_default("minrate", "0"); //1145000;
3414
        opt_default("bufsize", "1835008"); //224*1024*8;
3415
        opt_default("flags", "+SCAN_OFFSET");
3416

    
3417

    
3418
        opt_default("ab", "224000");
3419
        audio_sample_rate = 44100;
3420

    
3421
        opt_default("packetsize", "2324");
3422

    
3423
    } else if(!strcmp(arg, "dvd")) {
3424

    
3425
        opt_video_codec("mpeg2video");
3426
        opt_audio_codec("ac3");
3427
        opt_format("dvd");
3428

    
3429
        opt_frame_size(norm ? "720x480" : "720x576");
3430
        opt_frame_rate(frame_rates[norm]);
3431
        opt_default("gop", norm ? "18" : "15");
3432

    
3433
        opt_default("b", "6000000");
3434
        opt_default("maxrate", "9000000");
3435
        opt_default("minrate", "0"); //1500000;
3436
        opt_default("bufsize", "1835008"); //224*1024*8;
3437

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

    
3441
        opt_default("ab", "448000");
3442
        audio_sample_rate = 48000;
3443

    
3444
    } else if(!strncmp(arg, "dv", 2)) {
3445

    
3446
        opt_format("dv");
3447

    
3448
        opt_frame_size(norm ? "720x480" : "720x576");
3449
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3450
                                             (norm ? "yuv411p" : "yuv420p"));
3451
        opt_frame_rate(frame_rates[norm]);
3452

    
3453
        audio_sample_rate = 48000;
3454
        audio_channels = 2;
3455

    
3456
    } else {
3457
        fprintf(stderr, "Unknown target: %s\n", arg);
3458
        exit(1);
3459
    }
3460
}
3461

    
3462
static void opt_vstats_file (const char *arg)
3463
{
3464
    av_free (vstats_filename);
3465
    vstats_filename=av_strdup (arg);
3466
}
3467

    
3468
static void opt_vstats (void)
3469
{
3470
    char filename[40];
3471
    time_t today2 = time(NULL);
3472
    struct tm *today = localtime(&today2);
3473

    
3474
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3475
             today->tm_sec);
3476
    opt_vstats_file(filename);
3477
}
3478

    
3479
static void opt_video_bsf(const char *arg)
3480
{
3481
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3482
    AVBitStreamFilterContext **bsfp;
3483

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

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

    
3493
    *bsfp= bsfc;
3494
}
3495

    
3496
//FIXME avoid audio - video code duplication
3497
static void opt_audio_bsf(const char *arg)
3498
{
3499
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3500
    AVBitStreamFilterContext **bsfp;
3501

    
3502
    if(!bsfc){
3503
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3504
        exit(1);
3505
    }
3506

    
3507
    bsfp= &audio_bitstream_filters;
3508
    while(*bsfp)
3509
        bsfp= &(*bsfp)->next;
3510

    
3511
    *bsfp= bsfc;
3512
}
3513

    
3514
static void show_version(void)
3515
{
3516
    /* TODO: add function interface to avutil and avformat */
3517
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3518
           "libavutil   %d\n"
3519
           "libavcodec  %d\n"
3520
           "libavformat %d\n",
3521
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3522
    exit(1);
3523
}
3524

    
3525
static int opt_default(const char *opt, const char *arg){
3526
    int type;
3527
    const AVOption *o= NULL;
3528
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3529

    
3530
    for(type=0; type<CODEC_TYPE_NB; type++){
3531
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3532
        if(o2)
3533
            o = av_set_string(avctx_opts[type], opt, arg);
3534
    }
3535
    if(!o)
3536
        o = av_set_string(avformat_opts, opt, arg);
3537
    if(ENABLE_SWSCALER && !o)
3538
        o = av_set_string(sws_opts, opt, arg);
3539
    if(!o){
3540
        if(opt[0] == 'a')
3541
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3542
        else if(opt[0] == 'v')
3543
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3544
        else if(opt[0] == 's')
3545
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3546
    }
3547
    if(!o)
3548
        return -1;
3549

    
3550
//    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));
3551

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

    
3556
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3557
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3558
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3559
        ffm_nopts = 1;
3560
#endif
3561

    
3562
    if(avctx_opts[0]->debug)
3563
        av_log_level = AV_LOG_DEBUG;
3564
    return 0;
3565
}
3566

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

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

    
3653
    /* audio options */
3654
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3655
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3656
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3657
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3658
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3659
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3660
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3661
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3662
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3663
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3664

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

    
3670
    /* grab options */
3671
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3672
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3673
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3674

    
3675
    /* muxer options */
3676
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3677
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3678

    
3679
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3680
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3681

    
3682
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3683
    { NULL, },
3684
};
3685

    
3686
static void show_banner(void)
3687
{
3688
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3689
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3690
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3691
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3692
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3693
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3694
#ifdef __GNUC__
3695
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3696
#else
3697
    fprintf(stderr, ", using a non-gcc compiler\n");
3698
#endif
3699
}
3700

    
3701
static void show_license(void)
3702
{
3703
    show_banner();
3704
#ifdef CONFIG_GPL
3705
    printf(
3706
    "FFmpeg is free software; you can redistribute it and/or modify\n"
3707
    "it under the terms of the GNU General Public License as published by\n"
3708
    "the Free Software Foundation; either version 2 of the License, or\n"
3709
    "(at your option) any later version.\n"
3710
    "\n"
3711
    "FFmpeg is distributed in the hope that it will be useful,\n"
3712
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3713
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3714
    "GNU General Public License for more details.\n"
3715
    "\n"
3716
    "You should have received a copy of the GNU General Public License\n"
3717
    "along with FFmpeg; if not, write to the Free Software\n"
3718
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3719
    );
3720
#else
3721
    printf(
3722
    "FFmpeg is free software; you can redistribute it and/or\n"
3723
    "modify it under the terms of the GNU Lesser General Public\n"
3724
    "License as published by the Free Software Foundation; either\n"
3725
    "version 2.1 of the License, or (at your option) any later version.\n"
3726
    "\n"
3727
    "FFmpeg is distributed in the hope that it will be useful,\n"
3728
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3729
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3730
    "Lesser General Public License for more details.\n"
3731
    "\n"
3732
    "You should have received a copy of the GNU Lesser General Public\n"
3733
    "License along with FFmpeg; if not, write to the Free Software\n"
3734
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3735
    );
3736
#endif
3737
    exit(1);
3738
}
3739

    
3740
/**
3741
 * Trivial log callback.
3742
 * Only suitable for show_help and similar since it lacks prefix handling.
3743
 */
3744
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3745
{
3746
    vfprintf(stdout, fmt, vl);
3747
}
3748

    
3749
static void show_help(void)
3750
{
3751
    av_log_set_callback(log_callback_help);
3752
    show_banner();
3753
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3754
           "Hyper fast Audio and Video encoder\n");
3755
    printf("\n");
3756
    show_help_options(options, "Main options:\n",
3757
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3758
    show_help_options(options, "\nVideo options:\n",
3759
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3760
                      OPT_VIDEO);
3761
    show_help_options(options, "\nAdvanced Video options:\n",
3762
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3763
                      OPT_VIDEO | OPT_EXPERT);
3764
    show_help_options(options, "\nAudio options:\n",
3765
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3766
                      OPT_AUDIO);
3767
    show_help_options(options, "\nAdvanced Audio options:\n",
3768
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3769
                      OPT_AUDIO | OPT_EXPERT);
3770
    show_help_options(options, "\nSubtitle options:\n",
3771
                      OPT_SUBTITLE | OPT_GRAB,
3772
                      OPT_SUBTITLE);
3773
    show_help_options(options, "\nAudio/Video grab options:\n",
3774
                      OPT_GRAB,
3775
                      OPT_GRAB);
3776
    show_help_options(options, "\nAdvanced options:\n",
3777
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3778
                      OPT_EXPERT);
3779
    av_opt_show(avctx_opts[0], NULL);
3780
    av_opt_show(avformat_opts, NULL);
3781
    if (ENABLE_SWSCALER)
3782
        av_opt_show(sws_opts, NULL);
3783

    
3784
    exit(1);
3785
}
3786

    
3787
void parse_arg_file(const char *filename)
3788
{
3789
    opt_output_file(filename);
3790
}
3791

    
3792
int main(int argc, char **argv)
3793
{
3794
    int i;
3795
    int64_t ti;
3796

    
3797
    av_register_all();
3798

    
3799
    for(i=0; i<CODEC_TYPE_NB; i++){
3800
        avctx_opts[i]= avcodec_alloc_context2(i);
3801
    }
3802
    avformat_opts = av_alloc_format_context();
3803
    if (ENABLE_SWSCALER)
3804
        sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3805

    
3806
    if (argc <= 1)
3807
        show_help();
3808
    else
3809
        show_banner();
3810

    
3811
    /* parse options */
3812
    parse_options(argc, argv, options);
3813

    
3814
    /* file converter / grab */
3815
    if (nb_output_files <= 0) {
3816
        fprintf(stderr, "Must supply at least one output file\n");
3817
        exit(1);
3818
    }
3819

    
3820
    if (nb_input_files == 0) {
3821
        fprintf(stderr, "Must supply at least one input file\n");
3822
        exit(1);
3823
    }
3824

    
3825
    ti = getutime();
3826
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3827
              stream_maps, nb_stream_maps);
3828
    ti = getutime() - ti;
3829
    if (do_benchmark) {
3830
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3831
    }
3832

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

    
3849
    av_free_static();
3850

    
3851
    av_free(intra_matrix);
3852
    av_free(inter_matrix);
3853

    
3854
    if (fvstats)
3855
        fclose(fvstats);
3856
    av_free(vstats_filename);
3857

    
3858
    av_free(opt_names);
3859

    
3860
    av_free(video_standard);
3861

    
3862
#ifdef CONFIG_POWERPC_PERF
3863
    extern void powerpc_display_perf_report(void);
3864
    powerpc_display_perf_report();
3865
#endif /* CONFIG_POWERPC_PERF */
3866

    
3867
    if (received_sigterm) {
3868
        fprintf(stderr,
3869
            "Received signal %d: terminating.\n",
3870
            (int) received_sigterm);
3871
        exit (255);
3872
    }
3873

    
3874
    exit(0); /* not all OS-es handle main() return value */
3875
    return 0;
3876
}