Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4efd6f58

History | View | Annotate | Download (134 KB)

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

    
22
#include "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_disable = 0;
154
static int subtitle_codec_id = CODEC_ID_NONE;
155
static char *subtitle_language = NULL;
156

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

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

    
187
static int rate_emu = 0;
188

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

    
192
static int audio_volume = 256;
193

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

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

    
210
static int sws_flags = SWS_BICUBIC;
211

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

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

    
223
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
224

    
225
struct AVInputStream;
226

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

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

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

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

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

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

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

    
285
#ifdef HAVE_TERMIOS_H
286

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

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

    
298
static volatile sig_atomic_t received_sigterm = 0;
299

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
419
        bsfc= bsfc->next;
420
    }
421

    
422
    av_interleaved_write_frame(s, pkt);
423
}
424

    
425
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
426

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
698
    *frame_size = 0;
699

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
913

    
914
    oc = output_files[0];
915

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

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

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

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

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

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

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

    
993
        fflush(stderr);
994
    }
995

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

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

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

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

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

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

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

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

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

    
1155
            ist->frame++;
1156
        }
1157

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

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

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

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

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

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

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

    
1227
                        opkt.stream_index= ost->index;
1228
                        if(pkt->pts != AV_NOPTS_VALUE)
1229
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1230
                        else
1231
                            opkt.pts= AV_NOPTS_VALUE;
1232

    
1233
                            if (pkt->dts == AV_NOPTS_VALUE)
1234
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1235
                            else
1236
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1237

    
1238
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1239
                        opkt.flags= pkt->flags;
1240

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

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

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

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

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

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

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

    
1333
    return 0;
1334
 fail_decode:
1335
    return -1;
1336
}
1337

    
1338

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1505
        codec = ost->st->codec;
1506
        icodec = ist->st->codec;
1507

    
1508
        if (!ost->st->language[0])
1509
            av_strlcpy(ost->st->language, ist->st->language,
1510
                       sizeof(ost->st->language));
1511

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

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

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

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

    
1693
    if (!bit_buffer)
1694
        bit_buffer = av_malloc(bit_buffer_size);
1695
    if (!bit_buffer)
1696
        goto fail;
1697

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

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

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

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

    
1763
    /* init pts */
1764
    for(i=0;i<nb_istreams;i++) {
1765
        ist = ist_table[i];
1766
        is = input_files[ist->file_index];
1767
        ist->pts = 0;
1768
        ist->next_pts=0;
1769
        if(input_files_ts_offset[ist->file_index] != -is->start_time)
1770
            ist->next_pts= AV_NOPTS_VALUE;
1771
        ist->is_start = 1;
1772
    }
1773

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

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

    
1792
        out_file = output_files[out_file_index];
1793
        in_file = input_files[in_file_index];
1794

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

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

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

    
1821
    key = -1;
1822
    timer_start = av_gettime();
1823

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

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

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

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

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

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

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

    
1906
        if (pkt.dts != AV_NOPTS_VALUE)
1907
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1908
        if (pkt.pts != AV_NOPTS_VALUE)
1909
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1910

    
1911
//        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);
1912
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1913
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1914
            if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1915
                input_files_ts_offset[ist->file_index]-= delta;
1916
                if (verbose > 2)
1917
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1918
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1919
                if(pkt.pts != AV_NOPTS_VALUE)
1920
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1921
            }
1922
        }
1923

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

    
1927
            if (verbose >= 0)
1928
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1929
                        ist->file_index, ist->index);
1930

    
1931
            av_free_packet(&pkt);
1932
            goto redo;
1933
        }
1934

    
1935
    discard_packet:
1936
        av_free_packet(&pkt);
1937

    
1938
        /* dump report by using the output first video and audio streams */
1939
        print_report(output_files, ost_table, nb_ostreams, 0);
1940
    }
1941

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

    
1950
    term_exit();
1951

    
1952
    /* write the trailer if needed and close file */
1953
    for(i=0;i<nb_output_files;i++) {
1954
        os = output_files[i];
1955
        av_write_trailer(os);
1956
    }
1957

    
1958
    /* dump report by using the first video and audio streams */
1959
    print_report(output_files, ost_table, nb_ostreams, 1);
1960

    
1961
    /* close each encoder */
1962
    for(i=0;i<nb_ostreams;i++) {
1963
        ost = ost_table[i];
1964
        if (ost->encoding_needed) {
1965
            av_freep(&ost->st->codec->stats_in);
1966
            avcodec_close(ost->st->codec);
1967
        }
1968
    }
1969

    
1970
    /* close each decoder */
1971
    for(i=0;i<nb_istreams;i++) {
1972
        ist = ist_table[i];
1973
        if (ist->decoding_needed) {
1974
            avcodec_close(ist->st->codec);
1975
        }
1976
    }
1977

    
1978
    /* finished ! */
1979

    
1980
    ret = 0;
1981
 fail1:
1982
    av_freep(&bit_buffer);
1983
    av_free(file_table);
1984

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

    
2018
#if 0
2019
int file_read(const char *filename)
2020
{
2021
    URLContext *h;
2022
    unsigned char buffer[1024];
2023
    int len, i;
2024

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

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

    
2050
    file_iformat = av_find_input_format(arg);
2051
    file_oformat = guess_format(arg, NULL, NULL);
2052
    if (!file_iformat && !file_oformat) {
2053
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2054
        exit(1);
2055
    }
2056
}
2057

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

    
2063
static void opt_video_rc_override_string(char *arg)
2064
{
2065
    video_rc_override_string = arg;
2066
}
2067

    
2068
static void opt_me_threshold(const char *arg)
2069
{
2070
    me_threshold = atoi(arg);
2071
}
2072

    
2073
static void opt_verbose(const char *arg)
2074
{
2075
    verbose = atoi(arg);
2076
    av_log_level = atoi(arg);
2077
}
2078

    
2079
static void opt_frame_rate(const char *arg)
2080
{
2081
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2082
        fprintf(stderr, "Incorrect frame rate\n");
2083
        exit(1);
2084
    }
2085
}
2086

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

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

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

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

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

    
2171

    
2172
#define SCALEBITS 10
2173
#define ONE_HALF  (1 << (SCALEBITS - 1))
2174
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2175

    
2176
#define RGB_TO_Y(r, g, b) \
2177
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2178
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2179

    
2180
#define RGB_TO_U(r1, g1, b1, shift)\
2181
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2182
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2183

    
2184
#define RGB_TO_V(r1, g1, b1, shift)\
2185
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2186
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2187

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

    
2194
    r = (rgb >> 16);
2195
    g = ((rgb >> 8) & 255);
2196
    b = (rgb & 255);
2197

    
2198
    padcolor[0] = RGB_TO_Y(r,g,b);
2199
    padcolor[1] = RGB_TO_U(r,g,b,0);
2200
    padcolor[2] = RGB_TO_V(r,g,b,0);
2201
}
2202

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

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

    
2229

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

    
2243

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

    
2257
void list_pix_fmts(void)
2258
{
2259
    int i;
2260
    char pix_fmt_str[128];
2261
    for (i=-1; i < PIX_FMT_NB; i++) {
2262
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2263
        fprintf(stdout, "%s\n", pix_fmt_str);
2264
    }
2265
}
2266

    
2267
static void opt_frame_pix_fmt(const char *arg)
2268
{
2269
    if (strcmp(arg, "list"))
2270
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2271
    else {
2272
        list_pix_fmts();
2273
        exit(0);
2274
    }
2275
}
2276

    
2277
static void opt_frame_aspect_ratio(const char *arg)
2278
{
2279
    int x = 0, y = 0;
2280
    double ar = 0;
2281
    const char *p;
2282

    
2283
    p = strchr(arg, ':');
2284
    if (p) {
2285
        x = strtol(arg, (char **)&arg, 10);
2286
        if (arg == p)
2287
            y = strtol(arg+1, (char **)&arg, 10);
2288
        if (x > 0 && y > 0)
2289
            ar = (double)x / (double)y;
2290
    } else
2291
        ar = strtod(arg, (char **)&arg);
2292

    
2293
    if (!ar) {
2294
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2295
        exit(1);
2296
    }
2297
    frame_aspect_ratio = ar;
2298
}
2299

    
2300
static void opt_qscale(const char *arg)
2301
{
2302
    video_qscale = atof(arg);
2303
    if (video_qscale <= 0 ||
2304
        video_qscale > 255) {
2305
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2306
        exit(1);
2307
    }
2308
}
2309

    
2310
static void opt_qdiff(const char *arg)
2311
{
2312
    video_qdiff = atoi(arg);
2313
    if (video_qdiff < 0 ||
2314
        video_qdiff > 31) {
2315
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2316
        exit(1);
2317
    }
2318
}
2319

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

    
2325
static void opt_top_field_first(const char *arg)
2326
{
2327
    top_field_first= atoi(arg);
2328
}
2329

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

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

    
2344
static void opt_audio_channels(const char *arg)
2345
{
2346
    audio_channels = atoi(arg);
2347
}
2348

    
2349
static void opt_video_channel(const char *arg)
2350
{
2351
    video_channel = strtol(arg, NULL, 0);
2352
}
2353

    
2354
static void opt_video_standard(const char *arg)
2355
{
2356
    video_standard = av_strdup(arg);
2357
}
2358

    
2359
static void opt_codec(int *pstream_copy, int *pcodec_id,
2360
                      int codec_type, const char *arg)
2361
{
2362
    AVCodec *p;
2363

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

    
2382
static void opt_audio_codec(const char *arg)
2383
{
2384
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2385
}
2386

    
2387
static void opt_audio_tag(const char *arg)
2388
{
2389
    char *tail;
2390
    audio_codec_tag= strtol(arg, &tail, 0);
2391

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

    
2396
static void opt_video_tag(const char *arg)
2397
{
2398
    char *tail;
2399
    video_codec_tag= strtol(arg, &tail, 0);
2400

    
2401
    if(!tail || *tail)
2402
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2403
}
2404

    
2405
#ifdef CONFIG_VHOOK
2406
static void add_frame_hooker(const char *arg)
2407
{
2408
    int argc = 0;
2409
    char *argv[64];
2410
    int i;
2411
    char *args = av_strdup(arg);
2412

    
2413
    using_vhook = 1;
2414

    
2415
    argv[0] = strtok(args, " ");
2416
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2417
    }
2418

    
2419
    i = frame_hook_add(argc, argv);
2420

    
2421
    if (i != 0) {
2422
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2423
        exit(1);
2424
    }
2425
}
2426
#endif
2427

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2543
    ic->loop_input = loop_input;
2544

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

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

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

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

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

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

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

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

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

    
2644
    nb_input_files++;
2645
    file_iformat = NULL;
2646
    file_oformat = NULL;
2647

    
2648
    video_channel = 0;
2649

    
2650
    rate_emu = 0;
2651
}
2652

    
2653
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2654
                                         int *has_subtitle_ptr)
2655
{
2656
    int has_video, has_audio, has_subtitle, i, j;
2657
    AVFormatContext *ic;
2658

    
2659
    has_video = 0;
2660
    has_audio = 0;
2661
    has_subtitle = 0;
2662
    for(j=0;j<nb_input_files;j++) {
2663
        ic = input_files[j];
2664
        for(i=0;i<ic->nb_streams;i++) {
2665
            AVCodecContext *enc = ic->streams[i]->codec;
2666
            switch(enc->codec_type) {
2667
            case CODEC_TYPE_AUDIO:
2668
                has_audio = 1;
2669
                break;
2670
            case CODEC_TYPE_VIDEO:
2671
                has_video = 1;
2672
                break;
2673
            case CODEC_TYPE_SUBTITLE:
2674
                has_subtitle = 1;
2675
                break;
2676
            case CODEC_TYPE_DATA:
2677
            case CODEC_TYPE_UNKNOWN:
2678
                break;
2679
            default:
2680
                abort();
2681
            }
2682
        }
2683
    }
2684
    *has_video_ptr = has_video;
2685
    *has_audio_ptr = has_audio;
2686
    *has_subtitle_ptr = has_subtitle;
2687
}
2688

    
2689
static void new_video_stream(AVFormatContext *oc)
2690
{
2691
    AVStream *st;
2692
    AVCodecContext *video_enc;
2693
    int codec_id;
2694

    
2695
    st = av_new_stream(oc, oc->nb_streams);
2696
    if (!st) {
2697
        fprintf(stderr, "Could not alloc stream\n");
2698
        exit(1);
2699
    }
2700
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2701
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2702
    video_bitstream_filters= NULL;
2703

    
2704
    if(thread_count>1)
2705
        avcodec_thread_init(st->codec, thread_count);
2706

    
2707
    video_enc = st->codec;
2708

    
2709
    if(video_codec_tag)
2710
        video_enc->codec_tag= video_codec_tag;
2711

    
2712
    if(   (video_global_header&1)
2713
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2714
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2715
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2716
    }
2717
    if(video_global_header&2){
2718
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2719
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2720
    }
2721

    
2722
    if (video_stream_copy) {
2723
        st->stream_copy = 1;
2724
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2725
    } else {
2726
        char *p;
2727
        int i;
2728
        AVCodec *codec;
2729

    
2730
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2731
        if (video_codec_id != CODEC_ID_NONE)
2732
            codec_id = video_codec_id;
2733

    
2734
        video_enc->codec_id = codec_id;
2735
        codec = avcodec_find_encoder(codec_id);
2736

    
2737
        for(i=0; i<opt_name_count; i++){
2738
             const AVOption *opt;
2739
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2740
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2741
                 av_set_double(video_enc, opt_names[i], d);
2742
        }
2743

    
2744
        video_enc->time_base.den = frame_rate.num;
2745
        video_enc->time_base.num = frame_rate.den;
2746
        if(codec && codec->supported_framerates){
2747
            const AVRational *p= codec->supported_framerates;
2748
            AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2749
            const AVRational *best=NULL;
2750
            AVRational best_error= (AVRational){INT_MAX, 1};
2751
            for(; p->den!=0; p++){
2752
                AVRational error= av_sub_q(req, *p);
2753
                if(error.num <0) error.num *= -1;
2754
                if(av_cmp_q(error, best_error) < 0){
2755
                    best_error= error;
2756
                    best= p;
2757
                }
2758
            }
2759
            video_enc->time_base.den= best->num;
2760
            video_enc->time_base.num= best->den;
2761
        }
2762

    
2763
        video_enc->width = frame_width + frame_padright + frame_padleft;
2764
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2765
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2766
        video_enc->pix_fmt = frame_pix_fmt;
2767

    
2768
        if(codec && codec->pix_fmts){
2769
            const enum PixelFormat *p= codec->pix_fmts;
2770
            for(; *p!=-1; p++){
2771
                if(*p == video_enc->pix_fmt)
2772
                    break;
2773
            }
2774
            if(*p == -1)
2775
                video_enc->pix_fmt = codec->pix_fmts[0];
2776
        }
2777

    
2778
        if (intra_only)
2779
            video_enc->gop_size = 0;
2780
        if (video_qscale || same_quality) {
2781
            video_enc->flags |= CODEC_FLAG_QSCALE;
2782
            video_enc->global_quality=
2783
                st->quality = FF_QP2LAMBDA * video_qscale;
2784
        }
2785

    
2786
        if(intra_matrix)
2787
            video_enc->intra_matrix = intra_matrix;
2788
        if(inter_matrix)
2789
            video_enc->inter_matrix = inter_matrix;
2790

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

    
2825
        if (do_psnr)
2826
            video_enc->flags|= CODEC_FLAG_PSNR;
2827

    
2828
        /* two pass mode */
2829
        if (do_pass) {
2830
            if (do_pass == 1) {
2831
                video_enc->flags |= CODEC_FLAG_PASS1;
2832
            } else {
2833
                video_enc->flags |= CODEC_FLAG_PASS2;
2834
            }
2835
        }
2836
    }
2837

    
2838
    /* reset some key parameters */
2839
    video_disable = 0;
2840
    video_codec_id = CODEC_ID_NONE;
2841
    video_stream_copy = 0;
2842
}
2843

    
2844
static void new_audio_stream(AVFormatContext *oc)
2845
{
2846
    AVStream *st;
2847
    AVCodecContext *audio_enc;
2848
    int codec_id, i;
2849

    
2850
    st = av_new_stream(oc, oc->nb_streams);
2851
    if (!st) {
2852
        fprintf(stderr, "Could not alloc stream\n");
2853
        exit(1);
2854
    }
2855
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2856

    
2857
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2858
    audio_bitstream_filters= NULL;
2859

    
2860
    if(thread_count>1)
2861
        avcodec_thread_init(st->codec, thread_count);
2862

    
2863
    audio_enc = st->codec;
2864
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2865
    audio_enc->strict_std_compliance = strict;
2866

    
2867
    if(audio_codec_tag)
2868
        audio_enc->codec_tag= audio_codec_tag;
2869

    
2870
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2871
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2872
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2873
    }
2874
    if (audio_stream_copy) {
2875
        st->stream_copy = 1;
2876
        audio_enc->channels = audio_channels;
2877
    } else {
2878
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2879

    
2880
        for(i=0; i<opt_name_count; i++){
2881
            const AVOption *opt;
2882
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2883
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2884
                av_set_double(audio_enc, opt_names[i], d);
2885
        }
2886

    
2887
        if (audio_codec_id != CODEC_ID_NONE)
2888
            codec_id = audio_codec_id;
2889
        audio_enc->codec_id = codec_id;
2890

    
2891
        if (audio_qscale > QSCALE_NONE) {
2892
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2893
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2894
        }
2895
        audio_enc->thread_count = thread_count;
2896
        audio_enc->channels = audio_channels;
2897
    }
2898
    audio_enc->sample_rate = audio_sample_rate;
2899
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2900
    if (audio_language) {
2901
        av_strlcpy(st->language, audio_language, sizeof(st->language));
2902
        av_free(audio_language);
2903
        audio_language = NULL;
2904
    }
2905

    
2906
    /* reset some key parameters */
2907
    audio_disable = 0;
2908
    audio_codec_id = CODEC_ID_NONE;
2909
    audio_stream_copy = 0;
2910
}
2911

    
2912
static void new_subtitle_stream(AVFormatContext *oc)
2913
{
2914
    AVStream *st;
2915
    AVCodecContext *subtitle_enc;
2916
    int i;
2917

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

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

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

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

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

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

    
2972
static void opt_new_subtitle_stream(void)
2973
{
2974
    AVFormatContext *oc;
2975
    if (nb_output_files <= 0) {
2976
        fprintf(stderr, "At least one output file must be specified\n");
2977
        exit(1);
2978
    }
2979
    oc = output_files[nb_output_files - 1];
2980
    new_subtitle_stream(oc);
2981
}
2982

    
2983
static void opt_output_file(const char *filename)
2984
{
2985
    AVFormatContext *oc;
2986
    int use_video, use_audio, use_subtitle;
2987
    int input_has_video, input_has_audio, input_has_subtitle, i;
2988
    AVFormatParameters params, *ap = &params;
2989

    
2990
    if (!strcmp(filename, "-"))
2991
        filename = "pipe:";
2992

    
2993
    oc = av_alloc_format_context();
2994

    
2995
    if (!file_oformat) {
2996
        file_oformat = guess_format(NULL, filename, NULL);
2997
        if (!file_oformat) {
2998
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
2999
                    filename);
3000
            exit(1);
3001
        }
3002
    }
3003

    
3004
    oc->oformat = file_oformat;
3005
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3006

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

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

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

    
3044
        if (use_video) {
3045
            new_video_stream(oc);
3046
        }
3047

    
3048
        if (use_audio) {
3049
            new_audio_stream(oc);
3050
        }
3051

    
3052
        if (use_subtitle) {
3053
            new_subtitle_stream(oc);
3054
        }
3055

    
3056
        oc->timestamp = rec_timestamp;
3057

    
3058
        if (str_title)
3059
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3060
        if (str_author)
3061
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3062
        if (str_copyright)
3063
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3064
        if (str_comment)
3065
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3066
        if (str_album)
3067
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3068
    }
3069

    
3070
    output_files[nb_output_files++] = oc;
3071

    
3072
    /* check filename in case of an image number is expected */
3073
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3074
        if (!av_filename_number_test(oc->filename)) {
3075
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3076
            exit(1);
3077
        }
3078
    }
3079

    
3080
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3081
        /* test if it already exists to avoid loosing precious files */
3082
        if (!file_overwrite &&
3083
            (strchr(filename, ':') == NULL ||
3084
             av_strstart(filename, "file:", NULL))) {
3085
            if (url_exist(filename)) {
3086
                int c;
3087

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

    
3104
        /* open the file */
3105
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3106
            fprintf(stderr, "Could not open '%s'\n", filename);
3107
            exit(1);
3108
        }
3109
    }
3110

    
3111
    memset(ap, 0, sizeof(*ap));
3112
    if (av_set_parameters(oc, ap) < 0) {
3113
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3114
                oc->filename);
3115
        exit(1);
3116
    }
3117

    
3118
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3119
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3120
    oc->loop_output = loop_output;
3121

    
3122
    for(i=0; i<opt_name_count; i++){
3123
        const AVOption *opt;
3124
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3125
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3126
            av_set_double(oc, opt_names[i], d);
3127
    }
3128

    
3129
    /* reset some options */
3130
    file_oformat = NULL;
3131
    file_iformat = NULL;
3132
}
3133

    
3134
/* same option as mencoder */
3135
static void opt_pass(const char *pass_str)
3136
{
3137
    int pass;
3138
    pass = atoi(pass_str);
3139
    if (pass != 1 && pass != 2) {
3140
        fprintf(stderr, "pass number can be only 1 or 2\n");
3141
        exit(1);
3142
    }
3143
    do_pass = pass;
3144
}
3145

    
3146
static int64_t getutime(void)
3147
{
3148
#ifdef HAVE_GETRUSAGE
3149
    struct rusage rusage;
3150

    
3151
    getrusage(RUSAGE_SELF, &rusage);
3152
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3153
#elif defined(HAVE_GETPROCESSTIMES)
3154
    HANDLE proc;
3155
    FILETIME c, e, k, u;
3156
    proc = GetCurrentProcess();
3157
    GetProcessTimes(proc, &c, &e, &k, &u);
3158
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3159
#else
3160
  return av_gettime();
3161
#endif
3162
}
3163

    
3164
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3165
extern int ffm_nopts;
3166
#endif
3167

    
3168
static void show_formats(void)
3169
{
3170
    AVInputFormat *ifmt;
3171
    AVOutputFormat *ofmt;
3172
    URLProtocol *up;
3173
    AVCodec *p, *p2;
3174
    const char *last_name;
3175

    
3176
    printf("File formats:\n");
3177
    last_name= "000";
3178
    for(;;){
3179
        int decode=0;
3180
        int encode=0;
3181
        const char *name=NULL;
3182
        const char *long_name=NULL;
3183

    
3184
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3185
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3186
                strcmp(ofmt->name, last_name)>0){
3187
                name= ofmt->name;
3188
                long_name= ofmt->long_name;
3189
                encode=1;
3190
            }
3191
        }
3192
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3193
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3194
                strcmp(ifmt->name, last_name)>0){
3195
                name= ifmt->name;
3196
                long_name= ifmt->long_name;
3197
                encode=0;
3198
            }
3199
            if(name && strcmp(ifmt->name, name)==0)
3200
                decode=1;
3201
        }
3202
        if(name==NULL)
3203
            break;
3204
        last_name= name;
3205

    
3206
        printf(
3207
            " %s%s %-15s %s\n",
3208
            decode ? "D":" ",
3209
            encode ? "E":" ",
3210
            name,
3211
            long_name ? long_name:" ");
3212
    }
3213
    printf("\n");
3214

    
3215
    printf("Codecs:\n");
3216
    last_name= "000";
3217
    for(;;){
3218
        int decode=0;
3219
        int encode=0;
3220
        int cap=0;
3221
        const char *type_str;
3222

    
3223
        p2=NULL;
3224
        for(p = first_avcodec; p != NULL; p = p->next) {
3225
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3226
                strcmp(p->name, last_name)>0){
3227
                p2= p;
3228
                decode= encode= cap=0;
3229
            }
3230
            if(p2 && strcmp(p->name, p2->name)==0){
3231
                if(p->decode) decode=1;
3232
                if(p->encode) encode=1;
3233
                cap |= p->capabilities;
3234
            }
3235
        }
3236
        if(p2==NULL)
3237
            break;
3238
        last_name= p2->name;
3239

    
3240
        switch(p2->type) {
3241
        case CODEC_TYPE_VIDEO:
3242
            type_str = "V";
3243
            break;
3244
        case CODEC_TYPE_AUDIO:
3245
            type_str = "A";
3246
            break;
3247
        case CODEC_TYPE_SUBTITLE:
3248
            type_str = "S";
3249
            break;
3250
        default:
3251
            type_str = "?";
3252
            break;
3253
        }
3254
        printf(
3255
            " %s%s%s%s%s%s %s",
3256
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3257
            encode ? "E":" ",
3258
            type_str,
3259
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3260
            cap & CODEC_CAP_DR1 ? "D":" ",
3261
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3262
            p2->name);
3263
       /* if(p2->decoder && decode==0)
3264
            printf(" use %s for decoding", p2->decoder->name);*/
3265
        printf("\n");
3266
    }
3267
    printf("\n");
3268

    
3269
    printf("Supported file protocols:\n");
3270
    for(up = first_protocol; up != NULL; up = up->next)
3271
        printf(" %s:", up->name);
3272
    printf("\n");
3273

    
3274
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3275
    printf("\n");
3276
    printf(
3277
"Note, the names of encoders and decoders do not always match, so there are\n"
3278
"several cases where the above table shows encoder only or decoder only entries\n"
3279
"even though both encoding and decoding are supported. For example, the h263\n"
3280
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3281
"worse.\n");
3282
    exit(1);
3283
}
3284

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

    
3302
static void opt_inter_matrix(const char *arg)
3303
{
3304
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3305
    parse_matrix_coeffs(inter_matrix, arg);
3306
}
3307

    
3308
static void opt_intra_matrix(const char *arg)
3309
{
3310
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3311
    parse_matrix_coeffs(intra_matrix, arg);
3312
}
3313

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

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

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

    
3370
    if(!strcmp(arg, "vcd")) {
3371

    
3372
        opt_video_codec("mpeg1video");
3373
        opt_audio_codec("mp2");
3374
        opt_format("vcd");
3375

    
3376
        opt_frame_size(norm ? "352x240" : "352x288");
3377
        opt_frame_rate(frame_rates[norm]);
3378
        opt_default("gop", norm ? "18" : "15");
3379

    
3380
        opt_default("b", "1150000");
3381
        opt_default("maxrate", "1150000");
3382
        opt_default("minrate", "1150000");
3383
        opt_default("bufsize", "327680"); // 40*1024*8;
3384

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

    
3389
        opt_default("packetsize", "2324");
3390
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3391

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

    
3400
        opt_video_codec("mpeg2video");
3401
        opt_audio_codec("mp2");
3402
        opt_format("svcd");
3403

    
3404
        opt_frame_size(norm ? "480x480" : "480x576");
3405
        opt_frame_rate(frame_rates[norm]);
3406
        opt_default("gop", norm ? "18" : "15");
3407

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

    
3414

    
3415
        opt_default("ab", "224000");
3416
        audio_sample_rate = 44100;
3417

    
3418
        opt_default("packetsize", "2324");
3419

    
3420
    } else if(!strcmp(arg, "dvd")) {
3421

    
3422
        opt_video_codec("mpeg2video");
3423
        opt_audio_codec("ac3");
3424
        opt_format("dvd");
3425

    
3426
        opt_frame_size(norm ? "720x480" : "720x576");
3427
        opt_frame_rate(frame_rates[norm]);
3428
        opt_default("gop", norm ? "18" : "15");
3429

    
3430
        opt_default("b", "6000000");
3431
        opt_default("maxrate", "9000000");
3432
        opt_default("minrate", "0"); //1500000;
3433
        opt_default("bufsize", "1835008"); //224*1024*8;
3434

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

    
3438
        opt_default("ab", "448000");
3439
        audio_sample_rate = 48000;
3440

    
3441
    } else if(!strncmp(arg, "dv", 2)) {
3442

    
3443
        opt_format("dv");
3444

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

    
3450
        audio_sample_rate = 48000;
3451
        audio_channels = 2;
3452

    
3453
    } else {
3454
        fprintf(stderr, "Unknown target: %s\n", arg);
3455
        exit(1);
3456
    }
3457
}
3458

    
3459
static void opt_vstats_file (const char *arg)
3460
{
3461
    av_free (vstats_filename);
3462
    vstats_filename=av_strdup (arg);
3463
}
3464

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

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

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

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

    
3486
    bsfp= &video_bitstream_filters;
3487
    while(*bsfp)
3488
        bsfp= &(*bsfp)->next;
3489

    
3490
    *bsfp= bsfc;
3491
}
3492

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

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

    
3504
    bsfp= &audio_bitstream_filters;
3505
    while(*bsfp)
3506
        bsfp= &(*bsfp)->next;
3507

    
3508
    *bsfp= bsfc;
3509
}
3510

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

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

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

    
3547
//    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));
3548

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

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

    
3559
    if(avctx_opts[0]->debug)
3560
        av_log_level = AV_LOG_DEBUG;
3561
    return 0;
3562
}
3563

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

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

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

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

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

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

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

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

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

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

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

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

    
3781
    exit(1);
3782
}
3783

    
3784
void parse_arg_file(const char *filename)
3785
{
3786
    opt_output_file(filename);
3787
}
3788

    
3789
int main(int argc, char **argv)
3790
{
3791
    int i;
3792
    int64_t ti;
3793

    
3794
    av_register_all();
3795

    
3796
    for(i=0; i<CODEC_TYPE_NB; i++){
3797
        avctx_opts[i]= avcodec_alloc_context2(i);
3798
    }
3799
    avformat_opts = av_alloc_format_context();
3800
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3801

    
3802
    if (argc <= 1)
3803
        show_help();
3804
    else
3805
        show_banner();
3806

    
3807
    /* parse options */
3808
    parse_options(argc, argv, options);
3809

    
3810
    /* file converter / grab */
3811
    if (nb_output_files <= 0) {
3812
        fprintf(stderr, "Must supply at least one output file\n");
3813
        exit(1);
3814
    }
3815

    
3816
    if (nb_input_files == 0) {
3817
        fprintf(stderr, "Must supply at least one input file\n");
3818
        exit(1);
3819
    }
3820

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

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

    
3845
    av_free_static();
3846

    
3847
    av_free(intra_matrix);
3848
    av_free(inter_matrix);
3849

    
3850
    if (fvstats)
3851
        fclose(fvstats);
3852
    av_free(vstats_filename);
3853

    
3854
    av_free(opt_names);
3855

    
3856
    av_free(video_standard);
3857

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

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

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