Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a03d59b7

History | View | Annotate | Download (133 KB)

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

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

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

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

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

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

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

    
64
#undef exit
65

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

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

    
80
extern const OptionDef options[];
81

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

    
86
#define MAX_FILES 20
87

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

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

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

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

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

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

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

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

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

    
186
static int rate_emu = 0;
187

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

    
191
static int audio_volume = 256;
192

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

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

    
209
static int sws_flags = SWS_BICUBIC;
210

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

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

    
222
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
223

    
224
struct AVInputStream;
225

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

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

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

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

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

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

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

    
284
#ifdef HAVE_TERMIOS_H
285

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

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

    
297
static volatile sig_atomic_t received_sigterm = 0;
298

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
418
        bsfc= bsfc->next;
419
    }
420

    
421
    av_interleaved_write_frame(s, pkt);
422
}
423

    
424
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
425

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
697
    *frame_size = 0;
698

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
912

    
913
    oc = output_files[0];
914

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

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

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

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

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

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

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

    
992
        fflush(stderr);
993
    }
994

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

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

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

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

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

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

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

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

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

    
1154
            ist->frame++;
1155
        }
1156

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

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

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

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

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

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

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

    
1226
                        opkt.stream_index= ost->index;
1227
                        if(pkt->pts != AV_NOPTS_VALUE)
1228
                            opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1229
                        else
1230
                            opkt.pts= AV_NOPTS_VALUE;
1231

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

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

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

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

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

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

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

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

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

    
1340

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1930
    discard_packet:
1931
        av_free_packet(&pkt);
1932

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

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

    
1945
    term_exit();
1946

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

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

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

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

    
1973
    /* finished ! */
1974

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2166

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

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

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

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

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

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

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

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

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

    
2224

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

    
2238

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2408
    using_vhook = 1;
2409

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

    
2414
    i = frame_hook_add(argc, argv);
2415

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2538
    ic->loop_input = loop_input;
2539

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

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

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

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

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

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

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

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

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

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

    
2641
    video_channel = 0;
2642

    
2643
    rate_emu = 0;
2644
}
2645

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

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

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

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

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

    
2695
    video_enc = st->codec;
2696

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2975
    oc = av_alloc_format_context();
2976

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

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

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

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

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

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

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

    
3027
        oc->timestamp = rec_timestamp;
3028

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

    
3041
    output_files[nb_output_files++] = oc;
3042

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3385

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

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

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

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

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

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

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

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

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

    
3414
        opt_format("dv");
3415

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

    
3421
        audio_sample_rate = 48000;
3422
        audio_channels = 2;
3423

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

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

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

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

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

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

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

    
3461
    *bsfp= bsfc;
3462
}
3463

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

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

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

    
3479
    *bsfp= bsfc;
3480
}
3481

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3751
    exit(1);
3752
}
3753

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

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

    
3764
    av_register_all();
3765

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

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

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

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

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

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

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

    
3815
    av_free_static();
3816

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

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

    
3824
    av_free(opt_names);
3825

    
3826
    av_free(video_standard);
3827

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

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

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