Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 5508d26b

History | View | Annotate | Download (132 KB)

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

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

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

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

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

    
58
#undef exit
59

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

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

    
74
extern const OptionDef options[];
75

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

    
80
#define MAX_FILES 20
81

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

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

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

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

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

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

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

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

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

    
181
static int rate_emu = 0;
182

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

    
186
static int audio_volume = 256;
187

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

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

    
204
static int sws_flags = SWS_BICUBIC;
205

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

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

    
216
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
217

    
218
struct AVInputStream;
219

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

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

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

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

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

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

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

    
278
#ifndef __MINGW32__
279

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

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

    
291
static volatile sig_atomic_t received_sigterm = 0;
292

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
412
        bsfc= bsfc->next;
413
    }
414

    
415
    av_interleaved_write_frame(s, pkt);
416
}
417

    
418
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
419

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
604
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
605

    
606
    if (picture != picture2)
607
        *picture = *picture2;
608
    *bufp = buf;
609
}
610

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

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

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

    
631
    enc = ost->st->codec;
632

    
633
    if (!subtitle_out) {
634
        subtitle_out = av_malloc(subtitle_out_max_size);
635
    }
636

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

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

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

    
666
static int bit_buffer_size= 1024*256;
667
static uint8_t *bit_buffer= NULL;
668

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

    
680
    avcodec_get_frame_defaults(&picture_crop_temp);
681
    avcodec_get_frame_defaults(&picture_pad_temp);
682

    
683
    enc = ost->st->codec;
684
    dec = ist->st->codec;
685

    
686
    /* by default, we output a single frame */
687
    nb_frames = 1;
688

    
689
    *frame_size = 0;
690

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

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

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

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

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

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

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

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

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

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

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

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

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

    
840
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
841
                           int frame_size)
842
{
843
    static FILE *fvstats=NULL;
844
    char filename[40];
845
    time_t today2;
846
    struct tm *today;
847
    AVCodecContext *enc;
848
    int frame_number;
849
    int64_t ti;
850
    double ti1, bitrate, avg_bitrate;
851

    
852
    if (!fvstats) {
853
        today2 = time(NULL);
854
        today = localtime(&today2);
855
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
856
                                               today->tm_min,
857
                                               today->tm_sec);
858
        fvstats = fopen(filename,"w");
859
        if (!fvstats) {
860
            perror("fopen");
861
            exit(1);
862
        }
863
    }
864

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

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

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

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

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

    
914

    
915
    oc = output_files[0];
916

    
917
    total_size = url_ftell(&oc->pb);
918

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

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

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

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

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

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

    
992
        fflush(stderr);
993
    }
994

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

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

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

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

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

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

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

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

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

    
1154
            ist->frame++;
1155
        }
1156

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1339

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1572
                if(ost->audio_resample){
1573
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1574
                                                    codec->sample_rate, icodec->sample_rate);
1575
                    if(!ost->resample){
1576
                        printf("Can't resample.  Aborting.\n");
1577
                        av_abort();
1578
                    }
1579
                }
1580
                ist->decoding_needed = 1;
1581
                ost->encoding_needed = 1;
1582
                break;
1583
            case CODEC_TYPE_VIDEO:
1584
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1585
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1586
                ost->video_resample = ((codec->width != icodec->width -
1587
                                (frame_leftBand + frame_rightBand) +
1588
                                (frame_padleft + frame_padright)) ||
1589
                        (codec->height != icodec->height -
1590
                                (frame_topBand  + frame_bottomBand) +
1591
                                (frame_padtop + frame_padbottom)) ||
1592
                        (codec->pix_fmt != icodec->pix_fmt));
1593
                if (ost->video_crop) {
1594
                    ost->topBand = frame_topBand;
1595
                    ost->leftBand = frame_leftBand;
1596
                }
1597
                if (ost->video_pad) {
1598
                    ost->padtop = frame_padtop;
1599
                    ost->padleft = frame_padleft;
1600
                    ost->padbottom = frame_padbottom;
1601
                    ost->padright = frame_padright;
1602
                    if (!ost->video_resample) {
1603
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1604
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1605
                                         codec->width, codec->height ) )
1606
                            goto fail;
1607
                    }
1608
                }
1609
                if (ost->video_resample) {
1610
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1611
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1612
                                         codec->width, codec->height ) )
1613
                        exit(1);
1614

    
1615
                    ost->img_resample_ctx = sws_getContext(
1616
                            icodec->width - (frame_leftBand + frame_rightBand),
1617
                            icodec->height - (frame_topBand + frame_bottomBand),
1618
                            icodec->pix_fmt,
1619
                            codec->width - (frame_padleft + frame_padright),
1620
                            codec->height - (frame_padtop + frame_padbottom),
1621
                            codec->pix_fmt,
1622
                            sws_flags, NULL, NULL, NULL);
1623
                    if (ost->img_resample_ctx == NULL) {
1624
                        fprintf(stderr, "Cannot get resampling context\n");
1625
                        exit(1);
1626
                    }
1627
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1628
                }
1629
                ost->encoding_needed = 1;
1630
                ist->decoding_needed = 1;
1631
                break;
1632
            case CODEC_TYPE_SUBTITLE:
1633
                ost->encoding_needed = 1;
1634
                ist->decoding_needed = 1;
1635
                break;
1636
            default:
1637
                av_abort();
1638
                break;
1639
            }
1640
            /* two pass mode */
1641
            if (ost->encoding_needed &&
1642
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1643
                char logfilename[1024];
1644
                FILE *f;
1645
                int size;
1646
                char *logbuffer;
1647

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1924
    discard_packet:
1925
        av_free_packet(&pkt);
1926

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

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

    
1939
    term_exit();
1940

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

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

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

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

    
1967
    /* finished ! */
1968

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2160

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

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

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

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

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

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

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

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

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

    
2218

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

    
2232

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

    
2246

    
2247
static void opt_frame_pix_fmt(const char *arg)
2248
{
2249
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2250
}
2251

    
2252
static void opt_frame_aspect_ratio(const char *arg)
2253
{
2254
    int x = 0, y = 0;
2255
    double ar = 0;
2256
    const char *p;
2257

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

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

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

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

    
2295
static void opt_strict(const char *arg)
2296
{
2297
    strict= atoi(arg);
2298
}
2299

    
2300
static void opt_top_field_first(const char *arg)
2301
{
2302
    top_field_first= atoi(arg);
2303
}
2304

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

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

    
2319
static void opt_audio_channels(const char *arg)
2320
{
2321
    audio_channels = atoi(arg);
2322
}
2323

    
2324
static void opt_video_channel(const char *arg)
2325
{
2326
    video_channel = strtol(arg, NULL, 0);
2327
}
2328

    
2329
static void opt_video_standard(const char *arg)
2330
{
2331
    video_standard = av_strdup(arg);
2332
}
2333

    
2334
static void opt_codec(int *pstream_copy, int *pcodec_id,
2335
                      int codec_type, const char *arg)
2336
{
2337
    AVCodec *p;
2338

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

    
2357
static void opt_audio_codec(const char *arg)
2358
{
2359
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2360
}
2361

    
2362
static void opt_audio_tag(const char *arg)
2363
{
2364
    char *tail;
2365
    audio_codec_tag= strtol(arg, &tail, 0);
2366

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

    
2371
static void opt_video_tag(const char *arg)
2372
{
2373
    char *tail;
2374
    video_codec_tag= strtol(arg, &tail, 0);
2375

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

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

    
2387
    using_vhook = 1;
2388

    
2389
    argv[0] = strtok(args, " ");
2390
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2391
    }
2392

    
2393
    i = frame_hook_add(argc, argv);
2394

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

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

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

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

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

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

    
2445
    p = arg;
2446
    m = &stream_maps[nb_stream_maps++];
2447

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

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

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

    
2470
    p = arg;
2471
    m = &meta_data_maps[nb_meta_data_maps++];
2472

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

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

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

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

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

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

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

    
2507
    if (!strcmp(filename, "-"))
2508
        filename = "pipe:";
2509

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

    
2513
    /* get default parameters from command line */
2514
    ic = av_alloc_format_context();
2515

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

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

    
2545
    ic->loop_input = loop_input;
2546

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

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

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

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

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

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

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

    
2621
            enc->rate_emu = rate_emu;
2622
            if(video_disable)
2623
                ic->streams[i]->discard= AVDISCARD_ALL;
2624
            else if(video_discard)
2625
                ic->streams[i]->discard= video_discard;
2626
            break;
2627
        case CODEC_TYPE_DATA:
2628
            break;
2629
        case CODEC_TYPE_SUBTITLE:
2630
            break;
2631
        case CODEC_TYPE_UNKNOWN:
2632
            break;
2633
        default:
2634
            av_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_inputs(int *has_video_ptr, int *has_audio_ptr)
2654
{
2655
    int has_video, has_audio, i, j;
2656
    AVFormatContext *ic;
2657

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

    
2684
static void new_video_stream(AVFormatContext *oc)
2685
{
2686
    AVStream *st;
2687
    AVCodecContext *video_enc;
2688
    int codec_id;
2689

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

    
2699
    if(thread_count>1)
2700
        avcodec_thread_init(st->codec, thread_count);
2701

    
2702
    video_enc = st->codec;
2703

    
2704
    if(video_codec_tag)
2705
        video_enc->codec_tag= video_codec_tag;
2706

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

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

    
2725
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2726
        if (video_codec_id != CODEC_ID_NONE)
2727
            codec_id = video_codec_id;
2728

    
2729
        video_enc->codec_id = codec_id;
2730
        codec = avcodec_find_encoder(codec_id);
2731

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

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

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

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

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

    
2781
        if(intra_matrix)
2782
            video_enc->intra_matrix = intra_matrix;
2783
        if(inter_matrix)
2784
            video_enc->inter_matrix = inter_matrix;
2785

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

    
2820
        if (do_psnr)
2821
            video_enc->flags|= CODEC_FLAG_PSNR;
2822

    
2823
        video_enc->me_method = me_method;
2824

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

    
2835
    /* reset some key parameters */
2836
    video_disable = 0;
2837
    video_codec_id = CODEC_ID_NONE;
2838
    video_stream_copy = 0;
2839
}
2840

    
2841
static void new_audio_stream(AVFormatContext *oc)
2842
{
2843
    AVStream *st;
2844
    AVCodecContext *audio_enc;
2845
    int codec_id, i;
2846

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

    
2854
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2855
    audio_bitstream_filters= NULL;
2856

    
2857
    if(thread_count>1)
2858
        avcodec_thread_init(st->codec, thread_count);
2859

    
2860
    audio_enc = st->codec;
2861
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2862
    audio_enc->strict_std_compliance = strict;
2863

    
2864
    if(audio_codec_tag)
2865
        audio_enc->codec_tag= audio_codec_tag;
2866

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

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

    
2884
        if (audio_codec_id != CODEC_ID_NONE)
2885
            codec_id = audio_codec_id;
2886
        audio_enc->codec_id = codec_id;
2887

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

    
2903
    /* reset some key parameters */
2904
    audio_disable = 0;
2905
    audio_codec_id = CODEC_ID_NONE;
2906
    audio_stream_copy = 0;
2907
}
2908

    
2909
static void opt_new_subtitle_stream(void)
2910
{
2911
    AVFormatContext *oc;
2912
    AVStream *st;
2913
    AVCodecContext *subtitle_enc;
2914
    int i;
2915

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

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

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

    
2943
    if (subtitle_language) {
2944
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
2945
        av_free(subtitle_language);
2946
        subtitle_language = NULL;
2947
    }
2948

    
2949
    subtitle_codec_id = CODEC_ID_NONE;
2950
    subtitle_stream_copy = 0;
2951
}
2952

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

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

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

    
2981
    if (!strcmp(filename, "-"))
2982
        filename = "pipe:";
2983

    
2984
    oc = av_alloc_format_context();
2985

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

    
2995
    oc->oformat = file_oformat;
2996
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
2997

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

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

    
3020
        /* manual disable */
3021
        if (audio_disable) {
3022
            use_audio = 0;
3023
        }
3024
        if (video_disable) {
3025
            use_video = 0;
3026
        }
3027

    
3028
        if (use_video) {
3029
            new_video_stream(oc);
3030
        }
3031

    
3032
        if (use_audio) {
3033
            new_audio_stream(oc);
3034
        }
3035

    
3036
        oc->timestamp = rec_timestamp;
3037

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

    
3050
    output_files[nb_output_files++] = oc;
3051

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

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

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

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

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

    
3098
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3099
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3100
    oc->loop_output = loop_output;
3101

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

    
3109
    /* reset some options */
3110
    file_oformat = NULL;
3111
    file_iformat = NULL;
3112
}
3113

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

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

    
3136
    getrusage(RUSAGE_SELF, &rusage);
3137
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3138
}
3139
#endif
3140

    
3141
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3142
extern int ffm_nopts;
3143
#endif
3144

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

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

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

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

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

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

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

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

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

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

    
3291
static void opt_inter_matrix(const char *arg)
3292
{
3293
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3294
    parse_matrix_coeffs(inter_matrix, arg);
3295
}
3296

    
3297
static void opt_intra_matrix(const char *arg)
3298
{
3299
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3300
    parse_matrix_coeffs(intra_matrix, arg);
3301
}
3302

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

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

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

    
3359
    if(!strcmp(arg, "vcd")) {
3360

    
3361
        opt_video_codec("mpeg1video");
3362
        opt_audio_codec("mp2");
3363
        opt_format("vcd");
3364

    
3365
        opt_frame_size(norm ? "352x240" : "352x288");
3366
        opt_frame_rate(frame_rates[norm]);
3367
        opt_default("gop", norm ? "18" : "15");
3368

    
3369
        opt_default("b", "1150000");
3370
        opt_default("maxrate", "1150000");
3371
        opt_default("minrate", "1150000");
3372
        opt_default("bufsize", "327680"); // 40*1024*8;
3373

    
3374
        opt_default("ab", "224000");
3375
        audio_sample_rate = 44100;
3376
        audio_channels = 2;
3377

    
3378
        opt_default("packetsize", "2324");
3379
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3380

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

    
3389
        opt_video_codec("mpeg2video");
3390
        opt_audio_codec("mp2");
3391
        opt_format("svcd");
3392

    
3393
        opt_frame_size(norm ? "480x480" : "480x576");
3394
        opt_frame_rate(frame_rates[norm]);
3395
        opt_default("gop", norm ? "18" : "15");
3396

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

    
3403

    
3404
        opt_default("ab", "224000");
3405
        audio_sample_rate = 44100;
3406

    
3407
        opt_default("packetsize", "2324");
3408

    
3409
    } else if(!strcmp(arg, "dvd")) {
3410

    
3411
        opt_video_codec("mpeg2video");
3412
        opt_audio_codec("ac3");
3413
        opt_format("dvd");
3414

    
3415
        opt_frame_size(norm ? "720x480" : "720x576");
3416
        opt_frame_rate(frame_rates[norm]);
3417
        opt_default("gop", norm ? "18" : "15");
3418

    
3419
        opt_default("b", "6000000");
3420
        opt_default("maxrate", "9000000");
3421
        opt_default("minrate", "0"); //1500000;
3422
        opt_default("bufsize", "1835008"); //224*1024*8;
3423

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

    
3427
        opt_default("ab", "448000");
3428
        audio_sample_rate = 48000;
3429

    
3430
    } else if(!strncmp(arg, "dv", 2)) {
3431

    
3432
        opt_format("dv");
3433

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

    
3439
        audio_sample_rate = 48000;
3440
        audio_channels = 2;
3441

    
3442
    } else {
3443
        fprintf(stderr, "Unknown target: %s\n", arg);
3444
        exit(1);
3445
    }
3446
}
3447

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

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

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

    
3462
    *bsfp= bsfc;
3463
}
3464

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

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

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

    
3480
    *bsfp= bsfc;
3481
}
3482

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3706
static void show_help(void)
3707
{
3708
    show_banner();
3709
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3710
           "Hyper fast Audio and Video encoder\n");
3711
    printf("\n");
3712
    show_help_options(options, "Main options:\n",
3713
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3714
    show_help_options(options, "\nVideo options:\n",
3715
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3716
                      OPT_VIDEO);
3717
    show_help_options(options, "\nAdvanced Video options:\n",
3718
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3719
                      OPT_VIDEO | OPT_EXPERT);
3720
    show_help_options(options, "\nAudio options:\n",
3721
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3722
                      OPT_AUDIO);
3723
    show_help_options(options, "\nAdvanced Audio options:\n",
3724
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3725
                      OPT_AUDIO | OPT_EXPERT);
3726
    show_help_options(options, "\nSubtitle options:\n",
3727
                      OPT_SUBTITLE | OPT_GRAB,
3728
                      OPT_SUBTITLE);
3729
    show_help_options(options, "\nAudio/Video grab options:\n",
3730
                      OPT_GRAB,
3731
                      OPT_GRAB);
3732
    show_help_options(options, "\nAdvanced options:\n",
3733
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3734
                      OPT_EXPERT);
3735
    av_opt_show(avctx_opts[0], NULL);
3736
    av_opt_show(avformat_opts, NULL);
3737

    
3738
    exit(1);
3739
}
3740

    
3741
void parse_arg_file(const char *filename)
3742
{
3743
    opt_output_file(filename);
3744
}
3745

    
3746
int main(int argc, char **argv)
3747
{
3748
    int i;
3749
    int64_t ti;
3750

    
3751
    av_register_all();
3752

    
3753
    for(i=0; i<CODEC_TYPE_NB; i++){
3754
        avctx_opts[i]= avcodec_alloc_context2(i);
3755
    }
3756
    avformat_opts = av_alloc_format_context();
3757

    
3758
    if (argc <= 1)
3759
        show_help();
3760
    else
3761
        show_banner();
3762

    
3763
    /* parse options */
3764
    parse_options(argc, argv, options);
3765

    
3766
    /* file converter / grab */
3767
    if (nb_output_files <= 0) {
3768
        fprintf(stderr, "Must supply at least one output file\n");
3769
        exit(1);
3770
    }
3771

    
3772
    if (nb_input_files == 0) {
3773
        fprintf(stderr, "Must supply at least one input file\n");
3774
        exit(1);
3775
    }
3776

    
3777
    ti = getutime();
3778
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3779
              stream_maps, nb_stream_maps);
3780
    ti = getutime() - ti;
3781
    if (do_benchmark) {
3782
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3783
    }
3784

    
3785
    /* close files */
3786
    for(i=0;i<nb_output_files;i++) {
3787
        /* maybe av_close_output_file ??? */
3788
        AVFormatContext *s = output_files[i];
3789
        int j;
3790
        if (!(s->oformat->flags & AVFMT_NOFILE))
3791
            url_fclose(&s->pb);
3792
        for(j=0;j<s->nb_streams;j++) {
3793
            av_free(s->streams[j]->codec);
3794
            av_free(s->streams[j]);
3795
        }
3796
        av_free(s);
3797
    }
3798
    for(i=0;i<nb_input_files;i++)
3799
        av_close_input_file(input_files[i]);
3800

    
3801
    av_free_static();
3802

    
3803
    av_free(intra_matrix);
3804
    av_free(inter_matrix);
3805
    av_free(opt_names);
3806

    
3807
#ifdef CONFIG_POWERPC_PERF
3808
    extern void powerpc_display_perf_report(void);
3809
    powerpc_display_perf_report();
3810
#endif /* CONFIG_POWERPC_PERF */
3811

    
3812
    if (received_sigterm) {
3813
        fprintf(stderr,
3814
            "Received signal %d: terminating.\n",
3815
            (int) received_sigterm);
3816
        exit (255);
3817
    }
3818

    
3819
    exit(0); /* not all OS-es handle main() return value */
3820
    return 0;
3821
}