Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 150d5a25

History | View | Annotate | Download (135 KB)

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

    
22
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include "libavformat/avformat.h"
31
#include "libavdevice/avdevice.h"
32
#include "libswscale/swscale.h"
33
#include "libavformat/framehook.h"
34
#include "libavcodec/opt.h"
35
#include "libavutil/fifo.h"
36
#include "libavutil/avstring.h"
37
#include "libavformat/os_support.h"
38

    
39
#ifdef HAVE_SYS_RESOURCE_H
40
#include <sys/types.h>
41
#include <sys/resource.h>
42
#elif defined(HAVE_GETPROCESSTIMES)
43
#include <windows.h>
44
#endif
45

    
46
#if defined(HAVE_TERMIOS_H)
47
#include <unistd.h>
48
#include <fcntl.h>
49
#include <sys/ioctl.h>
50
#include <sys/time.h>
51
#include <termios.h>
52
#elif defined(HAVE_CONIO_H)
53
#include <conio.h>
54
#endif
55
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
56
#include <time.h>
57

    
58
#include "cmdutils.h"
59

    
60
#undef NDEBUG
61
#include <assert.h>
62

    
63
#undef exit
64

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

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

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

    
82
static const OptionDef options[];
83

    
84
#define MAX_FILES 20
85

    
86
static AVFormatContext *input_files[MAX_FILES];
87
static int64_t input_files_ts_offset[MAX_FILES];
88
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
89
static int nb_input_files = 0;
90

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

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

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

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

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

    
149
static int subtitle_disable = 0;
150
static char *subtitle_codec_name = NULL;
151
static char *subtitle_language = NULL;
152

    
153
static float mux_preload= 0.5;
154
static float mux_max_delay= 0.7;
155

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

    
186
static int rate_emu = 0;
187

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

    
191
static int audio_volume = 256;
192

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

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

    
209
static unsigned int sws_flags = SWS_BICUBIC;
210

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

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

    
223
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
224

    
225
struct AVInputStream;
226

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

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

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

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

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

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

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

    
285
#ifdef HAVE_TERMIOS_H
286

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

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

    
298
static volatile sig_atomic_t received_sigterm = 0;
299

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

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

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

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

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

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

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

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

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

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

    
374
static int av_exit(int ret)
375
{
376
    int i;
377

    
378
    /* close files */
379
    for(i=0;i<nb_output_files;i++) {
380
        /* maybe av_close_output_file ??? */
381
        AVFormatContext *s = output_files[i];
382
        int j;
383
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
384
            url_fclose(s->pb);
385
        for(j=0;j<s->nb_streams;j++) {
386
            av_free(s->streams[j]->codec);
387
            av_free(s->streams[j]);
388
        }
389
        av_free(s);
390
    }
391
    for(i=0;i<nb_input_files;i++)
392
        av_close_input_file(input_files[i]);
393

    
394
    av_free(intra_matrix);
395
    av_free(inter_matrix);
396

    
397
    if (vstats_file)
398
        fclose(vstats_file);
399
    av_free(vstats_filename);
400

    
401
    av_free(opt_names);
402

    
403
    av_free(video_codec_name);
404
    av_free(audio_codec_name);
405
    av_free(subtitle_codec_name);
406

    
407
    av_free(video_standard);
408

    
409
#ifdef CONFIG_POWERPC_PERF
410
    extern void powerpc_display_perf_report(void);
411
    powerpc_display_perf_report();
412
#endif /* CONFIG_POWERPC_PERF */
413

    
414
    if (received_sigterm) {
415
        fprintf(stderr,
416
            "Received signal %d: terminating.\n",
417
            (int) received_sigterm);
418
        exit (255);
419
    }
420

    
421
    exit(ret); /* not all OS-es handle main() return value */
422
    return ret;
423
}
424

    
425
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
426
{
427
    int i, err;
428
    AVFormatContext *ic;
429
    int nopts = 0;
430

    
431
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
432
    if (err < 0)
433
        return err;
434
    /* copy stream format */
435
    s->nb_streams = ic->nb_streams;
436
    for(i=0;i<ic->nb_streams;i++) {
437
        AVStream *st;
438

    
439
        // FIXME: a more elegant solution is needed
440
        st = av_mallocz(sizeof(AVStream));
441
        memcpy(st, ic->streams[i], sizeof(AVStream));
442
        st->codec = avcodec_alloc_context();
443
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
444
        s->streams[i] = st;
445

    
446
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
447
            st->stream_copy = 1;
448
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
449
            st->stream_copy = 1;
450

    
451
        if(!st->codec->thread_count)
452
            st->codec->thread_count = 1;
453
        if(st->codec->thread_count>1)
454
            avcodec_thread_init(st->codec, st->codec->thread_count);
455

    
456
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
457
            nopts = 1;
458
    }
459

    
460
    if (!nopts)
461
        s->timestamp = av_gettime();
462

    
463
    av_close_input_file(ic);
464
    return 0;
465
}
466

    
467
static double
468
get_sync_ipts(const AVOutputStream *ost)
469
{
470
    const AVInputStream *ist = ost->sync_ist;
471
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
472
}
473

    
474
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
475
    int ret;
476

    
477
    while(bsfc){
478
        AVPacket new_pkt= *pkt;
479
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
480
                                          &new_pkt.data, &new_pkt.size,
481
                                          pkt->data, pkt->size,
482
                                          pkt->flags & PKT_FLAG_KEY);
483
        if(a>0){
484
            av_free_packet(pkt);
485
            new_pkt.destruct= av_destruct_packet;
486
        } else if(a<0){
487
            fprintf(stderr, "%s failed for stream %d, codec %s",
488
                    bsfc->filter->name, pkt->stream_index,
489
                    avctx->codec ? avctx->codec->name : "copy");
490
            print_error("", a);
491
        }
492
        *pkt= new_pkt;
493

    
494
        bsfc= bsfc->next;
495
    }
496

    
497
    ret= av_interleaved_write_frame(s, pkt);
498
    if(ret < 0){
499
        print_error("av_interleaved_write_frame()", ret);
500
        av_exit(1);
501
    }
502
}
503

    
504
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
505

    
506
static void do_audio_out(AVFormatContext *s,
507
                         AVOutputStream *ost,
508
                         AVInputStream *ist,
509
                         unsigned char *buf, int size)
510
{
511
    uint8_t *buftmp;
512
    static uint8_t *audio_buf = NULL;
513
    static uint8_t *audio_out = NULL;
514
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
515

    
516
    int size_out, frame_bytes, ret;
517
    AVCodecContext *enc= ost->st->codec;
518
    AVCodecContext *dec= ist->st->codec;
519

    
520
    /* SC: dynamic allocation of buffers */
521
    if (!audio_buf)
522
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
523
    if (!audio_out)
524
        audio_out = av_malloc(audio_out_size);
525
    if (!audio_buf || !audio_out)
526
        return;               /* Should signal an error ! */
527

    
528
    if (enc->channels != dec->channels)
529
        ost->audio_resample = 1;
530

    
531
    if (ost->audio_resample && !ost->resample) {
532
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
533
                                            enc->sample_rate, dec->sample_rate);
534
        if (!ost->resample) {
535
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
536
                    dec->channels, dec->sample_rate,
537
                    enc->channels, enc->sample_rate);
538
            av_exit(1);
539
        }
540
    }
541

    
542
    if(audio_sync_method){
543
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
544
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
545
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
546
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
547

    
548
        //FIXME resample delay
549
        if(fabs(delta) > 50){
550
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
551
                if(byte_delta < 0){
552
                    byte_delta= FFMAX(byte_delta, -size);
553
                    size += byte_delta;
554
                    buf  -= byte_delta;
555
                    if(verbose > 2)
556
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
557
                    if(!size)
558
                        return;
559
                    ist->is_start=0;
560
                }else{
561
                    static uint8_t *input_tmp= NULL;
562
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
563

    
564
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
565
                        ist->is_start=0;
566
                    else
567
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
568

    
569
                    memset(input_tmp, 0, byte_delta);
570
                    memcpy(input_tmp + byte_delta, buf, size);
571
                    buf= input_tmp;
572
                    size += byte_delta;
573
                    if(verbose > 2)
574
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
575
                }
576
            }else if(audio_sync_method>1){
577
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
578
                assert(ost->audio_resample);
579
                if(verbose > 2)
580
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
581
//                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));
582
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
583
            }
584
        }
585
    }else
586
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
587
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
588

    
589
    if (ost->audio_resample) {
590
        buftmp = audio_buf;
591
        size_out = audio_resample(ost->resample,
592
                                  (short *)buftmp, (short *)buf,
593
                                  size / (ist->st->codec->channels * 2));
594
        size_out = size_out * enc->channels * 2;
595
    } else {
596
        buftmp = buf;
597
        size_out = size;
598
    }
599

    
600
    /* now encode as many frames as possible */
601
    if (enc->frame_size > 1) {
602
        /* output resampled raw samples */
603
        av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
604
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
605

    
606
        frame_bytes = enc->frame_size * 2 * enc->channels;
607

    
608
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
609
            AVPacket pkt;
610
            av_init_packet(&pkt);
611

    
612
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
613

    
614
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
615

    
616
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
617
                                       (short *)audio_buf);
618
            audio_size += ret;
619
            pkt.stream_index= ost->index;
620
            pkt.data= audio_out;
621
            pkt.size= ret;
622
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
623
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
624
            pkt.flags |= PKT_FLAG_KEY;
625
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
626

    
627
            ost->sync_opts += enc->frame_size;
628
        }
629
    } else {
630
        AVPacket pkt;
631
        av_init_packet(&pkt);
632

    
633
        ost->sync_opts += size_out / (2 * enc->channels);
634

    
635
        /* output a pcm frame */
636
        /* XXX: change encoding codec API to avoid this ? */
637
        switch(enc->codec->id) {
638
        case CODEC_ID_PCM_S32LE:
639
        case CODEC_ID_PCM_S32BE:
640
        case CODEC_ID_PCM_U32LE:
641
        case CODEC_ID_PCM_U32BE:
642
        case CODEC_ID_PCM_F32BE:
643
            size_out = size_out << 1;
644
            break;
645
        case CODEC_ID_PCM_S24LE:
646
        case CODEC_ID_PCM_S24BE:
647
        case CODEC_ID_PCM_U24LE:
648
        case CODEC_ID_PCM_U24BE:
649
        case CODEC_ID_PCM_S24DAUD:
650
            size_out = size_out / 2 * 3;
651
            break;
652
        case CODEC_ID_PCM_S16LE:
653
        case CODEC_ID_PCM_S16BE:
654
        case CODEC_ID_PCM_U16LE:
655
        case CODEC_ID_PCM_U16BE:
656
            break;
657
        default:
658
            size_out = size_out >> 1;
659
            break;
660
        }
661
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
662
        ret = avcodec_encode_audio(enc, audio_out, size_out,
663
                                   (short *)buftmp);
664
        audio_size += ret;
665
        pkt.stream_index= ost->index;
666
        pkt.data= audio_out;
667
        pkt.size= ret;
668
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
669
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
670
        pkt.flags |= PKT_FLAG_KEY;
671
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
672
    }
673
}
674

    
675
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
676
{
677
    AVCodecContext *dec;
678
    AVPicture *picture2;
679
    AVPicture picture_tmp;
680
    uint8_t *buf = 0;
681

    
682
    dec = ist->st->codec;
683

    
684
    /* deinterlace : must be done before any resize */
685
    if (do_deinterlace || using_vhook) {
686
        int size;
687

    
688
        /* create temporary picture */
689
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
690
        buf = av_malloc(size);
691
        if (!buf)
692
            return;
693

    
694
        picture2 = &picture_tmp;
695
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
696

    
697
        if (do_deinterlace){
698
            if(avpicture_deinterlace(picture2, picture,
699
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
700
                /* if error, do not deinterlace */
701
                av_free(buf);
702
                buf = NULL;
703
                picture2 = picture;
704
            }
705
        } else {
706
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
707
        }
708
    } else {
709
        picture2 = picture;
710
    }
711

    
712
    if (ENABLE_VHOOK)
713
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
714
                           1000000 * ist->pts / AV_TIME_BASE);
715

    
716
    if (picture != picture2)
717
        *picture = *picture2;
718
    *bufp = buf;
719
}
720

    
721
/* we begin to correct av delay at this threshold */
722
#define AV_DELAY_MAX 0.100
723

    
724
static void do_subtitle_out(AVFormatContext *s,
725
                            AVOutputStream *ost,
726
                            AVInputStream *ist,
727
                            AVSubtitle *sub,
728
                            int64_t pts)
729
{
730
    static uint8_t *subtitle_out = NULL;
731
    int subtitle_out_max_size = 65536;
732
    int subtitle_out_size, nb, i;
733
    AVCodecContext *enc;
734
    AVPacket pkt;
735

    
736
    if (pts == AV_NOPTS_VALUE) {
737
        fprintf(stderr, "Subtitle packets must have a pts\n");
738
        return;
739
    }
740

    
741
    enc = ost->st->codec;
742

    
743
    if (!subtitle_out) {
744
        subtitle_out = av_malloc(subtitle_out_max_size);
745
    }
746

    
747
    /* Note: DVB subtitle need one packet to draw them and one other
748
       packet to clear them */
749
    /* XXX: signal it in the codec context ? */
750
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
751
        nb = 2;
752
    else
753
        nb = 1;
754

    
755
    for(i = 0; i < nb; i++) {
756
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
757
                                                    subtitle_out_max_size, sub);
758

    
759
        av_init_packet(&pkt);
760
        pkt.stream_index = ost->index;
761
        pkt.data = subtitle_out;
762
        pkt.size = subtitle_out_size;
763
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
764
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
765
            /* XXX: the pts correction is handled here. Maybe handling
766
               it in the codec would be better */
767
            if (i == 0)
768
                pkt.pts += 90 * sub->start_display_time;
769
            else
770
                pkt.pts += 90 * sub->end_display_time;
771
        }
772
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
773
    }
774
}
775

    
776
static int bit_buffer_size= 1024*256;
777
static uint8_t *bit_buffer= NULL;
778

    
779
static void do_video_out(AVFormatContext *s,
780
                         AVOutputStream *ost,
781
                         AVInputStream *ist,
782
                         AVFrame *in_picture,
783
                         int *frame_size)
784
{
785
    int nb_frames, i, ret;
786
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
787
    AVFrame picture_crop_temp, picture_pad_temp;
788
    AVCodecContext *enc, *dec;
789

    
790
    avcodec_get_frame_defaults(&picture_crop_temp);
791
    avcodec_get_frame_defaults(&picture_pad_temp);
792

    
793
    enc = ost->st->codec;
794
    dec = ist->st->codec;
795

    
796
    /* by default, we output a single frame */
797
    nb_frames = 1;
798

    
799
    *frame_size = 0;
800

    
801
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
802
        double vdelta;
803
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
804
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
805
        if (vdelta < -1.1)
806
            nb_frames = 0;
807
        else if (video_sync_method == 2)
808
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
809
        else if (vdelta > 1.1)
810
            nb_frames = lrintf(vdelta);
811
//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);
812
        if (nb_frames == 0){
813
            ++nb_frames_drop;
814
            if (verbose>2)
815
                fprintf(stderr, "*** drop!\n");
816
        }else if (nb_frames > 1) {
817
            nb_frames_dup += nb_frames;
818
            if (verbose>2)
819
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
820
        }
821
    }else
822
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
823

    
824
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
825
    if (nb_frames <= 0)
826
        return;
827

    
828
    if (ost->video_crop) {
829
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
830
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
831
            return;
832
        }
833
        formatted_picture = &picture_crop_temp;
834
    } else {
835
        formatted_picture = in_picture;
836
    }
837

    
838
    final_picture = formatted_picture;
839
    padding_src = formatted_picture;
840
    resampling_dst = &ost->pict_tmp;
841
    if (ost->video_pad) {
842
        final_picture = &ost->pict_tmp;
843
        if (ost->video_resample) {
844
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
845
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
846
                return;
847
            }
848
            resampling_dst = &picture_pad_temp;
849
        }
850
    }
851

    
852
    if (ost->video_resample) {
853
        padding_src = NULL;
854
        final_picture = &ost->pict_tmp;
855
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
856
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
857
    }
858

    
859
    if (ost->video_pad) {
860
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
861
                enc->height, enc->width, enc->pix_fmt,
862
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
863
    }
864

    
865
    /* duplicates frame if needed */
866
    for(i=0;i<nb_frames;i++) {
867
        AVPacket pkt;
868
        av_init_packet(&pkt);
869
        pkt.stream_index= ost->index;
870

    
871
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
872
            /* raw pictures are written as AVPicture structure to
873
               avoid any copies. We support temorarily the older
874
               method. */
875
            AVFrame* old_frame = enc->coded_frame;
876
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
877
            pkt.data= (uint8_t *)final_picture;
878
            pkt.size=  sizeof(AVPicture);
879
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
880
            pkt.flags |= PKT_FLAG_KEY;
881

    
882
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
883
            enc->coded_frame = old_frame;
884
        } else {
885
            AVFrame big_picture;
886

    
887
            big_picture= *final_picture;
888
            /* better than nothing: use input picture interlaced
889
               settings */
890
            big_picture.interlaced_frame = in_picture->interlaced_frame;
891
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
892
                if(top_field_first == -1)
893
                    big_picture.top_field_first = in_picture->top_field_first;
894
                else
895
                    big_picture.top_field_first = top_field_first;
896
            }
897

    
898
            /* handles sameq here. This is not correct because it may
899
               not be a global option */
900
            if (same_quality) {
901
                big_picture.quality = ist->st->quality;
902
            }else
903
                big_picture.quality = ost->st->quality;
904
            if(!me_threshold)
905
                big_picture.pict_type = 0;
906
//            big_picture.pts = AV_NOPTS_VALUE;
907
            big_picture.pts= ost->sync_opts;
908
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
909
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
910
            ret = avcodec_encode_video(enc,
911
                                       bit_buffer, bit_buffer_size,
912
                                       &big_picture);
913
            if (ret == -1) {
914
                fprintf(stderr, "Video encoding failed\n");
915
                av_exit(1);
916
            }
917
            //enc->frame_number = enc->real_pict_num;
918
            if(ret>0){
919
                pkt.data= bit_buffer;
920
                pkt.size= ret;
921
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
922
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
923
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
924
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
925
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
926

    
927
                if(enc->coded_frame->key_frame)
928
                    pkt.flags |= PKT_FLAG_KEY;
929
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
930
                *frame_size = ret;
931
                video_size += ret;
932
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
933
                //        enc->frame_number-1, enc->real_pict_num, ret,
934
                //        enc->pict_type);
935
                /* if two pass, output log */
936
                if (ost->logfile && enc->stats_out) {
937
                    fprintf(ost->logfile, "%s", enc->stats_out);
938
                }
939
            }
940
        }
941
        ost->sync_opts++;
942
        ost->frame_number++;
943
    }
944
}
945

    
946
static double psnr(double d){
947
    return -10.0*log(d)/log(10.0);
948
}
949

    
950
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
951
                           int frame_size)
952
{
953
    AVCodecContext *enc;
954
    int frame_number;
955
    double ti1, bitrate, avg_bitrate;
956

    
957
    /* this is executed just the first time do_video_stats is called */
958
    if (!vstats_file) {
959
        vstats_file = fopen(vstats_filename, "w");
960
        if (!vstats_file) {
961
            perror("fopen");
962
            av_exit(1);
963
        }
964
    }
965

    
966
    enc = ost->st->codec;
967
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
968
        frame_number = ost->frame_number;
969
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
970
        if (enc->flags&CODEC_FLAG_PSNR)
971
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
972

    
973
        fprintf(vstats_file,"f_size= %6d ", frame_size);
974
        /* compute pts value */
975
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
976
        if (ti1 < 0.01)
977
            ti1 = 0.01;
978

    
979
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
980
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
981
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
982
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
983
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
984
    }
985
}
986

    
987
static void print_report(AVFormatContext **output_files,
988
                         AVOutputStream **ost_table, int nb_ostreams,
989
                         int is_last_report)
990
{
991
    char buf[1024];
992
    AVOutputStream *ost;
993
    AVFormatContext *oc, *os;
994
    int64_t total_size;
995
    AVCodecContext *enc;
996
    int frame_number, vid, i;
997
    double bitrate, ti1, pts;
998
    static int64_t last_time = -1;
999
    static int qp_histogram[52];
1000

    
1001
    if (!is_last_report) {
1002
        int64_t cur_time;
1003
        /* display the report every 0.5 seconds */
1004
        cur_time = av_gettime();
1005
        if (last_time == -1) {
1006
            last_time = cur_time;
1007
            return;
1008
        }
1009
        if ((cur_time - last_time) < 500000)
1010
            return;
1011
        last_time = cur_time;
1012
    }
1013

    
1014

    
1015
    oc = output_files[0];
1016

    
1017
    total_size = url_fsize(oc->pb);
1018
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1019
        total_size= url_ftell(oc->pb);
1020

    
1021
    buf[0] = '\0';
1022
    ti1 = 1e10;
1023
    vid = 0;
1024
    for(i=0;i<nb_ostreams;i++) {
1025
        ost = ost_table[i];
1026
        os = output_files[ost->file_index];
1027
        enc = ost->st->codec;
1028
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1029
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1030
                     !ost->st->stream_copy ?
1031
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1032
        }
1033
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1034
            float t = (av_gettime()-timer_start) / 1000000.0;
1035

    
1036
            frame_number = ost->frame_number;
1037
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1038
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1039
                     !ost->st->stream_copy ?
1040
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1041
            if(is_last_report)
1042
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1043
            if(qp_hist){
1044
                int j;
1045
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1046
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1047
                    qp_histogram[qp]++;
1048
                for(j=0; j<32; j++)
1049
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1050
            }
1051
            if (enc->flags&CODEC_FLAG_PSNR){
1052
                int j;
1053
                double error, error_sum=0;
1054
                double scale, scale_sum=0;
1055
                char type[3]= {'Y','U','V'};
1056
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1057
                for(j=0; j<3; j++){
1058
                    if(is_last_report){
1059
                        error= enc->error[j];
1060
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1061
                    }else{
1062
                        error= enc->coded_frame->error[j];
1063
                        scale= enc->width*enc->height*255.0*255.0;
1064
                    }
1065
                    if(j) scale/=4;
1066
                    error_sum += error;
1067
                    scale_sum += scale;
1068
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1069
                }
1070
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1071
            }
1072
            vid = 1;
1073
        }
1074
        /* compute min output value */
1075
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1076
        if ((pts < ti1) && (pts > 0))
1077
            ti1 = pts;
1078
    }
1079
    if (ti1 < 0.01)
1080
        ti1 = 0.01;
1081

    
1082
    if (verbose || is_last_report) {
1083
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1084

    
1085
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1086
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1087
            (double)total_size / 1024, ti1, bitrate);
1088

    
1089
        if (verbose > 1)
1090
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1091
                  nb_frames_dup, nb_frames_drop);
1092

    
1093
        if (verbose >= 0)
1094
            fprintf(stderr, "%s    \r", buf);
1095

    
1096
        fflush(stderr);
1097
    }
1098

    
1099
    if (is_last_report && verbose >= 0){
1100
        int64_t raw= audio_size + video_size + extra_size;
1101
        fprintf(stderr, "\n");
1102
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1103
                video_size/1024.0,
1104
                audio_size/1024.0,
1105
                extra_size/1024.0,
1106
                100.0*(total_size - raw)/raw
1107
        );
1108
    }
1109
}
1110

    
1111
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1112
static int output_packet(AVInputStream *ist, int ist_index,
1113
                         AVOutputStream **ost_table, int nb_ostreams,
1114
                         const AVPacket *pkt)
1115
{
1116
    AVFormatContext *os;
1117
    AVOutputStream *ost;
1118
    uint8_t *ptr;
1119
    int len, ret, i;
1120
    uint8_t *data_buf;
1121
    int data_size, got_picture;
1122
    AVFrame picture;
1123
    void *buffer_to_free;
1124
    static unsigned int samples_size= 0;
1125
    static short *samples= NULL;
1126
    AVSubtitle subtitle, *subtitle_to_free;
1127
    int got_subtitle;
1128

    
1129
    if(ist->next_pts == AV_NOPTS_VALUE)
1130
        ist->next_pts= ist->pts;
1131

    
1132
    if (pkt == NULL) {
1133
        /* EOF handling */
1134
        ptr = NULL;
1135
        len = 0;
1136
        goto handle_eof;
1137
    }
1138

    
1139
    if(pkt->dts != AV_NOPTS_VALUE)
1140
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1141

    
1142
    len = pkt->size;
1143
    ptr = pkt->data;
1144

    
1145
    //while we have more to decode or while the decoder did output something on EOF
1146
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1147
    handle_eof:
1148
        ist->pts= ist->next_pts;
1149

    
1150
        if(len && len != pkt->size && verbose>0)
1151
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1152

    
1153
        /* decode the packet if needed */
1154
        data_buf = NULL; /* fail safe */
1155
        data_size = 0;
1156
        subtitle_to_free = NULL;
1157
        if (ist->decoding_needed) {
1158
            switch(ist->st->codec->codec_type) {
1159
            case CODEC_TYPE_AUDIO:{
1160
                if(pkt)
1161
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1162
                data_size= samples_size;
1163
                    /* XXX: could avoid copy if PCM 16 bits with same
1164
                       endianness as CPU */
1165
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1166
                                           ptr, len);
1167
                if (ret < 0)
1168
                    goto fail_decode;
1169
                ptr += ret;
1170
                len -= ret;
1171
                /* Some bug in mpeg audio decoder gives */
1172
                /* data_size < 0, it seems they are overflows */
1173
                if (data_size <= 0) {
1174
                    /* no audio frame */
1175
                    continue;
1176
                }
1177
                data_buf = (uint8_t *)samples;
1178
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1179
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1180
                break;}
1181
            case CODEC_TYPE_VIDEO:
1182
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1183
                    /* XXX: allocate picture correctly */
1184
                    avcodec_get_frame_defaults(&picture);
1185

    
1186
                    ret = avcodec_decode_video(ist->st->codec,
1187
                                               &picture, &got_picture, ptr, len);
1188
                    ist->st->quality= picture.quality;
1189
                    if (ret < 0)
1190
                        goto fail_decode;
1191
                    if (!got_picture) {
1192
                        /* no picture yet */
1193
                        goto discard_packet;
1194
                    }
1195
                    if (ist->st->codec->time_base.num != 0) {
1196
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1197
                                          ist->st->codec->time_base.num) /
1198
                            ist->st->codec->time_base.den;
1199
                    }
1200
                    len = 0;
1201
                    break;
1202
            case CODEC_TYPE_SUBTITLE:
1203
                ret = avcodec_decode_subtitle(ist->st->codec,
1204
                                              &subtitle, &got_subtitle, ptr, len);
1205
                if (ret < 0)
1206
                    goto fail_decode;
1207
                if (!got_subtitle) {
1208
                    goto discard_packet;
1209
                }
1210
                subtitle_to_free = &subtitle;
1211
                len = 0;
1212
                break;
1213
            default:
1214
                goto fail_decode;
1215
            }
1216
        } else {
1217
            switch(ist->st->codec->codec_type) {
1218
            case CODEC_TYPE_AUDIO:
1219
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1220
                    ist->st->codec->sample_rate;
1221
                break;
1222
            case CODEC_TYPE_VIDEO:
1223
                if (ist->st->codec->time_base.num != 0) {
1224
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1225
                                      ist->st->codec->time_base.num) /
1226
                        ist->st->codec->time_base.den;
1227
                }
1228
                break;
1229
            }
1230
            data_buf = ptr;
1231
            data_size = len;
1232
            ret = len;
1233
            len = 0;
1234
        }
1235

    
1236
        buffer_to_free = NULL;
1237
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1238
            pre_process_video_frame(ist, (AVPicture *)&picture,
1239
                                    &buffer_to_free);
1240
        }
1241

    
1242
        // preprocess audio (volume)
1243
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1244
            if (audio_volume != 256) {
1245
                short *volp;
1246
                volp = samples;
1247
                for(i=0;i<(data_size / sizeof(short));i++) {
1248
                    int v = ((*volp) * audio_volume + 128) >> 8;
1249
                    if (v < -32768) v = -32768;
1250
                    if (v >  32767) v = 32767;
1251
                    *volp++ = v;
1252
                }
1253
            }
1254
        }
1255

    
1256
        /* frame rate emulation */
1257
        if (ist->st->codec->rate_emu) {
1258
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1259
            int64_t now = av_gettime() - ist->start;
1260
            if (pts > now)
1261
                usleep(pts - now);
1262

    
1263
            ist->frame++;
1264
        }
1265

    
1266
#if 0
1267
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1268
           is the one of the next displayed one */
1269
        /* XXX: add mpeg4 too ? */
1270
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1271
            if (ist->st->codec->pict_type != B_TYPE) {
1272
                int64_t tmp;
1273
                tmp = ist->last_ip_pts;
1274
                ist->last_ip_pts  = ist->frac_pts.val;
1275
                ist->frac_pts.val = tmp;
1276
            }
1277
        }
1278
#endif
1279
        /* if output time reached then transcode raw format,
1280
           encode packets and output them */
1281
        if (start_time == 0 || ist->pts >= start_time)
1282
            for(i=0;i<nb_ostreams;i++) {
1283
                int frame_size;
1284

    
1285
                ost = ost_table[i];
1286
                if (ost->source_index == ist_index) {
1287
                    os = output_files[ost->file_index];
1288

    
1289
#if 0
1290
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1291
                           (double)pkt->pts / AV_TIME_BASE,
1292
                           ((double)ist->pts / AV_TIME_BASE) -
1293
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1294
#endif
1295
                    /* set the input output pts pairs */
1296
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1297

    
1298
                    if (ost->encoding_needed) {
1299
                        switch(ost->st->codec->codec_type) {
1300
                        case CODEC_TYPE_AUDIO:
1301
                            do_audio_out(os, ost, ist, data_buf, data_size);
1302
                            break;
1303
                        case CODEC_TYPE_VIDEO:
1304
                            do_video_out(os, ost, ist, &picture, &frame_size);
1305
                            if (vstats_filename && frame_size)
1306
                                do_video_stats(os, ost, frame_size);
1307
                            break;
1308
                        case CODEC_TYPE_SUBTITLE:
1309
                            do_subtitle_out(os, ost, ist, &subtitle,
1310
                                            pkt->pts);
1311
                            break;
1312
                        default:
1313
                            abort();
1314
                        }
1315
                    } else {
1316
                        AVFrame avframe; //FIXME/XXX remove this
1317
                        AVPacket opkt;
1318
                        av_init_packet(&opkt);
1319

    
1320
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1321
                            continue;
1322

    
1323
                        /* no reencoding needed : output the packet directly */
1324
                        /* force the input stream PTS */
1325

    
1326
                        avcodec_get_frame_defaults(&avframe);
1327
                        ost->st->codec->coded_frame= &avframe;
1328
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1329

    
1330
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1331
                            audio_size += data_size;
1332
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1333
                            video_size += data_size;
1334
                            ost->sync_opts++;
1335
                        }
1336

    
1337
                        opkt.stream_index= ost->index;
1338
                        if(pkt->pts != AV_NOPTS_VALUE)
1339
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1340
                        else
1341
                            opkt.pts= AV_NOPTS_VALUE;
1342

    
1343
                        if (pkt->dts == AV_NOPTS_VALUE)
1344
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1345
                        else
1346
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1347

    
1348
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1349
                        opkt.flags= pkt->flags;
1350

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

    
1355
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1356
                        ost->st->codec->frame_number++;
1357
                        ost->frame_number++;
1358
                        av_free_packet(&opkt);
1359
                    }
1360
                }
1361
            }
1362
        av_free(buffer_to_free);
1363
        /* XXX: allocate the subtitles in the codec ? */
1364
        if (subtitle_to_free) {
1365
            if (subtitle_to_free->rects != NULL) {
1366
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1367
                    av_free(subtitle_to_free->rects[i].bitmap);
1368
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1369
                }
1370
                av_freep(&subtitle_to_free->rects);
1371
            }
1372
            subtitle_to_free->num_rects = 0;
1373
            subtitle_to_free = NULL;
1374
        }
1375
    }
1376
 discard_packet:
1377
    if (pkt == NULL) {
1378
        /* EOF handling */
1379

    
1380
        for(i=0;i<nb_ostreams;i++) {
1381
            ost = ost_table[i];
1382
            if (ost->source_index == ist_index) {
1383
                AVCodecContext *enc= ost->st->codec;
1384
                os = output_files[ost->file_index];
1385

    
1386
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1387
                    continue;
1388
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1389
                    continue;
1390

    
1391
                if (ost->encoding_needed) {
1392
                    for(;;) {
1393
                        AVPacket pkt;
1394
                        int fifo_bytes;
1395
                        av_init_packet(&pkt);
1396
                        pkt.stream_index= ost->index;
1397

    
1398
                        switch(ost->st->codec->codec_type) {
1399
                        case CODEC_TYPE_AUDIO:
1400
                            fifo_bytes = av_fifo_size(&ost->fifo);
1401
                            ret = 0;
1402
                            /* encode any samples remaining in fifo */
1403
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1404
                                int fs_tmp = enc->frame_size;
1405
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1406
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1407
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1408
                                enc->frame_size = fs_tmp;
1409
                            }
1410
                            if(ret <= 0) {
1411
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1412
                            }
1413
                            audio_size += ret;
1414
                            pkt.flags |= PKT_FLAG_KEY;
1415
                            break;
1416
                        case CODEC_TYPE_VIDEO:
1417
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1418
                            video_size += ret;
1419
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1420
                                pkt.flags |= PKT_FLAG_KEY;
1421
                            if (ost->logfile && enc->stats_out) {
1422
                                fprintf(ost->logfile, "%s", enc->stats_out);
1423
                            }
1424
                            break;
1425
                        default:
1426
                            ret=-1;
1427
                        }
1428

    
1429
                        if(ret<=0)
1430
                            break;
1431
                        pkt.data= bit_buffer;
1432
                        pkt.size= ret;
1433
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1434
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1435
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1436
                    }
1437
                }
1438
            }
1439
        }
1440
    }
1441

    
1442
    return 0;
1443
 fail_decode:
1444
    return -1;
1445
}
1446

    
1447
static void print_sdp(AVFormatContext **avc, int n)
1448
{
1449
    char sdp[2048];
1450

    
1451
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1452
    printf("SDP:\n%s\n", sdp);
1453
}
1454

    
1455
static int stream_index_from_inputs(AVFormatContext **input_files,
1456
                                    int nb_input_files,
1457
                                    AVInputFile *file_table,
1458
                                    AVInputStream **ist_table,
1459
                                    enum CodecType type,
1460
                                    int programid)
1461
{
1462
    int p, q, z;
1463
    for(z=0; z<nb_input_files; z++) {
1464
        AVFormatContext *ic = input_files[z];
1465
        for(p=0; p<ic->nb_programs; p++) {
1466
            AVProgram *program = ic->programs[p];
1467
            if(program->id != programid)
1468
                continue;
1469
            for(q=0; q<program->nb_stream_indexes; q++) {
1470
                int sidx = program->stream_index[q];
1471
                int ris = file_table[z].ist_index + sidx;
1472
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1473
                    return ris;
1474
            }
1475
        }
1476
    }
1477

    
1478
    return -1;
1479
}
1480

    
1481
/*
1482
 * The following code is the main loop of the file converter
1483
 */
1484
static int av_encode(AVFormatContext **output_files,
1485
                     int nb_output_files,
1486
                     AVFormatContext **input_files,
1487
                     int nb_input_files,
1488
                     AVStreamMap *stream_maps, int nb_stream_maps)
1489
{
1490
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1491
    AVFormatContext *is, *os;
1492
    AVCodecContext *codec, *icodec;
1493
    AVOutputStream *ost, **ost_table = NULL;
1494
    AVInputStream *ist, **ist_table = NULL;
1495
    AVInputFile *file_table;
1496
    int key;
1497
    int want_sdp = 1;
1498

    
1499
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1500
    if (!file_table)
1501
        goto fail;
1502

    
1503
    /* input stream init */
1504
    j = 0;
1505
    for(i=0;i<nb_input_files;i++) {
1506
        is = input_files[i];
1507
        file_table[i].ist_index = j;
1508
        file_table[i].nb_streams = is->nb_streams;
1509
        j += is->nb_streams;
1510
    }
1511
    nb_istreams = j;
1512

    
1513
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1514
    if (!ist_table)
1515
        goto fail;
1516

    
1517
    for(i=0;i<nb_istreams;i++) {
1518
        ist = av_mallocz(sizeof(AVInputStream));
1519
        if (!ist)
1520
            goto fail;
1521
        ist_table[i] = ist;
1522
    }
1523
    j = 0;
1524
    for(i=0;i<nb_input_files;i++) {
1525
        is = input_files[i];
1526
        for(k=0;k<is->nb_streams;k++) {
1527
            ist = ist_table[j++];
1528
            ist->st = is->streams[k];
1529
            ist->file_index = i;
1530
            ist->index = k;
1531
            ist->discard = 1; /* the stream is discarded by default
1532
                                 (changed later) */
1533

    
1534
            if (ist->st->codec->rate_emu) {
1535
                ist->start = av_gettime();
1536
                ist->frame = 0;
1537
            }
1538
        }
1539
    }
1540

    
1541
    /* output stream init */
1542
    nb_ostreams = 0;
1543
    for(i=0;i<nb_output_files;i++) {
1544
        os = output_files[i];
1545
        if (!os->nb_streams) {
1546
            fprintf(stderr, "Output file does not contain any stream\n");
1547
            av_exit(1);
1548
        }
1549
        nb_ostreams += os->nb_streams;
1550
    }
1551
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1552
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1553
        av_exit(1);
1554
    }
1555

    
1556
    /* Sanity check the mapping args -- do the input files & streams exist? */
1557
    for(i=0;i<nb_stream_maps;i++) {
1558
        int fi = stream_maps[i].file_index;
1559
        int si = stream_maps[i].stream_index;
1560

    
1561
        if (fi < 0 || fi > nb_input_files - 1 ||
1562
            si < 0 || si > file_table[fi].nb_streams - 1) {
1563
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1564
            av_exit(1);
1565
        }
1566
        fi = stream_maps[i].sync_file_index;
1567
        si = stream_maps[i].sync_stream_index;
1568
        if (fi < 0 || fi > nb_input_files - 1 ||
1569
            si < 0 || si > file_table[fi].nb_streams - 1) {
1570
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1571
            av_exit(1);
1572
        }
1573
    }
1574

    
1575
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1576
    if (!ost_table)
1577
        goto fail;
1578
    for(i=0;i<nb_ostreams;i++) {
1579
        ost = av_mallocz(sizeof(AVOutputStream));
1580
        if (!ost)
1581
            goto fail;
1582
        ost_table[i] = ost;
1583
    }
1584

    
1585
    n = 0;
1586
    for(k=0;k<nb_output_files;k++) {
1587
        os = output_files[k];
1588
        for(i=0;i<os->nb_streams;i++) {
1589
            int found;
1590
            ost = ost_table[n++];
1591
            ost->file_index = k;
1592
            ost->index = i;
1593
            ost->st = os->streams[i];
1594
            if (nb_stream_maps > 0) {
1595
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1596
                    stream_maps[n-1].stream_index;
1597

    
1598
                /* Sanity check that the stream types match */
1599
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1600
                    int i= ost->file_index;
1601
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1602
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1603
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1604
                        ost->file_index, ost->index);
1605
                    av_exit(1);
1606
                }
1607

    
1608
            } else {
1609
                if(opt_programid) {
1610
                    found = 0;
1611
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1612
                    if(j != -1) {
1613
                        ost->source_index = j;
1614
                        found = 1;
1615
                    }
1616
                } else {
1617
                    /* get corresponding input stream index : we select the first one with the right type */
1618
                    found = 0;
1619
                    for(j=0;j<nb_istreams;j++) {
1620
                        ist = ist_table[j];
1621
                        if (ist->discard &&
1622
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1623
                            ost->source_index = j;
1624
                            found = 1;
1625
                            break;
1626
                        }
1627
                    }
1628
                }
1629

    
1630
                if (!found) {
1631
                    if(! opt_programid) {
1632
                        /* try again and reuse existing stream */
1633
                        for(j=0;j<nb_istreams;j++) {
1634
                            ist = ist_table[j];
1635
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1636
                                ost->source_index = j;
1637
                                found = 1;
1638
                            }
1639
                        }
1640
                    }
1641
                    if (!found) {
1642
                        int i= ost->file_index;
1643
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1644
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1645
                                ost->file_index, ost->index);
1646
                        av_exit(1);
1647
                    }
1648
                }
1649
            }
1650
            ist = ist_table[ost->source_index];
1651
            ist->discard = 0;
1652
            ost->sync_ist = (nb_stream_maps > 0) ?
1653
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1654
                         stream_maps[n-1].sync_stream_index] : ist;
1655
        }
1656
    }
1657

    
1658
    /* for each output stream, we compute the right encoding parameters */
1659
    for(i=0;i<nb_ostreams;i++) {
1660
        ost = ost_table[i];
1661
        os = output_files[ost->file_index];
1662
        ist = ist_table[ost->source_index];
1663

    
1664
        codec = ost->st->codec;
1665
        icodec = ist->st->codec;
1666

    
1667
        if (!ost->st->language[0])
1668
            av_strlcpy(ost->st->language, ist->st->language,
1669
                       sizeof(ost->st->language));
1670

    
1671
        ost->st->disposition = ist->st->disposition;
1672

    
1673
        if (ost->st->stream_copy) {
1674
            /* if stream_copy is selected, no need to decode or encode */
1675
            codec->codec_id = icodec->codec_id;
1676
            codec->codec_type = icodec->codec_type;
1677

    
1678
            if(!codec->codec_tag){
1679
                if(   !os->oformat->codec_tag
1680
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1681
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1682
                    codec->codec_tag = icodec->codec_tag;
1683
            }
1684

    
1685
            codec->bit_rate = icodec->bit_rate;
1686
            codec->extradata= icodec->extradata;
1687
            codec->extradata_size= icodec->extradata_size;
1688
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1689
                codec->time_base = icodec->time_base;
1690
            else
1691
                codec->time_base = ist->st->time_base;
1692
            switch(codec->codec_type) {
1693
            case CODEC_TYPE_AUDIO:
1694
                if(audio_volume != 256) {
1695
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1696
                    av_exit(1);
1697
                }
1698
                codec->sample_rate = icodec->sample_rate;
1699
                codec->channels = icodec->channels;
1700
                codec->frame_size = icodec->frame_size;
1701
                codec->block_align= icodec->block_align;
1702
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1703
                    codec->block_align= 0;
1704
                if(codec->codec_id == CODEC_ID_AC3)
1705
                    codec->block_align= 0;
1706
                break;
1707
            case CODEC_TYPE_VIDEO:
1708
                if(using_vhook) {
1709
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1710
                    av_exit(1);
1711
                }
1712
                codec->pix_fmt = icodec->pix_fmt;
1713
                codec->width = icodec->width;
1714
                codec->height = icodec->height;
1715
                codec->has_b_frames = icodec->has_b_frames;
1716
                break;
1717
            case CODEC_TYPE_SUBTITLE:
1718
                break;
1719
            default:
1720
                abort();
1721
            }
1722
        } else {
1723
            switch(codec->codec_type) {
1724
            case CODEC_TYPE_AUDIO:
1725
                if (av_fifo_init(&ost->fifo, 1024))
1726
                    goto fail;
1727
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1728
                icodec->request_channels = codec->channels;
1729
                ist->decoding_needed = 1;
1730
                ost->encoding_needed = 1;
1731
                break;
1732
            case CODEC_TYPE_VIDEO:
1733
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1734
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1735
                ost->video_resample = ((codec->width != icodec->width -
1736
                                (frame_leftBand + frame_rightBand) +
1737
                                (frame_padleft + frame_padright)) ||
1738
                        (codec->height != icodec->height -
1739
                                (frame_topBand  + frame_bottomBand) +
1740
                                (frame_padtop + frame_padbottom)) ||
1741
                        (codec->pix_fmt != icodec->pix_fmt));
1742
                if (ost->video_crop) {
1743
                    ost->topBand = frame_topBand;
1744
                    ost->leftBand = frame_leftBand;
1745
                }
1746
                if (ost->video_pad) {
1747
                    ost->padtop = frame_padtop;
1748
                    ost->padleft = frame_padleft;
1749
                    ost->padbottom = frame_padbottom;
1750
                    ost->padright = frame_padright;
1751
                    if (!ost->video_resample) {
1752
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1753
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1754
                                         codec->width, codec->height))
1755
                            goto fail;
1756
                    }
1757
                }
1758
                if (ost->video_resample) {
1759
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1760
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1761
                                         codec->width, codec->height)) {
1762
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1763
                        av_exit(1);
1764
                    }
1765
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1766
                    ost->img_resample_ctx = sws_getContext(
1767
                            icodec->width - (frame_leftBand + frame_rightBand),
1768
                            icodec->height - (frame_topBand + frame_bottomBand),
1769
                            icodec->pix_fmt,
1770
                            codec->width - (frame_padleft + frame_padright),
1771
                            codec->height - (frame_padtop + frame_padbottom),
1772
                            codec->pix_fmt,
1773
                            sws_flags, NULL, NULL, NULL);
1774
                    if (ost->img_resample_ctx == NULL) {
1775
                        fprintf(stderr, "Cannot get resampling context\n");
1776
                        av_exit(1);
1777
                    }
1778
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1779
                }
1780
                ost->encoding_needed = 1;
1781
                ist->decoding_needed = 1;
1782
                break;
1783
            case CODEC_TYPE_SUBTITLE:
1784
                ost->encoding_needed = 1;
1785
                ist->decoding_needed = 1;
1786
                break;
1787
            default:
1788
                abort();
1789
                break;
1790
            }
1791
            /* two pass mode */
1792
            if (ost->encoding_needed &&
1793
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1794
                char logfilename[1024];
1795
                FILE *f;
1796
                int size;
1797
                char *logbuffer;
1798

    
1799
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1800
                         pass_logfilename ?
1801
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1802
                if (codec->flags & CODEC_FLAG_PASS1) {
1803
                    f = fopen(logfilename, "w");
1804
                    if (!f) {
1805
                        perror(logfilename);
1806
                        av_exit(1);
1807
                    }
1808
                    ost->logfile = f;
1809
                } else {
1810
                    /* read the log file */
1811
                    f = fopen(logfilename, "r");
1812
                    if (!f) {
1813
                        perror(logfilename);
1814
                        av_exit(1);
1815
                    }
1816
                    fseek(f, 0, SEEK_END);
1817
                    size = ftell(f);
1818
                    fseek(f, 0, SEEK_SET);
1819
                    logbuffer = av_malloc(size + 1);
1820
                    if (!logbuffer) {
1821
                        fprintf(stderr, "Could not allocate log buffer\n");
1822
                        av_exit(1);
1823
                    }
1824
                    size = fread(logbuffer, 1, size, f);
1825
                    fclose(f);
1826
                    logbuffer[size] = '\0';
1827
                    codec->stats_in = logbuffer;
1828
                }
1829
            }
1830
        }
1831
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1832
            int size= codec->width * codec->height;
1833
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1834
        }
1835
    }
1836

    
1837
    if (!bit_buffer)
1838
        bit_buffer = av_malloc(bit_buffer_size);
1839
    if (!bit_buffer)
1840
        goto fail;
1841

    
1842
    /* dump the file output parameters - cannot be done before in case
1843
       of stream copy */
1844
    for(i=0;i<nb_output_files;i++) {
1845
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1846
    }
1847

    
1848
    /* dump the stream mapping */
1849
    if (verbose >= 0) {
1850
        fprintf(stderr, "Stream mapping:\n");
1851
        for(i=0;i<nb_ostreams;i++) {
1852
            ost = ost_table[i];
1853
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1854
                    ist_table[ost->source_index]->file_index,
1855
                    ist_table[ost->source_index]->index,
1856
                    ost->file_index,
1857
                    ost->index);
1858
            if (ost->sync_ist != ist_table[ost->source_index])
1859
                fprintf(stderr, " [sync #%d.%d]",
1860
                        ost->sync_ist->file_index,
1861
                        ost->sync_ist->index);
1862
            fprintf(stderr, "\n");
1863
        }
1864
    }
1865

    
1866
    /* open each encoder */
1867
    for(i=0;i<nb_ostreams;i++) {
1868
        ost = ost_table[i];
1869
        if (ost->encoding_needed) {
1870
            AVCodec *codec;
1871
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1872
            if (!codec) {
1873
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1874
                        ost->file_index, ost->index);
1875
                av_exit(1);
1876
            }
1877
            if (avcodec_open(ost->st->codec, codec) < 0) {
1878
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1879
                        ost->file_index, ost->index);
1880
                av_exit(1);
1881
            }
1882
            extra_size += ost->st->codec->extradata_size;
1883
        }
1884
    }
1885

    
1886
    /* open each decoder */
1887
    for(i=0;i<nb_istreams;i++) {
1888
        ist = ist_table[i];
1889
        if (ist->decoding_needed) {
1890
            AVCodec *codec;
1891
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1892
            if (!codec) {
1893
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1894
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1895
                av_exit(1);
1896
            }
1897
            if (avcodec_open(ist->st->codec, codec) < 0) {
1898
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1899
                        ist->file_index, ist->index);
1900
                av_exit(1);
1901
            }
1902
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1903
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1904
        }
1905
    }
1906

    
1907
    /* init pts */
1908
    for(i=0;i<nb_istreams;i++) {
1909
        ist = ist_table[i];
1910
        is = input_files[ist->file_index];
1911
        ist->pts = 0;
1912
        ist->next_pts = AV_NOPTS_VALUE;
1913
        ist->is_start = 1;
1914
    }
1915

    
1916
    /* set meta data information from input file if required */
1917
    for (i=0;i<nb_meta_data_maps;i++) {
1918
        AVFormatContext *out_file;
1919
        AVFormatContext *in_file;
1920

    
1921
        int out_file_index = meta_data_maps[i].out_file;
1922
        int in_file_index = meta_data_maps[i].in_file;
1923
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1924
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1925
            ret = AVERROR(EINVAL);
1926
            goto fail;
1927
        }
1928
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1929
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1930
            ret = AVERROR(EINVAL);
1931
            goto fail;
1932
        }
1933

    
1934
        out_file = output_files[out_file_index];
1935
        in_file = input_files[in_file_index];
1936

    
1937
        strcpy(out_file->title, in_file->title);
1938
        strcpy(out_file->author, in_file->author);
1939
        strcpy(out_file->copyright, in_file->copyright);
1940
        strcpy(out_file->comment, in_file->comment);
1941
        strcpy(out_file->album, in_file->album);
1942
        out_file->year = in_file->year;
1943
        out_file->track = in_file->track;
1944
        strcpy(out_file->genre, in_file->genre);
1945
    }
1946

    
1947
    /* open files and write file headers */
1948
    for(i=0;i<nb_output_files;i++) {
1949
        os = output_files[i];
1950
        if (av_write_header(os) < 0) {
1951
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1952
            ret = AVERROR(EINVAL);
1953
            goto fail;
1954
        }
1955
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1956
            want_sdp = 0;
1957
        }
1958
    }
1959
    if (want_sdp) {
1960
        print_sdp(output_files, nb_output_files);
1961
    }
1962

    
1963
    if (!using_stdin && verbose >= 0) {
1964
        fprintf(stderr, "Press [q] to stop encoding\n");
1965
        url_set_interrupt_cb(decode_interrupt_cb);
1966
    }
1967
    term_init();
1968

    
1969
    key = -1;
1970
    timer_start = av_gettime();
1971

    
1972
    for(; received_sigterm == 0;) {
1973
        int file_index, ist_index;
1974
        AVPacket pkt;
1975
        double ipts_min;
1976
        double opts_min;
1977

    
1978
    redo:
1979
        ipts_min= 1e100;
1980
        opts_min= 1e100;
1981
        /* if 'q' pressed, exits */
1982
        if (!using_stdin) {
1983
            if (q_pressed)
1984
                break;
1985
            /* read_key() returns 0 on EOF */
1986
            key = read_key();
1987
            if (key == 'q')
1988
                break;
1989
        }
1990

    
1991
        /* select the stream that we must read now by looking at the
1992
           smallest output pts */
1993
        file_index = -1;
1994
        for(i=0;i<nb_ostreams;i++) {
1995
            double ipts, opts;
1996
            ost = ost_table[i];
1997
            os = output_files[ost->file_index];
1998
            ist = ist_table[ost->source_index];
1999
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2000
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2001
            else
2002
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2003
            ipts = (double)ist->pts;
2004
            if (!file_table[ist->file_index].eof_reached){
2005
                if(ipts < ipts_min) {
2006
                    ipts_min = ipts;
2007
                    if(input_sync ) file_index = ist->file_index;
2008
                }
2009
                if(opts < opts_min) {
2010
                    opts_min = opts;
2011
                    if(!input_sync) file_index = ist->file_index;
2012
                }
2013
            }
2014
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2015
                file_index= -1;
2016
                break;
2017
            }
2018
        }
2019
        /* if none, if is finished */
2020
        if (file_index < 0) {
2021
            break;
2022
        }
2023

    
2024
        /* finish if recording time exhausted */
2025
        if (opts_min >= (recording_time / 1000000.0))
2026
            break;
2027

    
2028
        /* finish if limit size exhausted */
2029
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2030
            break;
2031

    
2032
        /* read a frame from it and output it in the fifo */
2033
        is = input_files[file_index];
2034
        if (av_read_frame(is, &pkt) < 0) {
2035
            file_table[file_index].eof_reached = 1;
2036
            if (opt_shortest)
2037
                break;
2038
            else
2039
                continue;
2040
        }
2041

    
2042
        if (do_pkt_dump) {
2043
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2044
        }
2045
        /* the following test is needed in case new streams appear
2046
           dynamically in stream : we ignore them */
2047
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2048
            goto discard_packet;
2049
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2050
        ist = ist_table[ist_index];
2051
        if (ist->discard)
2052
            goto discard_packet;
2053

    
2054
        if (pkt.dts != AV_NOPTS_VALUE)
2055
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2056
        if (pkt.pts != AV_NOPTS_VALUE)
2057
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2058

    
2059
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2060
            if(pkt.pts != AV_NOPTS_VALUE)
2061
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2062
            if(pkt.dts != AV_NOPTS_VALUE)
2063
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2064
        }
2065

    
2066
//        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);
2067
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2068
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2069
            int64_t delta= pkt_dts - ist->next_pts;
2070
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2071
                input_files_ts_offset[ist->file_index]-= delta;
2072
                if (verbose > 2)
2073
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2074
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2075
                if(pkt.pts != AV_NOPTS_VALUE)
2076
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2077
            }
2078
        }
2079

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

    
2083
            if (verbose >= 0)
2084
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2085
                        ist->file_index, ist->index);
2086

    
2087
            av_free_packet(&pkt);
2088
            goto redo;
2089
        }
2090

    
2091
    discard_packet:
2092
        av_free_packet(&pkt);
2093

    
2094
        /* dump report by using the output first video and audio streams */
2095
        print_report(output_files, ost_table, nb_ostreams, 0);
2096
    }
2097

    
2098
    /* at the end of stream, we must flush the decoder buffers */
2099
    for(i=0;i<nb_istreams;i++) {
2100
        ist = ist_table[i];
2101
        if (ist->decoding_needed) {
2102
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2103
        }
2104
    }
2105

    
2106
    term_exit();
2107

    
2108
    /* write the trailer if needed and close file */
2109
    for(i=0;i<nb_output_files;i++) {
2110
        os = output_files[i];
2111
        av_write_trailer(os);
2112
    }
2113

    
2114
    /* dump report by using the first video and audio streams */
2115
    print_report(output_files, ost_table, nb_ostreams, 1);
2116

    
2117
    /* close each encoder */
2118
    for(i=0;i<nb_ostreams;i++) {
2119
        ost = ost_table[i];
2120
        if (ost->encoding_needed) {
2121
            av_freep(&ost->st->codec->stats_in);
2122
            avcodec_close(ost->st->codec);
2123
        }
2124
    }
2125

    
2126
    /* close each decoder */
2127
    for(i=0;i<nb_istreams;i++) {
2128
        ist = ist_table[i];
2129
        if (ist->decoding_needed) {
2130
            avcodec_close(ist->st->codec);
2131
        }
2132
    }
2133

    
2134
    /* finished ! */
2135

    
2136
    ret = 0;
2137
 fail1:
2138
    av_freep(&bit_buffer);
2139
    av_free(file_table);
2140

    
2141
    if (ist_table) {
2142
        for(i=0;i<nb_istreams;i++) {
2143
            ist = ist_table[i];
2144
            av_free(ist);
2145
        }
2146
        av_free(ist_table);
2147
    }
2148
    if (ost_table) {
2149
        for(i=0;i<nb_ostreams;i++) {
2150
            ost = ost_table[i];
2151
            if (ost) {
2152
                if (ost->logfile) {
2153
                    fclose(ost->logfile);
2154
                    ost->logfile = NULL;
2155
                }
2156
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2157
                                             initialized but set to zero */
2158
                av_free(ost->pict_tmp.data[0]);
2159
                if (ost->video_resample)
2160
                    sws_freeContext(ost->img_resample_ctx);
2161
                if (ost->resample)
2162
                    audio_resample_close(ost->resample);
2163
                av_free(ost);
2164
            }
2165
        }
2166
        av_free(ost_table);
2167
    }
2168
    return ret;
2169
 fail:
2170
    ret = AVERROR(ENOMEM);
2171
    goto fail1;
2172
}
2173

    
2174
#if 0
2175
int file_read(const char *filename)
2176
{
2177
    URLContext *h;
2178
    unsigned char buffer[1024];
2179
    int len, i;
2180

2181
    if (url_open(&h, filename, O_RDONLY) < 0) {
2182
        printf("could not open '%s'\n", filename);
2183
        return -1;
2184
    }
2185
    for(;;) {
2186
        len = url_read(h, buffer, sizeof(buffer));
2187
        if (len <= 0)
2188
            break;
2189
        for(i=0;i<len;i++) putchar(buffer[i]);
2190
    }
2191
    url_close(h);
2192
    return 0;
2193
}
2194
#endif
2195

    
2196
static void opt_format(const char *arg)
2197
{
2198
    /* compatibility stuff for pgmyuv */
2199
    if (!strcmp(arg, "pgmyuv")) {
2200
        pgmyuv_compatibility_hack=1;
2201
//        opt_image_format(arg);
2202
        arg = "image2";
2203
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2204
    }
2205

    
2206
    file_iformat = av_find_input_format(arg);
2207
    file_oformat = guess_format(arg, NULL, NULL);
2208
    if (!file_iformat && !file_oformat) {
2209
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2210
        av_exit(1);
2211
    }
2212
}
2213

    
2214
static int opt_default(const char *opt, const char *arg){
2215
    int type;
2216
    const AVOption *o= NULL;
2217
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2218

    
2219
    for(type=0; type<CODEC_TYPE_NB; type++){
2220
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2221
        if(o2)
2222
            o = av_set_string2(avctx_opts[type], opt, arg, 1);
2223
    }
2224
    if(!o)
2225
        o = av_set_string2(avformat_opts, opt, arg, 1);
2226
    if(!o)
2227
        o = av_set_string2(sws_opts, opt, arg, 1);
2228
    if(!o){
2229
        if(opt[0] == 'a')
2230
            o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2231
        else if(opt[0] == 'v')
2232
            o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2233
        else if(opt[0] == 's')
2234
            o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2235
    }
2236
    if(!o)
2237
        return -1;
2238

    
2239
//    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));
2240

    
2241
    //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
2242
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2243
    opt_names[opt_name_count++]= o->name;
2244

    
2245
    if(avctx_opts[0]->debug || avformat_opts->debug)
2246
        av_log_set_level(AV_LOG_DEBUG);
2247
    return 0;
2248
}
2249

    
2250
static void opt_video_rc_override_string(const char *arg)
2251
{
2252
    video_rc_override_string = arg;
2253
}
2254

    
2255
static int opt_me_threshold(const char *opt, const char *arg)
2256
{
2257
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2258
    return 0;
2259
}
2260

    
2261
static int opt_verbose(const char *opt, const char *arg)
2262
{
2263
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2264
    av_log_set_level(verbose);
2265
    return 0;
2266
}
2267

    
2268
static void opt_frame_rate(const char *arg)
2269
{
2270
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2271
        fprintf(stderr, "Incorrect frame rate\n");
2272
        av_exit(1);
2273
    }
2274
}
2275

    
2276
static int opt_bitrate(const char *opt, const char *arg)
2277
{
2278
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2279

    
2280
    opt_default(opt, arg);
2281

    
2282
    if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2283
        fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2284

    
2285
    return 0;
2286
}
2287

    
2288
static void opt_frame_crop_top(const char *arg)
2289
{
2290
    frame_topBand = atoi(arg);
2291
    if (frame_topBand < 0) {
2292
        fprintf(stderr, "Incorrect top crop size\n");
2293
        av_exit(1);
2294
    }
2295
    if ((frame_topBand % 2) != 0) {
2296
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2297
        av_exit(1);
2298
    }
2299
    if ((frame_topBand) >= frame_height){
2300
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2301
        av_exit(1);
2302
    }
2303
    frame_height -= frame_topBand;
2304
}
2305

    
2306
static void opt_frame_crop_bottom(const char *arg)
2307
{
2308
    frame_bottomBand = atoi(arg);
2309
    if (frame_bottomBand < 0) {
2310
        fprintf(stderr, "Incorrect bottom crop size\n");
2311
        av_exit(1);
2312
    }
2313
    if ((frame_bottomBand % 2) != 0) {
2314
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2315
        av_exit(1);
2316
    }
2317
    if ((frame_bottomBand) >= frame_height){
2318
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2319
        av_exit(1);
2320
    }
2321
    frame_height -= frame_bottomBand;
2322
}
2323

    
2324
static void opt_frame_crop_left(const char *arg)
2325
{
2326
    frame_leftBand = atoi(arg);
2327
    if (frame_leftBand < 0) {
2328
        fprintf(stderr, "Incorrect left crop size\n");
2329
        av_exit(1);
2330
    }
2331
    if ((frame_leftBand % 2) != 0) {
2332
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2333
        av_exit(1);
2334
    }
2335
    if ((frame_leftBand) >= frame_width){
2336
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2337
        av_exit(1);
2338
    }
2339
    frame_width -= frame_leftBand;
2340
}
2341

    
2342
static void opt_frame_crop_right(const char *arg)
2343
{
2344
    frame_rightBand = atoi(arg);
2345
    if (frame_rightBand < 0) {
2346
        fprintf(stderr, "Incorrect right crop size\n");
2347
        av_exit(1);
2348
    }
2349
    if ((frame_rightBand % 2) != 0) {
2350
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2351
        av_exit(1);
2352
    }
2353
    if ((frame_rightBand) >= frame_width){
2354
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2355
        av_exit(1);
2356
    }
2357
    frame_width -= frame_rightBand;
2358
}
2359

    
2360
static void opt_frame_size(const char *arg)
2361
{
2362
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2363
        fprintf(stderr, "Incorrect frame size\n");
2364
        av_exit(1);
2365
    }
2366
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2367
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2368
        av_exit(1);
2369
    }
2370
}
2371

    
2372

    
2373
#define SCALEBITS 10
2374
#define ONE_HALF  (1 << (SCALEBITS - 1))
2375
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2376

    
2377
#define RGB_TO_Y(r, g, b) \
2378
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2379
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2380

    
2381
#define RGB_TO_U(r1, g1, b1, shift)\
2382
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2383
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2384

    
2385
#define RGB_TO_V(r1, g1, b1, shift)\
2386
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2387
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2388

    
2389
static void opt_pad_color(const char *arg) {
2390
    /* Input is expected to be six hex digits similar to
2391
       how colors are expressed in html tags (but without the #) */
2392
    int rgb = strtol(arg, NULL, 16);
2393
    int r,g,b;
2394

    
2395
    r = (rgb >> 16);
2396
    g = ((rgb >> 8) & 255);
2397
    b = (rgb & 255);
2398

    
2399
    padcolor[0] = RGB_TO_Y(r,g,b);
2400
    padcolor[1] = RGB_TO_U(r,g,b,0);
2401
    padcolor[2] = RGB_TO_V(r,g,b,0);
2402
}
2403

    
2404
static void opt_frame_pad_top(const char *arg)
2405
{
2406
    frame_padtop = atoi(arg);
2407
    if (frame_padtop < 0) {
2408
        fprintf(stderr, "Incorrect top pad size\n");
2409
        av_exit(1);
2410
    }
2411
    if ((frame_padtop % 2) != 0) {
2412
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2413
        av_exit(1);
2414
    }
2415
}
2416

    
2417
static void opt_frame_pad_bottom(const char *arg)
2418
{
2419
    frame_padbottom = atoi(arg);
2420
    if (frame_padbottom < 0) {
2421
        fprintf(stderr, "Incorrect bottom pad size\n");
2422
        av_exit(1);
2423
    }
2424
    if ((frame_padbottom % 2) != 0) {
2425
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2426
        av_exit(1);
2427
    }
2428
}
2429

    
2430

    
2431
static void opt_frame_pad_left(const char *arg)
2432
{
2433
    frame_padleft = atoi(arg);
2434
    if (frame_padleft < 0) {
2435
        fprintf(stderr, "Incorrect left pad size\n");
2436
        av_exit(1);
2437
    }
2438
    if ((frame_padleft % 2) != 0) {
2439
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2440
        av_exit(1);
2441
    }
2442
}
2443

    
2444

    
2445
static void opt_frame_pad_right(const char *arg)
2446
{
2447
    frame_padright = atoi(arg);
2448
    if (frame_padright < 0) {
2449
        fprintf(stderr, "Incorrect right pad size\n");
2450
        av_exit(1);
2451
    }
2452
    if ((frame_padright % 2) != 0) {
2453
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2454
        av_exit(1);
2455
    }
2456
}
2457

    
2458
static void list_pix_fmts(void)
2459
{
2460
    int i;
2461
    char pix_fmt_str[128];
2462
    for (i=-1; i < PIX_FMT_NB; i++) {
2463
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2464
        fprintf(stdout, "%s\n", pix_fmt_str);
2465
    }
2466
}
2467

    
2468
static void opt_frame_pix_fmt(const char *arg)
2469
{
2470
    if (strcmp(arg, "list"))
2471
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2472
    else {
2473
        list_pix_fmts();
2474
        av_exit(0);
2475
    }
2476
}
2477

    
2478
static void opt_frame_aspect_ratio(const char *arg)
2479
{
2480
    int x = 0, y = 0;
2481
    double ar = 0;
2482
    const char *p;
2483
    char *end;
2484

    
2485
    p = strchr(arg, ':');
2486
    if (p) {
2487
        x = strtol(arg, &end, 10);
2488
        if (end == p)
2489
            y = strtol(end+1, &end, 10);
2490
        if (x > 0 && y > 0)
2491
            ar = (double)x / (double)y;
2492
    } else
2493
        ar = strtod(arg, NULL);
2494

    
2495
    if (!ar) {
2496
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2497
        av_exit(1);
2498
    }
2499
    frame_aspect_ratio = ar;
2500
}
2501

    
2502
static void opt_qscale(const char *arg)
2503
{
2504
    video_qscale = atof(arg);
2505
    if (video_qscale <= 0 ||
2506
        video_qscale > 255) {
2507
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2508
        av_exit(1);
2509
    }
2510
}
2511

    
2512
static void opt_top_field_first(const char *arg)
2513
{
2514
    top_field_first= atoi(arg);
2515
}
2516

    
2517
static int opt_thread_count(const char *opt, const char *arg)
2518
{
2519
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2520
#if !defined(HAVE_THREADS)
2521
    if (verbose >= 0)
2522
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2523
#endif
2524
    return 0;
2525
}
2526

    
2527
static int opt_audio_rate(const char *opt, const char *arg)
2528
{
2529
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2530
    return 0;
2531
}
2532

    
2533
static int opt_audio_channels(const char *opt, const char *arg)
2534
{
2535
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2536
    return 0;
2537
}
2538

    
2539
static void opt_video_channel(const char *arg)
2540
{
2541
    video_channel = strtol(arg, NULL, 0);
2542
}
2543

    
2544
static void opt_video_standard(const char *arg)
2545
{
2546
    video_standard = av_strdup(arg);
2547
}
2548

    
2549
static void opt_codec(int *pstream_copy, char **pcodec_name,
2550
                      int codec_type, const char *arg)
2551
{
2552
    av_freep(pcodec_name);
2553
    if (!strcmp(arg, "copy")) {
2554
        *pstream_copy = 1;
2555
    } else {
2556
        *pcodec_name = av_strdup(arg);
2557
    }
2558
}
2559

    
2560
static void opt_audio_codec(const char *arg)
2561
{
2562
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2563
}
2564

    
2565
static void opt_audio_tag(const char *arg)
2566
{
2567
    char *tail;
2568
    audio_codec_tag= strtol(arg, &tail, 0);
2569

    
2570
    if(!tail || *tail)
2571
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2572
}
2573

    
2574
static void opt_video_tag(const char *arg)
2575
{
2576
    char *tail;
2577
    video_codec_tag= strtol(arg, &tail, 0);
2578

    
2579
    if(!tail || *tail)
2580
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2581
}
2582

    
2583
#ifdef CONFIG_VHOOK
2584
static void add_frame_hooker(const char *arg)
2585
{
2586
    int argc = 0;
2587
    char *argv[64];
2588
    int i;
2589
    char *args = av_strdup(arg);
2590

    
2591
    using_vhook = 1;
2592

    
2593
    argv[0] = strtok(args, " ");
2594
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2595
    }
2596

    
2597
    i = frame_hook_add(argc, argv);
2598

    
2599
    if (i != 0) {
2600
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2601
        av_exit(1);
2602
    }
2603
}
2604
#endif
2605

    
2606
static void opt_video_codec(const char *arg)
2607
{
2608
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2609
}
2610

    
2611
static void opt_subtitle_codec(const char *arg)
2612
{
2613
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2614
}
2615

    
2616
static void opt_map(const char *arg)
2617
{
2618
    AVStreamMap *m;
2619
    char *p;
2620

    
2621
    m = &stream_maps[nb_stream_maps++];
2622

    
2623
    m->file_index = strtol(arg, &p, 0);
2624
    if (*p)
2625
        p++;
2626

    
2627
    m->stream_index = strtol(p, &p, 0);
2628
    if (*p) {
2629
        p++;
2630
        m->sync_file_index = strtol(p, &p, 0);
2631
        if (*p)
2632
            p++;
2633
        m->sync_stream_index = strtol(p, &p, 0);
2634
    } else {
2635
        m->sync_file_index = m->file_index;
2636
        m->sync_stream_index = m->stream_index;
2637
    }
2638
}
2639

    
2640
static void opt_map_meta_data(const char *arg)
2641
{
2642
    AVMetaDataMap *m;
2643
    char *p;
2644

    
2645
    m = &meta_data_maps[nb_meta_data_maps++];
2646

    
2647
    m->out_file = strtol(arg, &p, 0);
2648
    if (*p)
2649
        p++;
2650

    
2651
    m->in_file = strtol(p, &p, 0);
2652
}
2653

    
2654
static void opt_input_ts_scale(const char *arg)
2655
{
2656
    unsigned int stream;
2657
    double scale;
2658
    char *p;
2659

    
2660
    stream = strtol(arg, &p, 0);
2661
    if (*p)
2662
        p++;
2663
    scale= strtod(p, &p);
2664

    
2665
    if(stream >= MAX_STREAMS)
2666
        av_exit(1);
2667

    
2668
    input_files_ts_scale[nb_input_files][stream]= scale;
2669
}
2670

    
2671
static int opt_recording_time(const char *opt, const char *arg)
2672
{
2673
    recording_time = parse_time_or_die(opt, arg, 1);
2674
    return 0;
2675
}
2676

    
2677
static int opt_start_time(const char *opt, const char *arg)
2678
{
2679
    start_time = parse_time_or_die(opt, arg, 1);
2680
    return 0;
2681
}
2682

    
2683
static int opt_rec_timestamp(const char *opt, const char *arg)
2684
{
2685
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2686
    return 0;
2687
}
2688

    
2689
static int opt_input_ts_offset(const char *opt, const char *arg)
2690
{
2691
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2692
    return 0;
2693
}
2694

    
2695
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2696
{
2697
    const char *codec_string = encoder ? "encoder" : "decoder";
2698
    AVCodec *codec;
2699

    
2700
    if(!name)
2701
        return CODEC_ID_NONE;
2702
    codec = encoder ?
2703
        avcodec_find_encoder_by_name(name) :
2704
        avcodec_find_decoder_by_name(name);
2705
    if(!codec) {
2706
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2707
        av_exit(1);
2708
    }
2709
    if(codec->type != type) {
2710
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2711
        av_exit(1);
2712
    }
2713
    return codec->id;
2714
}
2715

    
2716
static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2717
{
2718
    int i;
2719
    for(i=0; i<opt_name_count; i++){
2720
        char buf[256];
2721
        const AVOption *opt;
2722
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2723
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2724
        if(str && ((opt->flags & flags) == flags))
2725
            av_set_string2(ctx, opt_names[i], str, 1);
2726
    }
2727
}
2728

    
2729
static void opt_input_file(const char *filename)
2730
{
2731
    AVFormatContext *ic;
2732
    AVFormatParameters params, *ap = &params;
2733
    int err, i, ret, rfps, rfps_base;
2734
    int64_t timestamp;
2735

    
2736
    if (!strcmp(filename, "-"))
2737
        filename = "pipe:";
2738

    
2739
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2740
                    !strcmp(filename, "/dev/stdin");
2741

    
2742
    /* get default parameters from command line */
2743
    ic = av_alloc_format_context();
2744

    
2745
    memset(ap, 0, sizeof(*ap));
2746
    ap->prealloced_context = 1;
2747
    ap->sample_rate = audio_sample_rate;
2748
    ap->channels = audio_channels;
2749
    ap->time_base.den = frame_rate.num;
2750
    ap->time_base.num = frame_rate.den;
2751
    ap->width = frame_width + frame_padleft + frame_padright;
2752
    ap->height = frame_height + frame_padtop + frame_padbottom;
2753
    ap->pix_fmt = frame_pix_fmt;
2754
    ap->channel = video_channel;
2755
    ap->standard = video_standard;
2756
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2757
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2758
    if(pgmyuv_compatibility_hack)
2759
        ap->video_codec_id= CODEC_ID_PGMYUV;
2760

    
2761
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2762

    
2763
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2764
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2765
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2766

    
2767
    /* open the input file with generic libav function */
2768
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2769
    if (err < 0) {
2770
        print_error(filename, err);
2771
        av_exit(1);
2772
    }
2773
    if(opt_programid) {
2774
        int i;
2775
        for(i=0; i<ic->nb_programs; i++)
2776
            if(ic->programs[i]->id != opt_programid)
2777
                ic->programs[i]->discard = AVDISCARD_ALL;
2778
    }
2779

    
2780
    ic->loop_input = loop_input;
2781

    
2782
    /* If not enough info to get the stream parameters, we decode the
2783
       first frames to get it. (used in mpeg case for example) */
2784
    ret = av_find_stream_info(ic);
2785
    if (ret < 0 && verbose >= 0) {
2786
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2787
        av_exit(1);
2788
    }
2789

    
2790
    timestamp = start_time;
2791
    /* add the stream start time */
2792
    if (ic->start_time != AV_NOPTS_VALUE)
2793
        timestamp += ic->start_time;
2794

    
2795
    /* if seeking requested, we execute it */
2796
    if (start_time != 0) {
2797
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2798
        if (ret < 0) {
2799
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2800
                    filename, (double)timestamp / AV_TIME_BASE);
2801
        }
2802
        /* reset seek info */
2803
        start_time = 0;
2804
    }
2805

    
2806
    /* update the current parameters so that they match the one of the input stream */
2807
    for(i=0;i<ic->nb_streams;i++) {
2808
        AVCodecContext *enc = ic->streams[i]->codec;
2809
        if(thread_count>1)
2810
            avcodec_thread_init(enc, thread_count);
2811
        enc->thread_count= thread_count;
2812
        switch(enc->codec_type) {
2813
        case CODEC_TYPE_AUDIO:
2814
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2815
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2816
            audio_channels = enc->channels;
2817
            audio_sample_rate = enc->sample_rate;
2818
            if(audio_disable)
2819
                ic->streams[i]->discard= AVDISCARD_ALL;
2820
            break;
2821
        case CODEC_TYPE_VIDEO:
2822
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2823
            frame_height = enc->height;
2824
            frame_width = enc->width;
2825
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2826
            frame_pix_fmt = enc->pix_fmt;
2827
            rfps      = ic->streams[i]->r_frame_rate.num;
2828
            rfps_base = ic->streams[i]->r_frame_rate.den;
2829
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2830
            if(me_threshold)
2831
                enc->debug |= FF_DEBUG_MV;
2832

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

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

    
2839
                    (float)rfps / rfps_base, rfps, rfps_base);
2840
            }
2841
            /* update the current frame rate to match the stream frame rate */
2842
            frame_rate.num = rfps;
2843
            frame_rate.den = rfps_base;
2844

    
2845
            enc->rate_emu = rate_emu;
2846
            if(video_disable)
2847
                ic->streams[i]->discard= AVDISCARD_ALL;
2848
            else if(video_discard)
2849
                ic->streams[i]->discard= video_discard;
2850
            break;
2851
        case CODEC_TYPE_DATA:
2852
            break;
2853
        case CODEC_TYPE_SUBTITLE:
2854
            if(subtitle_disable)
2855
                ic->streams[i]->discard = AVDISCARD_ALL;
2856
            break;
2857
        case CODEC_TYPE_ATTACHMENT:
2858
        case CODEC_TYPE_UNKNOWN:
2859
            break;
2860
        default:
2861
            abort();
2862
        }
2863
    }
2864

    
2865
    input_files[nb_input_files] = ic;
2866
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2867
    /* dump the file content */
2868
    if (verbose >= 0)
2869
        dump_format(ic, nb_input_files, filename, 0);
2870

    
2871
    nb_input_files++;
2872
    file_iformat = NULL;
2873
    file_oformat = NULL;
2874

    
2875
    video_channel = 0;
2876

    
2877
    rate_emu = 0;
2878
    av_freep(&video_codec_name);
2879
    av_freep(&audio_codec_name);
2880
    av_freep(&subtitle_codec_name);
2881
}
2882

    
2883
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2884
                                         int *has_subtitle_ptr)
2885
{
2886
    int has_video, has_audio, has_subtitle, i, j;
2887
    AVFormatContext *ic;
2888

    
2889
    has_video = 0;
2890
    has_audio = 0;
2891
    has_subtitle = 0;
2892
    for(j=0;j<nb_input_files;j++) {
2893
        ic = input_files[j];
2894
        for(i=0;i<ic->nb_streams;i++) {
2895
            AVCodecContext *enc = ic->streams[i]->codec;
2896
            switch(enc->codec_type) {
2897
            case CODEC_TYPE_AUDIO:
2898
                has_audio = 1;
2899
                break;
2900
            case CODEC_TYPE_VIDEO:
2901
                has_video = 1;
2902
                break;
2903
            case CODEC_TYPE_SUBTITLE:
2904
                has_subtitle = 1;
2905
                break;
2906
            case CODEC_TYPE_DATA:
2907
            case CODEC_TYPE_ATTACHMENT:
2908
            case CODEC_TYPE_UNKNOWN:
2909
                break;
2910
            default:
2911
                abort();
2912
            }
2913
        }
2914
    }
2915
    *has_video_ptr = has_video;
2916
    *has_audio_ptr = has_audio;
2917
    *has_subtitle_ptr = has_subtitle;
2918
}
2919

    
2920
static void new_video_stream(AVFormatContext *oc)
2921
{
2922
    AVStream *st;
2923
    AVCodecContext *video_enc;
2924
    int codec_id;
2925

    
2926
    st = av_new_stream(oc, oc->nb_streams);
2927
    if (!st) {
2928
        fprintf(stderr, "Could not alloc stream\n");
2929
        av_exit(1);
2930
    }
2931
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2932
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2933
    video_bitstream_filters= NULL;
2934

    
2935
    if(thread_count>1)
2936
        avcodec_thread_init(st->codec, thread_count);
2937

    
2938
    video_enc = st->codec;
2939

    
2940
    if(video_codec_tag)
2941
        video_enc->codec_tag= video_codec_tag;
2942

    
2943
    if(   (video_global_header&1)
2944
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2945
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2946
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2947
    }
2948
    if(video_global_header&2){
2949
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2950
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2951
    }
2952

    
2953
    if (video_stream_copy) {
2954
        st->stream_copy = 1;
2955
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2956
    } else {
2957
        const char *p;
2958
        int i;
2959
        AVCodec *codec;
2960
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2961

    
2962
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2963
        if (video_codec_name)
2964
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2965

    
2966
        video_enc->codec_id = codec_id;
2967
        codec = avcodec_find_encoder(codec_id);
2968

    
2969
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2970

    
2971
        video_enc->time_base.den = fps.num;
2972
        video_enc->time_base.num = fps.den;
2973
        if(codec && codec->supported_framerates){
2974
            const AVRational *p= codec->supported_framerates;
2975
            const AVRational *best=NULL;
2976
            AVRational best_error= (AVRational){INT_MAX, 1};
2977
            for(; p->den!=0; p++){
2978
                AVRational error= av_sub_q(fps, *p);
2979
                if(error.num <0) error.num *= -1;
2980
                if(av_cmp_q(error, best_error) < 0){
2981
                    best_error= error;
2982
                    best= p;
2983
                }
2984
            }
2985
            video_enc->time_base.den= best->num;
2986
            video_enc->time_base.num= best->den;
2987
        }
2988

    
2989
        video_enc->width = frame_width + frame_padright + frame_padleft;
2990
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2991
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2992
        video_enc->pix_fmt = frame_pix_fmt;
2993

    
2994
        if(codec && codec->pix_fmts){
2995
            const enum PixelFormat *p= codec->pix_fmts;
2996
            for(; *p!=-1; p++){
2997
                if(*p == video_enc->pix_fmt)
2998
                    break;
2999
            }
3000
            if(*p == -1)
3001
                video_enc->pix_fmt = codec->pix_fmts[0];
3002
        }
3003

    
3004
        if (intra_only)
3005
            video_enc->gop_size = 0;
3006
        if (video_qscale || same_quality) {
3007
            video_enc->flags |= CODEC_FLAG_QSCALE;
3008
            video_enc->global_quality=
3009
                st->quality = FF_QP2LAMBDA * video_qscale;
3010
        }
3011

    
3012
        if(intra_matrix)
3013
            video_enc->intra_matrix = intra_matrix;
3014
        if(inter_matrix)
3015
            video_enc->inter_matrix = inter_matrix;
3016

    
3017
        video_enc->thread_count = thread_count;
3018
        p= video_rc_override_string;
3019
        for(i=0; p; i++){
3020
            int start, end, q;
3021
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3022
            if(e!=3){
3023
                fprintf(stderr, "error parsing rc_override\n");
3024
                av_exit(1);
3025
            }
3026
            video_enc->rc_override=
3027
                av_realloc(video_enc->rc_override,
3028
                           sizeof(RcOverride)*(i+1));
3029
            video_enc->rc_override[i].start_frame= start;
3030
            video_enc->rc_override[i].end_frame  = end;
3031
            if(q>0){
3032
                video_enc->rc_override[i].qscale= q;
3033
                video_enc->rc_override[i].quality_factor= 1.0;
3034
            }
3035
            else{
3036
                video_enc->rc_override[i].qscale= 0;
3037
                video_enc->rc_override[i].quality_factor= -q/100.0;
3038
            }
3039
            p= strchr(p, '/');
3040
            if(p) p++;
3041
        }
3042
        video_enc->rc_override_count=i;
3043
        if (!video_enc->rc_initial_buffer_occupancy)
3044
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3045
        video_enc->me_threshold= me_threshold;
3046
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3047

    
3048
        if (do_psnr)
3049
            video_enc->flags|= CODEC_FLAG_PSNR;
3050

    
3051
        /* two pass mode */
3052
        if (do_pass) {
3053
            if (do_pass == 1) {
3054
                video_enc->flags |= CODEC_FLAG_PASS1;
3055
            } else {
3056
                video_enc->flags |= CODEC_FLAG_PASS2;
3057
            }
3058
        }
3059
    }
3060

    
3061
    /* reset some key parameters */
3062
    video_disable = 0;
3063
    av_freep(&video_codec_name);
3064
    video_stream_copy = 0;
3065
}
3066

    
3067
static void new_audio_stream(AVFormatContext *oc)
3068
{
3069
    AVStream *st;
3070
    AVCodecContext *audio_enc;
3071
    int codec_id;
3072

    
3073
    st = av_new_stream(oc, oc->nb_streams);
3074
    if (!st) {
3075
        fprintf(stderr, "Could not alloc stream\n");
3076
        av_exit(1);
3077
    }
3078
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3079

    
3080
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3081
    audio_bitstream_filters= NULL;
3082

    
3083
    if(thread_count>1)
3084
        avcodec_thread_init(st->codec, thread_count);
3085

    
3086
    audio_enc = st->codec;
3087
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3088

    
3089
    if(audio_codec_tag)
3090
        audio_enc->codec_tag= audio_codec_tag;
3091

    
3092
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3093
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3094
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3095
    }
3096
    if (audio_stream_copy) {
3097
        st->stream_copy = 1;
3098
        audio_enc->channels = audio_channels;
3099
    } else {
3100
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3101

    
3102
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3103

    
3104
        if (audio_codec_name)
3105
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3106
        audio_enc->codec_id = codec_id;
3107

    
3108
        if (audio_qscale > QSCALE_NONE) {
3109
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3110
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3111
        }
3112
        audio_enc->thread_count = thread_count;
3113
        audio_enc->channels = audio_channels;
3114
    }
3115
    audio_enc->sample_rate = audio_sample_rate;
3116
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3117
    if (audio_language) {
3118
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3119
        av_free(audio_language);
3120
        audio_language = NULL;
3121
    }
3122

    
3123
    /* reset some key parameters */
3124
    audio_disable = 0;
3125
    av_freep(&audio_codec_name);
3126
    audio_stream_copy = 0;
3127
}
3128

    
3129
static void new_subtitle_stream(AVFormatContext *oc)
3130
{
3131
    AVStream *st;
3132
    AVCodecContext *subtitle_enc;
3133

    
3134
    st = av_new_stream(oc, oc->nb_streams);
3135
    if (!st) {
3136
        fprintf(stderr, "Could not alloc stream\n");
3137
        av_exit(1);
3138
    }
3139
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3140

    
3141
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3142
    subtitle_bitstream_filters= NULL;
3143

    
3144
    subtitle_enc = st->codec;
3145
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3146
    if (subtitle_stream_copy) {
3147
        st->stream_copy = 1;
3148
    } else {
3149
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3150
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3151
    }
3152

    
3153
    if (subtitle_language) {
3154
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3155
        av_free(subtitle_language);
3156
        subtitle_language = NULL;
3157
    }
3158

    
3159
    subtitle_disable = 0;
3160
    av_freep(&subtitle_codec_name);
3161
    subtitle_stream_copy = 0;
3162
}
3163

    
3164
static void opt_new_audio_stream(void)
3165
{
3166
    AVFormatContext *oc;
3167
    if (nb_output_files <= 0) {
3168
        fprintf(stderr, "At least one output file must be specified\n");
3169
        av_exit(1);
3170
    }
3171
    oc = output_files[nb_output_files - 1];
3172
    new_audio_stream(oc);
3173
}
3174

    
3175
static void opt_new_video_stream(void)
3176
{
3177
    AVFormatContext *oc;
3178
    if (nb_output_files <= 0) {
3179
        fprintf(stderr, "At least one output file must be specified\n");
3180
        av_exit(1);
3181
    }
3182
    oc = output_files[nb_output_files - 1];
3183
    new_video_stream(oc);
3184
}
3185

    
3186
static void opt_new_subtitle_stream(void)
3187
{
3188
    AVFormatContext *oc;
3189
    if (nb_output_files <= 0) {
3190
        fprintf(stderr, "At least one output file must be specified\n");
3191
        av_exit(1);
3192
    }
3193
    oc = output_files[nb_output_files - 1];
3194
    new_subtitle_stream(oc);
3195
}
3196

    
3197
static void opt_output_file(const char *filename)
3198
{
3199
    AVFormatContext *oc;
3200
    int use_video, use_audio, use_subtitle;
3201
    int input_has_video, input_has_audio, input_has_subtitle;
3202
    AVFormatParameters params, *ap = &params;
3203

    
3204
    if (!strcmp(filename, "-"))
3205
        filename = "pipe:";
3206

    
3207
    oc = av_alloc_format_context();
3208

    
3209
    if (!file_oformat) {
3210
        file_oformat = guess_format(NULL, filename, NULL);
3211
        if (!file_oformat) {
3212
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3213
                    filename);
3214
            av_exit(1);
3215
        }
3216
    }
3217

    
3218
    oc->oformat = file_oformat;
3219
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3220

    
3221
    if (!strcmp(file_oformat->name, "ffm") &&
3222
        av_strstart(filename, "http:", NULL)) {
3223
        /* special case for files sent to ffserver: we get the stream
3224
           parameters from ffserver */
3225
        int err = read_ffserver_streams(oc, filename);
3226
        if (err < 0) {
3227
            print_error(filename, err);
3228
            av_exit(1);
3229
        }
3230
    } else {
3231
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3232
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3233
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3234

    
3235
        /* disable if no corresponding type found and at least one
3236
           input file */
3237
        if (nb_input_files > 0) {
3238
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3239
                                         &input_has_subtitle);
3240
            if (!input_has_video)
3241
                use_video = 0;
3242
            if (!input_has_audio)
3243
                use_audio = 0;
3244
            if (!input_has_subtitle)
3245
                use_subtitle = 0;
3246
        }
3247

    
3248
        /* manual disable */
3249
        if (audio_disable) {
3250
            use_audio = 0;
3251
        }
3252
        if (video_disable) {
3253
            use_video = 0;
3254
        }
3255
        if (subtitle_disable) {
3256
            use_subtitle = 0;
3257
        }
3258

    
3259
        if (use_video) {
3260
            new_video_stream(oc);
3261
        }
3262

    
3263
        if (use_audio) {
3264
            new_audio_stream(oc);
3265
        }
3266

    
3267
        if (use_subtitle) {
3268
            new_subtitle_stream(oc);
3269
        }
3270

    
3271
        oc->timestamp = rec_timestamp;
3272

    
3273
        if (str_title)
3274
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3275
        if (str_author)
3276
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3277
        if (str_copyright)
3278
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3279
        if (str_comment)
3280
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3281
        if (str_album)
3282
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3283
        if (str_genre)
3284
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3285
    }
3286

    
3287
    output_files[nb_output_files++] = oc;
3288

    
3289
    /* check filename in case of an image number is expected */
3290
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3291
        if (!av_filename_number_test(oc->filename)) {
3292
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3293
            av_exit(1);
3294
        }
3295
    }
3296

    
3297
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3298
        /* test if it already exists to avoid loosing precious files */
3299
        if (!file_overwrite &&
3300
            (strchr(filename, ':') == NULL ||
3301
             filename[1] == ':' ||
3302
             av_strstart(filename, "file:", NULL))) {
3303
            if (url_exist(filename)) {
3304
                int c;
3305

    
3306
                if (!using_stdin) {
3307
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3308
                    fflush(stderr);
3309
                    c = getchar();
3310
                    if (toupper(c) != 'Y') {
3311
                        fprintf(stderr, "Not overwriting - exiting\n");
3312
                        av_exit(1);
3313
                    }
3314
                }
3315
                else {
3316
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3317
                    av_exit(1);
3318
                }
3319
            }
3320
        }
3321

    
3322
        /* open the file */
3323
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3324
            fprintf(stderr, "Could not open '%s'\n", filename);
3325
            av_exit(1);
3326
        }
3327
    }
3328

    
3329
    memset(ap, 0, sizeof(*ap));
3330
    if (av_set_parameters(oc, ap) < 0) {
3331
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3332
                oc->filename);
3333
        av_exit(1);
3334
    }
3335

    
3336
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3337
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3338
    oc->loop_output = loop_output;
3339

    
3340
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3341

    
3342
    /* reset some options */
3343
    file_oformat = NULL;
3344
    file_iformat = NULL;
3345
}
3346

    
3347
/* same option as mencoder */
3348
static void opt_pass(const char *pass_str)
3349
{
3350
    int pass;
3351
    pass = atoi(pass_str);
3352
    if (pass != 1 && pass != 2) {
3353
        fprintf(stderr, "pass number can be only 1 or 2\n");
3354
        av_exit(1);
3355
    }
3356
    do_pass = pass;
3357
}
3358

    
3359
static int64_t getutime(void)
3360
{
3361
#ifdef HAVE_GETRUSAGE
3362
    struct rusage rusage;
3363

    
3364
    getrusage(RUSAGE_SELF, &rusage);
3365
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3366
#elif defined(HAVE_GETPROCESSTIMES)
3367
    HANDLE proc;
3368
    FILETIME c, e, k, u;
3369
    proc = GetCurrentProcess();
3370
    GetProcessTimes(proc, &c, &e, &k, &u);
3371
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3372
#else
3373
    return av_gettime();
3374
#endif
3375
}
3376

    
3377
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3378
{
3379
    int i;
3380
    const char *p = str;
3381
    for(i = 0;; i++) {
3382
        dest[i] = atoi(p);
3383
        if(i == 63)
3384
            break;
3385
        p = strchr(p, ',');
3386
        if(!p) {
3387
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3388
            av_exit(1);
3389
        }
3390
        p++;
3391
    }
3392
}
3393

    
3394
static void opt_inter_matrix(const char *arg)
3395
{
3396
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3397
    parse_matrix_coeffs(inter_matrix, arg);
3398
}
3399

    
3400
static void opt_intra_matrix(const char *arg)
3401
{
3402
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3403
    parse_matrix_coeffs(intra_matrix, arg);
3404
}
3405

    
3406
/**
3407
 * Trivial log callback.
3408
 * Only suitable for show_help and similar since it lacks prefix handling.
3409
 */
3410
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3411
{
3412
    vfprintf(stdout, fmt, vl);
3413
}
3414

    
3415
static void show_help(void)
3416
{
3417
    av_log_set_callback(log_callback_help);
3418
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3419
           "Hyper fast Audio and Video encoder\n");
3420
    printf("\n");
3421
    show_help_options(options, "Main options:\n",
3422
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3423
    show_help_options(options, "\nAdvanced options:\n",
3424
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3425
                      OPT_EXPERT);
3426
    show_help_options(options, "\nVideo options:\n",
3427
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3428
                      OPT_VIDEO);
3429
    show_help_options(options, "\nAdvanced Video options:\n",
3430
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3431
                      OPT_VIDEO | OPT_EXPERT);
3432
    show_help_options(options, "\nAudio options:\n",
3433
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3434
                      OPT_AUDIO);
3435
    show_help_options(options, "\nAdvanced Audio options:\n",
3436
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3437
                      OPT_AUDIO | OPT_EXPERT);
3438
    show_help_options(options, "\nSubtitle options:\n",
3439
                      OPT_SUBTITLE | OPT_GRAB,
3440
                      OPT_SUBTITLE);
3441
    show_help_options(options, "\nAudio/Video grab options:\n",
3442
                      OPT_GRAB,
3443
                      OPT_GRAB);
3444
    printf("\n");
3445
    av_opt_show(avctx_opts[0], NULL);
3446
    printf("\n");
3447
    av_opt_show(avformat_opts, NULL);
3448
    printf("\n");
3449
    av_opt_show(sws_opts, NULL);
3450
}
3451

    
3452
static void opt_target(const char *arg)
3453
{
3454
    int norm = -1;
3455
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3456

    
3457
    if(!strncmp(arg, "pal-", 4)) {
3458
        norm = 0;
3459
        arg += 4;
3460
    } else if(!strncmp(arg, "ntsc-", 5)) {
3461
        norm = 1;
3462
        arg += 5;
3463
    } else if(!strncmp(arg, "film-", 5)) {
3464
        norm = 2;
3465
        arg += 5;
3466
    } else {
3467
        int fr;
3468
        /* Calculate FR via float to avoid int overflow */
3469
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3470
        if(fr == 25000) {
3471
            norm = 0;
3472
        } else if((fr == 29970) || (fr == 23976)) {
3473
            norm = 1;
3474
        } else {
3475
            /* Try to determine PAL/NTSC by peeking in the input files */
3476
            if(nb_input_files) {
3477
                int i, j;
3478
                for(j = 0; j < nb_input_files; j++) {
3479
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3480
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3481
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3482
                            continue;
3483
                        fr = c->time_base.den * 1000 / c->time_base.num;
3484
                        if(fr == 25000) {
3485
                            norm = 0;
3486
                            break;
3487
                        } else if((fr == 29970) || (fr == 23976)) {
3488
                            norm = 1;
3489
                            break;
3490
                        }
3491
                    }
3492
                    if(norm >= 0)
3493
                        break;
3494
                }
3495
            }
3496
        }
3497
        if(verbose && norm >= 0)
3498
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3499
    }
3500

    
3501
    if(norm < 0) {
3502
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3503
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3504
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3505
        av_exit(1);
3506
    }
3507

    
3508
    if(!strcmp(arg, "vcd")) {
3509

    
3510
        opt_video_codec("mpeg1video");
3511
        opt_audio_codec("mp2");
3512
        opt_format("vcd");
3513

    
3514
        opt_frame_size(norm ? "352x240" : "352x288");
3515
        opt_frame_rate(frame_rates[norm]);
3516
        opt_default("gop", norm ? "18" : "15");
3517

    
3518
        opt_default("b", "1150000");
3519
        opt_default("maxrate", "1150000");
3520
        opt_default("minrate", "1150000");
3521
        opt_default("bufsize", "327680"); // 40*1024*8;
3522

    
3523
        opt_default("ab", "224000");
3524
        audio_sample_rate = 44100;
3525
        audio_channels = 2;
3526

    
3527
        opt_default("packetsize", "2324");
3528
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3529

    
3530
        /* We have to offset the PTS, so that it is consistent with the SCR.
3531
           SCR starts at 36000, but the first two packs contain only padding
3532
           and the first pack from the other stream, respectively, may also have
3533
           been written before.
3534
           So the real data starts at SCR 36000+3*1200. */
3535
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3536
    } else if(!strcmp(arg, "svcd")) {
3537

    
3538
        opt_video_codec("mpeg2video");
3539
        opt_audio_codec("mp2");
3540
        opt_format("svcd");
3541

    
3542
        opt_frame_size(norm ? "480x480" : "480x576");
3543
        opt_frame_rate(frame_rates[norm]);
3544
        opt_default("gop", norm ? "18" : "15");
3545

    
3546
        opt_default("b", "2040000");
3547
        opt_default("maxrate", "2516000");
3548
        opt_default("minrate", "0"); //1145000;
3549
        opt_default("bufsize", "1835008"); //224*1024*8;
3550
        opt_default("flags", "+SCAN_OFFSET");
3551

    
3552

    
3553
        opt_default("ab", "224000");
3554
        audio_sample_rate = 44100;
3555

    
3556
        opt_default("packetsize", "2324");
3557

    
3558
    } else if(!strcmp(arg, "dvd")) {
3559

    
3560
        opt_video_codec("mpeg2video");
3561
        opt_audio_codec("ac3");
3562
        opt_format("dvd");
3563

    
3564
        opt_frame_size(norm ? "720x480" : "720x576");
3565
        opt_frame_rate(frame_rates[norm]);
3566
        opt_default("gop", norm ? "18" : "15");
3567

    
3568
        opt_default("b", "6000000");
3569
        opt_default("maxrate", "9000000");
3570
        opt_default("minrate", "0"); //1500000;
3571
        opt_default("bufsize", "1835008"); //224*1024*8;
3572

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

    
3576
        opt_default("ab", "448000");
3577
        audio_sample_rate = 48000;
3578

    
3579
    } else if(!strncmp(arg, "dv", 2)) {
3580

    
3581
        opt_format("dv");
3582

    
3583
        opt_frame_size(norm ? "720x480" : "720x576");
3584
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3585
                                             (norm ? "yuv411p" : "yuv420p"));
3586
        opt_frame_rate(frame_rates[norm]);
3587

    
3588
        audio_sample_rate = 48000;
3589
        audio_channels = 2;
3590

    
3591
    } else {
3592
        fprintf(stderr, "Unknown target: %s\n", arg);
3593
        av_exit(1);
3594
    }
3595
}
3596

    
3597
static void opt_vstats_file (const char *arg)
3598
{
3599
    av_free (vstats_filename);
3600
    vstats_filename=av_strdup (arg);
3601
}
3602

    
3603
static void opt_vstats (void)
3604
{
3605
    char filename[40];
3606
    time_t today2 = time(NULL);
3607
    struct tm *today = localtime(&today2);
3608

    
3609
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3610
             today->tm_sec);
3611
    opt_vstats_file(filename);
3612
}
3613

    
3614
static int opt_bsf(const char *opt, const char *arg)
3615
{
3616
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3617
    AVBitStreamFilterContext **bsfp;
3618

    
3619
    if(!bsfc){
3620
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3621
        av_exit(1);
3622
    }
3623

    
3624
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3625
          *opt == 'a' ? &audio_bitstream_filters :
3626
                        &subtitle_bitstream_filters;
3627
    while(*bsfp)
3628
        bsfp= &(*bsfp)->next;
3629

    
3630
    *bsfp= bsfc;
3631

    
3632
    return 0;
3633
}
3634

    
3635
static int opt_preset(const char *opt, const char *arg)
3636
{
3637
    FILE *f=NULL;
3638
    char tmp[1000], tmp2[1000];
3639
    int i;
3640
    const char *base[3]= { getenv("HOME"),
3641
                           "/usr/local/share",
3642
                           "/usr/share",
3643
                         };
3644

    
3645
    for(i=!base[0]; i<3 && !f; i++){
3646
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3647
        f= fopen(tmp, "r");
3648
        if(!f){
3649
            char *codec_name= *opt == 'v' ? video_codec_name :
3650
                              *opt == 'a' ? audio_codec_name :
3651
                                            subtitle_codec_name;
3652
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3653
            f= fopen(tmp, "r");
3654
        }
3655
    }
3656

    
3657
    if(!f){
3658
        fprintf(stderr, "Preset file not found\n");
3659
        av_exit(1);
3660
    }
3661

    
3662
    while(!feof(f)){
3663
        int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3664
        if(e!=2){
3665
            fprintf(stderr, "Preset file invalid\n");
3666
            av_exit(1);
3667
        }
3668
        if(!strcmp(tmp, "acodec")){
3669
            opt_audio_codec(tmp2);
3670
        }else if(!strcmp(tmp, "vcodec")){
3671
            opt_video_codec(tmp2);
3672
        }else if(!strcmp(tmp, "scodec")){
3673
            opt_subtitle_codec(tmp2);
3674
        }else
3675
            opt_default(tmp, tmp2);
3676
    }
3677

    
3678
    fclose(f);
3679

    
3680
    return 0;
3681
}
3682

    
3683
static const OptionDef options[] = {
3684
    /* main options */
3685
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3686
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3687
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3688
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3689
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3690
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3691
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3692
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3693
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3694
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3695
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3696
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3697
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3698
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3699
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3700
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3701
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3702
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3703
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3704
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3705
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3706
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3707
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3708
      "add timings for benchmarking" },
3709
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3710
      "dump each input packet" },
3711
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3712
      "when dumping packets, also dump the payload" },
3713
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3714
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3715
    { "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)", "" },
3716
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3717
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3718
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3719
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3720
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3721
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3722
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3723
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3724
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3725
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3726
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3727

    
3728
    /* video options */
3729
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3730
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3731
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3732
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3733
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3734
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3735
    { "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" },
3736
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3737
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3738
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3739
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3740
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3741
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3742
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3743
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3744
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3745
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3746
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3747
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3748
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3749
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3750
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3751
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3752
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3753
      "use same video quality as source (implies VBR)" },
3754
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3755
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3756
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3757
      "deinterlace pictures" },
3758
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3759
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3760
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3761
#ifdef CONFIG_VHOOK
3762
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3763
#endif
3764
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3765
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3766
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3767
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3768
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3769
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3770
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3771

    
3772
    /* audio options */
3773
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3774
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3775
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3776
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3777
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3778
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3779
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3780
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3781
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3782
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3783
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3784

    
3785
    /* subtitle options */
3786
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3787
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3788
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3789
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3790

    
3791
    /* grab options */
3792
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3793
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3794
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3795

    
3796
    /* muxer options */
3797
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3798
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3799

    
3800
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3801
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3802
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3803

    
3804
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3805
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3806
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3807

    
3808
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3809
    { NULL, },
3810
};
3811

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

    
3817
    avcodec_register_all();
3818
    avdevice_register_all();
3819
    av_register_all();
3820

    
3821
    if(isatty(STDIN_FILENO))
3822
        url_set_interrupt_cb(decode_interrupt_cb);
3823

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

    
3830
    show_banner();
3831
    if (argc <= 1) {
3832
        show_help();
3833
        av_exit(1);
3834
    }
3835

    
3836
    /* parse options */
3837
    parse_options(argc, argv, options, opt_output_file);
3838

    
3839
    /* file converter / grab */
3840
    if (nb_output_files <= 0) {
3841
        fprintf(stderr, "Must supply at least one output file\n");
3842
        av_exit(1);
3843
    }
3844

    
3845
    if (nb_input_files == 0) {
3846
        fprintf(stderr, "Must supply at least one input file\n");
3847
        av_exit(1);
3848
    }
3849

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

    
3858
    return av_exit(0);
3859
}