Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ c20bd3e0

History | View | Annotate | Download (135 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 opt_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 char *video_codec_name = NULL;
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 char  *audio_codec_name = NULL;
150
static int audio_codec_tag = 0;
151
static char *audio_language = NULL;
152

    
153
static int subtitle_disable = 0;
154
static char *subtitle_codec_name = NULL;
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 float audio_drift_threshold= 0.1;
182
static int copy_ts= 0;
183
static int opt_shortest = 0; //
184
static int video_global_header = 0;
185
static char *vstats_filename;
186
static FILE *fvstats;
187

    
188
static int rate_emu = 0;
189

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

    
193
static int audio_volume = 256;
194

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

    
208
static int pgmyuv_compatibility_hack=0;
209
static float dts_delta_threshold = 10;
210

    
211
static int sws_flags = SWS_BICUBIC;
212

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

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

    
224
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
225

    
226
struct AVInputStream;
227

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

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

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

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

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

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

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

    
286
#ifdef HAVE_TERMIOS_H
287

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

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

    
299
static volatile sig_atomic_t received_sigterm = 0;
300

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
420
        bsfc= bsfc->next;
421
    }
422

    
423
    av_interleaved_write_frame(s, pkt);
424
}
425

    
426
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
427

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
699
    *frame_size = 0;
700

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
914

    
915
    oc = output_files[0];
916

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

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

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

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

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

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

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

    
994
        fflush(stderr);
995
    }
996

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

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

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

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

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

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

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

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

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

    
1156
            ist->frame++;
1157
        }
1158

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

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

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

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

    
1214
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1215
                            continue;
1216

    
1217
                        /* no reencoding needed : output the packet directly */
1218
                        /* force the input stream PTS */
1219

    
1220
                        avcodec_get_frame_defaults(&avframe);
1221
                        ost->st->codec->coded_frame= &avframe;
1222
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1223

    
1224
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1225
                            audio_size += data_size;
1226
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1227
                            video_size += data_size;
1228
                            ost->sync_opts++;
1229
                        }
1230

    
1231
                        opkt.stream_index= ost->index;
1232
                        if(pkt->pts != AV_NOPTS_VALUE)
1233
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1234
                        else
1235
                            opkt.pts= AV_NOPTS_VALUE;
1236

    
1237
                            if (pkt->dts == AV_NOPTS_VALUE)
1238
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1239
                            else
1240
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1241

    
1242
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1243
                        opkt.flags= pkt->flags;
1244

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

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

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

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

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

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

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

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

    
1342

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1510
        codec = ost->st->codec;
1511
        icodec = ist->st->codec;
1512

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

    
1517
        if (ost->st->stream_copy) {
1518
            /* if stream_copy is selected, no need to decode or encode */
1519
            codec->codec_id = icodec->codec_id;
1520
            codec->codec_type = icodec->codec_type;
1521

    
1522
            if(!codec->codec_tag){
1523
                if(   !os->oformat->codec_tag
1524
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1525
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1526
                    codec->codec_tag = icodec->codec_tag;
1527
            }
1528

    
1529
            codec->bit_rate = icodec->bit_rate;
1530
            codec->extradata= icodec->extradata;
1531
            codec->extradata_size= icodec->extradata_size;
1532
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1533
                codec->time_base = icodec->time_base;
1534
            else
1535
                codec->time_base = ist->st->time_base;
1536
            switch(codec->codec_type) {
1537
            case CODEC_TYPE_AUDIO:
1538
                codec->sample_rate = icodec->sample_rate;
1539
                codec->channels = icodec->channels;
1540
                codec->frame_size = icodec->frame_size;
1541
                codec->block_align= icodec->block_align;
1542
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1543
                    codec->block_align= 0;
1544
                break;
1545
            case CODEC_TYPE_VIDEO:
1546
                if(using_vhook) {
1547
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1548
                    exit(1);
1549
                }
1550
                codec->pix_fmt = icodec->pix_fmt;
1551
                codec->width = icodec->width;
1552
                codec->height = icodec->height;
1553
                codec->has_b_frames = icodec->has_b_frames;
1554
                break;
1555
            case CODEC_TYPE_SUBTITLE:
1556
                break;
1557
            default:
1558
                abort();
1559
            }
1560
        } else {
1561
            switch(codec->codec_type) {
1562
            case CODEC_TYPE_AUDIO:
1563
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1564
                    goto fail;
1565

    
1566
                if (codec->channels == icodec->channels &&
1567
                    codec->sample_rate == icodec->sample_rate) {
1568
                    ost->audio_resample = 0;
1569
                } else {
1570
                    if (codec->channels != icodec->channels &&
1571
                        (icodec->codec_id == CODEC_ID_AC3 ||
1572
                         icodec->codec_id == CODEC_ID_DTS)) {
1573
                        /* Special case for 5:1 AC3 and DTS input */
1574
                        /* and mono or stereo output      */
1575
                        /* Request specific number of channels */
1576
                        icodec->channels = codec->channels;
1577
                        if (codec->sample_rate == icodec->sample_rate)
1578
                            ost->audio_resample = 0;
1579
                        else {
1580
                            ost->audio_resample = 1;
1581
                        }
1582
                    } else {
1583
                        ost->audio_resample = 1;
1584
                    }
1585
                }
1586
                if(audio_sync_method>1)
1587
                    ost->audio_resample = 1;
1588

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

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

    
1705
    if (!bit_buffer)
1706
        bit_buffer = av_malloc(bit_buffer_size);
1707
    if (!bit_buffer)
1708
        goto fail;
1709

    
1710
    /* dump the file output parameters - cannot be done before in case
1711
       of stream copy */
1712
    for(i=0;i<nb_output_files;i++) {
1713
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1714
    }
1715

    
1716
    /* dump the stream mapping */
1717
    if (verbose >= 0) {
1718
        fprintf(stderr, "Stream mapping:\n");
1719
        for(i=0;i<nb_ostreams;i++) {
1720
            ost = ost_table[i];
1721
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1722
                    ist_table[ost->source_index]->file_index,
1723
                    ist_table[ost->source_index]->index,
1724
                    ost->file_index,
1725
                    ost->index);
1726
            if (ost->sync_ist != ist_table[ost->source_index])
1727
                fprintf(stderr, " [sync #%d.%d]",
1728
                        ost->sync_ist->file_index,
1729
                        ost->sync_ist->index);
1730
            fprintf(stderr, "\n");
1731
        }
1732
    }
1733

    
1734
    /* open each encoder */
1735
    for(i=0;i<nb_ostreams;i++) {
1736
        ost = ost_table[i];
1737
        if (ost->encoding_needed) {
1738
            AVCodec *codec;
1739
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1740
            if (!codec) {
1741
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1742
                        ost->file_index, ost->index);
1743
                exit(1);
1744
            }
1745
            if (avcodec_open(ost->st->codec, codec) < 0) {
1746
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1747
                        ost->file_index, ost->index);
1748
                exit(1);
1749
            }
1750
            extra_size += ost->st->codec->extradata_size;
1751
        }
1752
    }
1753

    
1754
    /* open each decoder */
1755
    for(i=0;i<nb_istreams;i++) {
1756
        ist = ist_table[i];
1757
        if (ist->decoding_needed) {
1758
            AVCodec *codec;
1759
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1760
            if (!codec) {
1761
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1762
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1763
                exit(1);
1764
            }
1765
            if (avcodec_open(ist->st->codec, codec) < 0) {
1766
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1767
                        ist->file_index, ist->index);
1768
                exit(1);
1769
            }
1770
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1771
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1772
        }
1773
    }
1774

    
1775
    /* init pts */
1776
    for(i=0;i<nb_istreams;i++) {
1777
        ist = ist_table[i];
1778
        is = input_files[ist->file_index];
1779
        ist->pts = 0;
1780
        ist->next_pts=0;
1781
        if(   input_files_ts_offset[ist->file_index] != -is->start_time
1782
           && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1783
            ist->next_pts= AV_NOPTS_VALUE;
1784
        ist->is_start = 1;
1785
    }
1786

    
1787
    /* set meta data information from input file if required */
1788
    for (i=0;i<nb_meta_data_maps;i++) {
1789
        AVFormatContext *out_file;
1790
        AVFormatContext *in_file;
1791

    
1792
        int out_file_index = meta_data_maps[i].out_file;
1793
        int in_file_index = meta_data_maps[i].in_file;
1794
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1795
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1796
            ret = AVERROR(EINVAL);
1797
            goto fail;
1798
        }
1799
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1800
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1801
            ret = AVERROR(EINVAL);
1802
            goto fail;
1803
        }
1804

    
1805
        out_file = output_files[out_file_index];
1806
        in_file = input_files[in_file_index];
1807

    
1808
        strcpy(out_file->title, in_file->title);
1809
        strcpy(out_file->author, in_file->author);
1810
        strcpy(out_file->copyright, in_file->copyright);
1811
        strcpy(out_file->comment, in_file->comment);
1812
        strcpy(out_file->album, in_file->album);
1813
        out_file->year = in_file->year;
1814
        out_file->track = in_file->track;
1815
        strcpy(out_file->genre, in_file->genre);
1816
    }
1817

    
1818
    /* open files and write file headers */
1819
    for(i=0;i<nb_output_files;i++) {
1820
        os = output_files[i];
1821
        if (av_write_header(os) < 0) {
1822
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1823
            ret = AVERROR(EINVAL);
1824
            goto fail;
1825
        }
1826
    }
1827

    
1828
    if ( !using_stdin && verbose >= 0) {
1829
        fprintf(stderr, "Press [q] to stop encoding\n");
1830
        url_set_interrupt_cb(decode_interrupt_cb);
1831
    }
1832
    term_init();
1833

    
1834
    key = -1;
1835
    timer_start = av_gettime();
1836

    
1837
    for(; received_sigterm == 0;) {
1838
        int file_index, ist_index;
1839
        AVPacket pkt;
1840
        double ipts_min;
1841
        double opts_min;
1842

    
1843
    redo:
1844
        ipts_min= 1e100;
1845
        opts_min= 1e100;
1846
        /* if 'q' pressed, exits */
1847
        if (!using_stdin) {
1848
            if (q_pressed)
1849
                break;
1850
            /* read_key() returns 0 on EOF */
1851
            key = read_key();
1852
            if (key == 'q')
1853
                break;
1854
        }
1855

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

    
1889
        /* finish if recording time exhausted */
1890
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1891
            break;
1892

    
1893
        /* finish if limit size exhausted */
1894
        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1895
            break;
1896

    
1897
        /* read a frame from it and output it in the fifo */
1898
        is = input_files[file_index];
1899
        if (av_read_frame(is, &pkt) < 0) {
1900
            file_table[file_index].eof_reached = 1;
1901
            if (opt_shortest)
1902
                break;
1903
            else
1904
                continue;
1905
        }
1906

    
1907
        if (do_pkt_dump) {
1908
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1909
        }
1910
        /* the following test is needed in case new streams appear
1911
           dynamically in stream : we ignore them */
1912
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1913
            goto discard_packet;
1914
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1915
        ist = ist_table[ist_index];
1916
        if (ist->discard)
1917
            goto discard_packet;
1918

    
1919
        if (pkt.dts != AV_NOPTS_VALUE)
1920
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1921
        if (pkt.pts != AV_NOPTS_VALUE)
1922
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1923

    
1924
//        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);
1925
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1926
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1927
            int64_t delta= pkt_dts - ist->next_pts;
1928
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1929
                input_files_ts_offset[ist->file_index]-= delta;
1930
                if (verbose > 2)
1931
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1932
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1933
                if(pkt.pts != AV_NOPTS_VALUE)
1934
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1935
            }
1936
        }
1937

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

    
1941
            if (verbose >= 0)
1942
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1943
                        ist->file_index, ist->index);
1944

    
1945
            av_free_packet(&pkt);
1946
            goto redo;
1947
        }
1948

    
1949
    discard_packet:
1950
        av_free_packet(&pkt);
1951

    
1952
        /* dump report by using the output first video and audio streams */
1953
        print_report(output_files, ost_table, nb_ostreams, 0);
1954
    }
1955

    
1956
    /* at the end of stream, we must flush the decoder buffers */
1957
    for(i=0;i<nb_istreams;i++) {
1958
        ist = ist_table[i];
1959
        if (ist->decoding_needed) {
1960
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1961
        }
1962
    }
1963

    
1964
    term_exit();
1965

    
1966
    /* write the trailer if needed and close file */
1967
    for(i=0;i<nb_output_files;i++) {
1968
        os = output_files[i];
1969
        av_write_trailer(os);
1970
    }
1971

    
1972
    /* dump report by using the first video and audio streams */
1973
    print_report(output_files, ost_table, nb_ostreams, 1);
1974

    
1975
    /* close each encoder */
1976
    for(i=0;i<nb_ostreams;i++) {
1977
        ost = ost_table[i];
1978
        if (ost->encoding_needed) {
1979
            av_freep(&ost->st->codec->stats_in);
1980
            avcodec_close(ost->st->codec);
1981
        }
1982
    }
1983

    
1984
    /* close each decoder */
1985
    for(i=0;i<nb_istreams;i++) {
1986
        ist = ist_table[i];
1987
        if (ist->decoding_needed) {
1988
            avcodec_close(ist->st->codec);
1989
        }
1990
    }
1991

    
1992
    /* finished ! */
1993

    
1994
    ret = 0;
1995
 fail1:
1996
    av_freep(&bit_buffer);
1997
    av_free(file_table);
1998

    
1999
    if (ist_table) {
2000
        for(i=0;i<nb_istreams;i++) {
2001
            ist = ist_table[i];
2002
            av_free(ist);
2003
        }
2004
        av_free(ist_table);
2005
    }
2006
    if (ost_table) {
2007
        for(i=0;i<nb_ostreams;i++) {
2008
            ost = ost_table[i];
2009
            if (ost) {
2010
                if (ost->logfile) {
2011
                    fclose(ost->logfile);
2012
                    ost->logfile = NULL;
2013
                }
2014
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2015
                                             initialized but set to zero */
2016
                av_free(ost->pict_tmp.data[0]);
2017
                if (ost->video_resample)
2018
                    sws_freeContext(ost->img_resample_ctx);
2019
                if (ost->audio_resample)
2020
                    audio_resample_close(ost->resample);
2021
                av_free(ost);
2022
            }
2023
        }
2024
        av_free(ost_table);
2025
    }
2026
    return ret;
2027
 fail:
2028
    ret = AVERROR(ENOMEM);
2029
    goto fail1;
2030
}
2031

    
2032
#if 0
2033
int file_read(const char *filename)
2034
{
2035
    URLContext *h;
2036
    unsigned char buffer[1024];
2037
    int len, i;
2038

2039
    if (url_open(&h, filename, O_RDONLY) < 0) {
2040
        printf("could not open '%s'\n", filename);
2041
        return -1;
2042
    }
2043
    for(;;) {
2044
        len = url_read(h, buffer, sizeof(buffer));
2045
        if (len <= 0)
2046
            break;
2047
        for(i=0;i<len;i++) putchar(buffer[i]);
2048
    }
2049
    url_close(h);
2050
    return 0;
2051
}
2052
#endif
2053

    
2054
static void opt_format(const char *arg)
2055
{
2056
    /* compatibility stuff for pgmyuv */
2057
    if (!strcmp(arg, "pgmyuv")) {
2058
        pgmyuv_compatibility_hack=1;
2059
//        opt_image_format(arg);
2060
        arg = "image2";
2061
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2062
    }
2063

    
2064
    file_iformat = av_find_input_format(arg);
2065
    file_oformat = guess_format(arg, NULL, NULL);
2066
    if (!file_iformat && !file_oformat) {
2067
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2068
        exit(1);
2069
    }
2070
}
2071

    
2072
static void opt_video_rc_eq(char *arg)
2073
{
2074
    video_rc_eq = arg;
2075
}
2076

    
2077
static void opt_video_rc_override_string(char *arg)
2078
{
2079
    video_rc_override_string = arg;
2080
}
2081

    
2082
static void opt_me_threshold(const char *arg)
2083
{
2084
    me_threshold = atoi(arg);
2085
}
2086

    
2087
static void opt_verbose(const char *arg)
2088
{
2089
    verbose = atoi(arg);
2090
    av_log_level = atoi(arg);
2091
}
2092

    
2093
static void opt_frame_rate(const char *arg)
2094
{
2095
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2096
        fprintf(stderr, "Incorrect frame rate\n");
2097
        exit(1);
2098
    }
2099
}
2100

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

    
2119
static void opt_frame_crop_bottom(const char *arg)
2120
{
2121
    frame_bottomBand = atoi(arg);
2122
    if (frame_bottomBand < 0) {
2123
        fprintf(stderr, "Incorrect bottom crop size\n");
2124
        exit(1);
2125
    }
2126
    if ((frame_bottomBand % 2) != 0) {
2127
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2128
        exit(1);
2129
    }
2130
    if ((frame_bottomBand) >= frame_height){
2131
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2132
        exit(1);
2133
    }
2134
    frame_height -= frame_bottomBand;
2135
}
2136

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

    
2155
static void opt_frame_crop_right(const char *arg)
2156
{
2157
    frame_rightBand = atoi(arg);
2158
    if (frame_rightBand < 0) {
2159
        fprintf(stderr, "Incorrect right crop size\n");
2160
        exit(1);
2161
    }
2162
    if ((frame_rightBand % 2) != 0) {
2163
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2164
        exit(1);
2165
    }
2166
    if ((frame_rightBand) >= frame_width){
2167
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2168
        exit(1);
2169
    }
2170
    frame_width -= frame_rightBand;
2171
}
2172

    
2173
static void opt_frame_size(const char *arg)
2174
{
2175
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2176
        fprintf(stderr, "Incorrect frame size\n");
2177
        exit(1);
2178
    }
2179
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2180
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2181
        exit(1);
2182
    }
2183
}
2184

    
2185

    
2186
#define SCALEBITS 10
2187
#define ONE_HALF  (1 << (SCALEBITS - 1))
2188
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2189

    
2190
#define RGB_TO_Y(r, g, b) \
2191
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2192
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2193

    
2194
#define RGB_TO_U(r1, g1, b1, shift)\
2195
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2196
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2197

    
2198
#define RGB_TO_V(r1, g1, b1, shift)\
2199
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2200
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2201

    
2202
static void opt_pad_color(const char *arg) {
2203
    /* Input is expected to be six hex digits similar to
2204
       how colors are expressed in html tags (but without the #) */
2205
    int rgb = strtol(arg, NULL, 16);
2206
    int r,g,b;
2207

    
2208
    r = (rgb >> 16);
2209
    g = ((rgb >> 8) & 255);
2210
    b = (rgb & 255);
2211

    
2212
    padcolor[0] = RGB_TO_Y(r,g,b);
2213
    padcolor[1] = RGB_TO_U(r,g,b,0);
2214
    padcolor[2] = RGB_TO_V(r,g,b,0);
2215
}
2216

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

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

    
2243

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

    
2257

    
2258
static void opt_frame_pad_right(const char *arg)
2259
{
2260
    frame_padright = atoi(arg);
2261
    if (frame_padright < 0) {
2262
        fprintf(stderr, "Incorrect right pad size\n");
2263
        exit(1);
2264
    }
2265
    if ((frame_padright % 2) != 0) {
2266
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2267
        exit(1);
2268
    }
2269
}
2270

    
2271
void list_pix_fmts(void)
2272
{
2273
    int i;
2274
    char pix_fmt_str[128];
2275
    for (i=-1; i < PIX_FMT_NB; i++) {
2276
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2277
        fprintf(stdout, "%s\n", pix_fmt_str);
2278
    }
2279
}
2280

    
2281
static void opt_frame_pix_fmt(const char *arg)
2282
{
2283
    if (strcmp(arg, "list"))
2284
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2285
    else {
2286
        list_pix_fmts();
2287
        exit(0);
2288
    }
2289
}
2290

    
2291
static void opt_frame_aspect_ratio(const char *arg)
2292
{
2293
    int x = 0, y = 0;
2294
    double ar = 0;
2295
    const char *p;
2296

    
2297
    p = strchr(arg, ':');
2298
    if (p) {
2299
        x = strtol(arg, (char **)&arg, 10);
2300
        if (arg == p)
2301
            y = strtol(arg+1, (char **)&arg, 10);
2302
        if (x > 0 && y > 0)
2303
            ar = (double)x / (double)y;
2304
    } else
2305
        ar = strtod(arg, (char **)&arg);
2306

    
2307
    if (!ar) {
2308
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2309
        exit(1);
2310
    }
2311
    frame_aspect_ratio = ar;
2312
}
2313

    
2314
static void opt_qscale(const char *arg)
2315
{
2316
    video_qscale = atof(arg);
2317
    if (video_qscale <= 0 ||
2318
        video_qscale > 255) {
2319
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2320
        exit(1);
2321
    }
2322
}
2323

    
2324
static void opt_qdiff(const char *arg)
2325
{
2326
    video_qdiff = atoi(arg);
2327
    if (video_qdiff < 0 ||
2328
        video_qdiff > 31) {
2329
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2330
        exit(1);
2331
    }
2332
}
2333

    
2334
static void opt_strict(const char *arg)
2335
{
2336
    strict= atoi(arg);
2337
}
2338

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

    
2344
static void opt_thread_count(const char *arg)
2345
{
2346
    thread_count= atoi(arg);
2347
#if !defined(HAVE_THREADS)
2348
    if (verbose >= 0)
2349
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2350
#endif
2351
}
2352

    
2353
static void opt_audio_rate(const char *arg)
2354
{
2355
    audio_sample_rate = atoi(arg);
2356
}
2357

    
2358
static void opt_audio_channels(const char *arg)
2359
{
2360
    audio_channels = atoi(arg);
2361
}
2362

    
2363
static void opt_video_channel(const char *arg)
2364
{
2365
    video_channel = strtol(arg, NULL, 0);
2366
}
2367

    
2368
static void opt_video_standard(const char *arg)
2369
{
2370
    video_standard = av_strdup(arg);
2371
}
2372

    
2373
static void opt_codec(int *pstream_copy, char **pcodec_name,
2374
                      int codec_type, const char *arg)
2375
{
2376
    av_freep(pcodec_name);
2377
    if (!strcmp(arg, "copy")) {
2378
        *pstream_copy = 1;
2379
    } else {
2380
        *pcodec_name = av_strdup(arg);
2381
    }
2382
}
2383

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

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

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

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

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

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

    
2415
    using_vhook = 1;
2416

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

    
2421
    i = frame_hook_add(argc, argv);
2422

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2500
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2501
{
2502
    AVCodec *codec;
2503

    
2504
    if(!name)
2505
        return CODEC_ID_NONE;
2506
    codec = encoder ?
2507
        avcodec_find_encoder_by_name(name) :
2508
        avcodec_find_decoder_by_name(name);
2509
    if(!codec) {
2510
        av_log(NULL, AV_LOG_ERROR, "Unknown codec '%s'\n", name);
2511
        exit(1);
2512
    }
2513
    if(codec->type != type) {
2514
        av_log(NULL, AV_LOG_ERROR, "Invalid codec type '%s'\n", name);
2515
        exit(1);
2516
    }
2517
    return codec->id;
2518
}
2519

    
2520
static void opt_input_file(const char *filename)
2521
{
2522
    AVFormatContext *ic;
2523
    AVFormatParameters params, *ap = &params;
2524
    int err, i, ret, rfps, rfps_base;
2525
    int64_t timestamp;
2526

    
2527
    if (!strcmp(filename, "-"))
2528
        filename = "pipe:";
2529

    
2530
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2531
                   !strcmp( filename, "/dev/stdin" );
2532

    
2533
    /* get default parameters from command line */
2534
    ic = av_alloc_format_context();
2535

    
2536
    memset(ap, 0, sizeof(*ap));
2537
    ap->prealloced_context = 1;
2538
    ap->sample_rate = audio_sample_rate;
2539
    ap->channels = audio_channels;
2540
    ap->time_base.den = frame_rate.num;
2541
    ap->time_base.num = frame_rate.den;
2542
    ap->width = frame_width + frame_padleft + frame_padright;
2543
    ap->height = frame_height + frame_padtop + frame_padbottom;
2544
    ap->pix_fmt = frame_pix_fmt;
2545
    ap->channel = video_channel;
2546
    ap->standard = video_standard;
2547
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2548
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2549
    if(pgmyuv_compatibility_hack)
2550
        ap->video_codec_id= CODEC_ID_PGMYUV;
2551

    
2552
    for(i=0; i<opt_name_count; i++){
2553
        const AVOption *opt;
2554
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2555
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2556
            av_set_double(ic, opt_names[i], d);
2557
    }
2558
    /* open the input file with generic libav function */
2559
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2560
    if (err < 0) {
2561
        print_error(filename, err);
2562
        exit(1);
2563
    }
2564

    
2565
    ic->loop_input = loop_input;
2566

    
2567
    /* If not enough info to get the stream parameters, we decode the
2568
       first frames to get it. (used in mpeg case for example) */
2569
    ret = av_find_stream_info(ic);
2570
    if (ret < 0 && verbose >= 0) {
2571
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2572
        exit(1);
2573
    }
2574

    
2575
    timestamp = start_time;
2576
    /* add the stream start time */
2577
    if (ic->start_time != AV_NOPTS_VALUE)
2578
        timestamp += ic->start_time;
2579

    
2580
    /* if seeking requested, we execute it */
2581
    if (start_time != 0) {
2582
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2583
        if (ret < 0) {
2584
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2585
                    filename, (double)timestamp / AV_TIME_BASE);
2586
        }
2587
        /* reset seek info */
2588
        start_time = 0;
2589
    }
2590

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

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

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

    
2635
                    (float)rfps / rfps_base, rfps, rfps_base);
2636
            }
2637
            /* update the current frame rate to match the stream frame rate */
2638
            frame_rate.num = rfps;
2639
            frame_rate.den = rfps_base;
2640

    
2641
            enc->rate_emu = rate_emu;
2642
            if(video_disable)
2643
                ic->streams[i]->discard= AVDISCARD_ALL;
2644
            else if(video_discard)
2645
                ic->streams[i]->discard= video_discard;
2646
            break;
2647
        case CODEC_TYPE_DATA:
2648
            break;
2649
        case CODEC_TYPE_SUBTITLE:
2650
            if(subtitle_disable)
2651
                ic->streams[i]->discard = AVDISCARD_ALL;
2652
            break;
2653
        case CODEC_TYPE_UNKNOWN:
2654
            break;
2655
        default:
2656
            abort();
2657
        }
2658
    }
2659

    
2660
    input_files[nb_input_files] = ic;
2661
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2662
    /* dump the file content */
2663
    if (verbose >= 0)
2664
        dump_format(ic, nb_input_files, filename, 0);
2665

    
2666
    nb_input_files++;
2667
    file_iformat = NULL;
2668
    file_oformat = NULL;
2669

    
2670
    video_channel = 0;
2671

    
2672
    rate_emu = 0;
2673
}
2674

    
2675
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2676
                                         int *has_subtitle_ptr)
2677
{
2678
    int has_video, has_audio, has_subtitle, i, j;
2679
    AVFormatContext *ic;
2680

    
2681
    has_video = 0;
2682
    has_audio = 0;
2683
    has_subtitle = 0;
2684
    for(j=0;j<nb_input_files;j++) {
2685
        ic = input_files[j];
2686
        for(i=0;i<ic->nb_streams;i++) {
2687
            AVCodecContext *enc = ic->streams[i]->codec;
2688
            switch(enc->codec_type) {
2689
            case CODEC_TYPE_AUDIO:
2690
                has_audio = 1;
2691
                break;
2692
            case CODEC_TYPE_VIDEO:
2693
                has_video = 1;
2694
                break;
2695
            case CODEC_TYPE_SUBTITLE:
2696
                has_subtitle = 1;
2697
                break;
2698
            case CODEC_TYPE_DATA:
2699
            case CODEC_TYPE_UNKNOWN:
2700
                break;
2701
            default:
2702
                abort();
2703
            }
2704
        }
2705
    }
2706
    *has_video_ptr = has_video;
2707
    *has_audio_ptr = has_audio;
2708
    *has_subtitle_ptr = has_subtitle;
2709
}
2710

    
2711
static void new_video_stream(AVFormatContext *oc)
2712
{
2713
    AVStream *st;
2714
    AVCodecContext *video_enc;
2715
    int codec_id;
2716

    
2717
    st = av_new_stream(oc, oc->nb_streams);
2718
    if (!st) {
2719
        fprintf(stderr, "Could not alloc stream\n");
2720
        exit(1);
2721
    }
2722
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2723
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2724
    video_bitstream_filters= NULL;
2725

    
2726
    if(thread_count>1)
2727
        avcodec_thread_init(st->codec, thread_count);
2728

    
2729
    video_enc = st->codec;
2730

    
2731
    if(video_codec_tag)
2732
        video_enc->codec_tag= video_codec_tag;
2733

    
2734
    if(   (video_global_header&1)
2735
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2736
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2737
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2738
    }
2739
    if(video_global_header&2){
2740
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2741
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2742
    }
2743

    
2744
    if (video_stream_copy) {
2745
        st->stream_copy = 1;
2746
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2747
    } else {
2748
        char *p;
2749
        int i;
2750
        AVCodec *codec;
2751

    
2752
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2753
        if (video_codec_name)
2754
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2755

    
2756
        video_enc->codec_id = codec_id;
2757
        codec = avcodec_find_encoder(codec_id);
2758

    
2759
        for(i=0; i<opt_name_count; i++){
2760
             const AVOption *opt;
2761
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2762
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2763
                 av_set_double(video_enc, opt_names[i], d);
2764
        }
2765

    
2766
        video_enc->time_base.den = frame_rate.num;
2767
        video_enc->time_base.num = frame_rate.den;
2768
        if(codec && codec->supported_framerates){
2769
            const AVRational *p= codec->supported_framerates;
2770
            AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2771
            const AVRational *best=NULL;
2772
            AVRational best_error= (AVRational){INT_MAX, 1};
2773
            for(; p->den!=0; p++){
2774
                AVRational error= av_sub_q(req, *p);
2775
                if(error.num <0) error.num *= -1;
2776
                if(av_cmp_q(error, best_error) < 0){
2777
                    best_error= error;
2778
                    best= p;
2779
                }
2780
            }
2781
            video_enc->time_base.den= best->num;
2782
            video_enc->time_base.num= best->den;
2783
        }
2784

    
2785
        video_enc->width = frame_width + frame_padright + frame_padleft;
2786
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2787
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2788
        video_enc->pix_fmt = frame_pix_fmt;
2789

    
2790
        if(codec && codec->pix_fmts){
2791
            const enum PixelFormat *p= codec->pix_fmts;
2792
            for(; *p!=-1; p++){
2793
                if(*p == video_enc->pix_fmt)
2794
                    break;
2795
            }
2796
            if(*p == -1)
2797
                video_enc->pix_fmt = codec->pix_fmts[0];
2798
        }
2799

    
2800
        if (intra_only)
2801
            video_enc->gop_size = 0;
2802
        if (video_qscale || same_quality) {
2803
            video_enc->flags |= CODEC_FLAG_QSCALE;
2804
            video_enc->global_quality=
2805
                st->quality = FF_QP2LAMBDA * video_qscale;
2806
        }
2807

    
2808
        if(intra_matrix)
2809
            video_enc->intra_matrix = intra_matrix;
2810
        if(inter_matrix)
2811
            video_enc->inter_matrix = inter_matrix;
2812

    
2813
        video_enc->max_qdiff = video_qdiff;
2814
        video_enc->rc_eq = video_rc_eq;
2815
        video_enc->thread_count = thread_count;
2816
        p= video_rc_override_string;
2817
        for(i=0; p; i++){
2818
            int start, end, q;
2819
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2820
            if(e!=3){
2821
                fprintf(stderr, "error parsing rc_override\n");
2822
                exit(1);
2823
            }
2824
            video_enc->rc_override=
2825
                av_realloc(video_enc->rc_override,
2826
                           sizeof(RcOverride)*(i+1));
2827
            video_enc->rc_override[i].start_frame= start;
2828
            video_enc->rc_override[i].end_frame  = end;
2829
            if(q>0){
2830
                video_enc->rc_override[i].qscale= q;
2831
                video_enc->rc_override[i].quality_factor= 1.0;
2832
            }
2833
            else{
2834
                video_enc->rc_override[i].qscale= 0;
2835
                video_enc->rc_override[i].quality_factor= -q/100.0;
2836
            }
2837
            p= strchr(p, '/');
2838
            if(p) p++;
2839
        }
2840
        video_enc->rc_override_count=i;
2841
        if (!video_enc->rc_initial_buffer_occupancy)
2842
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2843
        video_enc->me_threshold= me_threshold;
2844
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2845
        video_enc->strict_std_compliance = strict;
2846

    
2847
        if (do_psnr)
2848
            video_enc->flags|= CODEC_FLAG_PSNR;
2849

    
2850
        /* two pass mode */
2851
        if (do_pass) {
2852
            if (do_pass == 1) {
2853
                video_enc->flags |= CODEC_FLAG_PASS1;
2854
            } else {
2855
                video_enc->flags |= CODEC_FLAG_PASS2;
2856
            }
2857
        }
2858
    }
2859

    
2860
    /* reset some key parameters */
2861
    video_disable = 0;
2862
    av_freep(&video_codec_name);
2863
    video_stream_copy = 0;
2864
}
2865

    
2866
static void new_audio_stream(AVFormatContext *oc)
2867
{
2868
    AVStream *st;
2869
    AVCodecContext *audio_enc;
2870
    int codec_id, i;
2871

    
2872
    st = av_new_stream(oc, oc->nb_streams);
2873
    if (!st) {
2874
        fprintf(stderr, "Could not alloc stream\n");
2875
        exit(1);
2876
    }
2877
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2878

    
2879
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2880
    audio_bitstream_filters= NULL;
2881

    
2882
    if(thread_count>1)
2883
        avcodec_thread_init(st->codec, thread_count);
2884

    
2885
    audio_enc = st->codec;
2886
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2887
    audio_enc->strict_std_compliance = strict;
2888

    
2889
    if(audio_codec_tag)
2890
        audio_enc->codec_tag= audio_codec_tag;
2891

    
2892
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2893
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2894
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2895
    }
2896
    if (audio_stream_copy) {
2897
        st->stream_copy = 1;
2898
        audio_enc->channels = audio_channels;
2899
    } else {
2900
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2901

    
2902
        for(i=0; i<opt_name_count; i++){
2903
            const AVOption *opt;
2904
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2905
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2906
                av_set_double(audio_enc, opt_names[i], d);
2907
        }
2908

    
2909
        if (audio_codec_name)
2910
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
2911
        audio_enc->codec_id = codec_id;
2912

    
2913
        if (audio_qscale > QSCALE_NONE) {
2914
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2915
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2916
        }
2917
        audio_enc->thread_count = thread_count;
2918
        audio_enc->channels = audio_channels;
2919
    }
2920
    audio_enc->sample_rate = audio_sample_rate;
2921
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2922
    if (audio_language) {
2923
        av_strlcpy(st->language, audio_language, sizeof(st->language));
2924
        av_free(audio_language);
2925
        audio_language = NULL;
2926
    }
2927

    
2928
    /* reset some key parameters */
2929
    audio_disable = 0;
2930
    av_freep(&audio_codec_name);
2931
    audio_stream_copy = 0;
2932
}
2933

    
2934
static void new_subtitle_stream(AVFormatContext *oc)
2935
{
2936
    AVStream *st;
2937
    AVCodecContext *subtitle_enc;
2938
    int i;
2939

    
2940
    st = av_new_stream(oc, oc->nb_streams);
2941
    if (!st) {
2942
        fprintf(stderr, "Could not alloc stream\n");
2943
        exit(1);
2944
    }
2945
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2946

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

    
2961
    if (subtitle_language) {
2962
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2963
        av_free(subtitle_language);
2964
        subtitle_language = NULL;
2965
    }
2966

    
2967
    subtitle_disable = 0;
2968
    av_freep(&subtitle_codec_name);
2969
    subtitle_stream_copy = 0;
2970
}
2971

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

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

    
2994
static void opt_new_subtitle_stream(void)
2995
{
2996
    AVFormatContext *oc;
2997
    if (nb_output_files <= 0) {
2998
        fprintf(stderr, "At least one output file must be specified\n");
2999
        exit(1);
3000
    }
3001
    oc = output_files[nb_output_files - 1];
3002
    new_subtitle_stream(oc);
3003
}
3004

    
3005
static void opt_output_file(const char *filename)
3006
{
3007
    AVFormatContext *oc;
3008
    int use_video, use_audio, use_subtitle;
3009
    int input_has_video, input_has_audio, input_has_subtitle, i;
3010
    AVFormatParameters params, *ap = &params;
3011

    
3012
    if (!strcmp(filename, "-"))
3013
        filename = "pipe:";
3014

    
3015
    oc = av_alloc_format_context();
3016

    
3017
    if (!file_oformat) {
3018
        file_oformat = guess_format(NULL, filename, NULL);
3019
        if (!file_oformat) {
3020
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3021
                    filename);
3022
            exit(1);
3023
        }
3024
    }
3025

    
3026
    oc->oformat = file_oformat;
3027
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3028

    
3029
    if (!strcmp(file_oformat->name, "ffm") &&
3030
        av_strstart(filename, "http:", NULL)) {
3031
        /* special case for files sent to ffserver: we get the stream
3032
           parameters from ffserver */
3033
        if (read_ffserver_streams(oc, filename) < 0) {
3034
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3035
            exit(1);
3036
        }
3037
    } else {
3038
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3039
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3040
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3041

    
3042
        /* disable if no corresponding type found and at least one
3043
           input file */
3044
        if (nb_input_files > 0) {
3045
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3046
                                         &input_has_subtitle);
3047
            if (!input_has_video)
3048
                use_video = 0;
3049
            if (!input_has_audio)
3050
                use_audio = 0;
3051
            if (!input_has_subtitle)
3052
                use_subtitle = 0;
3053
        }
3054

    
3055
        /* manual disable */
3056
        if (audio_disable) {
3057
            use_audio = 0;
3058
        }
3059
        if (video_disable) {
3060
            use_video = 0;
3061
        }
3062
        if (subtitle_disable) {
3063
            use_subtitle = 0;
3064
        }
3065

    
3066
        if (use_video) {
3067
            new_video_stream(oc);
3068
        }
3069

    
3070
        if (use_audio) {
3071
            new_audio_stream(oc);
3072
        }
3073

    
3074
        if (use_subtitle) {
3075
            new_subtitle_stream(oc);
3076
        }
3077

    
3078
        oc->timestamp = rec_timestamp;
3079

    
3080
        if (str_title)
3081
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3082
        if (str_author)
3083
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3084
        if (str_copyright)
3085
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3086
        if (str_comment)
3087
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3088
        if (str_album)
3089
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3090
    }
3091

    
3092
    output_files[nb_output_files++] = oc;
3093

    
3094
    /* check filename in case of an image number is expected */
3095
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3096
        if (!av_filename_number_test(oc->filename)) {
3097
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3098
            exit(1);
3099
        }
3100
    }
3101

    
3102
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3103
        /* test if it already exists to avoid loosing precious files */
3104
        if (!file_overwrite &&
3105
            (strchr(filename, ':') == NULL ||
3106
             av_strstart(filename, "file:", NULL))) {
3107
            if (url_exist(filename)) {
3108
                int c;
3109

    
3110
                if ( !using_stdin ) {
3111
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3112
                    fflush(stderr);
3113
                    c = getchar();
3114
                    if (toupper(c) != 'Y') {
3115
                        fprintf(stderr, "Not overwriting - exiting\n");
3116
                        exit(1);
3117
                    }
3118
                                }
3119
                                else {
3120
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3121
                    exit(1);
3122
                                }
3123
            }
3124
        }
3125

    
3126
        /* open the file */
3127
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3128
            fprintf(stderr, "Could not open '%s'\n", filename);
3129
            exit(1);
3130
        }
3131
    }
3132

    
3133
    memset(ap, 0, sizeof(*ap));
3134
    if (av_set_parameters(oc, ap) < 0) {
3135
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3136
                oc->filename);
3137
        exit(1);
3138
    }
3139

    
3140
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3141
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3142
    oc->loop_output = loop_output;
3143

    
3144
    for(i=0; i<opt_name_count; i++){
3145
        const AVOption *opt;
3146
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3147
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3148
            av_set_double(oc, opt_names[i], d);
3149
    }
3150

    
3151
    /* reset some options */
3152
    file_oformat = NULL;
3153
    file_iformat = NULL;
3154
}
3155

    
3156
/* same option as mencoder */
3157
static void opt_pass(const char *pass_str)
3158
{
3159
    int pass;
3160
    pass = atoi(pass_str);
3161
    if (pass != 1 && pass != 2) {
3162
        fprintf(stderr, "pass number can be only 1 or 2\n");
3163
        exit(1);
3164
    }
3165
    do_pass = pass;
3166
}
3167

    
3168
static int64_t getutime(void)
3169
{
3170
#ifdef HAVE_GETRUSAGE
3171
    struct rusage rusage;
3172

    
3173
    getrusage(RUSAGE_SELF, &rusage);
3174
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3175
#elif defined(HAVE_GETPROCESSTIMES)
3176
    HANDLE proc;
3177
    FILETIME c, e, k, u;
3178
    proc = GetCurrentProcess();
3179
    GetProcessTimes(proc, &c, &e, &k, &u);
3180
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3181
#else
3182
    return av_gettime();
3183
#endif
3184
}
3185

    
3186
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3187
extern int ffm_nopts;
3188
#endif
3189

    
3190
static void opt_show_formats(void)
3191
{
3192
    AVInputFormat *ifmt;
3193
    AVOutputFormat *ofmt;
3194
    URLProtocol *up;
3195
    AVCodec *p, *p2;
3196
    const char *last_name;
3197

    
3198
    printf("File formats:\n");
3199
    last_name= "000";
3200
    for(;;){
3201
        int decode=0;
3202
        int encode=0;
3203
        const char *name=NULL;
3204
        const char *long_name=NULL;
3205

    
3206
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3207
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3208
                strcmp(ofmt->name, last_name)>0){
3209
                name= ofmt->name;
3210
                long_name= ofmt->long_name;
3211
                encode=1;
3212
            }
3213
        }
3214
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3215
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3216
                strcmp(ifmt->name, last_name)>0){
3217
                name= ifmt->name;
3218
                long_name= ifmt->long_name;
3219
                encode=0;
3220
            }
3221
            if(name && strcmp(ifmt->name, name)==0)
3222
                decode=1;
3223
        }
3224
        if(name==NULL)
3225
            break;
3226
        last_name= name;
3227

    
3228
        printf(
3229
            " %s%s %-15s %s\n",
3230
            decode ? "D":" ",
3231
            encode ? "E":" ",
3232
            name,
3233
            long_name ? long_name:" ");
3234
    }
3235
    printf("\n");
3236

    
3237
    printf("Codecs:\n");
3238
    last_name= "000";
3239
    for(;;){
3240
        int decode=0;
3241
        int encode=0;
3242
        int cap=0;
3243
        const char *type_str;
3244

    
3245
        p2=NULL;
3246
        for(p = first_avcodec; p != NULL; p = p->next) {
3247
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3248
                strcmp(p->name, last_name)>0){
3249
                p2= p;
3250
                decode= encode= cap=0;
3251
            }
3252
            if(p2 && strcmp(p->name, p2->name)==0){
3253
                if(p->decode) decode=1;
3254
                if(p->encode) encode=1;
3255
                cap |= p->capabilities;
3256
            }
3257
        }
3258
        if(p2==NULL)
3259
            break;
3260
        last_name= p2->name;
3261

    
3262
        switch(p2->type) {
3263
        case CODEC_TYPE_VIDEO:
3264
            type_str = "V";
3265
            break;
3266
        case CODEC_TYPE_AUDIO:
3267
            type_str = "A";
3268
            break;
3269
        case CODEC_TYPE_SUBTITLE:
3270
            type_str = "S";
3271
            break;
3272
        default:
3273
            type_str = "?";
3274
            break;
3275
        }
3276
        printf(
3277
            " %s%s%s%s%s%s %s",
3278
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3279
            encode ? "E":" ",
3280
            type_str,
3281
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3282
            cap & CODEC_CAP_DR1 ? "D":" ",
3283
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3284
            p2->name);
3285
       /* if(p2->decoder && decode==0)
3286
            printf(" use %s for decoding", p2->decoder->name);*/
3287
        printf("\n");
3288
    }
3289
    printf("\n");
3290

    
3291
    printf("Supported file protocols:\n");
3292
    for(up = first_protocol; up != NULL; up = up->next)
3293
        printf(" %s:", up->name);
3294
    printf("\n");
3295

    
3296
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3297
    printf("\n");
3298
    printf(
3299
"Note, the names of encoders and decoders do not always match, so there are\n"
3300
"several cases where the above table shows encoder only or decoder only entries\n"
3301
"even though both encoding and decoding are supported. For example, the h263\n"
3302
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3303
"worse.\n");
3304
    exit(0);
3305
}
3306

    
3307
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3308
{
3309
    int i;
3310
    const char *p = str;
3311
    for(i = 0;; i++) {
3312
        dest[i] = atoi(p);
3313
        if(i == 63)
3314
            break;
3315
        p = strchr(p, ',');
3316
        if(!p) {
3317
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3318
            exit(1);
3319
        }
3320
        p++;
3321
    }
3322
}
3323

    
3324
static void opt_inter_matrix(const char *arg)
3325
{
3326
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3327
    parse_matrix_coeffs(inter_matrix, arg);
3328
}
3329

    
3330
static void opt_intra_matrix(const char *arg)
3331
{
3332
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3333
    parse_matrix_coeffs(intra_matrix, arg);
3334
}
3335

    
3336
static void opt_show_help(void)
3337
{
3338
    show_help();
3339
    exit(0);
3340
}
3341

    
3342
static void opt_target(const char *arg)
3343
{
3344
    int norm = -1;
3345
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3346

    
3347
    if(!strncmp(arg, "pal-", 4)) {
3348
        norm = 0;
3349
        arg += 4;
3350
    } else if(!strncmp(arg, "ntsc-", 5)) {
3351
        norm = 1;
3352
        arg += 5;
3353
    } else if(!strncmp(arg, "film-", 5)) {
3354
        norm = 2;
3355
        arg += 5;
3356
    } else {
3357
        int fr;
3358
        /* Calculate FR via float to avoid int overflow */
3359
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3360
        if(fr == 25000) {
3361
            norm = 0;
3362
        } else if((fr == 29970) || (fr == 23976)) {
3363
            norm = 1;
3364
        } else {
3365
            /* Try to determine PAL/NTSC by peeking in the input files */
3366
            if(nb_input_files) {
3367
                int i, j;
3368
                for(j = 0; j < nb_input_files; j++) {
3369
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3370
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3371
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3372
                            continue;
3373
                        fr = c->time_base.den * 1000 / c->time_base.num;
3374
                        if(fr == 25000) {
3375
                            norm = 0;
3376
                            break;
3377
                        } else if((fr == 29970) || (fr == 23976)) {
3378
                            norm = 1;
3379
                            break;
3380
                        }
3381
                    }
3382
                    if(norm >= 0)
3383
                        break;
3384
                }
3385
            }
3386
        }
3387
        if(verbose && norm >= 0)
3388
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3389
    }
3390

    
3391
    if(norm < 0) {
3392
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3393
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3394
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3395
        exit(1);
3396
    }
3397

    
3398
    if(!strcmp(arg, "vcd")) {
3399

    
3400
        opt_video_codec("mpeg1video");
3401
        opt_audio_codec("mp2");
3402
        opt_format("vcd");
3403

    
3404
        opt_frame_size(norm ? "352x240" : "352x288");
3405
        opt_frame_rate(frame_rates[norm]);
3406
        opt_default("gop", norm ? "18" : "15");
3407

    
3408
        opt_default("b", "1150000");
3409
        opt_default("maxrate", "1150000");
3410
        opt_default("minrate", "1150000");
3411
        opt_default("bufsize", "327680"); // 40*1024*8;
3412

    
3413
        opt_default("ab", "224000");
3414
        audio_sample_rate = 44100;
3415
        audio_channels = 2;
3416

    
3417
        opt_default("packetsize", "2324");
3418
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3419

    
3420
        /* We have to offset the PTS, so that it is consistent with the SCR.
3421
           SCR starts at 36000, but the first two packs contain only padding
3422
           and the first pack from the other stream, respectively, may also have
3423
           been written before.
3424
           So the real data starts at SCR 36000+3*1200. */
3425
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3426
    } else if(!strcmp(arg, "svcd")) {
3427

    
3428
        opt_video_codec("mpeg2video");
3429
        opt_audio_codec("mp2");
3430
        opt_format("svcd");
3431

    
3432
        opt_frame_size(norm ? "480x480" : "480x576");
3433
        opt_frame_rate(frame_rates[norm]);
3434
        opt_default("gop", norm ? "18" : "15");
3435

    
3436
        opt_default("b", "2040000");
3437
        opt_default("maxrate", "2516000");
3438
        opt_default("minrate", "0"); //1145000;
3439
        opt_default("bufsize", "1835008"); //224*1024*8;
3440
        opt_default("flags", "+SCAN_OFFSET");
3441

    
3442

    
3443
        opt_default("ab", "224000");
3444
        audio_sample_rate = 44100;
3445

    
3446
        opt_default("packetsize", "2324");
3447

    
3448
    } else if(!strcmp(arg, "dvd")) {
3449

    
3450
        opt_video_codec("mpeg2video");
3451
        opt_audio_codec("ac3");
3452
        opt_format("dvd");
3453

    
3454
        opt_frame_size(norm ? "720x480" : "720x576");
3455
        opt_frame_rate(frame_rates[norm]);
3456
        opt_default("gop", norm ? "18" : "15");
3457

    
3458
        opt_default("b", "6000000");
3459
        opt_default("maxrate", "9000000");
3460
        opt_default("minrate", "0"); //1500000;
3461
        opt_default("bufsize", "1835008"); //224*1024*8;
3462

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

    
3466
        opt_default("ab", "448000");
3467
        audio_sample_rate = 48000;
3468

    
3469
    } else if(!strncmp(arg, "dv", 2)) {
3470

    
3471
        opt_format("dv");
3472

    
3473
        opt_frame_size(norm ? "720x480" : "720x576");
3474
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3475
                                             (norm ? "yuv411p" : "yuv420p"));
3476
        opt_frame_rate(frame_rates[norm]);
3477

    
3478
        audio_sample_rate = 48000;
3479
        audio_channels = 2;
3480

    
3481
    } else {
3482
        fprintf(stderr, "Unknown target: %s\n", arg);
3483
        exit(1);
3484
    }
3485
}
3486

    
3487
static void opt_vstats_file (const char *arg)
3488
{
3489
    av_free (vstats_filename);
3490
    vstats_filename=av_strdup (arg);
3491
}
3492

    
3493
static void opt_vstats (void)
3494
{
3495
    char filename[40];
3496
    time_t today2 = time(NULL);
3497
    struct tm *today = localtime(&today2);
3498

    
3499
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3500
             today->tm_sec);
3501
    opt_vstats_file(filename);
3502
}
3503

    
3504
static void opt_video_bsf(const char *arg)
3505
{
3506
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3507
    AVBitStreamFilterContext **bsfp;
3508

    
3509
    if(!bsfc){
3510
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3511
        exit(1);
3512
    }
3513

    
3514
    bsfp= &video_bitstream_filters;
3515
    while(*bsfp)
3516
        bsfp= &(*bsfp)->next;
3517

    
3518
    *bsfp= bsfc;
3519
}
3520

    
3521
//FIXME avoid audio - video code duplication
3522
static void opt_audio_bsf(const char *arg)
3523
{
3524
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3525
    AVBitStreamFilterContext **bsfp;
3526

    
3527
    if(!bsfc){
3528
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3529
        exit(1);
3530
    }
3531

    
3532
    bsfp= &audio_bitstream_filters;
3533
    while(*bsfp)
3534
        bsfp= &(*bsfp)->next;
3535

    
3536
    *bsfp= bsfc;
3537
}
3538

    
3539
static void opt_show_version(void)
3540
{
3541
    /* TODO: add function interface to avutil and avformat */
3542
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3543
           "libavutil   %d\n"
3544
           "libavcodec  %d\n"
3545
           "libavformat %d\n",
3546
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3547
    exit(1);
3548
}
3549

    
3550
static int opt_default(const char *opt, const char *arg){
3551
    int type;
3552
    const AVOption *o= NULL;
3553
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3554

    
3555
    for(type=0; type<CODEC_TYPE_NB; type++){
3556
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3557
        if(o2)
3558
            o = av_set_string(avctx_opts[type], opt, arg);
3559
    }
3560
    if(!o)
3561
        o = av_set_string(avformat_opts, opt, arg);
3562
    if(!o)
3563
        o = av_set_string(sws_opts, opt, arg);
3564
    if(!o){
3565
        if(opt[0] == 'a')
3566
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3567
        else if(opt[0] == 'v')
3568
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3569
        else if(opt[0] == 's')
3570
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3571
    }
3572
    if(!o)
3573
        return -1;
3574

    
3575
//    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));
3576

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

    
3581
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3582
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3583
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3584
        ffm_nopts = 1;
3585
#endif
3586

    
3587
    if(avctx_opts[0]->debug)
3588
        av_log_level = AV_LOG_DEBUG;
3589
    return 0;
3590
}
3591

    
3592
const OptionDef options[] = {
3593
    /* main options */
3594
    { "L", 0, {(void*)opt_show_license}, "show license" },
3595
    { "h", 0, {(void*)opt_show_help}, "show help" },
3596
    { "version", 0, {(void*)opt_show_version}, "show version" },
3597
    { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3598
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3599
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3600
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3601
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3602
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3603
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3604
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3605
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3606
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3607
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3608
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3609
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3610
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3611
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3612
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3613
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3614
      "add timings for benchmarking" },
3615
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3616
      "dump each input packet" },
3617
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3618
      "when dumping packets, also dump the payload" },
3619
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3620
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3621
    { "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)", "" },
3622
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3623
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3624
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3625
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3626
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3627
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3628
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3629
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3630
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3631
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3632

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

    
3679
    /* audio options */
3680
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3681
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3682
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3683
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3684
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3685
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3686
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3687
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3688
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3689
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3690

    
3691
    /* subtitle options */
3692
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3693
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3694
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3695
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3696

    
3697
    /* grab options */
3698
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3699
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3700
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3701

    
3702
    /* muxer options */
3703
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3704
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3705

    
3706
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3707
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3708

    
3709
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3710
    { NULL, },
3711
};
3712

    
3713
static void show_banner(void)
3714
{
3715
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3716
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3717
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3718
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3719
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3720
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3721
#ifdef __GNUC__
3722
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3723
#else
3724
    fprintf(stderr, ", using a non-gcc compiler\n");
3725
#endif
3726
}
3727

    
3728
static void opt_show_license(void)
3729
{
3730
#ifdef CONFIG_GPL
3731
    printf(
3732
    "FFmpeg is free software; you can redistribute it and/or modify\n"
3733
    "it under the terms of the GNU General Public License as published by\n"
3734
    "the Free Software Foundation; either version 2 of the License, or\n"
3735
    "(at your option) any later version.\n"
3736
    "\n"
3737
    "FFmpeg is distributed in the hope that it will be useful,\n"
3738
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3739
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3740
    "GNU General Public License for more details.\n"
3741
    "\n"
3742
    "You should have received a copy of the GNU General Public License\n"
3743
    "along with FFmpeg; if not, write to the Free Software\n"
3744
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3745
    );
3746
#else
3747
    printf(
3748
    "FFmpeg is free software; you can redistribute it and/or\n"
3749
    "modify it under the terms of the GNU Lesser General Public\n"
3750
    "License as published by the Free Software Foundation; either\n"
3751
    "version 2.1 of the License, or (at your option) any later version.\n"
3752
    "\n"
3753
    "FFmpeg is distributed in the hope that it will be useful,\n"
3754
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3755
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3756
    "Lesser General Public License for more details.\n"
3757
    "\n"
3758
    "You should have received a copy of the GNU Lesser General Public\n"
3759
    "License along with FFmpeg; if not, write to the Free Software\n"
3760
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3761
    );
3762
#endif
3763
    exit(1);
3764
}
3765

    
3766
/**
3767
 * Trivial log callback.
3768
 * Only suitable for show_help and similar since it lacks prefix handling.
3769
 */
3770
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3771
{
3772
    vfprintf(stdout, fmt, vl);
3773
}
3774

    
3775
static void show_help(void)
3776
{
3777
    av_log_set_callback(log_callback_help);
3778
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3779
           "Hyper fast Audio and Video encoder\n");
3780
    printf("\n");
3781
    show_help_options(options, "Main options:\n",
3782
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3783
    show_help_options(options, "\nVideo options:\n",
3784
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3785
                      OPT_VIDEO);
3786
    show_help_options(options, "\nAdvanced Video options:\n",
3787
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3788
                      OPT_VIDEO | OPT_EXPERT);
3789
    show_help_options(options, "\nAudio options:\n",
3790
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3791
                      OPT_AUDIO);
3792
    show_help_options(options, "\nAdvanced Audio options:\n",
3793
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3794
                      OPT_AUDIO | OPT_EXPERT);
3795
    show_help_options(options, "\nSubtitle options:\n",
3796
                      OPT_SUBTITLE | OPT_GRAB,
3797
                      OPT_SUBTITLE);
3798
    show_help_options(options, "\nAudio/Video grab options:\n",
3799
                      OPT_GRAB,
3800
                      OPT_GRAB);
3801
    show_help_options(options, "\nAdvanced options:\n",
3802
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3803
                      OPT_EXPERT);
3804
    av_opt_show(avctx_opts[0], NULL);
3805
    av_opt_show(avformat_opts, NULL);
3806
    av_opt_show(sws_opts, NULL);
3807
}
3808

    
3809
void parse_arg_file(const char *filename)
3810
{
3811
    opt_output_file(filename);
3812
}
3813

    
3814
int main(int argc, char **argv)
3815
{
3816
    int i;
3817
    int64_t ti;
3818

    
3819
    av_register_all();
3820

    
3821
    for(i=0; i<CODEC_TYPE_NB; i++){
3822
        avctx_opts[i]= avcodec_alloc_context2(i);
3823
    }
3824
    avformat_opts = av_alloc_format_context();
3825
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3826

    
3827
    show_banner();
3828
    if (argc <= 1) {
3829
        show_help();
3830
        exit(1);
3831
    }
3832

    
3833
    /* parse options */
3834
    parse_options(argc, argv, options);
3835

    
3836
    /* file converter / grab */
3837
    if (nb_output_files <= 0) {
3838
        fprintf(stderr, "Must supply at least one output file\n");
3839
        exit(1);
3840
    }
3841

    
3842
    if (nb_input_files == 0) {
3843
        fprintf(stderr, "Must supply at least one input file\n");
3844
        exit(1);
3845
    }
3846

    
3847
    ti = getutime();
3848
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3849
              stream_maps, nb_stream_maps);
3850
    ti = getutime() - ti;
3851
    if (do_benchmark) {
3852
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3853
    }
3854

    
3855
    /* close files */
3856
    for(i=0;i<nb_output_files;i++) {
3857
        /* maybe av_close_output_file ??? */
3858
        AVFormatContext *s = output_files[i];
3859
        int j;
3860
        if (!(s->oformat->flags & AVFMT_NOFILE))
3861
            url_fclose(&s->pb);
3862
        for(j=0;j<s->nb_streams;j++) {
3863
            av_free(s->streams[j]->codec);
3864
            av_free(s->streams[j]);
3865
        }
3866
        av_free(s);
3867
    }
3868
    for(i=0;i<nb_input_files;i++)
3869
        av_close_input_file(input_files[i]);
3870

    
3871
    av_free_static();
3872

    
3873
    av_free(intra_matrix);
3874
    av_free(inter_matrix);
3875

    
3876
    if (fvstats)
3877
        fclose(fvstats);
3878
    av_free(vstats_filename);
3879

    
3880
    av_free(opt_names);
3881

    
3882
    av_free(video_codec_name);
3883
    av_free(audio_codec_name);
3884
    av_free(subtitle_codec_name);
3885

    
3886
    av_free(video_standard);
3887

    
3888
#ifdef CONFIG_POWERPC_PERF
3889
    extern void powerpc_display_perf_report(void);
3890
    powerpc_display_perf_report();
3891
#endif /* CONFIG_POWERPC_PERF */
3892

    
3893
    if (received_sigterm) {
3894
        fprintf(stderr,
3895
            "Received signal %d: terminating.\n",
3896
            (int) received_sigterm);
3897
        exit (255);
3898
    }
3899

    
3900
    exit(0); /* not all OS-es handle main() return value */
3901
    return 0;
3902
}