Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ fec401f7

History | View | Annotate | Download (134 KB)

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

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

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

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

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

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

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

    
64
#undef exit
65

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

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

    
80
extern const OptionDef options[];
81

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

    
86
#define MAX_FILES 20
87

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

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

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

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

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

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

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

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

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

    
187
static int rate_emu = 0;
188

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

    
192
static int audio_volume = 256;
193

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

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

    
210
static int sws_flags = SWS_BICUBIC;
211

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

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

    
223
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
224

    
225
struct AVInputStream;
226

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

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

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

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

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

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

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

    
285
#ifdef HAVE_TERMIOS_H
286

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

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

    
298
static volatile sig_atomic_t received_sigterm = 0;
299

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
419
        bsfc= bsfc->next;
420
    }
421

    
422
    av_interleaved_write_frame(s, pkt);
423
}
424

    
425
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
426

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
698
    *frame_size = 0;
699

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
913

    
914
    oc = output_files[0];
915

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

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

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

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

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

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

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

    
993
        fflush(stderr);
994
    }
995

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

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

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

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

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

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

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

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

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

    
1155
            ist->frame++;
1156
        }
1157

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1341

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1511
        if (!ost->st->language[0])
1512
            av_strlcpy(ost->st->language, ist->st->language,
1513
                       sizeof(ost->st->language));
1514

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1936
    discard_packet:
1937
        av_free_packet(&pkt);
1938

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

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

    
1951
    term_exit();
1952

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

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

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

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

    
1979
    /* finished ! */
1980

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2172

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

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

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

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

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

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

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

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

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

    
2230

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

    
2244

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2414
    using_vhook = 1;
2415

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

    
2420
    i = frame_hook_add(argc, argv);
2421

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2544
    ic->loop_input = loop_input;
2545

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

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

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

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

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

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

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

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

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

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

    
2649
    video_channel = 0;
2650

    
2651
    rate_emu = 0;
2652
}
2653

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

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

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

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

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

    
2708
    video_enc = st->codec;
2709

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2951
static void opt_new_audio_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_audio_stream(oc);
2960
}
2961

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

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

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

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

    
2994
    oc = av_alloc_format_context();
2995

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

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

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

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

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

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

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

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

    
3057
        oc->timestamp = rec_timestamp;
3058

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

    
3071
    output_files[nb_output_files++] = oc;
3072

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3415

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

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

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

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

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

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

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

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

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

    
3444
        opt_format("dv");
3445

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

    
3451
        audio_sample_rate = 48000;
3452
        audio_channels = 2;
3453

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

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

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

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

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

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

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

    
3491
    *bsfp= bsfc;
3492
}
3493

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

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

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

    
3509
    *bsfp= bsfc;
3510
}
3511

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3782
    exit(1);
3783
}
3784

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

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

    
3795
    av_register_all();
3796

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

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

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

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

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

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

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

    
3846
    av_free_static();
3847

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

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

    
3855
    av_free(opt_names);
3856

    
3857
    av_free(video_standard);
3858

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

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

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