Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 86074ed1

History | View | Annotate | Download (134 KB)

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

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

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

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

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

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

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

    
64
#undef exit
65

    
66
static const char program_name[] = "FFmpeg";
67
static const int program_birth_year = 2000;
68

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

    
77
/** select an input file for an output file */
78
typedef struct AVMetaDataMap {
79
    int out_file;
80
    int in_file;
81
} AVMetaDataMap;
82

    
83
extern const OptionDef options[];
84

    
85
static void show_help(void);
86
static void opt_show_license(void);
87
static int opt_default(const char *opt, const char *arg);
88

    
89
#define MAX_FILES 20
90

    
91
static AVFormatContext *input_files[MAX_FILES];
92
static int64_t input_files_ts_offset[MAX_FILES];
93
static int nb_input_files = 0;
94

    
95
static AVFormatContext *output_files[MAX_FILES];
96
static int nb_output_files = 0;
97

    
98
static AVStreamMap stream_maps[MAX_FILES];
99
static int nb_stream_maps;
100

    
101
static AVMetaDataMap meta_data_maps[MAX_FILES];
102
static int nb_meta_data_maps;
103

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

    
146
static int intra_only = 0;
147
static int audio_sample_rate = 44100;
148
#define QSCALE_NONE -99999
149
static float audio_qscale = QSCALE_NONE;
150
static int audio_disable = 0;
151
static int audio_channels = 1;
152
static char  *audio_codec_name = NULL;
153
static int audio_codec_tag = 0;
154
static char *audio_language = NULL;
155

    
156
static int subtitle_disable = 0;
157
static char *subtitle_codec_name = NULL;
158
static char *subtitle_language = NULL;
159

    
160
static float mux_preload= 0.5;
161
static float mux_max_delay= 0.7;
162

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

    
191
static int rate_emu = 0;
192

    
193
static int  video_channel = 0;
194
static char *video_standard;
195

    
196
static int audio_volume = 256;
197

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

    
211
static int pgmyuv_compatibility_hack=0;
212
static float dts_delta_threshold = 10;
213

    
214
static int sws_flags = SWS_BICUBIC;
215

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

    
223
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
224
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
225
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
226

    
227
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
228

    
229
struct AVInputStream;
230

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

    
249
    int video_crop;
250
    int topBand;             /* cropping area sizes */
251
    int leftBand;
252

    
253
    int video_pad;
254
    int padtop;              /* padding area sizes */
255
    int padbottom;
256
    int padleft;
257
    int padright;
258

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

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

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

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

    
289
#ifdef HAVE_TERMIOS_H
290

    
291
/* init terminal so that we can grab keys */
292
static struct termios oldtty;
293
#endif
294

    
295
static void term_exit(void)
296
{
297
#ifdef HAVE_TERMIOS_H
298
    tcsetattr (0, TCSANOW, &oldtty);
299
#endif
300
}
301

    
302
static volatile sig_atomic_t received_sigterm = 0;
303

    
304
static void
305
sigterm_handler(int sig)
306
{
307
    received_sigterm = sig;
308
    term_exit();
309
}
310

    
311
static void term_init(void)
312
{
313
#ifdef HAVE_TERMIOS_H
314
    struct termios tty;
315

    
316
    tcgetattr (0, &tty);
317
    oldtty = tty;
318

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

    
328
    tcsetattr (0, TCSANOW, &tty);
329
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
330
#endif
331

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

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

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

    
364
        return n;
365
    }
366
#elif defined(HAVE_CONIO_H)
367
    if(kbhit())
368
        return(getch());
369
#endif
370
    return -1;
371
}
372

    
373
static int decode_interrupt_cb(void)
374
{
375
    return q_pressed || (q_pressed = read_key() == 'q');
376
}
377

    
378
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
379
{
380
    int i, err;
381
    AVFormatContext *ic;
382

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

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

    
399
    av_close_input_file(ic);
400
    return 0;
401
}
402

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

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

    
423
        bsfc= bsfc->next;
424
    }
425

    
426
    av_interleaved_write_frame(s, pkt);
427
}
428

    
429
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
430

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

    
441
    int size_out, frame_bytes, ret;
442
    AVCodecContext *enc= ost->st->codec;
443

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

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

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

    
474
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
475
                        ist->is_start=0;
476
                    else
477
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
478

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

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

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

    
515
        frame_bytes = enc->frame_size * 2 * enc->channels;
516

    
517
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
518
            AVPacket pkt;
519
            av_init_packet(&pkt);
520

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

    
532
            ost->sync_opts += enc->frame_size;
533
        }
534
    } else {
535
        AVPacket pkt;
536
        av_init_packet(&pkt);
537

    
538
        ost->sync_opts += size_out / (2 * enc->channels);
539

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

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

    
585
    dec = ist->st->codec;
586

    
587
    /* deinterlace : must be done before any resize */
588
    if (do_deinterlace || using_vhook) {
589
        int size;
590

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

    
597
        picture2 = &picture_tmp;
598
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
599

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

    
615
    if (ENABLE_VHOOK)
616
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
617
                           1000000 * ist->pts / AV_TIME_BASE);
618

    
619
    if (picture != picture2)
620
        *picture = *picture2;
621
    *bufp = buf;
622
}
623

    
624
/* we begin to correct av delay at this threshold */
625
#define AV_DELAY_MAX 0.100
626

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

    
639
    if (pts == AV_NOPTS_VALUE) {
640
        fprintf(stderr, "Subtitle packets must have a pts\n");
641
        return;
642
    }
643

    
644
    enc = ost->st->codec;
645

    
646
    if (!subtitle_out) {
647
        subtitle_out = av_malloc(subtitle_out_max_size);
648
    }
649

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

    
658
    for(i = 0; i < nb; i++) {
659
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
660
                                                    subtitle_out_max_size, sub);
661

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

    
679
static int bit_buffer_size= 1024*256;
680
static uint8_t *bit_buffer= NULL;
681

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

    
693
    avcodec_get_frame_defaults(&picture_crop_temp);
694
    avcodec_get_frame_defaults(&picture_pad_temp);
695

    
696
    enc = ost->st->codec;
697
    dec = ist->st->codec;
698

    
699
    /* by default, we output a single frame */
700
    nb_frames = 1;
701

    
702
    *frame_size = 0;
703

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

    
725
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
726
    if (nb_frames <= 0)
727
        return;
728

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

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

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

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

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

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

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

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

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

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

    
848
static double psnr(double d){
849
    if(d==0) return INFINITY;
850
    return -10.0*log(d)/log(10.0);
851
}
852

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

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

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

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

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

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

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

    
917

    
918
    oc = output_files[0];
919

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

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

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

    
983
    if (verbose || is_last_report) {
984
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
985

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

    
990
        if (verbose > 1)
991
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
992
                  nb_frames_dup, nb_frames_drop);
993

    
994
        if (verbose >= 0)
995
            fprintf(stderr, "%s    \r", buf);
996

    
997
        fflush(stderr);
998
    }
999

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

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

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

    
1038
    if (pkt == NULL) {
1039
        /* EOF handling */
1040
        ptr = NULL;
1041
        len = 0;
1042
        goto handle_eof;
1043
    }
1044

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

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

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

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

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

    
1159
            ist->frame++;
1160
        }
1161

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

    
1181
                ost = ost_table[i];
1182
                if (ost->source_index == ist_index) {
1183
                    os = output_files[ost->file_index];
1184

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

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

    
1217
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1218
                            continue;
1219

    
1220
                        /* no reencoding needed : output the packet directly */
1221
                        /* force the input stream PTS */
1222

    
1223
                        avcodec_get_frame_defaults(&avframe);
1224
                        ost->st->codec->coded_frame= &avframe;
1225
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1226

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

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

    
1240
                            if (pkt->dts == AV_NOPTS_VALUE)
1241
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1242
                            else
1243
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1244

    
1245
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1246
                        opkt.flags= pkt->flags;
1247

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

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

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

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

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

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

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

    
1340
    return 0;
1341
 fail_decode:
1342
    return -1;
1343
}
1344

    
1345
static void print_sdp(AVFormatContext **avc, int n)
1346
{
1347
    char sdp[2048];
1348

    
1349
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1350
    printf("SDP:\n%s\n", sdp);
1351
}
1352

    
1353
/*
1354
 * The following code is the main loop of the file converter
1355
 */
1356
static int av_encode(AVFormatContext **output_files,
1357
                     int nb_output_files,
1358
                     AVFormatContext **input_files,
1359
                     int nb_input_files,
1360
                     AVStreamMap *stream_maps, int nb_stream_maps)
1361
{
1362
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1363
    AVFormatContext *is, *os;
1364
    AVCodecContext *codec, *icodec;
1365
    AVOutputStream *ost, **ost_table = NULL;
1366
    AVInputStream *ist, **ist_table = NULL;
1367
    AVInputFile *file_table;
1368
    int key;
1369
    int want_sdp = 1;
1370

    
1371
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1372
    if (!file_table)
1373
        goto fail;
1374

    
1375
    /* input stream init */
1376
    j = 0;
1377
    for(i=0;i<nb_input_files;i++) {
1378
        is = input_files[i];
1379
        file_table[i].ist_index = j;
1380
        file_table[i].nb_streams = is->nb_streams;
1381
        j += is->nb_streams;
1382
    }
1383
    nb_istreams = j;
1384

    
1385
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1386
    if (!ist_table)
1387
        goto fail;
1388

    
1389
    for(i=0;i<nb_istreams;i++) {
1390
        ist = av_mallocz(sizeof(AVInputStream));
1391
        if (!ist)
1392
            goto fail;
1393
        ist_table[i] = ist;
1394
    }
1395
    j = 0;
1396
    for(i=0;i<nb_input_files;i++) {
1397
        is = input_files[i];
1398
        for(k=0;k<is->nb_streams;k++) {
1399
            ist = ist_table[j++];
1400
            ist->st = is->streams[k];
1401
            ist->file_index = i;
1402
            ist->index = k;
1403
            ist->discard = 1; /* the stream is discarded by default
1404
                                 (changed later) */
1405

    
1406
            if (ist->st->codec->rate_emu) {
1407
                ist->start = av_gettime();
1408
                ist->frame = 0;
1409
            }
1410
        }
1411
    }
1412

    
1413
    /* output stream init */
1414
    nb_ostreams = 0;
1415
    for(i=0;i<nb_output_files;i++) {
1416
        os = output_files[i];
1417
        if (!os->nb_streams) {
1418
            fprintf(stderr, "Output file does not contain any stream\n");
1419
            exit(1);
1420
        }
1421
        nb_ostreams += os->nb_streams;
1422
    }
1423
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1424
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1425
        exit(1);
1426
    }
1427

    
1428
    /* Sanity check the mapping args -- do the input files & streams exist? */
1429
    for(i=0;i<nb_stream_maps;i++) {
1430
        int fi = stream_maps[i].file_index;
1431
        int si = stream_maps[i].stream_index;
1432

    
1433
        if (fi < 0 || fi > nb_input_files - 1 ||
1434
            si < 0 || si > file_table[fi].nb_streams - 1) {
1435
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1436
            exit(1);
1437
        }
1438
        fi = stream_maps[i].sync_file_index;
1439
        si = stream_maps[i].sync_stream_index;
1440
        if (fi < 0 || fi > nb_input_files - 1 ||
1441
            si < 0 || si > file_table[fi].nb_streams - 1) {
1442
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1443
            exit(1);
1444
        }
1445
    }
1446

    
1447
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1448
    if (!ost_table)
1449
        goto fail;
1450
    for(i=0;i<nb_ostreams;i++) {
1451
        ost = av_mallocz(sizeof(AVOutputStream));
1452
        if (!ost)
1453
            goto fail;
1454
        ost_table[i] = ost;
1455
    }
1456

    
1457
    n = 0;
1458
    for(k=0;k<nb_output_files;k++) {
1459
        os = output_files[k];
1460
        for(i=0;i<os->nb_streams;i++) {
1461
            int found;
1462
            ost = ost_table[n++];
1463
            ost->file_index = k;
1464
            ost->index = i;
1465
            ost->st = os->streams[i];
1466
            if (nb_stream_maps > 0) {
1467
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1468
                    stream_maps[n-1].stream_index;
1469

    
1470
                /* Sanity check that the stream types match */
1471
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1472
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1473
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1474
                        ost->file_index, ost->index);
1475
                    exit(1);
1476
                }
1477

    
1478
            } else {
1479
                /* get corresponding input stream index : we select the first one with the right type */
1480
                found = 0;
1481
                for(j=0;j<nb_istreams;j++) {
1482
                    ist = ist_table[j];
1483
                    if (ist->discard &&
1484
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1485
                        ost->source_index = j;
1486
                        found = 1;
1487
                        break;
1488
                    }
1489
                }
1490

    
1491
                if (!found) {
1492
                    /* try again and reuse existing stream */
1493
                    for(j=0;j<nb_istreams;j++) {
1494
                        ist = ist_table[j];
1495
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1496
                            ost->source_index = j;
1497
                            found = 1;
1498
                        }
1499
                    }
1500
                    if (!found) {
1501
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1502
                                ost->file_index, ost->index);
1503
                        exit(1);
1504
                    }
1505
                }
1506
            }
1507
            ist = ist_table[ost->source_index];
1508
            ist->discard = 0;
1509
            ost->sync_ist = (nb_stream_maps > 0) ?
1510
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1511
                         stream_maps[n-1].sync_stream_index] : ist;
1512
        }
1513
    }
1514

    
1515
    /* for each output stream, we compute the right encoding parameters */
1516
    for(i=0;i<nb_ostreams;i++) {
1517
        ost = ost_table[i];
1518
        os = output_files[ost->file_index];
1519
        ist = ist_table[ost->source_index];
1520

    
1521
        codec = ost->st->codec;
1522
        icodec = ist->st->codec;
1523

    
1524
        if (!ost->st->language[0])
1525
            av_strlcpy(ost->st->language, ist->st->language,
1526
                       sizeof(ost->st->language));
1527

    
1528
        if (ost->st->stream_copy) {
1529
            /* if stream_copy is selected, no need to decode or encode */
1530
            codec->codec_id = icodec->codec_id;
1531
            codec->codec_type = icodec->codec_type;
1532

    
1533
            if(!codec->codec_tag){
1534
                if(   !os->oformat->codec_tag
1535
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1536
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1537
                    codec->codec_tag = icodec->codec_tag;
1538
            }
1539

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

    
1577
                if (codec->channels == icodec->channels &&
1578
                    codec->sample_rate == icodec->sample_rate) {
1579
                    ost->audio_resample = 0;
1580
                } else {
1581
                    if (codec->channels != icodec->channels &&
1582
                        (icodec->codec_id == CODEC_ID_AC3 ||
1583
                         icodec->codec_id == CODEC_ID_DTS)) {
1584
                        /* Special case for 5:1 AC3 and DTS input */
1585
                        /* and mono or stereo output      */
1586
                        /* Request specific number of channels */
1587
                        icodec->channels = codec->channels;
1588
                        if (codec->sample_rate == icodec->sample_rate)
1589
                            ost->audio_resample = 0;
1590
                        else {
1591
                            ost->audio_resample = 1;
1592
                        }
1593
                    } else {
1594
                        ost->audio_resample = 1;
1595
                    }
1596
                }
1597
                if(audio_sync_method>1)
1598
                    ost->audio_resample = 1;
1599

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

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

    
1716
    if (!bit_buffer)
1717
        bit_buffer = av_malloc(bit_buffer_size);
1718
    if (!bit_buffer)
1719
        goto fail;
1720

    
1721
    /* dump the file output parameters - cannot be done before in case
1722
       of stream copy */
1723
    for(i=0;i<nb_output_files;i++) {
1724
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1725
    }
1726

    
1727
    /* dump the stream mapping */
1728
    if (verbose >= 0) {
1729
        fprintf(stderr, "Stream mapping:\n");
1730
        for(i=0;i<nb_ostreams;i++) {
1731
            ost = ost_table[i];
1732
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1733
                    ist_table[ost->source_index]->file_index,
1734
                    ist_table[ost->source_index]->index,
1735
                    ost->file_index,
1736
                    ost->index);
1737
            if (ost->sync_ist != ist_table[ost->source_index])
1738
                fprintf(stderr, " [sync #%d.%d]",
1739
                        ost->sync_ist->file_index,
1740
                        ost->sync_ist->index);
1741
            fprintf(stderr, "\n");
1742
        }
1743
    }
1744

    
1745
    /* open each encoder */
1746
    for(i=0;i<nb_ostreams;i++) {
1747
        ost = ost_table[i];
1748
        if (ost->encoding_needed) {
1749
            AVCodec *codec;
1750
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1751
            if (!codec) {
1752
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1753
                        ost->file_index, ost->index);
1754
                exit(1);
1755
            }
1756
            if (avcodec_open(ost->st->codec, codec) < 0) {
1757
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1758
                        ost->file_index, ost->index);
1759
                exit(1);
1760
            }
1761
            extra_size += ost->st->codec->extradata_size;
1762
        }
1763
    }
1764

    
1765
    /* open each decoder */
1766
    for(i=0;i<nb_istreams;i++) {
1767
        ist = ist_table[i];
1768
        if (ist->decoding_needed) {
1769
            AVCodec *codec;
1770
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1771
            if (!codec) {
1772
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1773
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1774
                exit(1);
1775
            }
1776
            if (avcodec_open(ist->st->codec, codec) < 0) {
1777
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1778
                        ist->file_index, ist->index);
1779
                exit(1);
1780
            }
1781
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1782
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1783
        }
1784
    }
1785

    
1786
    /* init pts */
1787
    for(i=0;i<nb_istreams;i++) {
1788
        ist = ist_table[i];
1789
        is = input_files[ist->file_index];
1790
        ist->pts = 0;
1791
        ist->next_pts=0;
1792
        if(   input_files_ts_offset[ist->file_index] != -is->start_time
1793
           && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1794
            ist->next_pts= AV_NOPTS_VALUE;
1795
        ist->is_start = 1;
1796
    }
1797

    
1798
    /* set meta data information from input file if required */
1799
    for (i=0;i<nb_meta_data_maps;i++) {
1800
        AVFormatContext *out_file;
1801
        AVFormatContext *in_file;
1802

    
1803
        int out_file_index = meta_data_maps[i].out_file;
1804
        int in_file_index = meta_data_maps[i].in_file;
1805
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1806
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1807
            ret = AVERROR(EINVAL);
1808
            goto fail;
1809
        }
1810
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1811
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1812
            ret = AVERROR(EINVAL);
1813
            goto fail;
1814
        }
1815

    
1816
        out_file = output_files[out_file_index];
1817
        in_file = input_files[in_file_index];
1818

    
1819
        strcpy(out_file->title, in_file->title);
1820
        strcpy(out_file->author, in_file->author);
1821
        strcpy(out_file->copyright, in_file->copyright);
1822
        strcpy(out_file->comment, in_file->comment);
1823
        strcpy(out_file->album, in_file->album);
1824
        out_file->year = in_file->year;
1825
        out_file->track = in_file->track;
1826
        strcpy(out_file->genre, in_file->genre);
1827
    }
1828

    
1829
    /* open files and write file headers */
1830
    for(i=0;i<nb_output_files;i++) {
1831
        os = output_files[i];
1832
        if (av_write_header(os) < 0) {
1833
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1834
            ret = AVERROR(EINVAL);
1835
            goto fail;
1836
        }
1837
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1838
            want_sdp = 0;
1839
        }
1840
    }
1841
    if (want_sdp) {
1842
        print_sdp(output_files, nb_output_files);
1843
    }
1844

    
1845
    if ( !using_stdin && verbose >= 0) {
1846
        fprintf(stderr, "Press [q] to stop encoding\n");
1847
        url_set_interrupt_cb(decode_interrupt_cb);
1848
    }
1849
    term_init();
1850

    
1851
    key = -1;
1852
    timer_start = av_gettime();
1853

    
1854
    for(; received_sigterm == 0;) {
1855
        int file_index, ist_index;
1856
        AVPacket pkt;
1857
        double ipts_min;
1858
        double opts_min;
1859

    
1860
    redo:
1861
        ipts_min= 1e100;
1862
        opts_min= 1e100;
1863
        /* if 'q' pressed, exits */
1864
        if (!using_stdin) {
1865
            if (q_pressed)
1866
                break;
1867
            /* read_key() returns 0 on EOF */
1868
            key = read_key();
1869
            if (key == 'q')
1870
                break;
1871
        }
1872

    
1873
        /* select the stream that we must read now by looking at the
1874
           smallest output pts */
1875
        file_index = -1;
1876
        for(i=0;i<nb_ostreams;i++) {
1877
            double ipts, opts;
1878
            ost = ost_table[i];
1879
            os = output_files[ost->file_index];
1880
            ist = ist_table[ost->source_index];
1881
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1882
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1883
            else
1884
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1885
            ipts = (double)ist->pts;
1886
            if (!file_table[ist->file_index].eof_reached){
1887
                if(ipts < ipts_min) {
1888
                    ipts_min = ipts;
1889
                    if(input_sync ) file_index = ist->file_index;
1890
                }
1891
                if(opts < opts_min) {
1892
                    opts_min = opts;
1893
                    if(!input_sync) file_index = ist->file_index;
1894
                }
1895
            }
1896
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1897
                file_index= -1;
1898
                break;
1899
            }
1900
        }
1901
        /* if none, if is finished */
1902
        if (file_index < 0) {
1903
            break;
1904
        }
1905

    
1906
        /* finish if recording time exhausted */
1907
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1908
            break;
1909

    
1910
        /* finish if limit size exhausted */
1911
        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1912
            break;
1913

    
1914
        /* read a frame from it and output it in the fifo */
1915
        is = input_files[file_index];
1916
        if (av_read_frame(is, &pkt) < 0) {
1917
            file_table[file_index].eof_reached = 1;
1918
            if (opt_shortest)
1919
                break;
1920
            else
1921
                continue;
1922
        }
1923

    
1924
        if (do_pkt_dump) {
1925
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1926
        }
1927
        /* the following test is needed in case new streams appear
1928
           dynamically in stream : we ignore them */
1929
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1930
            goto discard_packet;
1931
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1932
        ist = ist_table[ist_index];
1933
        if (ist->discard)
1934
            goto discard_packet;
1935

    
1936
        if (pkt.dts != AV_NOPTS_VALUE)
1937
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1938
        if (pkt.pts != AV_NOPTS_VALUE)
1939
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1940

    
1941
//        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);
1942
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1943
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1944
            int64_t delta= pkt_dts - ist->next_pts;
1945
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1946
                input_files_ts_offset[ist->file_index]-= delta;
1947
                if (verbose > 2)
1948
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1949
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1950
                if(pkt.pts != AV_NOPTS_VALUE)
1951
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1952
            }
1953
        }
1954

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

    
1958
            if (verbose >= 0)
1959
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1960
                        ist->file_index, ist->index);
1961

    
1962
            av_free_packet(&pkt);
1963
            goto redo;
1964
        }
1965

    
1966
    discard_packet:
1967
        av_free_packet(&pkt);
1968

    
1969
        /* dump report by using the output first video and audio streams */
1970
        print_report(output_files, ost_table, nb_ostreams, 0);
1971
    }
1972

    
1973
    /* at the end of stream, we must flush the decoder buffers */
1974
    for(i=0;i<nb_istreams;i++) {
1975
        ist = ist_table[i];
1976
        if (ist->decoding_needed) {
1977
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1978
        }
1979
    }
1980

    
1981
    term_exit();
1982

    
1983
    /* write the trailer if needed and close file */
1984
    for(i=0;i<nb_output_files;i++) {
1985
        os = output_files[i];
1986
        av_write_trailer(os);
1987
    }
1988

    
1989
    /* dump report by using the first video and audio streams */
1990
    print_report(output_files, ost_table, nb_ostreams, 1);
1991

    
1992
    /* close each encoder */
1993
    for(i=0;i<nb_ostreams;i++) {
1994
        ost = ost_table[i];
1995
        if (ost->encoding_needed) {
1996
            av_freep(&ost->st->codec->stats_in);
1997
            avcodec_close(ost->st->codec);
1998
        }
1999
    }
2000

    
2001
    /* close each decoder */
2002
    for(i=0;i<nb_istreams;i++) {
2003
        ist = ist_table[i];
2004
        if (ist->decoding_needed) {
2005
            avcodec_close(ist->st->codec);
2006
        }
2007
    }
2008

    
2009
    /* finished ! */
2010

    
2011
    ret = 0;
2012
 fail1:
2013
    av_freep(&bit_buffer);
2014
    av_free(file_table);
2015

    
2016
    if (ist_table) {
2017
        for(i=0;i<nb_istreams;i++) {
2018
            ist = ist_table[i];
2019
            av_free(ist);
2020
        }
2021
        av_free(ist_table);
2022
    }
2023
    if (ost_table) {
2024
        for(i=0;i<nb_ostreams;i++) {
2025
            ost = ost_table[i];
2026
            if (ost) {
2027
                if (ost->logfile) {
2028
                    fclose(ost->logfile);
2029
                    ost->logfile = NULL;
2030
                }
2031
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2032
                                             initialized but set to zero */
2033
                av_free(ost->pict_tmp.data[0]);
2034
                if (ost->video_resample)
2035
                    sws_freeContext(ost->img_resample_ctx);
2036
                if (ost->audio_resample)
2037
                    audio_resample_close(ost->resample);
2038
                av_free(ost);
2039
            }
2040
        }
2041
        av_free(ost_table);
2042
    }
2043
    return ret;
2044
 fail:
2045
    ret = AVERROR(ENOMEM);
2046
    goto fail1;
2047
}
2048

    
2049
#if 0
2050
int file_read(const char *filename)
2051
{
2052
    URLContext *h;
2053
    unsigned char buffer[1024];
2054
    int len, i;
2055

2056
    if (url_open(&h, filename, O_RDONLY) < 0) {
2057
        printf("could not open '%s'\n", filename);
2058
        return -1;
2059
    }
2060
    for(;;) {
2061
        len = url_read(h, buffer, sizeof(buffer));
2062
        if (len <= 0)
2063
            break;
2064
        for(i=0;i<len;i++) putchar(buffer[i]);
2065
    }
2066
    url_close(h);
2067
    return 0;
2068
}
2069
#endif
2070

    
2071
static void opt_format(const char *arg)
2072
{
2073
    /* compatibility stuff for pgmyuv */
2074
    if (!strcmp(arg, "pgmyuv")) {
2075
        pgmyuv_compatibility_hack=1;
2076
//        opt_image_format(arg);
2077
        arg = "image2";
2078
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2079
    }
2080

    
2081
    file_iformat = av_find_input_format(arg);
2082
    file_oformat = guess_format(arg, NULL, NULL);
2083
    if (!file_iformat && !file_oformat) {
2084
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2085
        exit(1);
2086
    }
2087
}
2088

    
2089
static void opt_video_rc_eq(char *arg)
2090
{
2091
    video_rc_eq = arg;
2092
}
2093

    
2094
static void opt_video_rc_override_string(char *arg)
2095
{
2096
    video_rc_override_string = arg;
2097
}
2098

    
2099
static void opt_me_threshold(const char *arg)
2100
{
2101
    me_threshold = atoi(arg);
2102
}
2103

    
2104
static void opt_verbose(const char *arg)
2105
{
2106
    verbose = atoi(arg);
2107
    av_log_level = atoi(arg);
2108
}
2109

    
2110
static void opt_frame_rate(const char *arg)
2111
{
2112
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2113
        fprintf(stderr, "Incorrect frame rate\n");
2114
        exit(1);
2115
    }
2116
}
2117

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

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

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

    
2172
static void opt_frame_crop_right(const char *arg)
2173
{
2174
    frame_rightBand = atoi(arg);
2175
    if (frame_rightBand < 0) {
2176
        fprintf(stderr, "Incorrect right crop size\n");
2177
        exit(1);
2178
    }
2179
    if ((frame_rightBand % 2) != 0) {
2180
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2181
        exit(1);
2182
    }
2183
    if ((frame_rightBand) >= frame_width){
2184
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2185
        exit(1);
2186
    }
2187
    frame_width -= frame_rightBand;
2188
}
2189

    
2190
static void opt_frame_size(const char *arg)
2191
{
2192
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2193
        fprintf(stderr, "Incorrect frame size\n");
2194
        exit(1);
2195
    }
2196
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2197
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2198
        exit(1);
2199
    }
2200
}
2201

    
2202

    
2203
#define SCALEBITS 10
2204
#define ONE_HALF  (1 << (SCALEBITS - 1))
2205
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2206

    
2207
#define RGB_TO_Y(r, g, b) \
2208
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2209
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2210

    
2211
#define RGB_TO_U(r1, g1, b1, shift)\
2212
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2213
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2214

    
2215
#define RGB_TO_V(r1, g1, b1, shift)\
2216
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2217
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2218

    
2219
static void opt_pad_color(const char *arg) {
2220
    /* Input is expected to be six hex digits similar to
2221
       how colors are expressed in html tags (but without the #) */
2222
    int rgb = strtol(arg, NULL, 16);
2223
    int r,g,b;
2224

    
2225
    r = (rgb >> 16);
2226
    g = ((rgb >> 8) & 255);
2227
    b = (rgb & 255);
2228

    
2229
    padcolor[0] = RGB_TO_Y(r,g,b);
2230
    padcolor[1] = RGB_TO_U(r,g,b,0);
2231
    padcolor[2] = RGB_TO_V(r,g,b,0);
2232
}
2233

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

    
2247
static void opt_frame_pad_bottom(const char *arg)
2248
{
2249
    frame_padbottom = atoi(arg);
2250
    if (frame_padbottom < 0) {
2251
        fprintf(stderr, "Incorrect bottom pad size\n");
2252
        exit(1);
2253
    }
2254
    if ((frame_padbottom % 2) != 0) {
2255
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2256
        exit(1);
2257
    }
2258
}
2259

    
2260

    
2261
static void opt_frame_pad_left(const char *arg)
2262
{
2263
    frame_padleft = atoi(arg);
2264
    if (frame_padleft < 0) {
2265
        fprintf(stderr, "Incorrect left pad size\n");
2266
        exit(1);
2267
    }
2268
    if ((frame_padleft % 2) != 0) {
2269
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2270
        exit(1);
2271
    }
2272
}
2273

    
2274

    
2275
static void opt_frame_pad_right(const char *arg)
2276
{
2277
    frame_padright = atoi(arg);
2278
    if (frame_padright < 0) {
2279
        fprintf(stderr, "Incorrect right pad size\n");
2280
        exit(1);
2281
    }
2282
    if ((frame_padright % 2) != 0) {
2283
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2284
        exit(1);
2285
    }
2286
}
2287

    
2288
void list_pix_fmts(void)
2289
{
2290
    int i;
2291
    char pix_fmt_str[128];
2292
    for (i=-1; i < PIX_FMT_NB; i++) {
2293
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2294
        fprintf(stdout, "%s\n", pix_fmt_str);
2295
    }
2296
}
2297

    
2298
static void opt_frame_pix_fmt(const char *arg)
2299
{
2300
    if (strcmp(arg, "list"))
2301
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2302
    else {
2303
        list_pix_fmts();
2304
        exit(0);
2305
    }
2306
}
2307

    
2308
static void opt_frame_aspect_ratio(const char *arg)
2309
{
2310
    int x = 0, y = 0;
2311
    double ar = 0;
2312
    const char *p;
2313

    
2314
    p = strchr(arg, ':');
2315
    if (p) {
2316
        x = strtol(arg, (char **)&arg, 10);
2317
        if (arg == p)
2318
            y = strtol(arg+1, (char **)&arg, 10);
2319
        if (x > 0 && y > 0)
2320
            ar = (double)x / (double)y;
2321
    } else
2322
        ar = strtod(arg, (char **)&arg);
2323

    
2324
    if (!ar) {
2325
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2326
        exit(1);
2327
    }
2328
    frame_aspect_ratio = ar;
2329
}
2330

    
2331
static void opt_qscale(const char *arg)
2332
{
2333
    video_qscale = atof(arg);
2334
    if (video_qscale <= 0 ||
2335
        video_qscale > 255) {
2336
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2337
        exit(1);
2338
    }
2339
}
2340

    
2341
static void opt_qdiff(const char *arg)
2342
{
2343
    video_qdiff = atoi(arg);
2344
    if (video_qdiff < 0 ||
2345
        video_qdiff > 31) {
2346
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2347
        exit(1);
2348
    }
2349
}
2350

    
2351
static void opt_strict(const char *arg)
2352
{
2353
    strict= atoi(arg);
2354
}
2355

    
2356
static void opt_top_field_first(const char *arg)
2357
{
2358
    top_field_first= atoi(arg);
2359
}
2360

    
2361
static void opt_thread_count(const char *arg)
2362
{
2363
    thread_count= atoi(arg);
2364
#if !defined(HAVE_THREADS)
2365
    if (verbose >= 0)
2366
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2367
#endif
2368
}
2369

    
2370
static void opt_audio_rate(const char *arg)
2371
{
2372
    audio_sample_rate = atoi(arg);
2373
}
2374

    
2375
static void opt_audio_channels(const char *arg)
2376
{
2377
    audio_channels = atoi(arg);
2378
}
2379

    
2380
static void opt_video_channel(const char *arg)
2381
{
2382
    video_channel = strtol(arg, NULL, 0);
2383
}
2384

    
2385
static void opt_video_standard(const char *arg)
2386
{
2387
    video_standard = av_strdup(arg);
2388
}
2389

    
2390
static void opt_codec(int *pstream_copy, char **pcodec_name,
2391
                      int codec_type, const char *arg)
2392
{
2393
    av_freep(pcodec_name);
2394
    if (!strcmp(arg, "copy")) {
2395
        *pstream_copy = 1;
2396
    } else {
2397
        *pcodec_name = av_strdup(arg);
2398
    }
2399
}
2400

    
2401
static void opt_audio_codec(const char *arg)
2402
{
2403
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2404
}
2405

    
2406
static void opt_audio_tag(const char *arg)
2407
{
2408
    char *tail;
2409
    audio_codec_tag= strtol(arg, &tail, 0);
2410

    
2411
    if(!tail || *tail)
2412
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2413
}
2414

    
2415
static void opt_video_tag(const char *arg)
2416
{
2417
    char *tail;
2418
    video_codec_tag= strtol(arg, &tail, 0);
2419

    
2420
    if(!tail || *tail)
2421
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2422
}
2423

    
2424
#ifdef CONFIG_VHOOK
2425
static void add_frame_hooker(const char *arg)
2426
{
2427
    int argc = 0;
2428
    char *argv[64];
2429
    int i;
2430
    char *args = av_strdup(arg);
2431

    
2432
    using_vhook = 1;
2433

    
2434
    argv[0] = strtok(args, " ");
2435
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2436
    }
2437

    
2438
    i = frame_hook_add(argc, argv);
2439

    
2440
    if (i != 0) {
2441
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2442
        exit(1);
2443
    }
2444
}
2445
#endif
2446

    
2447
static void opt_video_codec(const char *arg)
2448
{
2449
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2450
}
2451

    
2452
static void opt_subtitle_codec(const char *arg)
2453
{
2454
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2455
}
2456

    
2457
static void opt_map(const char *arg)
2458
{
2459
    AVStreamMap *m;
2460
    const char *p;
2461

    
2462
    p = arg;
2463
    m = &stream_maps[nb_stream_maps++];
2464

    
2465
    m->file_index = strtol(arg, (char **)&p, 0);
2466
    if (*p)
2467
        p++;
2468

    
2469
    m->stream_index = strtol(p, (char **)&p, 0);
2470
    if (*p) {
2471
        p++;
2472
        m->sync_file_index = strtol(p, (char **)&p, 0);
2473
        if (*p)
2474
            p++;
2475
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2476
    } else {
2477
        m->sync_file_index = m->file_index;
2478
        m->sync_stream_index = m->stream_index;
2479
    }
2480
}
2481

    
2482
static void opt_map_meta_data(const char *arg)
2483
{
2484
    AVMetaDataMap *m;
2485
    const char *p;
2486

    
2487
    p = arg;
2488
    m = &meta_data_maps[nb_meta_data_maps++];
2489

    
2490
    m->out_file = strtol(arg, (char **)&p, 0);
2491
    if (*p)
2492
        p++;
2493

    
2494
    m->in_file = strtol(p, (char **)&p, 0);
2495
}
2496

    
2497
static int64_t parse_time_or_die(const char *timestr, int is_duration)
2498
{
2499
    int64_t us = parse_date(timestr, is_duration);
2500
    if (us == INT64_MIN) {
2501
        fprintf(stderr, "Invalid %s specification: %s\n",
2502
                is_duration ? "duration" : "date", timestr);
2503
        exit(1);
2504
    }
2505
    return us;
2506
}
2507

    
2508
static void opt_recording_time(const char *arg)
2509
{
2510
    recording_time = parse_time_or_die(arg, 1);
2511
}
2512

    
2513
static void opt_start_time(const char *arg)
2514
{
2515
    start_time = parse_time_or_die(arg, 1);
2516
}
2517

    
2518
static void opt_rec_timestamp(const char *arg)
2519
{
2520
    rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2521
}
2522

    
2523
static void opt_input_ts_offset(const char *arg)
2524
{
2525
    input_ts_offset = parse_time_or_die(arg, 1);
2526
}
2527

    
2528
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2529
{
2530
    char *codec_string = encoder ? "encoder" : "decoder";
2531
    AVCodec *codec;
2532

    
2533
    if(!name)
2534
        return CODEC_ID_NONE;
2535
    codec = encoder ?
2536
        avcodec_find_encoder_by_name(name) :
2537
        avcodec_find_decoder_by_name(name);
2538
    if(!codec) {
2539
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2540
        exit(1);
2541
    }
2542
    if(codec->type != type) {
2543
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2544
        exit(1);
2545
    }
2546
    return codec->id;
2547
}
2548

    
2549
static void opt_input_file(const char *filename)
2550
{
2551
    AVFormatContext *ic;
2552
    AVFormatParameters params, *ap = &params;
2553
    int err, i, ret, rfps, rfps_base;
2554
    int64_t timestamp;
2555

    
2556
    if (!strcmp(filename, "-"))
2557
        filename = "pipe:";
2558

    
2559
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2560
                   !strcmp( filename, "/dev/stdin" );
2561

    
2562
    /* get default parameters from command line */
2563
    ic = av_alloc_format_context();
2564

    
2565
    memset(ap, 0, sizeof(*ap));
2566
    ap->prealloced_context = 1;
2567
    ap->sample_rate = audio_sample_rate;
2568
    ap->channels = audio_channels;
2569
    ap->time_base.den = frame_rate.num;
2570
    ap->time_base.num = frame_rate.den;
2571
    ap->width = frame_width + frame_padleft + frame_padright;
2572
    ap->height = frame_height + frame_padtop + frame_padbottom;
2573
    ap->pix_fmt = frame_pix_fmt;
2574
    ap->channel = video_channel;
2575
    ap->standard = video_standard;
2576
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2577
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2578
    if(pgmyuv_compatibility_hack)
2579
        ap->video_codec_id= CODEC_ID_PGMYUV;
2580

    
2581
    for(i=0; i<opt_name_count; i++){
2582
        const AVOption *opt;
2583
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2584
        if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2585
            av_set_double(ic, opt_names[i], d);
2586
    }
2587
    /* open the input file with generic libav function */
2588
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2589
    if (err < 0) {
2590
        print_error(filename, err);
2591
        exit(1);
2592
    }
2593

    
2594
    ic->loop_input = loop_input;
2595

    
2596
    /* If not enough info to get the stream parameters, we decode the
2597
       first frames to get it. (used in mpeg case for example) */
2598
    ret = av_find_stream_info(ic);
2599
    if (ret < 0 && verbose >= 0) {
2600
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2601
        exit(1);
2602
    }
2603

    
2604
    timestamp = start_time;
2605
    /* add the stream start time */
2606
    if (ic->start_time != AV_NOPTS_VALUE)
2607
        timestamp += ic->start_time;
2608

    
2609
    /* if seeking requested, we execute it */
2610
    if (start_time != 0) {
2611
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2612
        if (ret < 0) {
2613
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2614
                    filename, (double)timestamp / AV_TIME_BASE);
2615
        }
2616
        /* reset seek info */
2617
        start_time = 0;
2618
    }
2619

    
2620
    /* update the current parameters so that they match the one of the input stream */
2621
    for(i=0;i<ic->nb_streams;i++) {
2622
        int j;
2623
        AVCodecContext *enc = ic->streams[i]->codec;
2624
        if(thread_count>1)
2625
            avcodec_thread_init(enc, thread_count);
2626
        enc->thread_count= thread_count;
2627
        switch(enc->codec_type) {
2628
        case CODEC_TYPE_AUDIO:
2629
            for(j=0; j<opt_name_count; j++){
2630
                const AVOption *opt;
2631
                double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2632
                if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2633
                    av_set_double(enc, opt_names[j], d);
2634
            }
2635
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2636
            audio_channels = enc->channels;
2637
            audio_sample_rate = enc->sample_rate;
2638
            if(audio_disable)
2639
                ic->streams[i]->discard= AVDISCARD_ALL;
2640
            break;
2641
        case CODEC_TYPE_VIDEO:
2642
            for(j=0; j<opt_name_count; j++){
2643
                const AVOption *opt;
2644
                double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2645
                if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2646
                    av_set_double(enc, opt_names[j], d);
2647
            }
2648
            frame_height = enc->height;
2649
            frame_width = enc->width;
2650
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2651
            frame_pix_fmt = enc->pix_fmt;
2652
            rfps      = ic->streams[i]->r_frame_rate.num;
2653
            rfps_base = ic->streams[i]->r_frame_rate.den;
2654
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2655
            if(me_threshold)
2656
                enc->debug |= FF_DEBUG_MV;
2657

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

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

    
2664
                    (float)rfps / rfps_base, rfps, rfps_base);
2665
            }
2666
            /* update the current frame rate to match the stream frame rate */
2667
            frame_rate.num = rfps;
2668
            frame_rate.den = rfps_base;
2669

    
2670
            enc->rate_emu = rate_emu;
2671
            if(video_disable)
2672
                ic->streams[i]->discard= AVDISCARD_ALL;
2673
            else if(video_discard)
2674
                ic->streams[i]->discard= video_discard;
2675
            break;
2676
        case CODEC_TYPE_DATA:
2677
            break;
2678
        case CODEC_TYPE_SUBTITLE:
2679
            if(subtitle_disable)
2680
                ic->streams[i]->discard = AVDISCARD_ALL;
2681
            break;
2682
        case CODEC_TYPE_UNKNOWN:
2683
            break;
2684
        default:
2685
            abort();
2686
        }
2687
    }
2688

    
2689
    input_files[nb_input_files] = ic;
2690
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2691
    /* dump the file content */
2692
    if (verbose >= 0)
2693
        dump_format(ic, nb_input_files, filename, 0);
2694

    
2695
    nb_input_files++;
2696
    file_iformat = NULL;
2697
    file_oformat = NULL;
2698

    
2699
    video_channel = 0;
2700

    
2701
    rate_emu = 0;
2702
}
2703

    
2704
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2705
                                         int *has_subtitle_ptr)
2706
{
2707
    int has_video, has_audio, has_subtitle, i, j;
2708
    AVFormatContext *ic;
2709

    
2710
    has_video = 0;
2711
    has_audio = 0;
2712
    has_subtitle = 0;
2713
    for(j=0;j<nb_input_files;j++) {
2714
        ic = input_files[j];
2715
        for(i=0;i<ic->nb_streams;i++) {
2716
            AVCodecContext *enc = ic->streams[i]->codec;
2717
            switch(enc->codec_type) {
2718
            case CODEC_TYPE_AUDIO:
2719
                has_audio = 1;
2720
                break;
2721
            case CODEC_TYPE_VIDEO:
2722
                has_video = 1;
2723
                break;
2724
            case CODEC_TYPE_SUBTITLE:
2725
                has_subtitle = 1;
2726
                break;
2727
            case CODEC_TYPE_DATA:
2728
            case CODEC_TYPE_UNKNOWN:
2729
                break;
2730
            default:
2731
                abort();
2732
            }
2733
        }
2734
    }
2735
    *has_video_ptr = has_video;
2736
    *has_audio_ptr = has_audio;
2737
    *has_subtitle_ptr = has_subtitle;
2738
}
2739

    
2740
static void new_video_stream(AVFormatContext *oc)
2741
{
2742
    AVStream *st;
2743
    AVCodecContext *video_enc;
2744
    int codec_id;
2745

    
2746
    st = av_new_stream(oc, oc->nb_streams);
2747
    if (!st) {
2748
        fprintf(stderr, "Could not alloc stream\n");
2749
        exit(1);
2750
    }
2751
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2752
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2753
    video_bitstream_filters= NULL;
2754

    
2755
    if(thread_count>1)
2756
        avcodec_thread_init(st->codec, thread_count);
2757

    
2758
    video_enc = st->codec;
2759

    
2760
    if(video_codec_tag)
2761
        video_enc->codec_tag= video_codec_tag;
2762

    
2763
    if(   (video_global_header&1)
2764
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2765
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2766
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2767
    }
2768
    if(video_global_header&2){
2769
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2770
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2771
    }
2772

    
2773
    if (video_stream_copy) {
2774
        st->stream_copy = 1;
2775
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2776
    } else {
2777
        char *p;
2778
        int i;
2779
        AVCodec *codec;
2780

    
2781
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2782
        if (video_codec_name)
2783
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2784

    
2785
        video_enc->codec_id = codec_id;
2786
        codec = avcodec_find_encoder(codec_id);
2787

    
2788
        for(i=0; i<opt_name_count; i++){
2789
             const AVOption *opt;
2790
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2791
             if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2792
                 av_set_double(video_enc, opt_names[i], d);
2793
        }
2794

    
2795
        video_enc->time_base.den = frame_rate.num;
2796
        video_enc->time_base.num = frame_rate.den;
2797
        if(codec && codec->supported_framerates){
2798
            const AVRational *p= codec->supported_framerates;
2799
            AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2800
            const AVRational *best=NULL;
2801
            AVRational best_error= (AVRational){INT_MAX, 1};
2802
            for(; p->den!=0; p++){
2803
                AVRational error= av_sub_q(req, *p);
2804
                if(error.num <0) error.num *= -1;
2805
                if(av_cmp_q(error, best_error) < 0){
2806
                    best_error= error;
2807
                    best= p;
2808
                }
2809
            }
2810
            video_enc->time_base.den= best->num;
2811
            video_enc->time_base.num= best->den;
2812
        }
2813

    
2814
        video_enc->width = frame_width + frame_padright + frame_padleft;
2815
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2816
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2817
        video_enc->pix_fmt = frame_pix_fmt;
2818

    
2819
        if(codec && codec->pix_fmts){
2820
            const enum PixelFormat *p= codec->pix_fmts;
2821
            for(; *p!=-1; p++){
2822
                if(*p == video_enc->pix_fmt)
2823
                    break;
2824
            }
2825
            if(*p == -1)
2826
                video_enc->pix_fmt = codec->pix_fmts[0];
2827
        }
2828

    
2829
        if (intra_only)
2830
            video_enc->gop_size = 0;
2831
        if (video_qscale || same_quality) {
2832
            video_enc->flags |= CODEC_FLAG_QSCALE;
2833
            video_enc->global_quality=
2834
                st->quality = FF_QP2LAMBDA * video_qscale;
2835
        }
2836

    
2837
        if(intra_matrix)
2838
            video_enc->intra_matrix = intra_matrix;
2839
        if(inter_matrix)
2840
            video_enc->inter_matrix = inter_matrix;
2841

    
2842
        video_enc->max_qdiff = video_qdiff;
2843
        video_enc->rc_eq = video_rc_eq;
2844
        video_enc->thread_count = thread_count;
2845
        p= video_rc_override_string;
2846
        for(i=0; p; i++){
2847
            int start, end, q;
2848
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2849
            if(e!=3){
2850
                fprintf(stderr, "error parsing rc_override\n");
2851
                exit(1);
2852
            }
2853
            video_enc->rc_override=
2854
                av_realloc(video_enc->rc_override,
2855
                           sizeof(RcOverride)*(i+1));
2856
            video_enc->rc_override[i].start_frame= start;
2857
            video_enc->rc_override[i].end_frame  = end;
2858
            if(q>0){
2859
                video_enc->rc_override[i].qscale= q;
2860
                video_enc->rc_override[i].quality_factor= 1.0;
2861
            }
2862
            else{
2863
                video_enc->rc_override[i].qscale= 0;
2864
                video_enc->rc_override[i].quality_factor= -q/100.0;
2865
            }
2866
            p= strchr(p, '/');
2867
            if(p) p++;
2868
        }
2869
        video_enc->rc_override_count=i;
2870
        if (!video_enc->rc_initial_buffer_occupancy)
2871
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2872
        video_enc->me_threshold= me_threshold;
2873
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2874
        video_enc->strict_std_compliance = strict;
2875

    
2876
        if (do_psnr)
2877
            video_enc->flags|= CODEC_FLAG_PSNR;
2878

    
2879
        /* two pass mode */
2880
        if (do_pass) {
2881
            if (do_pass == 1) {
2882
                video_enc->flags |= CODEC_FLAG_PASS1;
2883
            } else {
2884
                video_enc->flags |= CODEC_FLAG_PASS2;
2885
            }
2886
        }
2887
    }
2888

    
2889
    /* reset some key parameters */
2890
    video_disable = 0;
2891
    av_freep(&video_codec_name);
2892
    video_stream_copy = 0;
2893
}
2894

    
2895
static void new_audio_stream(AVFormatContext *oc)
2896
{
2897
    AVStream *st;
2898
    AVCodecContext *audio_enc;
2899
    int codec_id, i;
2900

    
2901
    st = av_new_stream(oc, oc->nb_streams);
2902
    if (!st) {
2903
        fprintf(stderr, "Could not alloc stream\n");
2904
        exit(1);
2905
    }
2906
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2907

    
2908
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2909
    audio_bitstream_filters= NULL;
2910

    
2911
    if(thread_count>1)
2912
        avcodec_thread_init(st->codec, thread_count);
2913

    
2914
    audio_enc = st->codec;
2915
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2916
    audio_enc->strict_std_compliance = strict;
2917

    
2918
    if(audio_codec_tag)
2919
        audio_enc->codec_tag= audio_codec_tag;
2920

    
2921
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2922
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2923
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2924
    }
2925
    if (audio_stream_copy) {
2926
        st->stream_copy = 1;
2927
        audio_enc->channels = audio_channels;
2928
    } else {
2929
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2930

    
2931
        for(i=0; i<opt_name_count; i++){
2932
            const AVOption *opt;
2933
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2934
            if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2935
                av_set_double(audio_enc, opt_names[i], d);
2936
        }
2937

    
2938
        if (audio_codec_name)
2939
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
2940
        audio_enc->codec_id = codec_id;
2941

    
2942
        if (audio_qscale > QSCALE_NONE) {
2943
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2944
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2945
        }
2946
        audio_enc->thread_count = thread_count;
2947
        audio_enc->channels = audio_channels;
2948
    }
2949
    audio_enc->sample_rate = audio_sample_rate;
2950
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2951
    if (audio_language) {
2952
        av_strlcpy(st->language, audio_language, sizeof(st->language));
2953
        av_free(audio_language);
2954
        audio_language = NULL;
2955
    }
2956

    
2957
    /* reset some key parameters */
2958
    audio_disable = 0;
2959
    av_freep(&audio_codec_name);
2960
    audio_stream_copy = 0;
2961
}
2962

    
2963
static void new_subtitle_stream(AVFormatContext *oc)
2964
{
2965
    AVStream *st;
2966
    AVCodecContext *subtitle_enc;
2967
    int i;
2968

    
2969
    st = av_new_stream(oc, oc->nb_streams);
2970
    if (!st) {
2971
        fprintf(stderr, "Could not alloc stream\n");
2972
        exit(1);
2973
    }
2974
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2975

    
2976
    subtitle_enc = st->codec;
2977
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2978
    if (subtitle_stream_copy) {
2979
        st->stream_copy = 1;
2980
    } else {
2981
        for(i=0; i<opt_name_count; i++){
2982
             const AVOption *opt;
2983
             double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2984
             if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2985
                 av_set_double(subtitle_enc, opt_names[i], d);
2986
        }
2987
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
2988
    }
2989

    
2990
    if (subtitle_language) {
2991
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2992
        av_free(subtitle_language);
2993
        subtitle_language = NULL;
2994
    }
2995

    
2996
    subtitle_disable = 0;
2997
    av_freep(&subtitle_codec_name);
2998
    subtitle_stream_copy = 0;
2999
}
3000

    
3001
static void opt_new_audio_stream(void)
3002
{
3003
    AVFormatContext *oc;
3004
    if (nb_output_files <= 0) {
3005
        fprintf(stderr, "At least one output file must be specified\n");
3006
        exit(1);
3007
    }
3008
    oc = output_files[nb_output_files - 1];
3009
    new_audio_stream(oc);
3010
}
3011

    
3012
static void opt_new_video_stream(void)
3013
{
3014
    AVFormatContext *oc;
3015
    if (nb_output_files <= 0) {
3016
        fprintf(stderr, "At least one output file must be specified\n");
3017
        exit(1);
3018
    }
3019
    oc = output_files[nb_output_files - 1];
3020
    new_video_stream(oc);
3021
}
3022

    
3023
static void opt_new_subtitle_stream(void)
3024
{
3025
    AVFormatContext *oc;
3026
    if (nb_output_files <= 0) {
3027
        fprintf(stderr, "At least one output file must be specified\n");
3028
        exit(1);
3029
    }
3030
    oc = output_files[nb_output_files - 1];
3031
    new_subtitle_stream(oc);
3032
}
3033

    
3034
static void opt_output_file(const char *filename)
3035
{
3036
    AVFormatContext *oc;
3037
    int use_video, use_audio, use_subtitle;
3038
    int input_has_video, input_has_audio, input_has_subtitle, i;
3039
    AVFormatParameters params, *ap = &params;
3040

    
3041
    if (!strcmp(filename, "-"))
3042
        filename = "pipe:";
3043

    
3044
    oc = av_alloc_format_context();
3045

    
3046
    if (!file_oformat) {
3047
        file_oformat = guess_format(NULL, filename, NULL);
3048
        if (!file_oformat) {
3049
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3050
                    filename);
3051
            exit(1);
3052
        }
3053
    }
3054

    
3055
    oc->oformat = file_oformat;
3056
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3057

    
3058
    if (!strcmp(file_oformat->name, "ffm") &&
3059
        av_strstart(filename, "http:", NULL)) {
3060
        /* special case for files sent to ffserver: we get the stream
3061
           parameters from ffserver */
3062
        if (read_ffserver_streams(oc, filename) < 0) {
3063
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3064
            exit(1);
3065
        }
3066
    } else {
3067
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3068
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3069
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3070

    
3071
        /* disable if no corresponding type found and at least one
3072
           input file */
3073
        if (nb_input_files > 0) {
3074
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3075
                                         &input_has_subtitle);
3076
            if (!input_has_video)
3077
                use_video = 0;
3078
            if (!input_has_audio)
3079
                use_audio = 0;
3080
            if (!input_has_subtitle)
3081
                use_subtitle = 0;
3082
        }
3083

    
3084
        /* manual disable */
3085
        if (audio_disable) {
3086
            use_audio = 0;
3087
        }
3088
        if (video_disable) {
3089
            use_video = 0;
3090
        }
3091
        if (subtitle_disable) {
3092
            use_subtitle = 0;
3093
        }
3094

    
3095
        if (use_video) {
3096
            new_video_stream(oc);
3097
        }
3098

    
3099
        if (use_audio) {
3100
            new_audio_stream(oc);
3101
        }
3102

    
3103
        if (use_subtitle) {
3104
            new_subtitle_stream(oc);
3105
        }
3106

    
3107
        oc->timestamp = rec_timestamp;
3108

    
3109
        if (str_title)
3110
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3111
        if (str_author)
3112
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3113
        if (str_copyright)
3114
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3115
        if (str_comment)
3116
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3117
        if (str_album)
3118
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3119
    }
3120

    
3121
    output_files[nb_output_files++] = oc;
3122

    
3123
    /* check filename in case of an image number is expected */
3124
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3125
        if (!av_filename_number_test(oc->filename)) {
3126
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3127
            exit(1);
3128
        }
3129
    }
3130

    
3131
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3132
        /* test if it already exists to avoid loosing precious files */
3133
        if (!file_overwrite &&
3134
            (strchr(filename, ':') == NULL ||
3135
             av_strstart(filename, "file:", NULL))) {
3136
            if (url_exist(filename)) {
3137
                int c;
3138

    
3139
                if ( !using_stdin ) {
3140
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3141
                    fflush(stderr);
3142
                    c = getchar();
3143
                    if (toupper(c) != 'Y') {
3144
                        fprintf(stderr, "Not overwriting - exiting\n");
3145
                        exit(1);
3146
                    }
3147
                                }
3148
                                else {
3149
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3150
                    exit(1);
3151
                                }
3152
            }
3153
        }
3154

    
3155
        /* open the file */
3156
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3157
            fprintf(stderr, "Could not open '%s'\n", filename);
3158
            exit(1);
3159
        }
3160
    }
3161

    
3162
    memset(ap, 0, sizeof(*ap));
3163
    if (av_set_parameters(oc, ap) < 0) {
3164
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3165
                oc->filename);
3166
        exit(1);
3167
    }
3168

    
3169
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3170
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3171
    oc->loop_output = loop_output;
3172

    
3173
    for(i=0; i<opt_name_count; i++){
3174
        const AVOption *opt;
3175
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3176
        if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3177
            av_set_double(oc, opt_names[i], d);
3178
    }
3179

    
3180
    /* reset some options */
3181
    file_oformat = NULL;
3182
    file_iformat = NULL;
3183
}
3184

    
3185
/* same option as mencoder */
3186
static void opt_pass(const char *pass_str)
3187
{
3188
    int pass;
3189
    pass = atoi(pass_str);
3190
    if (pass != 1 && pass != 2) {
3191
        fprintf(stderr, "pass number can be only 1 or 2\n");
3192
        exit(1);
3193
    }
3194
    do_pass = pass;
3195
}
3196

    
3197
static int64_t getutime(void)
3198
{
3199
#ifdef HAVE_GETRUSAGE
3200
    struct rusage rusage;
3201

    
3202
    getrusage(RUSAGE_SELF, &rusage);
3203
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3204
#elif defined(HAVE_GETPROCESSTIMES)
3205
    HANDLE proc;
3206
    FILETIME c, e, k, u;
3207
    proc = GetCurrentProcess();
3208
    GetProcessTimes(proc, &c, &e, &k, &u);
3209
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3210
#else
3211
    return av_gettime();
3212
#endif
3213
}
3214

    
3215
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3216
extern int ffm_nopts;
3217
#endif
3218

    
3219
static void opt_show_formats(void)
3220
{
3221
    AVInputFormat *ifmt;
3222
    AVOutputFormat *ofmt;
3223
    URLProtocol *up;
3224
    AVCodec *p, *p2;
3225
    const char *last_name;
3226

    
3227
    printf("File formats:\n");
3228
    last_name= "000";
3229
    for(;;){
3230
        int decode=0;
3231
        int encode=0;
3232
        const char *name=NULL;
3233
        const char *long_name=NULL;
3234

    
3235
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3236
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3237
                strcmp(ofmt->name, last_name)>0){
3238
                name= ofmt->name;
3239
                long_name= ofmt->long_name;
3240
                encode=1;
3241
            }
3242
        }
3243
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3244
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3245
                strcmp(ifmt->name, last_name)>0){
3246
                name= ifmt->name;
3247
                long_name= ifmt->long_name;
3248
                encode=0;
3249
            }
3250
            if(name && strcmp(ifmt->name, name)==0)
3251
                decode=1;
3252
        }
3253
        if(name==NULL)
3254
            break;
3255
        last_name= name;
3256

    
3257
        printf(
3258
            " %s%s %-15s %s\n",
3259
            decode ? "D":" ",
3260
            encode ? "E":" ",
3261
            name,
3262
            long_name ? long_name:" ");
3263
    }
3264
    printf("\n");
3265

    
3266
    printf("Codecs:\n");
3267
    last_name= "000";
3268
    for(;;){
3269
        int decode=0;
3270
        int encode=0;
3271
        int cap=0;
3272
        const char *type_str;
3273

    
3274
        p2=NULL;
3275
        for(p = first_avcodec; p != NULL; p = p->next) {
3276
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3277
                strcmp(p->name, last_name)>0){
3278
                p2= p;
3279
                decode= encode= cap=0;
3280
            }
3281
            if(p2 && strcmp(p->name, p2->name)==0){
3282
                if(p->decode) decode=1;
3283
                if(p->encode) encode=1;
3284
                cap |= p->capabilities;
3285
            }
3286
        }
3287
        if(p2==NULL)
3288
            break;
3289
        last_name= p2->name;
3290

    
3291
        switch(p2->type) {
3292
        case CODEC_TYPE_VIDEO:
3293
            type_str = "V";
3294
            break;
3295
        case CODEC_TYPE_AUDIO:
3296
            type_str = "A";
3297
            break;
3298
        case CODEC_TYPE_SUBTITLE:
3299
            type_str = "S";
3300
            break;
3301
        default:
3302
            type_str = "?";
3303
            break;
3304
        }
3305
        printf(
3306
            " %s%s%s%s%s%s %s",
3307
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3308
            encode ? "E":" ",
3309
            type_str,
3310
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3311
            cap & CODEC_CAP_DR1 ? "D":" ",
3312
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3313
            p2->name);
3314
       /* if(p2->decoder && decode==0)
3315
            printf(" use %s for decoding", p2->decoder->name);*/
3316
        printf("\n");
3317
    }
3318
    printf("\n");
3319

    
3320
    printf("Supported file protocols:\n");
3321
    for(up = first_protocol; up != NULL; up = up->next)
3322
        printf(" %s:", up->name);
3323
    printf("\n");
3324

    
3325
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3326
    printf("\n");
3327
    printf(
3328
"Note, the names of encoders and decoders do not always match, so there are\n"
3329
"several cases where the above table shows encoder only or decoder only entries\n"
3330
"even though both encoding and decoding are supported. For example, the h263\n"
3331
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3332
"worse.\n");
3333
    exit(0);
3334
}
3335

    
3336
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3337
{
3338
    int i;
3339
    const char *p = str;
3340
    for(i = 0;; i++) {
3341
        dest[i] = atoi(p);
3342
        if(i == 63)
3343
            break;
3344
        p = strchr(p, ',');
3345
        if(!p) {
3346
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3347
            exit(1);
3348
        }
3349
        p++;
3350
    }
3351
}
3352

    
3353
static void opt_inter_matrix(const char *arg)
3354
{
3355
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3356
    parse_matrix_coeffs(inter_matrix, arg);
3357
}
3358

    
3359
static void opt_intra_matrix(const char *arg)
3360
{
3361
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3362
    parse_matrix_coeffs(intra_matrix, arg);
3363
}
3364

    
3365
static void opt_show_help(void)
3366
{
3367
    show_help();
3368
    exit(0);
3369
}
3370

    
3371
static void opt_target(const char *arg)
3372
{
3373
    int norm = -1;
3374
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3375

    
3376
    if(!strncmp(arg, "pal-", 4)) {
3377
        norm = 0;
3378
        arg += 4;
3379
    } else if(!strncmp(arg, "ntsc-", 5)) {
3380
        norm = 1;
3381
        arg += 5;
3382
    } else if(!strncmp(arg, "film-", 5)) {
3383
        norm = 2;
3384
        arg += 5;
3385
    } else {
3386
        int fr;
3387
        /* Calculate FR via float to avoid int overflow */
3388
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3389
        if(fr == 25000) {
3390
            norm = 0;
3391
        } else if((fr == 29970) || (fr == 23976)) {
3392
            norm = 1;
3393
        } else {
3394
            /* Try to determine PAL/NTSC by peeking in the input files */
3395
            if(nb_input_files) {
3396
                int i, j;
3397
                for(j = 0; j < nb_input_files; j++) {
3398
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3399
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3400
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3401
                            continue;
3402
                        fr = c->time_base.den * 1000 / c->time_base.num;
3403
                        if(fr == 25000) {
3404
                            norm = 0;
3405
                            break;
3406
                        } else if((fr == 29970) || (fr == 23976)) {
3407
                            norm = 1;
3408
                            break;
3409
                        }
3410
                    }
3411
                    if(norm >= 0)
3412
                        break;
3413
                }
3414
            }
3415
        }
3416
        if(verbose && norm >= 0)
3417
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3418
    }
3419

    
3420
    if(norm < 0) {
3421
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3422
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3423
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3424
        exit(1);
3425
    }
3426

    
3427
    if(!strcmp(arg, "vcd")) {
3428

    
3429
        opt_video_codec("mpeg1video");
3430
        opt_audio_codec("mp2");
3431
        opt_format("vcd");
3432

    
3433
        opt_frame_size(norm ? "352x240" : "352x288");
3434
        opt_frame_rate(frame_rates[norm]);
3435
        opt_default("gop", norm ? "18" : "15");
3436

    
3437
        opt_default("b", "1150000");
3438
        opt_default("maxrate", "1150000");
3439
        opt_default("minrate", "1150000");
3440
        opt_default("bufsize", "327680"); // 40*1024*8;
3441

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

    
3446
        opt_default("packetsize", "2324");
3447
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3448

    
3449
        /* We have to offset the PTS, so that it is consistent with the SCR.
3450
           SCR starts at 36000, but the first two packs contain only padding
3451
           and the first pack from the other stream, respectively, may also have
3452
           been written before.
3453
           So the real data starts at SCR 36000+3*1200. */
3454
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3455
    } else if(!strcmp(arg, "svcd")) {
3456

    
3457
        opt_video_codec("mpeg2video");
3458
        opt_audio_codec("mp2");
3459
        opt_format("svcd");
3460

    
3461
        opt_frame_size(norm ? "480x480" : "480x576");
3462
        opt_frame_rate(frame_rates[norm]);
3463
        opt_default("gop", norm ? "18" : "15");
3464

    
3465
        opt_default("b", "2040000");
3466
        opt_default("maxrate", "2516000");
3467
        opt_default("minrate", "0"); //1145000;
3468
        opt_default("bufsize", "1835008"); //224*1024*8;
3469
        opt_default("flags", "+SCAN_OFFSET");
3470

    
3471

    
3472
        opt_default("ab", "224000");
3473
        audio_sample_rate = 44100;
3474

    
3475
        opt_default("packetsize", "2324");
3476

    
3477
    } else if(!strcmp(arg, "dvd")) {
3478

    
3479
        opt_video_codec("mpeg2video");
3480
        opt_audio_codec("ac3");
3481
        opt_format("dvd");
3482

    
3483
        opt_frame_size(norm ? "720x480" : "720x576");
3484
        opt_frame_rate(frame_rates[norm]);
3485
        opt_default("gop", norm ? "18" : "15");
3486

    
3487
        opt_default("b", "6000000");
3488
        opt_default("maxrate", "9000000");
3489
        opt_default("minrate", "0"); //1500000;
3490
        opt_default("bufsize", "1835008"); //224*1024*8;
3491

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

    
3495
        opt_default("ab", "448000");
3496
        audio_sample_rate = 48000;
3497

    
3498
    } else if(!strncmp(arg, "dv", 2)) {
3499

    
3500
        opt_format("dv");
3501

    
3502
        opt_frame_size(norm ? "720x480" : "720x576");
3503
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3504
                                             (norm ? "yuv411p" : "yuv420p"));
3505
        opt_frame_rate(frame_rates[norm]);
3506

    
3507
        audio_sample_rate = 48000;
3508
        audio_channels = 2;
3509

    
3510
    } else {
3511
        fprintf(stderr, "Unknown target: %s\n", arg);
3512
        exit(1);
3513
    }
3514
}
3515

    
3516
static void opt_vstats_file (const char *arg)
3517
{
3518
    av_free (vstats_filename);
3519
    vstats_filename=av_strdup (arg);
3520
}
3521

    
3522
static void opt_vstats (void)
3523
{
3524
    char filename[40];
3525
    time_t today2 = time(NULL);
3526
    struct tm *today = localtime(&today2);
3527

    
3528
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3529
             today->tm_sec);
3530
    opt_vstats_file(filename);
3531
}
3532

    
3533
static void opt_video_bsf(const char *arg)
3534
{
3535
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3536
    AVBitStreamFilterContext **bsfp;
3537

    
3538
    if(!bsfc){
3539
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3540
        exit(1);
3541
    }
3542

    
3543
    bsfp= &video_bitstream_filters;
3544
    while(*bsfp)
3545
        bsfp= &(*bsfp)->next;
3546

    
3547
    *bsfp= bsfc;
3548
}
3549

    
3550
//FIXME avoid audio - video code duplication
3551
static void opt_audio_bsf(const char *arg)
3552
{
3553
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3554
    AVBitStreamFilterContext **bsfp;
3555

    
3556
    if(!bsfc){
3557
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3558
        exit(1);
3559
    }
3560

    
3561
    bsfp= &audio_bitstream_filters;
3562
    while(*bsfp)
3563
        bsfp= &(*bsfp)->next;
3564

    
3565
    *bsfp= bsfc;
3566
}
3567

    
3568
static void opt_show_version(void)
3569
{
3570
    show_version(program_name);
3571
    exit(0);
3572
}
3573

    
3574
static int opt_default(const char *opt, const char *arg){
3575
    int type;
3576
    const AVOption *o= NULL;
3577
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3578

    
3579
    for(type=0; type<CODEC_TYPE_NB; type++){
3580
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3581
        if(o2)
3582
            o = av_set_string(avctx_opts[type], opt, arg);
3583
    }
3584
    if(!o)
3585
        o = av_set_string(avformat_opts, opt, arg);
3586
    if(!o)
3587
        o = av_set_string(sws_opts, opt, arg);
3588
    if(!o){
3589
        if(opt[0] == 'a')
3590
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3591
        else if(opt[0] == 'v')
3592
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3593
        else if(opt[0] == 's')
3594
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3595
    }
3596
    if(!o)
3597
        return -1;
3598

    
3599
//    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));
3600

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

    
3605
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3606
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3607
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3608
        ffm_nopts = 1;
3609
#endif
3610

    
3611
    if(avctx_opts[0]->debug)
3612
        av_log_level = AV_LOG_DEBUG;
3613
    return 0;
3614
}
3615

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

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

    
3703
    /* audio options */
3704
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3705
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3706
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3707
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3708
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3709
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3710
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3711
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3712
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3713
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3714

    
3715
    /* subtitle options */
3716
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3717
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3718
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3719
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3720

    
3721
    /* grab options */
3722
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3723
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3724
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3725

    
3726
    /* muxer options */
3727
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3728
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3729

    
3730
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3731
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3732

    
3733
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3734
    { NULL, },
3735
};
3736

    
3737
static void opt_show_license(void)
3738
{
3739
    show_license();
3740
    exit(0);
3741
}
3742

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

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

    
3786
static int av_exit()
3787
{
3788
    int i;
3789

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

    
3806
    av_free_static();
3807

    
3808
    av_free(intra_matrix);
3809
    av_free(inter_matrix);
3810

    
3811
    if (vstats_file)
3812
        fclose(vstats_file);
3813
    av_free(vstats_filename);
3814

    
3815
    av_free(opt_names);
3816

    
3817
    av_free(video_codec_name);
3818
    av_free(audio_codec_name);
3819
    av_free(subtitle_codec_name);
3820

    
3821
    av_free(video_standard);
3822

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

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

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

    
3839
int main(int argc, char **argv)
3840
{
3841
    int i;
3842
    int64_t ti;
3843

    
3844
    av_register_all();
3845

    
3846
    for(i=0; i<CODEC_TYPE_NB; i++){
3847
        avctx_opts[i]= avcodec_alloc_context2(i);
3848
    }
3849
    avformat_opts = av_alloc_format_context();
3850
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3851

    
3852
    show_banner(program_name, program_birth_year);
3853
    if (argc <= 1) {
3854
        show_help();
3855
        exit(1);
3856
    }
3857

    
3858
    /* parse options */
3859
    parse_options(argc, argv, options, opt_output_file);
3860

    
3861
    /* file converter / grab */
3862
    if (nb_output_files <= 0) {
3863
        fprintf(stderr, "Must supply at least one output file\n");
3864
        exit(1);
3865
    }
3866

    
3867
    if (nb_input_files == 0) {
3868
        fprintf(stderr, "Must supply at least one input file\n");
3869
        exit(1);
3870
    }
3871

    
3872
    ti = getutime();
3873
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3874
              stream_maps, nb_stream_maps);
3875
    ti = getutime() - ti;
3876
    if (do_benchmark) {
3877
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3878
    }
3879

    
3880
    return av_exit();
3881
}