Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4dcc383a

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 "dsputil.h"
28
#include "opt.h"
29
#include "fifo.h"
30

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

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

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

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

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

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

    
73
extern const OptionDef options[];
74

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

    
79
#define MAX_FILES 20
80

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

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

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

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

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

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

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

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

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

    
180
static int rate_emu = 0;
181

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

    
185
static int audio_volume = 256;
186

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

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

    
203
static int sws_flags = SWS_BICUBIC;
204

    
205
const char **opt_names=NULL;
206
int opt_name_count=0;
207
AVCodecContext *avctx_opts[CODEC_TYPE_NB];
208
AVFormatContext *avformat_opts;
209

    
210
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
211
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
212
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
213

    
214
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
215

    
216
struct AVInputStream;
217

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

    
236
    int video_crop;
237
    int topBand;             /* cropping area sizes */
238
    int leftBand;
239

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

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

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

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

    
269
typedef struct AVInputFile {
270
    int eof_reached;      /* true if eof reached */
271
    int ist_index;        /* index of first stream in ist_table */
272
    int buffer_size;      /* current total buffer size */
273
    int buffer_size_max;  /* buffer size at which we consider we can stop
274
                             buffering */
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
    uint8_t *buf = NULL, *buf1 = NULL;
679
    AVCodecContext *enc, *dec;
680

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

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

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

    
690
    *frame_size = 0;
691

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
877
        fprintf(fvstats,"f_size= %6d ", frame_size);
878
        /* compute pts value */
879
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
880
        if (ti1 < 0.01)
881
            ti1 = 0.01;
882

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

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

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

    
918

    
919
    oc = output_files[0];
920

    
921
    total_size = url_ftell(&oc->pb);
922

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

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

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

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

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

    
993
        fflush(stderr);
994
    }
995

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

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

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

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

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

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

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

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

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

    
1155
                ist->frame++;
1156
            }
1157

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

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

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

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

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

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

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

    
1227
                            opkt.stream_index= ost->index;
1228
                            if(pkt->pts != AV_NOPTS_VALUE)
1229
                                opkt.pts= av_rescale_q(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);
1230
                            else
1231
                                opkt.pts= AV_NOPTS_VALUE;
1232

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

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

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

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

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

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

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

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

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

    
1340

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1771
    /* compute buffer size max (should use a complete heuristic) */
1772
    for(i=0;i<nb_input_files;i++) {
1773
        file_table[i].buffer_size_max = 2048;
1774
    }
1775

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

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

    
1794
        out_file = output_files[out_file_index];
1795
        in_file = input_files[in_file_index];
1796

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

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

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

    
1823
    stream_no_data = 0;
1824
    key = -1;
1825

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

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

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

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

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

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

    
1893
        if (!pkt.size) {
1894
            stream_no_data = is;
1895
        } else {
1896
            stream_no_data = 0;
1897
        }
1898
        if (do_pkt_dump) {
1899
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1900
        }
1901
        /* the following test is needed in case new streams appear
1902
           dynamically in stream : we ignore them */
1903
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1904
            goto discard_packet;
1905
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1906
        ist = ist_table[ist_index];
1907
        if (ist->discard)
1908
            goto discard_packet;
1909

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

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

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

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

    
1936
    discard_packet:
1937
        av_free_packet(&pkt);
1938

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

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

    
1951
    term_exit();
1952

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

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

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

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

    
1979
    /* finished ! */
1980

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2171

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

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

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

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

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

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

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

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

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

    
2229

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

    
2243

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

    
2257

    
2258
static void opt_frame_pix_fmt(const char *arg)
2259
{
2260
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2261
}
2262

    
2263
static void opt_frame_aspect_ratio(const char *arg)
2264
{
2265
    int x = 0, y = 0;
2266
    double ar = 0;
2267
    const char *p;
2268

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

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

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

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

    
2306
static void opt_strict(const char *arg)
2307
{
2308
    strict= atoi(arg);
2309
}
2310

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

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

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

    
2330
static void opt_audio_channels(const char *arg)
2331
{
2332
    audio_channels = atoi(arg);
2333
}
2334

    
2335
static void opt_video_channel(const char *arg)
2336
{
2337
    video_channel = strtol(arg, NULL, 0);
2338
}
2339

    
2340
static void opt_video_standard(const char *arg)
2341
{
2342
    video_standard = av_strdup(arg);
2343
}
2344

    
2345
static void opt_codec(int *pstream_copy, int *pcodec_id,
2346
                      int codec_type, const char *arg)
2347
{
2348
    AVCodec *p;
2349

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

    
2368
static void opt_audio_codec(const char *arg)
2369
{
2370
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2371
}
2372

    
2373
static void opt_audio_tag(const char *arg)
2374
{
2375
    char *tail;
2376
    audio_codec_tag= strtol(arg, &tail, 0);
2377

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

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

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

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

    
2398
    using_vhook = 1;
2399

    
2400
    argv[0] = strtok(args, " ");
2401
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2402
    }
2403

    
2404
    i = frame_hook_add(argc, argv);
2405

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

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

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

    
2441
static void opt_video_codec(const char *arg)
2442
{
2443
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2444
}
2445

    
2446
static void opt_subtitle_codec(const char *arg)
2447
{
2448
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2449
}
2450

    
2451
static void opt_map(const char *arg)
2452
{
2453
    AVStreamMap *m;
2454
    const char *p;
2455

    
2456
    p = arg;
2457
    m = &stream_maps[nb_stream_maps++];
2458

    
2459
    m->file_index = strtol(arg, (char **)&p, 0);
2460
    if (*p)
2461
        p++;
2462

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

    
2476
static void opt_map_meta_data(const char *arg)
2477
{
2478
    AVMetaDataMap *m;
2479
    const char *p;
2480

    
2481
    p = arg;
2482
    m = &meta_data_maps[nb_meta_data_maps++];
2483

    
2484
    m->out_file = strtol(arg, (char **)&p, 0);
2485
    if (*p)
2486
        p++;
2487

    
2488
    m->in_file = strtol(p, (char **)&p, 0);
2489
}
2490

    
2491
static void opt_recording_time(const char *arg)
2492
{
2493
    recording_time = parse_date(arg, 1);
2494
}
2495

    
2496
static void opt_start_time(const char *arg)
2497
{
2498
    start_time = parse_date(arg, 1);
2499
}
2500

    
2501
static void opt_rec_timestamp(const char *arg)
2502
{
2503
    rec_timestamp = parse_date(arg, 0) / 1000000;
2504
}
2505

    
2506
static void opt_input_ts_offset(const char *arg)
2507
{
2508
    input_ts_offset = parse_date(arg, 1);
2509
}
2510

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

    
2518
    if (!strcmp(filename, "-"))
2519
        filename = "pipe:";
2520

    
2521
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2522
                   !strcmp( filename, "/dev/stdin" );
2523

    
2524
    /* get default parameters from command line */
2525
    ic = av_alloc_format_context();
2526

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

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

    
2556
    ic->loop_input = loop_input;
2557

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

    
2566
    timestamp = start_time;
2567
    /* add the stream start time */
2568
    if (ic->start_time != AV_NOPTS_VALUE)
2569
        timestamp += ic->start_time;
2570

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

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

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

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

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

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

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

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

    
2661
    video_channel = 0;
2662

    
2663
    rate_emu = 0;
2664
}
2665

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

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

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

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

    
2711
#if defined(HAVE_THREADS)
2712
    if(thread_count>1)
2713
        avcodec_thread_init(st->codec, thread_count);
2714
#endif
2715

    
2716
    video_enc = st->codec;
2717

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2837
        video_enc->me_method = me_method;
2838

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

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

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

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

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

    
2870
#if defined(HAVE_THREADS)
2871
    if(thread_count>1)
2872
        avcodec_thread_init(st->codec, thread_count);
2873
#endif
2874

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2998
    oc = av_alloc_format_context();
2999

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

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

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

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

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

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

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

    
3050
        oc->timestamp = rec_timestamp;
3051

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

    
3064
    output_files[nb_output_files++] = oc;
3065

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3417

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

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

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

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

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

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

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

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

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

    
3446
        opt_format("dv");
3447

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

    
3453
        audio_sample_rate = 48000;
3454
        audio_channels = 2;
3455

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

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

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

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

    
3476
    *bsfp= bsfc;
3477
}
3478

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

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

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

    
3494
    *bsfp= bsfc;
3495
}
3496

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

    
3508
static int opt_default(const char *opt, const char *arg){
3509
    int type;
3510
    const AVOption *o;
3511
    for(type=0; type<CODEC_TYPE_NB; type++)
3512
        o = av_set_string(avctx_opts[type], opt, arg);
3513
    if(!o)
3514
        o = av_set_string(avformat_opts, opt, arg);
3515
    if(!o){
3516
        if(opt[0] == 'a')
3517
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3518
        else if(opt[0] == 'v')
3519
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3520
        else if(opt[0] == 's')
3521
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3522
    }
3523
    if(!o)
3524
        return -1;
3525

    
3526
//    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));
3527

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

    
3532
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3533
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3534
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3535
        ffm_nopts = 1;
3536
#endif
3537

    
3538
    if(avctx_opts[0]->debug)
3539
        av_log_level = AV_LOG_DEBUG;
3540
    return 0;
3541
}
3542

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

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

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

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

    
3645
    /* grab options */
3646
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3647
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3648
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3649

    
3650
    /* muxer options */
3651
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3652
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3653

    
3654
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3655
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3656

    
3657
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3658
    { NULL, },
3659
};
3660

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

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

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

    
3747
    exit(1);
3748
}
3749

    
3750
void parse_arg_file(const char *filename)
3751
{
3752
    opt_output_file(filename);
3753
}
3754

    
3755
int main(int argc, char **argv)
3756
{
3757
    int i;
3758
    int64_t ti;
3759

    
3760
    av_register_all();
3761

    
3762
    for(i=0; i<CODEC_TYPE_NB; i++)
3763
        avctx_opts[i]= avcodec_alloc_context();
3764
    avformat_opts = av_alloc_format_context();
3765

    
3766
    if (argc <= 1)
3767
        show_help();
3768
    else
3769
        show_banner();
3770

    
3771
    /* parse options */
3772
    parse_options(argc, argv, options);
3773

    
3774
    /* file converter / grab */
3775
    if (nb_output_files <= 0) {
3776
        fprintf(stderr, "Must supply at least one output file\n");
3777
        exit(1);
3778
    }
3779

    
3780
    if (nb_input_files == 0) {
3781
        fprintf(stderr, "Must supply at least one input file\n");
3782
        exit(1);
3783
    }
3784

    
3785
    ti = getutime();
3786
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3787
              stream_maps, nb_stream_maps);
3788
    ti = getutime() - ti;
3789
    if (do_benchmark) {
3790
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3791
    }
3792

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

    
3809
    av_free_static();
3810

    
3811
    av_free(intra_matrix);
3812
    av_free(inter_matrix);
3813

    
3814
#ifdef CONFIG_POWERPC_PERF
3815
    extern void powerpc_display_perf_report(void);
3816
    powerpc_display_perf_report();
3817
#endif /* CONFIG_POWERPC_PERF */
3818

    
3819
    if (received_sigterm) {
3820
        fprintf(stderr,
3821
            "Received signal %d: terminating.\n",
3822
            (int) received_sigterm);
3823
        exit (255);
3824
    }
3825

    
3826
    exit(0); /* not all OS-es handle main() return value */
3827
    return 0;
3828
}