Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ d24ce947

History | View | Annotate | Download (133 KB)

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

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

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

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

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

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

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

    
64
#undef exit
65

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

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

    
80
extern const OptionDef options[];
81

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

    
86
#define MAX_FILES 20
87

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

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

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

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

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

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

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

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

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

    
186
static int rate_emu = 0;
187

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

    
191
static int audio_volume = 256;
192

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

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

    
209
static int sws_flags = SWS_BICUBIC;
210

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

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

    
222
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
223

    
224
struct AVInputStream;
225

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

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

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

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

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

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

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

    
284
#ifdef HAVE_TERMIOS_H
285

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

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

    
297
static volatile sig_atomic_t received_sigterm = 0;
298

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
418
        bsfc= bsfc->next;
419
    }
420

    
421
    av_interleaved_write_frame(s, pkt);
422
}
423

    
424
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
425

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
696
    *frame_size = 0;
697

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
911

    
912
    oc = output_files[0];
913

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

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

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

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

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

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

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

    
991
        fflush(stderr);
992
    }
993

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

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

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

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

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

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

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

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

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

    
1153
            ist->frame++;
1154
        }
1155

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1338

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1924
            av_free_packet(&pkt);
1925
            goto redo;
1926
        }
1927

    
1928
    discard_packet:
1929
        av_free_packet(&pkt);
1930

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

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

    
1943
    term_exit();
1944

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

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

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

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

    
1971
    /* finished ! */
1972

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2164

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

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

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

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

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

    
2187
    r = (rgb >> 16);
2188
    g = ((rgb >> 8) & 255);
2189
    b = (rgb & 255);
2190

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

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

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

    
2222

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

    
2236

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2398
static void add_frame_hooker(const char *arg)
2399
{
2400
    int argc = 0;
2401
    char *argv[64];
2402
    int i;
2403
    char *args = av_strdup(arg);
2404

    
2405
    using_vhook = 1;
2406

    
2407
    argv[0] = strtok(args, " ");
2408
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2409
    }
2410

    
2411
    i = frame_hook_add(argc, argv);
2412

    
2413
    if (i != 0) {
2414
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2415
        exit(1);
2416
    }
2417
}
2418

    
2419
static void opt_video_codec(const char *arg)
2420
{
2421
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2422
}
2423

    
2424
static void opt_subtitle_codec(const char *arg)
2425
{
2426
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2427
}
2428

    
2429
static void opt_map(const char *arg)
2430
{
2431
    AVStreamMap *m;
2432
    const char *p;
2433

    
2434
    p = arg;
2435
    m = &stream_maps[nb_stream_maps++];
2436

    
2437
    m->file_index = strtol(arg, (char **)&p, 0);
2438
    if (*p)
2439
        p++;
2440

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

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

    
2459
    p = arg;
2460
    m = &meta_data_maps[nb_meta_data_maps++];
2461

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

    
2466
    m->in_file = strtol(p, (char **)&p, 0);
2467
}
2468

    
2469
static void opt_recording_time(const char *arg)
2470
{
2471
    recording_time = parse_date(arg, 1);
2472
}
2473

    
2474
static void opt_start_time(const char *arg)
2475
{
2476
    start_time = parse_date(arg, 1);
2477
}
2478

    
2479
static void opt_rec_timestamp(const char *arg)
2480
{
2481
    rec_timestamp = parse_date(arg, 0) / 1000000;
2482
}
2483

    
2484
static void opt_input_ts_offset(const char *arg)
2485
{
2486
    input_ts_offset = parse_date(arg, 1);
2487
}
2488

    
2489
static void opt_input_file(const char *filename)
2490
{
2491
    AVFormatContext *ic;
2492
    AVFormatParameters params, *ap = &params;
2493
    int err, i, ret, rfps, rfps_base;
2494
    int64_t timestamp;
2495

    
2496
    if (!strcmp(filename, "-"))
2497
        filename = "pipe:";
2498

    
2499
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2500
                   !strcmp( filename, "/dev/stdin" );
2501

    
2502
    /* get default parameters from command line */
2503
    ic = av_alloc_format_context();
2504

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

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

    
2534
    ic->loop_input = loop_input;
2535

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

    
2544
    timestamp = start_time;
2545
    /* add the stream start time */
2546
    if (ic->start_time != AV_NOPTS_VALUE)
2547
        timestamp += ic->start_time;
2548

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

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

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

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

    
2604
                    (float)rfps / rfps_base, rfps, rfps_base);
2605
            }
2606
            /* update the current frame rate to match the stream frame rate */
2607
            frame_rate.num = rfps;
2608
            frame_rate.den = rfps_base;
2609

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

    
2627
    input_files[nb_input_files] = ic;
2628
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2629
    /* dump the file content */
2630
    if (verbose >= 0)
2631
        dump_format(ic, nb_input_files, filename, 0);
2632

    
2633
    nb_input_files++;
2634
    file_iformat = NULL;
2635
    file_oformat = NULL;
2636

    
2637
    video_channel = 0;
2638

    
2639
    rate_emu = 0;
2640
}
2641

    
2642
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2643
{
2644
    int has_video, has_audio, i, j;
2645
    AVFormatContext *ic;
2646

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

    
2673
static void new_video_stream(AVFormatContext *oc)
2674
{
2675
    AVStream *st;
2676
    AVCodecContext *video_enc;
2677
    int codec_id;
2678

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

    
2688
    if(thread_count>1)
2689
        avcodec_thread_init(st->codec, thread_count);
2690

    
2691
    video_enc = st->codec;
2692

    
2693
    if(video_codec_tag)
2694
        video_enc->codec_tag= video_codec_tag;
2695

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

    
2706
    if (video_stream_copy) {
2707
        st->stream_copy = 1;
2708
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2709
    } else {
2710
        char *p;
2711
        int i;
2712
        AVCodec *codec;
2713

    
2714
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2715
        if (video_codec_id != CODEC_ID_NONE)
2716
            codec_id = video_codec_id;
2717

    
2718
        video_enc->codec_id = codec_id;
2719
        codec = avcodec_find_encoder(codec_id);
2720

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

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

    
2747
        video_enc->width = frame_width + frame_padright + frame_padleft;
2748
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2749
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2750
        video_enc->pix_fmt = frame_pix_fmt;
2751

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

    
2762
        if (intra_only)
2763
            video_enc->gop_size = 0;
2764
        if (video_qscale || same_quality) {
2765
            video_enc->flags |= CODEC_FLAG_QSCALE;
2766
            video_enc->global_quality=
2767
                st->quality = FF_QP2LAMBDA * video_qscale;
2768
        }
2769

    
2770
        if(intra_matrix)
2771
            video_enc->intra_matrix = intra_matrix;
2772
        if(inter_matrix)
2773
            video_enc->inter_matrix = inter_matrix;
2774

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

    
2809
        if (do_psnr)
2810
            video_enc->flags|= CODEC_FLAG_PSNR;
2811

    
2812
        /* two pass mode */
2813
        if (do_pass) {
2814
            if (do_pass == 1) {
2815
                video_enc->flags |= CODEC_FLAG_PASS1;
2816
            } else {
2817
                video_enc->flags |= CODEC_FLAG_PASS2;
2818
            }
2819
        }
2820
    }
2821

    
2822
    /* reset some key parameters */
2823
    video_disable = 0;
2824
    video_codec_id = CODEC_ID_NONE;
2825
    video_stream_copy = 0;
2826
}
2827

    
2828
static void new_audio_stream(AVFormatContext *oc)
2829
{
2830
    AVStream *st;
2831
    AVCodecContext *audio_enc;
2832
    int codec_id, i;
2833

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

    
2841
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2842
    audio_bitstream_filters= NULL;
2843

    
2844
    if(thread_count>1)
2845
        avcodec_thread_init(st->codec, thread_count);
2846

    
2847
    audio_enc = st->codec;
2848
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2849
    audio_enc->strict_std_compliance = strict;
2850

    
2851
    if(audio_codec_tag)
2852
        audio_enc->codec_tag= audio_codec_tag;
2853

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

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

    
2871
        if (audio_codec_id != CODEC_ID_NONE)
2872
            codec_id = audio_codec_id;
2873
        audio_enc->codec_id = codec_id;
2874

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

    
2890
    /* reset some key parameters */
2891
    audio_disable = 0;
2892
    audio_codec_id = CODEC_ID_NONE;
2893
    audio_stream_copy = 0;
2894
}
2895

    
2896
static void opt_new_subtitle_stream(void)
2897
{
2898
    AVFormatContext *oc;
2899
    AVStream *st;
2900
    AVCodecContext *subtitle_enc;
2901
    int i;
2902

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

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

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

    
2930
    if (subtitle_language) {
2931
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2932
        av_free(subtitle_language);
2933
        subtitle_language = NULL;
2934
    }
2935

    
2936
    subtitle_codec_id = CODEC_ID_NONE;
2937
    subtitle_stream_copy = 0;
2938
}
2939

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

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

    
2962
static void opt_output_file(const char *filename)
2963
{
2964
    AVFormatContext *oc;
2965
    int use_video, use_audio, input_has_video, input_has_audio, i;
2966
    AVFormatParameters params, *ap = &params;
2967

    
2968
    if (!strcmp(filename, "-"))
2969
        filename = "pipe:";
2970

    
2971
    oc = av_alloc_format_context();
2972

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

    
2982
    oc->oformat = file_oformat;
2983
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
2984

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

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

    
3007
        /* manual disable */
3008
        if (audio_disable) {
3009
            use_audio = 0;
3010
        }
3011
        if (video_disable) {
3012
            use_video = 0;
3013
        }
3014

    
3015
        if (use_video) {
3016
            new_video_stream(oc);
3017
        }
3018

    
3019
        if (use_audio) {
3020
            new_audio_stream(oc);
3021
        }
3022

    
3023
        oc->timestamp = rec_timestamp;
3024

    
3025
        if (str_title)
3026
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3027
        if (str_author)
3028
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3029
        if (str_copyright)
3030
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3031
        if (str_comment)
3032
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3033
        if (str_album)
3034
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3035
    }
3036

    
3037
    output_files[nb_output_files++] = oc;
3038

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

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

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

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

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

    
3085
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3086
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3087
    oc->loop_output = loop_output;
3088

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

    
3096
    /* reset some options */
3097
    file_oformat = NULL;
3098
    file_iformat = NULL;
3099
}
3100

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

    
3113
static int64_t getutime(void)
3114
{
3115
#ifdef HAVE_GETRUSAGE
3116
    struct rusage rusage;
3117

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

    
3131
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3132
extern int ffm_nopts;
3133
#endif
3134

    
3135
static void show_formats(void)
3136
{
3137
    AVInputFormat *ifmt;
3138
    AVOutputFormat *ofmt;
3139
    URLProtocol *up;
3140
    AVCodec *p, *p2;
3141
    const char *last_name;
3142

    
3143
    printf("File formats:\n");
3144
    last_name= "000";
3145
    for(;;){
3146
        int decode=0;
3147
        int encode=0;
3148
        const char *name=NULL;
3149
        const char *long_name=NULL;
3150

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

    
3173
        printf(
3174
            " %s%s %-15s %s\n",
3175
            decode ? "D":" ",
3176
            encode ? "E":" ",
3177
            name,
3178
            long_name ? long_name:" ");
3179
    }
3180
    printf("\n");
3181

    
3182
    printf("Codecs:\n");
3183
    last_name= "000";
3184
    for(;;){
3185
        int decode=0;
3186
        int encode=0;
3187
        int cap=0;
3188
        const char *type_str;
3189

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

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

    
3236
    printf("Supported file protocols:\n");
3237
    for(up = first_protocol; up != NULL; up = up->next)
3238
        printf(" %s:", up->name);
3239
    printf("\n");
3240

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

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

    
3269
static void opt_inter_matrix(const char *arg)
3270
{
3271
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3272
    parse_matrix_coeffs(inter_matrix, arg);
3273
}
3274

    
3275
static void opt_intra_matrix(const char *arg)
3276
{
3277
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3278
    parse_matrix_coeffs(intra_matrix, arg);
3279
}
3280

    
3281
static void opt_target(const char *arg)
3282
{
3283
    int norm = -1;
3284
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3285

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

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

    
3337
    if(!strcmp(arg, "vcd")) {
3338

    
3339
        opt_video_codec("mpeg1video");
3340
        opt_audio_codec("mp2");
3341
        opt_format("vcd");
3342

    
3343
        opt_frame_size(norm ? "352x240" : "352x288");
3344
        opt_frame_rate(frame_rates[norm]);
3345
        opt_default("gop", norm ? "18" : "15");
3346

    
3347
        opt_default("b", "1150000");
3348
        opt_default("maxrate", "1150000");
3349
        opt_default("minrate", "1150000");
3350
        opt_default("bufsize", "327680"); // 40*1024*8;
3351

    
3352
        opt_default("ab", "224000");
3353
        audio_sample_rate = 44100;
3354
        audio_channels = 2;
3355

    
3356
        opt_default("packetsize", "2324");
3357
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3358

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

    
3367
        opt_video_codec("mpeg2video");
3368
        opt_audio_codec("mp2");
3369
        opt_format("svcd");
3370

    
3371
        opt_frame_size(norm ? "480x480" : "480x576");
3372
        opt_frame_rate(frame_rates[norm]);
3373
        opt_default("gop", norm ? "18" : "15");
3374

    
3375
        opt_default("b", "2040000");
3376
        opt_default("maxrate", "2516000");
3377
        opt_default("minrate", "0"); //1145000;
3378
        opt_default("bufsize", "1835008"); //224*1024*8;
3379
        opt_default("flags", "+SCAN_OFFSET");
3380

    
3381

    
3382
        opt_default("ab", "224000");
3383
        audio_sample_rate = 44100;
3384

    
3385
        opt_default("packetsize", "2324");
3386

    
3387
    } else if(!strcmp(arg, "dvd")) {
3388

    
3389
        opt_video_codec("mpeg2video");
3390
        opt_audio_codec("ac3");
3391
        opt_format("dvd");
3392

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

    
3397
        opt_default("b", "6000000");
3398
        opt_default("maxrate", "9000000");
3399
        opt_default("minrate", "0"); //1500000;
3400
        opt_default("bufsize", "1835008"); //224*1024*8;
3401

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

    
3405
        opt_default("ab", "448000");
3406
        audio_sample_rate = 48000;
3407

    
3408
    } else if(!strncmp(arg, "dv", 2)) {
3409

    
3410
        opt_format("dv");
3411

    
3412
        opt_frame_size(norm ? "720x480" : "720x576");
3413
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3414
                                             (norm ? "yuv411p" : "yuv420p"));
3415
        opt_frame_rate(frame_rates[norm]);
3416

    
3417
        audio_sample_rate = 48000;
3418
        audio_channels = 2;
3419

    
3420
    } else {
3421
        fprintf(stderr, "Unknown target: %s\n", arg);
3422
        exit(1);
3423
    }
3424
}
3425

    
3426
static void opt_vstats_file (const char *arg)
3427
{
3428
    av_free (vstats_filename);
3429
    vstats_filename=av_strdup (arg);
3430
}
3431

    
3432
static void opt_vstats (void)
3433
{
3434
    char filename[40];
3435
    time_t today2 = time(NULL);
3436
    struct tm *today = localtime(&today2);
3437

    
3438
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3439
             today->tm_sec);
3440
    opt_vstats_file(filename);
3441
}
3442

    
3443
static void opt_video_bsf(const char *arg)
3444
{
3445
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3446
    AVBitStreamFilterContext **bsfp;
3447

    
3448
    if(!bsfc){
3449
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3450
        exit(1);
3451
    }
3452

    
3453
    bsfp= &video_bitstream_filters;
3454
    while(*bsfp)
3455
        bsfp= &(*bsfp)->next;
3456

    
3457
    *bsfp= bsfc;
3458
}
3459

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

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

    
3471
    bsfp= &audio_bitstream_filters;
3472
    while(*bsfp)
3473
        bsfp= &(*bsfp)->next;
3474

    
3475
    *bsfp= bsfc;
3476
}
3477

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

    
3489
static int opt_default(const char *opt, const char *arg){
3490
    int type;
3491
    const AVOption *o= NULL;
3492
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3493

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

    
3514
//    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));
3515

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

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

    
3526
    if(avctx_opts[0]->debug)
3527
        av_log_level = AV_LOG_DEBUG;
3528
    return 0;
3529
}
3530

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

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

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

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

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

    
3637
    /* muxer options */
3638
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3639
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3640

    
3641
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3642
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3643

    
3644
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3645
    { NULL, },
3646
};
3647

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

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

    
3702
/**
3703
 * Trivial log callback.
3704
 * Only suitable for show_help and similar since it lacks prefix handling.
3705
 */
3706
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3707
{
3708
    vfprintf(stdout, fmt, vl);
3709
}
3710

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

    
3745
    exit(1);
3746
}
3747

    
3748
void parse_arg_file(const char *filename)
3749
{
3750
    opt_output_file(filename);
3751
}
3752

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

    
3758
    av_register_all();
3759

    
3760
    for(i=0; i<CODEC_TYPE_NB; i++){
3761
        avctx_opts[i]= avcodec_alloc_context2(i);
3762
    }
3763
    avformat_opts = av_alloc_format_context();
3764
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
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
    if (fvstats)
3815
        fclose(fvstats);
3816
    av_free(vstats_filename);
3817

    
3818
    av_free(opt_names);
3819

    
3820
    av_free(video_standard);
3821

    
3822
#ifdef CONFIG_POWERPC_PERF
3823
    extern void powerpc_display_perf_report(void);
3824
    powerpc_display_perf_report();
3825
#endif /* CONFIG_POWERPC_PERF */
3826

    
3827
    if (received_sigterm) {
3828
        fprintf(stderr,
3829
            "Received signal %d: terminating.\n",
3830
            (int) received_sigterm);
3831
        exit (255);
3832
    }
3833

    
3834
    exit(0); /* not all OS-es handle main() return value */
3835
    return 0;
3836
}