Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 831ec935

History | View | Annotate | Download (133 KB)

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

    
22
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include "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 int nb_input_files = 0;
89

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

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

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

    
99
static AVInputFormat *file_iformat;
100
static AVOutputFormat *file_oformat;
101
static int frame_width  = 0;
102
static int frame_height = 0;
103
static float frame_aspect_ratio = 0;
104
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
105
static int frame_padtop  = 0;
106
static int frame_padbottom = 0;
107
static int frame_padleft  = 0;
108
static int frame_padright = 0;
109
static int padcolor[3] = {16,128,128}; /* default to black */
110
static int frame_topBand  = 0;
111
static int frame_bottomBand = 0;
112
static int frame_leftBand  = 0;
113
static int frame_rightBand = 0;
114
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
115
static AVRational frame_rate = (AVRational) {0,0};
116
static float video_qscale = 0;
117
static int video_qdiff = 3;
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 strict = 0;
133
static int top_field_first = -1;
134
static int me_threshold = 0;
135
static int intra_dc_precision = 8;
136
static int loop_input = 0;
137
static int loop_output = AVFMT_NOOUTPUTLOOP;
138
static int qp_hist = 0;
139

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

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

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

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

    
187
static int rate_emu = 0;
188

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

    
192
static int audio_volume = 256;
193

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

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

    
210
static unsigned int sws_flags = SWS_BICUBIC;
211

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

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

    
224
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
225

    
226
struct AVInputStream;
227

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

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

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

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

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

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

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

    
286
#ifdef HAVE_TERMIOS_H
287

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

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

    
299
static volatile sig_atomic_t received_sigterm = 0;
300

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
402
    av_free(opt_names);
403

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

    
408
    av_free(video_standard);
409

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

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

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

    
426
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
427
{
428
    int i, err;
429
    AVFormatContext *ic;
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

    
447
    av_close_input_file(ic);
448
    return 0;
449
}
450

    
451
static double
452
get_sync_ipts(const AVOutputStream *ost)
453
{
454
    const AVInputStream *ist = ost->sync_ist;
455
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
456
}
457

    
458
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
459
    int ret;
460

    
461
    while(bsfc){
462
        AVPacket new_pkt= *pkt;
463
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
464
                                          &new_pkt.data, &new_pkt.size,
465
                                          pkt->data, pkt->size,
466
                                          pkt->flags & PKT_FLAG_KEY);
467
        if(a>0){
468
            av_free_packet(pkt);
469
            new_pkt.destruct= av_destruct_packet;
470
        } else if(a<0){
471
            fprintf(stderr, "%s failed for stream %d, codec %s",
472
                    bsfc->filter->name, pkt->stream_index,
473
                    avctx->codec ? avctx->codec->name : "copy");
474
            print_error("", a);
475
        }
476
        *pkt= new_pkt;
477

    
478
        bsfc= bsfc->next;
479
    }
480

    
481
    ret= av_interleaved_write_frame(s, pkt);
482
    if(ret < 0){
483
        print_error("av_interleaved_write_frame()", ret);
484
        av_exit(1);
485
    }
486
}
487

    
488
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
489

    
490
static void do_audio_out(AVFormatContext *s,
491
                         AVOutputStream *ost,
492
                         AVInputStream *ist,
493
                         unsigned char *buf, int size)
494
{
495
    uint8_t *buftmp;
496
    static uint8_t *audio_buf = NULL;
497
    static uint8_t *audio_out = NULL;
498
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
499

    
500
    int size_out, frame_bytes, ret;
501
    AVCodecContext *enc= ost->st->codec;
502
    AVCodecContext *dec= ist->st->codec;
503

    
504
    /* SC: dynamic allocation of buffers */
505
    if (!audio_buf)
506
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
507
    if (!audio_out)
508
        audio_out = av_malloc(audio_out_size);
509
    if (!audio_buf || !audio_out)
510
        return;               /* Should signal an error ! */
511

    
512
    if (enc->channels != dec->channels)
513
        ost->audio_resample = 1;
514

    
515
    if (ost->audio_resample && !ost->resample) {
516
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
517
                                            enc->sample_rate, dec->sample_rate);
518
        if (!ost->resample) {
519
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
520
                    dec->channels, dec->sample_rate,
521
                    enc->channels, enc->sample_rate);
522
            av_exit(1);
523
        }
524
    }
525

    
526
    if(audio_sync_method){
527
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
528
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
529
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
530
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
531

    
532
        //FIXME resample delay
533
        if(fabs(delta) > 50){
534
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
535
                if(byte_delta < 0){
536
                    byte_delta= FFMAX(byte_delta, -size);
537
                    size += byte_delta;
538
                    buf  -= byte_delta;
539
                    if(verbose > 2)
540
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
541
                    if(!size)
542
                        return;
543
                    ist->is_start=0;
544
                }else{
545
                    static uint8_t *input_tmp= NULL;
546
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
547

    
548
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
549
                        ist->is_start=0;
550
                    else
551
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
552

    
553
                    memset(input_tmp, 0, byte_delta);
554
                    memcpy(input_tmp + byte_delta, buf, size);
555
                    buf= input_tmp;
556
                    size += byte_delta;
557
                    if(verbose > 2)
558
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
559
                }
560
            }else if(audio_sync_method>1){
561
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
562
                assert(ost->audio_resample);
563
                if(verbose > 2)
564
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
565
//                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));
566
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
567
            }
568
        }
569
    }else
570
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
571
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
572

    
573
    if (ost->audio_resample) {
574
        buftmp = audio_buf;
575
        size_out = audio_resample(ost->resample,
576
                                  (short *)buftmp, (short *)buf,
577
                                  size / (ist->st->codec->channels * 2));
578
        size_out = size_out * enc->channels * 2;
579
    } else {
580
        buftmp = buf;
581
        size_out = size;
582
    }
583

    
584
    /* now encode as many frames as possible */
585
    if (enc->frame_size > 1) {
586
        /* output resampled raw samples */
587
        av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
588
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
589

    
590
        frame_bytes = enc->frame_size * 2 * enc->channels;
591

    
592
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
593
            AVPacket pkt;
594
            av_init_packet(&pkt);
595

    
596
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
597

    
598
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
599

    
600
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
601
                                       (short *)audio_buf);
602
            audio_size += ret;
603
            pkt.stream_index= ost->index;
604
            pkt.data= audio_out;
605
            pkt.size= ret;
606
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
607
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
608
            pkt.flags |= PKT_FLAG_KEY;
609
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
610

    
611
            ost->sync_opts += enc->frame_size;
612
        }
613
    } else {
614
        AVPacket pkt;
615
        av_init_packet(&pkt);
616

    
617
        ost->sync_opts += size_out / (2 * enc->channels);
618

    
619
        /* output a pcm frame */
620
        /* XXX: change encoding codec API to avoid this ? */
621
        switch(enc->codec->id) {
622
        case CODEC_ID_PCM_S32LE:
623
        case CODEC_ID_PCM_S32BE:
624
        case CODEC_ID_PCM_U32LE:
625
        case CODEC_ID_PCM_U32BE:
626
            size_out = size_out << 1;
627
            break;
628
        case CODEC_ID_PCM_S24LE:
629
        case CODEC_ID_PCM_S24BE:
630
        case CODEC_ID_PCM_U24LE:
631
        case CODEC_ID_PCM_U24BE:
632
        case CODEC_ID_PCM_S24DAUD:
633
            size_out = size_out / 2 * 3;
634
            break;
635
        case CODEC_ID_PCM_S16LE:
636
        case CODEC_ID_PCM_S16BE:
637
        case CODEC_ID_PCM_U16LE:
638
        case CODEC_ID_PCM_U16BE:
639
            break;
640
        default:
641
            size_out = size_out >> 1;
642
            break;
643
        }
644
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
645
        ret = avcodec_encode_audio(enc, audio_out, size_out,
646
                                   (short *)buftmp);
647
        audio_size += ret;
648
        pkt.stream_index= ost->index;
649
        pkt.data= audio_out;
650
        pkt.size= ret;
651
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
652
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
653
        pkt.flags |= PKT_FLAG_KEY;
654
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
655
    }
656
}
657

    
658
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
659
{
660
    AVCodecContext *dec;
661
    AVPicture *picture2;
662
    AVPicture picture_tmp;
663
    uint8_t *buf = 0;
664

    
665
    dec = ist->st->codec;
666

    
667
    /* deinterlace : must be done before any resize */
668
    if (do_deinterlace || using_vhook) {
669
        int size;
670

    
671
        /* create temporary picture */
672
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
673
        buf = av_malloc(size);
674
        if (!buf)
675
            return;
676

    
677
        picture2 = &picture_tmp;
678
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
679

    
680
        if (do_deinterlace){
681
            if(avpicture_deinterlace(picture2, picture,
682
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
683
                /* if error, do not deinterlace */
684
                av_free(buf);
685
                buf = NULL;
686
                picture2 = picture;
687
            }
688
        } else {
689
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
690
        }
691
    } else {
692
        picture2 = picture;
693
    }
694

    
695
    if (ENABLE_VHOOK)
696
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
697
                           1000000 * ist->pts / AV_TIME_BASE);
698

    
699
    if (picture != picture2)
700
        *picture = *picture2;
701
    *bufp = buf;
702
}
703

    
704
/* we begin to correct av delay at this threshold */
705
#define AV_DELAY_MAX 0.100
706

    
707
static void do_subtitle_out(AVFormatContext *s,
708
                            AVOutputStream *ost,
709
                            AVInputStream *ist,
710
                            AVSubtitle *sub,
711
                            int64_t pts)
712
{
713
    static uint8_t *subtitle_out = NULL;
714
    int subtitle_out_max_size = 65536;
715
    int subtitle_out_size, nb, i;
716
    AVCodecContext *enc;
717
    AVPacket pkt;
718

    
719
    if (pts == AV_NOPTS_VALUE) {
720
        fprintf(stderr, "Subtitle packets must have a pts\n");
721
        return;
722
    }
723

    
724
    enc = ost->st->codec;
725

    
726
    if (!subtitle_out) {
727
        subtitle_out = av_malloc(subtitle_out_max_size);
728
    }
729

    
730
    /* Note: DVB subtitle need one packet to draw them and one other
731
       packet to clear them */
732
    /* XXX: signal it in the codec context ? */
733
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
734
        nb = 2;
735
    else
736
        nb = 1;
737

    
738
    for(i = 0; i < nb; i++) {
739
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
740
                                                    subtitle_out_max_size, sub);
741

    
742
        av_init_packet(&pkt);
743
        pkt.stream_index = ost->index;
744
        pkt.data = subtitle_out;
745
        pkt.size = subtitle_out_size;
746
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
747
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
748
            /* XXX: the pts correction is handled here. Maybe handling
749
               it in the codec would be better */
750
            if (i == 0)
751
                pkt.pts += 90 * sub->start_display_time;
752
            else
753
                pkt.pts += 90 * sub->end_display_time;
754
        }
755
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
756
    }
757
}
758

    
759
static int bit_buffer_size= 1024*256;
760
static uint8_t *bit_buffer= NULL;
761

    
762
static void do_video_out(AVFormatContext *s,
763
                         AVOutputStream *ost,
764
                         AVInputStream *ist,
765
                         AVFrame *in_picture,
766
                         int *frame_size)
767
{
768
    int nb_frames, i, ret;
769
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
770
    AVFrame picture_crop_temp, picture_pad_temp;
771
    AVCodecContext *enc, *dec;
772

    
773
    avcodec_get_frame_defaults(&picture_crop_temp);
774
    avcodec_get_frame_defaults(&picture_pad_temp);
775

    
776
    enc = ost->st->codec;
777
    dec = ist->st->codec;
778

    
779
    /* by default, we output a single frame */
780
    nb_frames = 1;
781

    
782
    *frame_size = 0;
783

    
784
    if(video_sync_method){
785
        double vdelta;
786
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
787
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
788
        if (vdelta < -1.1)
789
            nb_frames = 0;
790
        else if (video_sync_method == 2)
791
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
792
        else if (vdelta > 1.1)
793
            nb_frames = lrintf(vdelta);
794
//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);
795
        if (nb_frames == 0){
796
            ++nb_frames_drop;
797
            if (verbose>2)
798
                fprintf(stderr, "*** drop!\n");
799
        }else if (nb_frames > 1) {
800
            nb_frames_dup += nb_frames;
801
            if (verbose>2)
802
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
803
        }
804
    }else
805
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
806

    
807
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
808
    if (nb_frames <= 0)
809
        return;
810

    
811
    if (ost->video_crop) {
812
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
813
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
814
            return;
815
        }
816
        formatted_picture = &picture_crop_temp;
817
    } else {
818
        formatted_picture = in_picture;
819
    }
820

    
821
    final_picture = formatted_picture;
822
    padding_src = formatted_picture;
823
    resampling_dst = &ost->pict_tmp;
824
    if (ost->video_pad) {
825
        final_picture = &ost->pict_tmp;
826
        if (ost->video_resample) {
827
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
828
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
829
                return;
830
            }
831
            resampling_dst = &picture_pad_temp;
832
        }
833
    }
834

    
835
    if (ost->video_resample) {
836
        padding_src = NULL;
837
        final_picture = &ost->pict_tmp;
838
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
839
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
840
    }
841

    
842
    if (ost->video_pad) {
843
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
844
                enc->height, enc->width, enc->pix_fmt,
845
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
846
    }
847

    
848
    /* duplicates frame if needed */
849
    for(i=0;i<nb_frames;i++) {
850
        AVPacket pkt;
851
        av_init_packet(&pkt);
852
        pkt.stream_index= ost->index;
853

    
854
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
855
            /* raw pictures are written as AVPicture structure to
856
               avoid any copies. We support temorarily the older
857
               method. */
858
            AVFrame* old_frame = enc->coded_frame;
859
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
860
            pkt.data= (uint8_t *)final_picture;
861
            pkt.size=  sizeof(AVPicture);
862
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
863
            pkt.flags |= PKT_FLAG_KEY;
864

    
865
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
866
            enc->coded_frame = old_frame;
867
        } else {
868
            AVFrame big_picture;
869

    
870
            big_picture= *final_picture;
871
            /* better than nothing: use input picture interlaced
872
               settings */
873
            big_picture.interlaced_frame = in_picture->interlaced_frame;
874
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
875
                if(top_field_first == -1)
876
                    big_picture.top_field_first = in_picture->top_field_first;
877
                else
878
                    big_picture.top_field_first = top_field_first;
879
            }
880

    
881
            /* handles sameq here. This is not correct because it may
882
               not be a global option */
883
            if (same_quality) {
884
                big_picture.quality = ist->st->quality;
885
            }else
886
                big_picture.quality = ost->st->quality;
887
            if(!me_threshold)
888
                big_picture.pict_type = 0;
889
//            big_picture.pts = AV_NOPTS_VALUE;
890
            big_picture.pts= ost->sync_opts;
891
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
892
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
893
            ret = avcodec_encode_video(enc,
894
                                       bit_buffer, bit_buffer_size,
895
                                       &big_picture);
896
            if (ret == -1) {
897
                fprintf(stderr, "Video encoding failed\n");
898
                av_exit(1);
899
            }
900
            //enc->frame_number = enc->real_pict_num;
901
            if(ret>0){
902
                pkt.data= bit_buffer;
903
                pkt.size= ret;
904
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
905
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
906
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
907
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
908
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
909

    
910
                if(enc->coded_frame->key_frame)
911
                    pkt.flags |= PKT_FLAG_KEY;
912
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
913
                *frame_size = ret;
914
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
915
                //        enc->frame_number-1, enc->real_pict_num, ret,
916
                //        enc->pict_type);
917
                /* if two pass, output log */
918
                if (ost->logfile && enc->stats_out) {
919
                    fprintf(ost->logfile, "%s", enc->stats_out);
920
                }
921
            }
922
        }
923
        ost->sync_opts++;
924
        ost->frame_number++;
925
    }
926
}
927

    
928
static double psnr(double d){
929
    return -10.0*log(d)/log(10.0);
930
}
931

    
932
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
933
                           int frame_size)
934
{
935
    AVCodecContext *enc;
936
    int frame_number;
937
    double ti1, bitrate, avg_bitrate;
938

    
939
    /* this is executed just the first time do_video_stats is called */
940
    if (!vstats_file) {
941
        vstats_file = fopen(vstats_filename, "w");
942
        if (!vstats_file) {
943
            perror("fopen");
944
            av_exit(1);
945
        }
946
    }
947

    
948
    enc = ost->st->codec;
949
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
950
        frame_number = ost->frame_number;
951
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
952
        if (enc->flags&CODEC_FLAG_PSNR)
953
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
954

    
955
        fprintf(vstats_file,"f_size= %6d ", frame_size);
956
        /* compute pts value */
957
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
958
        if (ti1 < 0.01)
959
            ti1 = 0.01;
960

    
961
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
962
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
963
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
964
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
965
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
966
    }
967
}
968

    
969
static void print_report(AVFormatContext **output_files,
970
                         AVOutputStream **ost_table, int nb_ostreams,
971
                         int is_last_report)
972
{
973
    char buf[1024];
974
    AVOutputStream *ost;
975
    AVFormatContext *oc, *os;
976
    int64_t total_size;
977
    AVCodecContext *enc;
978
    int frame_number, vid, i;
979
    double bitrate, ti1, pts;
980
    static int64_t last_time = -1;
981
    static int qp_histogram[52];
982

    
983
    if (!is_last_report) {
984
        int64_t cur_time;
985
        /* display the report every 0.5 seconds */
986
        cur_time = av_gettime();
987
        if (last_time == -1) {
988
            last_time = cur_time;
989
            return;
990
        }
991
        if ((cur_time - last_time) < 500000)
992
            return;
993
        last_time = cur_time;
994
    }
995

    
996

    
997
    oc = output_files[0];
998

    
999
    total_size = url_fsize(oc->pb);
1000
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1001
        total_size= url_ftell(oc->pb);
1002

    
1003
    buf[0] = '\0';
1004
    ti1 = 1e10;
1005
    vid = 0;
1006
    for(i=0;i<nb_ostreams;i++) {
1007
        ost = ost_table[i];
1008
        os = output_files[ost->file_index];
1009
        enc = ost->st->codec;
1010
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1011
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1012
                     !ost->st->stream_copy ?
1013
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1014
        }
1015
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1016
            float t = (av_gettime()-timer_start) / 1000000.0;
1017

    
1018
            frame_number = ost->frame_number;
1019
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1020
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1021
                     !ost->st->stream_copy ?
1022
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1023
            if(is_last_report)
1024
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1025
            if(qp_hist){
1026
                int j;
1027
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1028
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1029
                    qp_histogram[qp]++;
1030
                for(j=0; j<32; j++)
1031
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1032
            }
1033
            if (enc->flags&CODEC_FLAG_PSNR){
1034
                int j;
1035
                double error, error_sum=0;
1036
                double scale, scale_sum=0;
1037
                char type[3]= {'Y','U','V'};
1038
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1039
                for(j=0; j<3; j++){
1040
                    if(is_last_report){
1041
                        error= enc->error[j];
1042
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1043
                    }else{
1044
                        error= enc->coded_frame->error[j];
1045
                        scale= enc->width*enc->height*255.0*255.0;
1046
                    }
1047
                    if(j) scale/=4;
1048
                    error_sum += error;
1049
                    scale_sum += scale;
1050
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1051
                }
1052
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1053
            }
1054
            vid = 1;
1055
        }
1056
        /* compute min output value */
1057
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1058
        if ((pts < ti1) && (pts > 0))
1059
            ti1 = pts;
1060
    }
1061
    if (ti1 < 0.01)
1062
        ti1 = 0.01;
1063

    
1064
    if (verbose || is_last_report) {
1065
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1066

    
1067
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1068
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1069
            (double)total_size / 1024, ti1, bitrate);
1070

    
1071
        if (verbose > 1)
1072
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1073
                  nb_frames_dup, nb_frames_drop);
1074

    
1075
        if (verbose >= 0)
1076
            fprintf(stderr, "%s    \r", buf);
1077

    
1078
        fflush(stderr);
1079
    }
1080

    
1081
    if (is_last_report && verbose >= 0){
1082
        int64_t raw= audio_size + video_size + extra_size;
1083
        fprintf(stderr, "\n");
1084
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1085
                video_size/1024.0,
1086
                audio_size/1024.0,
1087
                extra_size/1024.0,
1088
                100.0*(total_size - raw)/raw
1089
        );
1090
    }
1091
}
1092

    
1093
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1094
static int output_packet(AVInputStream *ist, int ist_index,
1095
                         AVOutputStream **ost_table, int nb_ostreams,
1096
                         const AVPacket *pkt)
1097
{
1098
    AVFormatContext *os;
1099
    AVOutputStream *ost;
1100
    uint8_t *ptr;
1101
    int len, ret, i;
1102
    uint8_t *data_buf;
1103
    int data_size, got_picture;
1104
    AVFrame picture;
1105
    void *buffer_to_free;
1106
    static unsigned int samples_size= 0;
1107
    static short *samples= NULL;
1108
    AVSubtitle subtitle, *subtitle_to_free;
1109
    int got_subtitle;
1110

    
1111
    if(ist->next_pts == AV_NOPTS_VALUE)
1112
        ist->next_pts= ist->pts;
1113

    
1114
    if (pkt == NULL) {
1115
        /* EOF handling */
1116
        ptr = NULL;
1117
        len = 0;
1118
        goto handle_eof;
1119
    }
1120

    
1121
    if(pkt->dts != AV_NOPTS_VALUE)
1122
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1123

    
1124
    len = pkt->size;
1125
    ptr = pkt->data;
1126
    while (len > 0) {
1127
    handle_eof:
1128
        ist->pts= ist->next_pts;
1129

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

    
1133
        /* decode the packet if needed */
1134
        data_buf = NULL; /* fail safe */
1135
        data_size = 0;
1136
        subtitle_to_free = NULL;
1137
        if (ist->decoding_needed) {
1138
            switch(ist->st->codec->codec_type) {
1139
            case CODEC_TYPE_AUDIO:{
1140
                if(pkt)
1141
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1142
                data_size= samples_size;
1143
                    /* XXX: could avoid copy if PCM 16 bits with same
1144
                       endianness as CPU */
1145
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1146
                                           ptr, len);
1147
                if (ret < 0)
1148
                    goto fail_decode;
1149
                ptr += ret;
1150
                len -= ret;
1151
                /* Some bug in mpeg audio decoder gives */
1152
                /* data_size < 0, it seems they are overflows */
1153
                if (data_size <= 0) {
1154
                    /* no audio frame */
1155
                    continue;
1156
                }
1157
                data_buf = (uint8_t *)samples;
1158
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1159
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1160
                break;}
1161
            case CODEC_TYPE_VIDEO:
1162
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1163
                    /* XXX: allocate picture correctly */
1164
                    avcodec_get_frame_defaults(&picture);
1165

    
1166
                    ret = avcodec_decode_video(ist->st->codec,
1167
                                               &picture, &got_picture, ptr, len);
1168
                    ist->st->quality= picture.quality;
1169
                    if (ret < 0)
1170
                        goto fail_decode;
1171
                    if (!got_picture) {
1172
                        /* no picture yet */
1173
                        goto discard_packet;
1174
                    }
1175
                    if (ist->st->codec->time_base.num != 0) {
1176
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1177
                                          ist->st->codec->time_base.num) /
1178
                            ist->st->codec->time_base.den;
1179
                    }
1180
                    len = 0;
1181
                    break;
1182
            case CODEC_TYPE_SUBTITLE:
1183
                ret = avcodec_decode_subtitle(ist->st->codec,
1184
                                              &subtitle, &got_subtitle, ptr, len);
1185
                if (ret < 0)
1186
                    goto fail_decode;
1187
                if (!got_subtitle) {
1188
                    goto discard_packet;
1189
                }
1190
                subtitle_to_free = &subtitle;
1191
                len = 0;
1192
                break;
1193
            default:
1194
                goto fail_decode;
1195
            }
1196
        } else {
1197
            switch(ist->st->codec->codec_type) {
1198
            case CODEC_TYPE_AUDIO:
1199
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1200
                    ist->st->codec->sample_rate;
1201
                break;
1202
            case CODEC_TYPE_VIDEO:
1203
                if (ist->st->codec->time_base.num != 0) {
1204
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1205
                                      ist->st->codec->time_base.num) /
1206
                        ist->st->codec->time_base.den;
1207
                }
1208
                break;
1209
            }
1210
            data_buf = ptr;
1211
            data_size = len;
1212
            ret = len;
1213
            len = 0;
1214
        }
1215

    
1216
        buffer_to_free = NULL;
1217
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1218
            pre_process_video_frame(ist, (AVPicture *)&picture,
1219
                                    &buffer_to_free);
1220
        }
1221

    
1222
        // preprocess audio (volume)
1223
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1224
            if (audio_volume != 256) {
1225
                short *volp;
1226
                volp = samples;
1227
                for(i=0;i<(data_size / sizeof(short));i++) {
1228
                    int v = ((*volp) * audio_volume + 128) >> 8;
1229
                    if (v < -32768) v = -32768;
1230
                    if (v >  32767) v = 32767;
1231
                    *volp++ = v;
1232
                }
1233
            }
1234
        }
1235

    
1236
        /* frame rate emulation */
1237
        if (ist->st->codec->rate_emu) {
1238
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1239
            int64_t now = av_gettime() - ist->start;
1240
            if (pts > now)
1241
                usleep(pts - now);
1242

    
1243
            ist->frame++;
1244
        }
1245

    
1246
#if 0
1247
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1248
           is the one of the next displayed one */
1249
        /* XXX: add mpeg4 too ? */
1250
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1251
            if (ist->st->codec->pict_type != B_TYPE) {
1252
                int64_t tmp;
1253
                tmp = ist->last_ip_pts;
1254
                ist->last_ip_pts  = ist->frac_pts.val;
1255
                ist->frac_pts.val = tmp;
1256
            }
1257
        }
1258
#endif
1259
        /* if output time reached then transcode raw format,
1260
           encode packets and output them */
1261
        if (start_time == 0 || ist->pts >= start_time)
1262
            for(i=0;i<nb_ostreams;i++) {
1263
                int frame_size;
1264

    
1265
                ost = ost_table[i];
1266
                if (ost->source_index == ist_index) {
1267
                    os = output_files[ost->file_index];
1268

    
1269
#if 0
1270
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1271
                           (double)pkt->pts / AV_TIME_BASE,
1272
                           ((double)ist->pts / AV_TIME_BASE) -
1273
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1274
#endif
1275
                    /* set the input output pts pairs */
1276
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1277

    
1278
                    if (ost->encoding_needed) {
1279
                        switch(ost->st->codec->codec_type) {
1280
                        case CODEC_TYPE_AUDIO:
1281
                            do_audio_out(os, ost, ist, data_buf, data_size);
1282
                            break;
1283
                        case CODEC_TYPE_VIDEO:
1284
                            do_video_out(os, ost, ist, &picture, &frame_size);
1285
                            video_size += frame_size;
1286
                            if (vstats_filename && frame_size)
1287
                                do_video_stats(os, ost, frame_size);
1288
                            break;
1289
                        case CODEC_TYPE_SUBTITLE:
1290
                            do_subtitle_out(os, ost, ist, &subtitle,
1291
                                            pkt->pts);
1292
                            break;
1293
                        default:
1294
                            abort();
1295
                        }
1296
                    } else {
1297
                        AVFrame avframe; //FIXME/XXX remove this
1298
                        AVPacket opkt;
1299
                        av_init_packet(&opkt);
1300

    
1301
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1302
                            continue;
1303

    
1304
                        /* no reencoding needed : output the packet directly */
1305
                        /* force the input stream PTS */
1306

    
1307
                        avcodec_get_frame_defaults(&avframe);
1308
                        ost->st->codec->coded_frame= &avframe;
1309
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1310

    
1311
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1312
                            audio_size += data_size;
1313
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1314
                            video_size += data_size;
1315
                            ost->sync_opts++;
1316
                        }
1317

    
1318
                        opkt.stream_index= ost->index;
1319
                        if(pkt->pts != AV_NOPTS_VALUE)
1320
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1321
                        else
1322
                            opkt.pts= AV_NOPTS_VALUE;
1323

    
1324
                            if (pkt->dts == AV_NOPTS_VALUE)
1325
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1326
                            else
1327
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1328

    
1329
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1330
                        opkt.flags= pkt->flags;
1331

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

    
1336
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1337
                        ost->st->codec->frame_number++;
1338
                        ost->frame_number++;
1339
                        av_free_packet(&opkt);
1340
                    }
1341
                }
1342
            }
1343
        av_free(buffer_to_free);
1344
        /* XXX: allocate the subtitles in the codec ? */
1345
        if (subtitle_to_free) {
1346
            if (subtitle_to_free->rects != NULL) {
1347
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1348
                    av_free(subtitle_to_free->rects[i].bitmap);
1349
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1350
                }
1351
                av_freep(&subtitle_to_free->rects);
1352
            }
1353
            subtitle_to_free->num_rects = 0;
1354
            subtitle_to_free = NULL;
1355
        }
1356
    }
1357
 discard_packet:
1358
    if (pkt == NULL) {
1359
        /* EOF handling */
1360

    
1361
        for(i=0;i<nb_ostreams;i++) {
1362
            ost = ost_table[i];
1363
            if (ost->source_index == ist_index) {
1364
                AVCodecContext *enc= ost->st->codec;
1365
                os = output_files[ost->file_index];
1366

    
1367
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1368
                    continue;
1369
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1370
                    continue;
1371

    
1372
                if (ost->encoding_needed) {
1373
                    for(;;) {
1374
                        AVPacket pkt;
1375
                        int fifo_bytes;
1376
                        av_init_packet(&pkt);
1377
                        pkt.stream_index= ost->index;
1378

    
1379
                        switch(ost->st->codec->codec_type) {
1380
                        case CODEC_TYPE_AUDIO:
1381
                            fifo_bytes = av_fifo_size(&ost->fifo);
1382
                            ret = 0;
1383
                            /* encode any samples remaining in fifo */
1384
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1385
                                int fs_tmp = enc->frame_size;
1386
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1387
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1388
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1389
                                enc->frame_size = fs_tmp;
1390
                            }
1391
                            if(ret <= 0) {
1392
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1393
                            }
1394
                            audio_size += ret;
1395
                            pkt.flags |= PKT_FLAG_KEY;
1396
                            break;
1397
                        case CODEC_TYPE_VIDEO:
1398
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1399
                            video_size += ret;
1400
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1401
                                pkt.flags |= PKT_FLAG_KEY;
1402
                            if (ost->logfile && enc->stats_out) {
1403
                                fprintf(ost->logfile, "%s", enc->stats_out);
1404
                            }
1405
                            break;
1406
                        default:
1407
                            ret=-1;
1408
                        }
1409

    
1410
                        if(ret<=0)
1411
                            break;
1412
                        pkt.data= bit_buffer;
1413
                        pkt.size= ret;
1414
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1415
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1416
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1417
                    }
1418
                }
1419
            }
1420
        }
1421
    }
1422

    
1423
    return 0;
1424
 fail_decode:
1425
    return -1;
1426
}
1427

    
1428
static void print_sdp(AVFormatContext **avc, int n)
1429
{
1430
    char sdp[2048];
1431

    
1432
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1433
    printf("SDP:\n%s\n", sdp);
1434
}
1435

    
1436
static int stream_index_from_inputs(AVFormatContext **input_files,
1437
                                    int nb_input_files,
1438
                                    AVInputFile *file_table,
1439
                                    AVInputStream **ist_table,
1440
                                    enum CodecType type,
1441
                                    int programid)
1442
{
1443
    int p, q, z;
1444
    for(z=0; z<nb_input_files; z++) {
1445
        AVFormatContext *ic = input_files[z];
1446
        for(p=0; p<ic->nb_programs; p++) {
1447
            AVProgram *program = ic->programs[p];
1448
            if(program->id != programid)
1449
                continue;
1450
            for(q=0; q<program->nb_stream_indexes; q++) {
1451
                int sidx = program->stream_index[q];
1452
                int ris = file_table[z].ist_index + sidx;
1453
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1454
                    return ris;
1455
            }
1456
        }
1457
    }
1458

    
1459
    return -1;
1460
}
1461

    
1462
/*
1463
 * The following code is the main loop of the file converter
1464
 */
1465
static int av_encode(AVFormatContext **output_files,
1466
                     int nb_output_files,
1467
                     AVFormatContext **input_files,
1468
                     int nb_input_files,
1469
                     AVStreamMap *stream_maps, int nb_stream_maps)
1470
{
1471
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1472
    AVFormatContext *is, *os;
1473
    AVCodecContext *codec, *icodec;
1474
    AVOutputStream *ost, **ost_table = NULL;
1475
    AVInputStream *ist, **ist_table = NULL;
1476
    AVInputFile *file_table;
1477
    int key;
1478
    int want_sdp = 1;
1479

    
1480
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1481
    if (!file_table)
1482
        goto fail;
1483

    
1484
    /* input stream init */
1485
    j = 0;
1486
    for(i=0;i<nb_input_files;i++) {
1487
        is = input_files[i];
1488
        file_table[i].ist_index = j;
1489
        file_table[i].nb_streams = is->nb_streams;
1490
        j += is->nb_streams;
1491
    }
1492
    nb_istreams = j;
1493

    
1494
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1495
    if (!ist_table)
1496
        goto fail;
1497

    
1498
    for(i=0;i<nb_istreams;i++) {
1499
        ist = av_mallocz(sizeof(AVInputStream));
1500
        if (!ist)
1501
            goto fail;
1502
        ist_table[i] = ist;
1503
    }
1504
    j = 0;
1505
    for(i=0;i<nb_input_files;i++) {
1506
        is = input_files[i];
1507
        for(k=0;k<is->nb_streams;k++) {
1508
            ist = ist_table[j++];
1509
            ist->st = is->streams[k];
1510
            ist->file_index = i;
1511
            ist->index = k;
1512
            ist->discard = 1; /* the stream is discarded by default
1513
                                 (changed later) */
1514

    
1515
            if (ist->st->codec->rate_emu) {
1516
                ist->start = av_gettime();
1517
                ist->frame = 0;
1518
            }
1519
        }
1520
    }
1521

    
1522
    /* output stream init */
1523
    nb_ostreams = 0;
1524
    for(i=0;i<nb_output_files;i++) {
1525
        os = output_files[i];
1526
        if (!os->nb_streams) {
1527
            fprintf(stderr, "Output file does not contain any stream\n");
1528
            av_exit(1);
1529
        }
1530
        nb_ostreams += os->nb_streams;
1531
    }
1532
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1533
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1534
        av_exit(1);
1535
    }
1536

    
1537
    /* Sanity check the mapping args -- do the input files & streams exist? */
1538
    for(i=0;i<nb_stream_maps;i++) {
1539
        int fi = stream_maps[i].file_index;
1540
        int si = stream_maps[i].stream_index;
1541

    
1542
        if (fi < 0 || fi > nb_input_files - 1 ||
1543
            si < 0 || si > file_table[fi].nb_streams - 1) {
1544
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1545
            av_exit(1);
1546
        }
1547
        fi = stream_maps[i].sync_file_index;
1548
        si = stream_maps[i].sync_stream_index;
1549
        if (fi < 0 || fi > nb_input_files - 1 ||
1550
            si < 0 || si > file_table[fi].nb_streams - 1) {
1551
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1552
            av_exit(1);
1553
        }
1554
    }
1555

    
1556
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1557
    if (!ost_table)
1558
        goto fail;
1559
    for(i=0;i<nb_ostreams;i++) {
1560
        ost = av_mallocz(sizeof(AVOutputStream));
1561
        if (!ost)
1562
            goto fail;
1563
        ost_table[i] = ost;
1564
    }
1565

    
1566
    n = 0;
1567
    for(k=0;k<nb_output_files;k++) {
1568
        os = output_files[k];
1569
        for(i=0;i<os->nb_streams;i++) {
1570
            int found;
1571
            ost = ost_table[n++];
1572
            ost->file_index = k;
1573
            ost->index = i;
1574
            ost->st = os->streams[i];
1575
            if (nb_stream_maps > 0) {
1576
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1577
                    stream_maps[n-1].stream_index;
1578

    
1579
                /* Sanity check that the stream types match */
1580
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1581
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1582
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1583
                        ost->file_index, ost->index);
1584
                    av_exit(1);
1585
                }
1586

    
1587
            } else {
1588
                if(opt_programid) {
1589
                    found = 0;
1590
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1591
                    if(j != -1) {
1592
                        ost->source_index = j;
1593
                        found = 1;
1594
                    }
1595
                } else {
1596
                    /* get corresponding input stream index : we select the first one with the right type */
1597
                    found = 0;
1598
                    for(j=0;j<nb_istreams;j++) {
1599
                        ist = ist_table[j];
1600
                        if (ist->discard &&
1601
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1602
                            ost->source_index = j;
1603
                            found = 1;
1604
                            break;
1605
                        }
1606
                    }
1607
                }
1608

    
1609
                if (!found) {
1610
                    if(! opt_programid) {
1611
                        /* try again and reuse existing stream */
1612
                        for(j=0;j<nb_istreams;j++) {
1613
                            ist = ist_table[j];
1614
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1615
                                ost->source_index = j;
1616
                                found = 1;
1617
                            }
1618
                        }
1619
                    }
1620
                    if (!found) {
1621
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1622
                                ost->file_index, ost->index);
1623
                        av_exit(1);
1624
                    }
1625
                }
1626
            }
1627
            ist = ist_table[ost->source_index];
1628
            ist->discard = 0;
1629
            ost->sync_ist = (nb_stream_maps > 0) ?
1630
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1631
                         stream_maps[n-1].sync_stream_index] : ist;
1632
        }
1633
    }
1634

    
1635
    /* for each output stream, we compute the right encoding parameters */
1636
    for(i=0;i<nb_ostreams;i++) {
1637
        ost = ost_table[i];
1638
        os = output_files[ost->file_index];
1639
        ist = ist_table[ost->source_index];
1640

    
1641
        codec = ost->st->codec;
1642
        icodec = ist->st->codec;
1643

    
1644
        if (!ost->st->language[0])
1645
            av_strlcpy(ost->st->language, ist->st->language,
1646
                       sizeof(ost->st->language));
1647

    
1648
        ost->st->disposition = ist->st->disposition;
1649

    
1650
        if (ost->st->stream_copy) {
1651
            /* if stream_copy is selected, no need to decode or encode */
1652
            codec->codec_id = icodec->codec_id;
1653
            codec->codec_type = icodec->codec_type;
1654

    
1655
            if(!codec->codec_tag){
1656
                if(   !os->oformat->codec_tag
1657
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1658
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1659
                    codec->codec_tag = icodec->codec_tag;
1660
            }
1661

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

    
1772
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1773
                         pass_logfilename ?
1774
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1775
                if (codec->flags & CODEC_FLAG_PASS1) {
1776
                    f = fopen(logfilename, "w");
1777
                    if (!f) {
1778
                        perror(logfilename);
1779
                        av_exit(1);
1780
                    }
1781
                    ost->logfile = f;
1782
                } else {
1783
                    /* read the log file */
1784
                    f = fopen(logfilename, "r");
1785
                    if (!f) {
1786
                        perror(logfilename);
1787
                        av_exit(1);
1788
                    }
1789
                    fseek(f, 0, SEEK_END);
1790
                    size = ftell(f);
1791
                    fseek(f, 0, SEEK_SET);
1792
                    logbuffer = av_malloc(size + 1);
1793
                    if (!logbuffer) {
1794
                        fprintf(stderr, "Could not allocate log buffer\n");
1795
                        av_exit(1);
1796
                    }
1797
                    size = fread(logbuffer, 1, size, f);
1798
                    fclose(f);
1799
                    logbuffer[size] = '\0';
1800
                    codec->stats_in = logbuffer;
1801
                }
1802
            }
1803
        }
1804
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1805
            int size= codec->width * codec->height;
1806
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1807
        }
1808
    }
1809

    
1810
    if (!bit_buffer)
1811
        bit_buffer = av_malloc(bit_buffer_size);
1812
    if (!bit_buffer)
1813
        goto fail;
1814

    
1815
    /* dump the file output parameters - cannot be done before in case
1816
       of stream copy */
1817
    for(i=0;i<nb_output_files;i++) {
1818
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1819
    }
1820

    
1821
    /* dump the stream mapping */
1822
    if (verbose >= 0) {
1823
        fprintf(stderr, "Stream mapping:\n");
1824
        for(i=0;i<nb_ostreams;i++) {
1825
            ost = ost_table[i];
1826
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1827
                    ist_table[ost->source_index]->file_index,
1828
                    ist_table[ost->source_index]->index,
1829
                    ost->file_index,
1830
                    ost->index);
1831
            if (ost->sync_ist != ist_table[ost->source_index])
1832
                fprintf(stderr, " [sync #%d.%d]",
1833
                        ost->sync_ist->file_index,
1834
                        ost->sync_ist->index);
1835
            fprintf(stderr, "\n");
1836
        }
1837
    }
1838

    
1839
    /* open each encoder */
1840
    for(i=0;i<nb_ostreams;i++) {
1841
        ost = ost_table[i];
1842
        if (ost->encoding_needed) {
1843
            AVCodec *codec;
1844
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1845
            if (!codec) {
1846
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1847
                        ost->file_index, ost->index);
1848
                av_exit(1);
1849
            }
1850
            if (avcodec_open(ost->st->codec, codec) < 0) {
1851
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1852
                        ost->file_index, ost->index);
1853
                av_exit(1);
1854
            }
1855
            extra_size += ost->st->codec->extradata_size;
1856
        }
1857
    }
1858

    
1859
    /* open each decoder */
1860
    for(i=0;i<nb_istreams;i++) {
1861
        ist = ist_table[i];
1862
        if (ist->decoding_needed) {
1863
            AVCodec *codec;
1864
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1865
            if (!codec) {
1866
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1867
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1868
                av_exit(1);
1869
            }
1870
            if (avcodec_open(ist->st->codec, codec) < 0) {
1871
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1872
                        ist->file_index, ist->index);
1873
                av_exit(1);
1874
            }
1875
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1876
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1877
        }
1878
    }
1879

    
1880
    /* init pts */
1881
    for(i=0;i<nb_istreams;i++) {
1882
        ist = ist_table[i];
1883
        is = input_files[ist->file_index];
1884
        ist->pts = 0;
1885
        ist->next_pts = AV_NOPTS_VALUE;
1886
        ist->is_start = 1;
1887
    }
1888

    
1889
    /* set meta data information from input file if required */
1890
    for (i=0;i<nb_meta_data_maps;i++) {
1891
        AVFormatContext *out_file;
1892
        AVFormatContext *in_file;
1893

    
1894
        int out_file_index = meta_data_maps[i].out_file;
1895
        int in_file_index = meta_data_maps[i].in_file;
1896
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1897
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1898
            ret = AVERROR(EINVAL);
1899
            goto fail;
1900
        }
1901
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1902
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1903
            ret = AVERROR(EINVAL);
1904
            goto fail;
1905
        }
1906

    
1907
        out_file = output_files[out_file_index];
1908
        in_file = input_files[in_file_index];
1909

    
1910
        strcpy(out_file->title, in_file->title);
1911
        strcpy(out_file->author, in_file->author);
1912
        strcpy(out_file->copyright, in_file->copyright);
1913
        strcpy(out_file->comment, in_file->comment);
1914
        strcpy(out_file->album, in_file->album);
1915
        out_file->year = in_file->year;
1916
        out_file->track = in_file->track;
1917
        strcpy(out_file->genre, in_file->genre);
1918
    }
1919

    
1920
    /* open files and write file headers */
1921
    for(i=0;i<nb_output_files;i++) {
1922
        os = output_files[i];
1923
        if (av_write_header(os) < 0) {
1924
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1925
            ret = AVERROR(EINVAL);
1926
            goto fail;
1927
        }
1928
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1929
            want_sdp = 0;
1930
        }
1931
    }
1932
    if (want_sdp) {
1933
        print_sdp(output_files, nb_output_files);
1934
    }
1935

    
1936
    if (!using_stdin && verbose >= 0) {
1937
        fprintf(stderr, "Press [q] to stop encoding\n");
1938
        url_set_interrupt_cb(decode_interrupt_cb);
1939
    }
1940
    term_init();
1941

    
1942
    key = -1;
1943
    timer_start = av_gettime();
1944

    
1945
    for(; received_sigterm == 0;) {
1946
        int file_index, ist_index;
1947
        AVPacket pkt;
1948
        double ipts_min;
1949
        double opts_min;
1950

    
1951
    redo:
1952
        ipts_min= 1e100;
1953
        opts_min= 1e100;
1954
        /* if 'q' pressed, exits */
1955
        if (!using_stdin) {
1956
            if (q_pressed)
1957
                break;
1958
            /* read_key() returns 0 on EOF */
1959
            key = read_key();
1960
            if (key == 'q')
1961
                break;
1962
        }
1963

    
1964
        /* select the stream that we must read now by looking at the
1965
           smallest output pts */
1966
        file_index = -1;
1967
        for(i=0;i<nb_ostreams;i++) {
1968
            double ipts, opts;
1969
            ost = ost_table[i];
1970
            os = output_files[ost->file_index];
1971
            ist = ist_table[ost->source_index];
1972
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1973
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1974
            else
1975
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1976
            ipts = (double)ist->pts;
1977
            if (!file_table[ist->file_index].eof_reached){
1978
                if(ipts < ipts_min) {
1979
                    ipts_min = ipts;
1980
                    if(input_sync ) file_index = ist->file_index;
1981
                }
1982
                if(opts < opts_min) {
1983
                    opts_min = opts;
1984
                    if(!input_sync) file_index = ist->file_index;
1985
                }
1986
            }
1987
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1988
                file_index= -1;
1989
                break;
1990
            }
1991
        }
1992
        /* if none, if is finished */
1993
        if (file_index < 0) {
1994
            break;
1995
        }
1996

    
1997
        /* finish if recording time exhausted */
1998
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1999
            break;
2000

    
2001
        /* finish if limit size exhausted */
2002
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2003
            break;
2004

    
2005
        /* read a frame from it and output it in the fifo */
2006
        is = input_files[file_index];
2007
        if (av_read_frame(is, &pkt) < 0) {
2008
            file_table[file_index].eof_reached = 1;
2009
            if (opt_shortest)
2010
                break;
2011
            else
2012
                continue;
2013
        }
2014

    
2015
        if (do_pkt_dump) {
2016
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2017
        }
2018
        /* the following test is needed in case new streams appear
2019
           dynamically in stream : we ignore them */
2020
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2021
            goto discard_packet;
2022
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2023
        ist = ist_table[ist_index];
2024
        if (ist->discard)
2025
            goto discard_packet;
2026

    
2027
        if (pkt.dts != AV_NOPTS_VALUE)
2028
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2029
        if (pkt.pts != AV_NOPTS_VALUE)
2030
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2031

    
2032
//        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);
2033
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2034
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2035
            int64_t delta= pkt_dts - ist->next_pts;
2036
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2037
                input_files_ts_offset[ist->file_index]-= delta;
2038
                if (verbose > 2)
2039
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2040
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2041
                if(pkt.pts != AV_NOPTS_VALUE)
2042
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2043
            }
2044
        }
2045

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

    
2049
            if (verbose >= 0)
2050
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2051
                        ist->file_index, ist->index);
2052

    
2053
            av_free_packet(&pkt);
2054
            goto redo;
2055
        }
2056

    
2057
    discard_packet:
2058
        av_free_packet(&pkt);
2059

    
2060
        /* dump report by using the output first video and audio streams */
2061
        print_report(output_files, ost_table, nb_ostreams, 0);
2062
    }
2063

    
2064
    /* at the end of stream, we must flush the decoder buffers */
2065
    for(i=0;i<nb_istreams;i++) {
2066
        ist = ist_table[i];
2067
        if (ist->decoding_needed) {
2068
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2069
        }
2070
    }
2071

    
2072
    term_exit();
2073

    
2074
    /* write the trailer if needed and close file */
2075
    for(i=0;i<nb_output_files;i++) {
2076
        os = output_files[i];
2077
        av_write_trailer(os);
2078
    }
2079

    
2080
    /* dump report by using the first video and audio streams */
2081
    print_report(output_files, ost_table, nb_ostreams, 1);
2082

    
2083
    /* close each encoder */
2084
    for(i=0;i<nb_ostreams;i++) {
2085
        ost = ost_table[i];
2086
        if (ost->encoding_needed) {
2087
            av_freep(&ost->st->codec->stats_in);
2088
            avcodec_close(ost->st->codec);
2089
        }
2090
    }
2091

    
2092
    /* close each decoder */
2093
    for(i=0;i<nb_istreams;i++) {
2094
        ist = ist_table[i];
2095
        if (ist->decoding_needed) {
2096
            avcodec_close(ist->st->codec);
2097
        }
2098
    }
2099

    
2100
    /* finished ! */
2101

    
2102
    ret = 0;
2103
 fail1:
2104
    av_freep(&bit_buffer);
2105
    av_free(file_table);
2106

    
2107
    if (ist_table) {
2108
        for(i=0;i<nb_istreams;i++) {
2109
            ist = ist_table[i];
2110
            av_free(ist);
2111
        }
2112
        av_free(ist_table);
2113
    }
2114
    if (ost_table) {
2115
        for(i=0;i<nb_ostreams;i++) {
2116
            ost = ost_table[i];
2117
            if (ost) {
2118
                if (ost->logfile) {
2119
                    fclose(ost->logfile);
2120
                    ost->logfile = NULL;
2121
                }
2122
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2123
                                             initialized but set to zero */
2124
                av_free(ost->pict_tmp.data[0]);
2125
                if (ost->video_resample)
2126
                    sws_freeContext(ost->img_resample_ctx);
2127
                if (ost->resample)
2128
                    audio_resample_close(ost->resample);
2129
                av_free(ost);
2130
            }
2131
        }
2132
        av_free(ost_table);
2133
    }
2134
    return ret;
2135
 fail:
2136
    ret = AVERROR(ENOMEM);
2137
    goto fail1;
2138
}
2139

    
2140
#if 0
2141
int file_read(const char *filename)
2142
{
2143
    URLContext *h;
2144
    unsigned char buffer[1024];
2145
    int len, i;
2146

2147
    if (url_open(&h, filename, O_RDONLY) < 0) {
2148
        printf("could not open '%s'\n", filename);
2149
        return -1;
2150
    }
2151
    for(;;) {
2152
        len = url_read(h, buffer, sizeof(buffer));
2153
        if (len <= 0)
2154
            break;
2155
        for(i=0;i<len;i++) putchar(buffer[i]);
2156
    }
2157
    url_close(h);
2158
    return 0;
2159
}
2160
#endif
2161

    
2162
static void opt_format(const char *arg)
2163
{
2164
    /* compatibility stuff for pgmyuv */
2165
    if (!strcmp(arg, "pgmyuv")) {
2166
        pgmyuv_compatibility_hack=1;
2167
//        opt_image_format(arg);
2168
        arg = "image2";
2169
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2170
    }
2171

    
2172
    file_iformat = av_find_input_format(arg);
2173
    file_oformat = guess_format(arg, NULL, NULL);
2174
    if (!file_iformat && !file_oformat) {
2175
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2176
        av_exit(1);
2177
    }
2178
}
2179

    
2180
extern int ffm_nopts;
2181

    
2182
static int opt_default(const char *opt, const char *arg){
2183
    int type;
2184
    const AVOption *o= NULL;
2185
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2186

    
2187
    for(type=0; type<CODEC_TYPE_NB; type++){
2188
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2189
        if(o2)
2190
            o = av_set_string(avctx_opts[type], opt, arg);
2191
    }
2192
    if(!o)
2193
        o = av_set_string(avformat_opts, opt, arg);
2194
    if(!o)
2195
        o = av_set_string(sws_opts, opt, arg);
2196
    if(!o){
2197
        if(opt[0] == 'a')
2198
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2199
        else if(opt[0] == 'v')
2200
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2201
        else if(opt[0] == 's')
2202
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2203
    }
2204
    if(!o)
2205
        return -1;
2206

    
2207
//    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));
2208

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

    
2213
#ifdef CONFIG_FFM_MUXER
2214
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
2215
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2216
        ffm_nopts = 1;
2217
#endif
2218

    
2219
    if(avctx_opts[0]->debug)
2220
        av_log_set_level(AV_LOG_DEBUG);
2221
    return 0;
2222
}
2223

    
2224
static void opt_video_rc_override_string(const char *arg)
2225
{
2226
    video_rc_override_string = arg;
2227
}
2228

    
2229
static int opt_me_threshold(const char *opt, const char *arg)
2230
{
2231
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2232
    return 0;
2233
}
2234

    
2235
static int opt_verbose(const char *opt, const char *arg)
2236
{
2237
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2238
    av_log_set_level(verbose);
2239
    return 0;
2240
}
2241

    
2242
static void opt_frame_rate(const char *arg)
2243
{
2244
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2245
        fprintf(stderr, "Incorrect frame rate\n");
2246
        av_exit(1);
2247
    }
2248
}
2249

    
2250
static int opt_bitrate(const char *opt, const char *arg)
2251
{
2252
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2253

    
2254
    opt_default(opt, arg);
2255

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

    
2259
    return 0;
2260
}
2261

    
2262
static void opt_frame_crop_top(const char *arg)
2263
{
2264
    frame_topBand = atoi(arg);
2265
    if (frame_topBand < 0) {
2266
        fprintf(stderr, "Incorrect top crop size\n");
2267
        av_exit(1);
2268
    }
2269
    if ((frame_topBand % 2) != 0) {
2270
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2271
        av_exit(1);
2272
    }
2273
    if ((frame_topBand) >= frame_height){
2274
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2275
        av_exit(1);
2276
    }
2277
    frame_height -= frame_topBand;
2278
}
2279

    
2280
static void opt_frame_crop_bottom(const char *arg)
2281
{
2282
    frame_bottomBand = atoi(arg);
2283
    if (frame_bottomBand < 0) {
2284
        fprintf(stderr, "Incorrect bottom crop size\n");
2285
        av_exit(1);
2286
    }
2287
    if ((frame_bottomBand % 2) != 0) {
2288
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2289
        av_exit(1);
2290
    }
2291
    if ((frame_bottomBand) >= frame_height){
2292
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2293
        av_exit(1);
2294
    }
2295
    frame_height -= frame_bottomBand;
2296
}
2297

    
2298
static void opt_frame_crop_left(const char *arg)
2299
{
2300
    frame_leftBand = atoi(arg);
2301
    if (frame_leftBand < 0) {
2302
        fprintf(stderr, "Incorrect left crop size\n");
2303
        av_exit(1);
2304
    }
2305
    if ((frame_leftBand % 2) != 0) {
2306
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2307
        av_exit(1);
2308
    }
2309
    if ((frame_leftBand) >= frame_width){
2310
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2311
        av_exit(1);
2312
    }
2313
    frame_width -= frame_leftBand;
2314
}
2315

    
2316
static void opt_frame_crop_right(const char *arg)
2317
{
2318
    frame_rightBand = atoi(arg);
2319
    if (frame_rightBand < 0) {
2320
        fprintf(stderr, "Incorrect right crop size\n");
2321
        av_exit(1);
2322
    }
2323
    if ((frame_rightBand % 2) != 0) {
2324
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2325
        av_exit(1);
2326
    }
2327
    if ((frame_rightBand) >= frame_width){
2328
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2329
        av_exit(1);
2330
    }
2331
    frame_width -= frame_rightBand;
2332
}
2333

    
2334
static void opt_frame_size(const char *arg)
2335
{
2336
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2337
        fprintf(stderr, "Incorrect frame size\n");
2338
        av_exit(1);
2339
    }
2340
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2341
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2342
        av_exit(1);
2343
    }
2344
}
2345

    
2346

    
2347
#define SCALEBITS 10
2348
#define ONE_HALF  (1 << (SCALEBITS - 1))
2349
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2350

    
2351
#define RGB_TO_Y(r, g, b) \
2352
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2353
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2354

    
2355
#define RGB_TO_U(r1, g1, b1, shift)\
2356
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2357
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2358

    
2359
#define RGB_TO_V(r1, g1, b1, shift)\
2360
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2361
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2362

    
2363
static void opt_pad_color(const char *arg) {
2364
    /* Input is expected to be six hex digits similar to
2365
       how colors are expressed in html tags (but without the #) */
2366
    int rgb = strtol(arg, NULL, 16);
2367
    int r,g,b;
2368

    
2369
    r = (rgb >> 16);
2370
    g = ((rgb >> 8) & 255);
2371
    b = (rgb & 255);
2372

    
2373
    padcolor[0] = RGB_TO_Y(r,g,b);
2374
    padcolor[1] = RGB_TO_U(r,g,b,0);
2375
    padcolor[2] = RGB_TO_V(r,g,b,0);
2376
}
2377

    
2378
static void opt_frame_pad_top(const char *arg)
2379
{
2380
    frame_padtop = atoi(arg);
2381
    if (frame_padtop < 0) {
2382
        fprintf(stderr, "Incorrect top pad size\n");
2383
        av_exit(1);
2384
    }
2385
    if ((frame_padtop % 2) != 0) {
2386
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2387
        av_exit(1);
2388
    }
2389
}
2390

    
2391
static void opt_frame_pad_bottom(const char *arg)
2392
{
2393
    frame_padbottom = atoi(arg);
2394
    if (frame_padbottom < 0) {
2395
        fprintf(stderr, "Incorrect bottom pad size\n");
2396
        av_exit(1);
2397
    }
2398
    if ((frame_padbottom % 2) != 0) {
2399
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2400
        av_exit(1);
2401
    }
2402
}
2403

    
2404

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

    
2418

    
2419
static void opt_frame_pad_right(const char *arg)
2420
{
2421
    frame_padright = atoi(arg);
2422
    if (frame_padright < 0) {
2423
        fprintf(stderr, "Incorrect right pad size\n");
2424
        av_exit(1);
2425
    }
2426
    if ((frame_padright % 2) != 0) {
2427
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2428
        av_exit(1);
2429
    }
2430
}
2431

    
2432
static void list_pix_fmts(void)
2433
{
2434
    int i;
2435
    char pix_fmt_str[128];
2436
    for (i=-1; i < PIX_FMT_NB; i++) {
2437
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2438
        fprintf(stdout, "%s\n", pix_fmt_str);
2439
    }
2440
}
2441

    
2442
static void opt_frame_pix_fmt(const char *arg)
2443
{
2444
    if (strcmp(arg, "list"))
2445
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2446
    else {
2447
        list_pix_fmts();
2448
        av_exit(0);
2449
    }
2450
}
2451

    
2452
static void opt_frame_aspect_ratio(const char *arg)
2453
{
2454
    int x = 0, y = 0;
2455
    double ar = 0;
2456
    const char *p;
2457
    char *end;
2458

    
2459
    p = strchr(arg, ':');
2460
    if (p) {
2461
        x = strtol(arg, &end, 10);
2462
        if (end == p)
2463
            y = strtol(end+1, &end, 10);
2464
        if (x > 0 && y > 0)
2465
            ar = (double)x / (double)y;
2466
    } else
2467
        ar = strtod(arg, NULL);
2468

    
2469
    if (!ar) {
2470
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2471
        av_exit(1);
2472
    }
2473
    frame_aspect_ratio = ar;
2474
}
2475

    
2476
static void opt_qscale(const char *arg)
2477
{
2478
    video_qscale = atof(arg);
2479
    if (video_qscale <= 0 ||
2480
        video_qscale > 255) {
2481
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2482
        av_exit(1);
2483
    }
2484
}
2485

    
2486
static void opt_qdiff(const char *arg)
2487
{
2488
    video_qdiff = atoi(arg);
2489
    if (video_qdiff < 0 ||
2490
        video_qdiff > 31) {
2491
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2492
        av_exit(1);
2493
    }
2494
}
2495

    
2496
static void opt_strict(const char *arg)
2497
{
2498
    strict= atoi(arg);
2499
}
2500

    
2501
static void opt_top_field_first(const char *arg)
2502
{
2503
    top_field_first= atoi(arg);
2504
}
2505

    
2506
static void opt_thread_count(const char *arg)
2507
{
2508
    thread_count= atoi(arg);
2509
#if !defined(HAVE_THREADS)
2510
    if (verbose >= 0)
2511
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2512
#endif
2513
}
2514

    
2515
static int opt_audio_rate(const char *opt, const char *arg)
2516
{
2517
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2518
    return 0;
2519
}
2520

    
2521
static int opt_audio_channels(const char *opt, const char *arg)
2522
{
2523
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2524
    return 0;
2525
}
2526

    
2527
static void opt_video_channel(const char *arg)
2528
{
2529
    video_channel = strtol(arg, NULL, 0);
2530
}
2531

    
2532
static void opt_video_standard(const char *arg)
2533
{
2534
    video_standard = av_strdup(arg);
2535
}
2536

    
2537
static void opt_codec(int *pstream_copy, char **pcodec_name,
2538
                      int codec_type, const char *arg)
2539
{
2540
    av_freep(pcodec_name);
2541
    if (!strcmp(arg, "copy")) {
2542
        *pstream_copy = 1;
2543
    } else {
2544
        *pcodec_name = av_strdup(arg);
2545
    }
2546
}
2547

    
2548
static void opt_audio_codec(const char *arg)
2549
{
2550
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2551
}
2552

    
2553
static void opt_audio_tag(const char *arg)
2554
{
2555
    char *tail;
2556
    audio_codec_tag= strtol(arg, &tail, 0);
2557

    
2558
    if(!tail || *tail)
2559
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2560
}
2561

    
2562
static void opt_video_tag(const char *arg)
2563
{
2564
    char *tail;
2565
    video_codec_tag= strtol(arg, &tail, 0);
2566

    
2567
    if(!tail || *tail)
2568
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2569
}
2570

    
2571
#ifdef CONFIG_VHOOK
2572
static void add_frame_hooker(const char *arg)
2573
{
2574
    int argc = 0;
2575
    char *argv[64];
2576
    int i;
2577
    char *args = av_strdup(arg);
2578

    
2579
    using_vhook = 1;
2580

    
2581
    argv[0] = strtok(args, " ");
2582
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2583
    }
2584

    
2585
    i = frame_hook_add(argc, argv);
2586

    
2587
    if (i != 0) {
2588
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2589
        av_exit(1);
2590
    }
2591
}
2592
#endif
2593

    
2594
static void opt_video_codec(const char *arg)
2595
{
2596
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2597
}
2598

    
2599
static void opt_subtitle_codec(const char *arg)
2600
{
2601
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2602
}
2603

    
2604
static void opt_map(const char *arg)
2605
{
2606
    AVStreamMap *m;
2607
    char *p;
2608

    
2609
    m = &stream_maps[nb_stream_maps++];
2610

    
2611
    m->file_index = strtol(arg, &p, 0);
2612
    if (*p)
2613
        p++;
2614

    
2615
    m->stream_index = strtol(p, &p, 0);
2616
    if (*p) {
2617
        p++;
2618
        m->sync_file_index = strtol(p, &p, 0);
2619
        if (*p)
2620
            p++;
2621
        m->sync_stream_index = strtol(p, &p, 0);
2622
    } else {
2623
        m->sync_file_index = m->file_index;
2624
        m->sync_stream_index = m->stream_index;
2625
    }
2626
}
2627

    
2628
static void opt_map_meta_data(const char *arg)
2629
{
2630
    AVMetaDataMap *m;
2631
    char *p;
2632

    
2633
    m = &meta_data_maps[nb_meta_data_maps++];
2634

    
2635
    m->out_file = strtol(arg, &p, 0);
2636
    if (*p)
2637
        p++;
2638

    
2639
    m->in_file = strtol(p, &p, 0);
2640
}
2641

    
2642
static int opt_recording_time(const char *opt, const char *arg)
2643
{
2644
    recording_time = parse_time_or_die(opt, arg, 1);
2645
    return 0;
2646
}
2647

    
2648
static int opt_start_time(const char *opt, const char *arg)
2649
{
2650
    start_time = parse_time_or_die(opt, arg, 1);
2651
    return 0;
2652
}
2653

    
2654
static int opt_rec_timestamp(const char *opt, const char *arg)
2655
{
2656
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2657
    return 0;
2658
}
2659

    
2660
static int opt_input_ts_offset(const char *opt, const char *arg)
2661
{
2662
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2663
    return 0;
2664
}
2665

    
2666
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2667
{
2668
    const char *codec_string = encoder ? "encoder" : "decoder";
2669
    AVCodec *codec;
2670

    
2671
    if(!name)
2672
        return CODEC_ID_NONE;
2673
    codec = encoder ?
2674
        avcodec_find_encoder_by_name(name) :
2675
        avcodec_find_decoder_by_name(name);
2676
    if(!codec) {
2677
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2678
        av_exit(1);
2679
    }
2680
    if(codec->type != type) {
2681
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2682
        av_exit(1);
2683
    }
2684
    return codec->id;
2685
}
2686

    
2687
static void opt_input_file(const char *filename)
2688
{
2689
    AVFormatContext *ic;
2690
    AVFormatParameters params, *ap = &params;
2691
    int err, i, ret, rfps, rfps_base;
2692
    int64_t timestamp;
2693

    
2694
    if (!strcmp(filename, "-"))
2695
        filename = "pipe:";
2696

    
2697
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2698
                    !strcmp(filename, "/dev/stdin");
2699

    
2700
    /* get default parameters from command line */
2701
    ic = av_alloc_format_context();
2702

    
2703
    memset(ap, 0, sizeof(*ap));
2704
    ap->prealloced_context = 1;
2705
    ap->sample_rate = audio_sample_rate;
2706
    ap->channels = audio_channels;
2707
    ap->time_base.den = frame_rate.num;
2708
    ap->time_base.num = frame_rate.den;
2709
    ap->width = frame_width + frame_padleft + frame_padright;
2710
    ap->height = frame_height + frame_padtop + frame_padbottom;
2711
    ap->pix_fmt = frame_pix_fmt;
2712
    ap->channel = video_channel;
2713
    ap->standard = video_standard;
2714
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2715
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2716
    if(pgmyuv_compatibility_hack)
2717
        ap->video_codec_id= CODEC_ID_PGMYUV;
2718

    
2719
    for(i=0; i<opt_name_count; i++){
2720
        char buf[256];
2721
        const AVOption *opt;
2722
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2723
        if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2724
            av_set_string(ic, opt_names[i], str);
2725
    }
2726

    
2727
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2728
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2729
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2730

    
2731
    /* open the input file with generic libav function */
2732
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2733
    if (err < 0) {
2734
        print_error(filename, err);
2735
        av_exit(1);
2736
    }
2737
    if(opt_programid) {
2738
        int i;
2739
        for(i=0; i<ic->nb_programs; i++)
2740
            if(ic->programs[i]->id != opt_programid)
2741
                ic->programs[i]->discard = AVDISCARD_ALL;
2742
    }
2743

    
2744
    ic->loop_input = loop_input;
2745

    
2746
    /* If not enough info to get the stream parameters, we decode the
2747
       first frames to get it. (used in mpeg case for example) */
2748
    ret = av_find_stream_info(ic);
2749
    if (ret < 0 && verbose >= 0) {
2750
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2751
        av_exit(1);
2752
    }
2753

    
2754
    timestamp = start_time;
2755
    /* add the stream start time */
2756
    if (ic->start_time != AV_NOPTS_VALUE)
2757
        timestamp += ic->start_time;
2758

    
2759
    /* if seeking requested, we execute it */
2760
    if (start_time != 0) {
2761
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2762
        if (ret < 0) {
2763
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2764
                    filename, (double)timestamp / AV_TIME_BASE);
2765
        }
2766
        /* reset seek info */
2767
        start_time = 0;
2768
    }
2769

    
2770
    /* update the current parameters so that they match the one of the input stream */
2771
    for(i=0;i<ic->nb_streams;i++) {
2772
        int j;
2773
        AVCodecContext *enc = ic->streams[i]->codec;
2774
        if(thread_count>1)
2775
            avcodec_thread_init(enc, thread_count);
2776
        enc->thread_count= thread_count;
2777
        switch(enc->codec_type) {
2778
        case CODEC_TYPE_AUDIO:
2779
            for(j=0; j<opt_name_count; j++){
2780
                char buf[256];
2781
                const AVOption *opt;
2782
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2783
                if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2784
                    av_set_string(enc, opt_names[j], str);
2785
            }
2786
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2787
            audio_channels = enc->channels;
2788
            audio_sample_rate = enc->sample_rate;
2789
            if(audio_disable)
2790
                ic->streams[i]->discard= AVDISCARD_ALL;
2791
            break;
2792
        case CODEC_TYPE_VIDEO:
2793
            for(j=0; j<opt_name_count; j++){
2794
                char buf[256];
2795
                const AVOption *opt;
2796
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2797
                if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2798
                    av_set_string(enc, opt_names[j], str);
2799
            }
2800
            frame_height = enc->height;
2801
            frame_width = enc->width;
2802
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2803
            frame_pix_fmt = enc->pix_fmt;
2804
            rfps      = ic->streams[i]->r_frame_rate.num;
2805
            rfps_base = ic->streams[i]->r_frame_rate.den;
2806
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2807
            if(me_threshold)
2808
                enc->debug |= FF_DEBUG_MV;
2809

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

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

    
2816
                    (float)rfps / rfps_base, rfps, rfps_base);
2817
            }
2818
            /* update the current frame rate to match the stream frame rate */
2819
            frame_rate.num = rfps;
2820
            frame_rate.den = rfps_base;
2821

    
2822
            enc->rate_emu = rate_emu;
2823
            if(video_disable)
2824
                ic->streams[i]->discard= AVDISCARD_ALL;
2825
            else if(video_discard)
2826
                ic->streams[i]->discard= video_discard;
2827
            break;
2828
        case CODEC_TYPE_DATA:
2829
            break;
2830
        case CODEC_TYPE_SUBTITLE:
2831
            if(subtitle_disable)
2832
                ic->streams[i]->discard = AVDISCARD_ALL;
2833
            break;
2834
        case CODEC_TYPE_ATTACHMENT:
2835
        case CODEC_TYPE_UNKNOWN:
2836
            break;
2837
        default:
2838
            abort();
2839
        }
2840
    }
2841

    
2842
    input_files[nb_input_files] = ic;
2843
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2844
    /* dump the file content */
2845
    if (verbose >= 0)
2846
        dump_format(ic, nb_input_files, filename, 0);
2847

    
2848
    nb_input_files++;
2849
    file_iformat = NULL;
2850
    file_oformat = NULL;
2851

    
2852
    video_channel = 0;
2853

    
2854
    rate_emu = 0;
2855
    av_freep(&video_codec_name);
2856
    av_freep(&audio_codec_name);
2857
    av_freep(&subtitle_codec_name);
2858
}
2859

    
2860
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2861
                                         int *has_subtitle_ptr)
2862
{
2863
    int has_video, has_audio, has_subtitle, i, j;
2864
    AVFormatContext *ic;
2865

    
2866
    has_video = 0;
2867
    has_audio = 0;
2868
    has_subtitle = 0;
2869
    for(j=0;j<nb_input_files;j++) {
2870
        ic = input_files[j];
2871
        for(i=0;i<ic->nb_streams;i++) {
2872
            AVCodecContext *enc = ic->streams[i]->codec;
2873
            switch(enc->codec_type) {
2874
            case CODEC_TYPE_AUDIO:
2875
                has_audio = 1;
2876
                break;
2877
            case CODEC_TYPE_VIDEO:
2878
                has_video = 1;
2879
                break;
2880
            case CODEC_TYPE_SUBTITLE:
2881
                has_subtitle = 1;
2882
                break;
2883
            case CODEC_TYPE_DATA:
2884
            case CODEC_TYPE_ATTACHMENT:
2885
            case CODEC_TYPE_UNKNOWN:
2886
                break;
2887
            default:
2888
                abort();
2889
            }
2890
        }
2891
    }
2892
    *has_video_ptr = has_video;
2893
    *has_audio_ptr = has_audio;
2894
    *has_subtitle_ptr = has_subtitle;
2895
}
2896

    
2897
static void new_video_stream(AVFormatContext *oc)
2898
{
2899
    AVStream *st;
2900
    AVCodecContext *video_enc;
2901
    int codec_id;
2902

    
2903
    st = av_new_stream(oc, oc->nb_streams);
2904
    if (!st) {
2905
        fprintf(stderr, "Could not alloc stream\n");
2906
        av_exit(1);
2907
    }
2908
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2909
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2910
    video_bitstream_filters= NULL;
2911

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

    
2915
    video_enc = st->codec;
2916

    
2917
    if(video_codec_tag)
2918
        video_enc->codec_tag= video_codec_tag;
2919

    
2920
    if(   (video_global_header&1)
2921
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2922
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2923
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2924
    }
2925
    if(video_global_header&2){
2926
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2927
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2928
    }
2929

    
2930
    if (video_stream_copy) {
2931
        st->stream_copy = 1;
2932
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2933
    } else {
2934
        const char *p;
2935
        int i;
2936
        AVCodec *codec;
2937
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2938

    
2939
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2940
        if (video_codec_name)
2941
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2942

    
2943
        video_enc->codec_id = codec_id;
2944
        codec = avcodec_find_encoder(codec_id);
2945

    
2946
        for(i=0; i<opt_name_count; i++){
2947
            char buf[256];
2948
            const AVOption *opt;
2949
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2950
            if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2951
                av_set_string(video_enc, opt_names[i], str);
2952
        }
2953

    
2954
        video_enc->time_base.den = fps.num;
2955
        video_enc->time_base.num = fps.den;
2956
        if(codec && codec->supported_framerates){
2957
            const AVRational *p= codec->supported_framerates;
2958
            const AVRational *best=NULL;
2959
            AVRational best_error= (AVRational){INT_MAX, 1};
2960
            for(; p->den!=0; p++){
2961
                AVRational error= av_sub_q(fps, *p);
2962
                if(error.num <0) error.num *= -1;
2963
                if(av_cmp_q(error, best_error) < 0){
2964
                    best_error= error;
2965
                    best= p;
2966
                }
2967
            }
2968
            video_enc->time_base.den= best->num;
2969
            video_enc->time_base.num= best->den;
2970
        }
2971

    
2972
        video_enc->width = frame_width + frame_padright + frame_padleft;
2973
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2974
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2975
        video_enc->pix_fmt = frame_pix_fmt;
2976

    
2977
        if(codec && codec->pix_fmts){
2978
            const enum PixelFormat *p= codec->pix_fmts;
2979
            for(; *p!=-1; p++){
2980
                if(*p == video_enc->pix_fmt)
2981
                    break;
2982
            }
2983
            if(*p == -1)
2984
                video_enc->pix_fmt = codec->pix_fmts[0];
2985
        }
2986

    
2987
        if (intra_only)
2988
            video_enc->gop_size = 0;
2989
        if (video_qscale || same_quality) {
2990
            video_enc->flags |= CODEC_FLAG_QSCALE;
2991
            video_enc->global_quality=
2992
                st->quality = FF_QP2LAMBDA * video_qscale;
2993
        }
2994

    
2995
        if(intra_matrix)
2996
            video_enc->intra_matrix = intra_matrix;
2997
        if(inter_matrix)
2998
            video_enc->inter_matrix = inter_matrix;
2999

    
3000
        video_enc->max_qdiff = video_qdiff;
3001
        video_enc->thread_count = thread_count;
3002
        p= video_rc_override_string;
3003
        for(i=0; p; i++){
3004
            int start, end, q;
3005
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3006
            if(e!=3){
3007
                fprintf(stderr, "error parsing rc_override\n");
3008
                av_exit(1);
3009
            }
3010
            video_enc->rc_override=
3011
                av_realloc(video_enc->rc_override,
3012
                           sizeof(RcOverride)*(i+1));
3013
            video_enc->rc_override[i].start_frame= start;
3014
            video_enc->rc_override[i].end_frame  = end;
3015
            if(q>0){
3016
                video_enc->rc_override[i].qscale= q;
3017
                video_enc->rc_override[i].quality_factor= 1.0;
3018
            }
3019
            else{
3020
                video_enc->rc_override[i].qscale= 0;
3021
                video_enc->rc_override[i].quality_factor= -q/100.0;
3022
            }
3023
            p= strchr(p, '/');
3024
            if(p) p++;
3025
        }
3026
        video_enc->rc_override_count=i;
3027
        if (!video_enc->rc_initial_buffer_occupancy)
3028
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3029
        video_enc->me_threshold= me_threshold;
3030
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3031
        video_enc->strict_std_compliance = strict;
3032

    
3033
        if (do_psnr)
3034
            video_enc->flags|= CODEC_FLAG_PSNR;
3035

    
3036
        /* two pass mode */
3037
        if (do_pass) {
3038
            if (do_pass == 1) {
3039
                video_enc->flags |= CODEC_FLAG_PASS1;
3040
            } else {
3041
                video_enc->flags |= CODEC_FLAG_PASS2;
3042
            }
3043
        }
3044
    }
3045

    
3046
    /* reset some key parameters */
3047
    video_disable = 0;
3048
    av_freep(&video_codec_name);
3049
    video_stream_copy = 0;
3050
}
3051

    
3052
static void new_audio_stream(AVFormatContext *oc)
3053
{
3054
    AVStream *st;
3055
    AVCodecContext *audio_enc;
3056
    int codec_id, i;
3057

    
3058
    st = av_new_stream(oc, oc->nb_streams);
3059
    if (!st) {
3060
        fprintf(stderr, "Could not alloc stream\n");
3061
        av_exit(1);
3062
    }
3063
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3064

    
3065
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3066
    audio_bitstream_filters= NULL;
3067

    
3068
    if(thread_count>1)
3069
        avcodec_thread_init(st->codec, thread_count);
3070

    
3071
    audio_enc = st->codec;
3072
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3073
    audio_enc->strict_std_compliance = strict;
3074

    
3075
    if(audio_codec_tag)
3076
        audio_enc->codec_tag= audio_codec_tag;
3077

    
3078
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3079
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3080
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3081
    }
3082
    if (audio_stream_copy) {
3083
        st->stream_copy = 1;
3084
        audio_enc->channels = audio_channels;
3085
    } else {
3086
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3087

    
3088
        for(i=0; i<opt_name_count; i++){
3089
            char buf[256];
3090
            const AVOption *opt;
3091
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3092
            if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3093
                av_set_string(audio_enc, opt_names[i], str);
3094
        }
3095

    
3096
        if (audio_codec_name)
3097
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3098
        audio_enc->codec_id = codec_id;
3099

    
3100
        if (audio_qscale > QSCALE_NONE) {
3101
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3102
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3103
        }
3104
        audio_enc->thread_count = thread_count;
3105
        audio_enc->channels = audio_channels;
3106
    }
3107
    audio_enc->sample_rate = audio_sample_rate;
3108
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3109
    if (audio_language) {
3110
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3111
        av_free(audio_language);
3112
        audio_language = NULL;
3113
    }
3114

    
3115
    /* reset some key parameters */
3116
    audio_disable = 0;
3117
    av_freep(&audio_codec_name);
3118
    audio_stream_copy = 0;
3119
}
3120

    
3121
static void new_subtitle_stream(AVFormatContext *oc)
3122
{
3123
    AVStream *st;
3124
    AVCodecContext *subtitle_enc;
3125
    int i;
3126

    
3127
    st = av_new_stream(oc, oc->nb_streams);
3128
    if (!st) {
3129
        fprintf(stderr, "Could not alloc stream\n");
3130
        av_exit(1);
3131
    }
3132
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3133

    
3134
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3135
    subtitle_bitstream_filters= NULL;
3136

    
3137
    subtitle_enc = st->codec;
3138
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3139
    if (subtitle_stream_copy) {
3140
        st->stream_copy = 1;
3141
    } else {
3142
        for(i=0; i<opt_name_count; i++){
3143
            char buf[256];
3144
            const AVOption *opt;
3145
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3146
            if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3147
                av_set_string(subtitle_enc, opt_names[i], str);
3148
        }
3149
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3150
    }
3151

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

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

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

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

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

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

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

    
3206
    oc = av_alloc_format_context();
3207

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

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

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

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

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

    
3257
        if (use_video) {
3258
            new_video_stream(oc);
3259
        }
3260

    
3261
        if (use_audio) {
3262
            new_audio_stream(oc);
3263
        }
3264

    
3265
        if (use_subtitle) {
3266
            new_subtitle_stream(oc);
3267
        }
3268

    
3269
        oc->timestamp = rec_timestamp;
3270

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

    
3285
    output_files[nb_output_files++] = oc;
3286

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

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

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

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

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

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

    
3338
    for(i=0; i<opt_name_count; i++){
3339
        char buf[256];
3340
        const AVOption *opt;
3341
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3342
        if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3343
            av_set_string(oc, opt_names[i], str);
3344
    }
3345

    
3346
    /* reset some options */
3347
    file_oformat = NULL;
3348
    file_iformat = NULL;
3349
}
3350

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

    
3363
static int64_t getutime(void)
3364
{
3365
#ifdef HAVE_GETRUSAGE
3366
    struct rusage rusage;
3367

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

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

    
3398
static void opt_inter_matrix(const char *arg)
3399
{
3400
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3401
    parse_matrix_coeffs(inter_matrix, arg);
3402
}
3403

    
3404
static void opt_intra_matrix(const char *arg)
3405
{
3406
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3407
    parse_matrix_coeffs(intra_matrix, arg);
3408
}
3409

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

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

    
3456
static void opt_target(const char *arg)
3457
{
3458
    int norm = -1;
3459
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3460

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

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

    
3512
    if(!strcmp(arg, "vcd")) {
3513

    
3514
        opt_video_codec("mpeg1video");
3515
        opt_audio_codec("mp2");
3516
        opt_format("vcd");
3517

    
3518
        opt_frame_size(norm ? "352x240" : "352x288");
3519
        opt_frame_rate(frame_rates[norm]);
3520
        opt_default("gop", norm ? "18" : "15");
3521

    
3522
        opt_default("b", "1150000");
3523
        opt_default("maxrate", "1150000");
3524
        opt_default("minrate", "1150000");
3525
        opt_default("bufsize", "327680"); // 40*1024*8;
3526

    
3527
        opt_default("ab", "224000");
3528
        audio_sample_rate = 44100;
3529
        audio_channels = 2;
3530

    
3531
        opt_default("packetsize", "2324");
3532
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3533

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

    
3542
        opt_video_codec("mpeg2video");
3543
        opt_audio_codec("mp2");
3544
        opt_format("svcd");
3545

    
3546
        opt_frame_size(norm ? "480x480" : "480x576");
3547
        opt_frame_rate(frame_rates[norm]);
3548
        opt_default("gop", norm ? "18" : "15");
3549

    
3550
        opt_default("b", "2040000");
3551
        opt_default("maxrate", "2516000");
3552
        opt_default("minrate", "0"); //1145000;
3553
        opt_default("bufsize", "1835008"); //224*1024*8;
3554
        opt_default("flags", "+SCAN_OFFSET");
3555

    
3556

    
3557
        opt_default("ab", "224000");
3558
        audio_sample_rate = 44100;
3559

    
3560
        opt_default("packetsize", "2324");
3561

    
3562
    } else if(!strcmp(arg, "dvd")) {
3563

    
3564
        opt_video_codec("mpeg2video");
3565
        opt_audio_codec("ac3");
3566
        opt_format("dvd");
3567

    
3568
        opt_frame_size(norm ? "720x480" : "720x576");
3569
        opt_frame_rate(frame_rates[norm]);
3570
        opt_default("gop", norm ? "18" : "15");
3571

    
3572
        opt_default("b", "6000000");
3573
        opt_default("maxrate", "9000000");
3574
        opt_default("minrate", "0"); //1500000;
3575
        opt_default("bufsize", "1835008"); //224*1024*8;
3576

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

    
3580
        opt_default("ab", "448000");
3581
        audio_sample_rate = 48000;
3582

    
3583
    } else if(!strncmp(arg, "dv", 2)) {
3584

    
3585
        opt_format("dv");
3586

    
3587
        opt_frame_size(norm ? "720x480" : "720x576");
3588
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3589
                                             (norm ? "yuv411p" : "yuv420p"));
3590
        opt_frame_rate(frame_rates[norm]);
3591

    
3592
        audio_sample_rate = 48000;
3593
        audio_channels = 2;
3594

    
3595
    } else {
3596
        fprintf(stderr, "Unknown target: %s\n", arg);
3597
        av_exit(1);
3598
    }
3599
}
3600

    
3601
static void opt_vstats_file (const char *arg)
3602
{
3603
    av_free (vstats_filename);
3604
    vstats_filename=av_strdup (arg);
3605
}
3606

    
3607
static void opt_vstats (void)
3608
{
3609
    char filename[40];
3610
    time_t today2 = time(NULL);
3611
    struct tm *today = localtime(&today2);
3612

    
3613
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3614
             today->tm_sec);
3615
    opt_vstats_file(filename);
3616
}
3617

    
3618
static int opt_bsf(const char *opt, const char *arg)
3619
{
3620
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3621
    AVBitStreamFilterContext **bsfp;
3622

    
3623
    if(!bsfc){
3624
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3625
        av_exit(1);
3626
    }
3627

    
3628
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3629
          *opt == 'a' ? &audio_bitstream_filters :
3630
                        &subtitle_bitstream_filters;
3631
    while(*bsfp)
3632
        bsfp= &(*bsfp)->next;
3633

    
3634
    *bsfp= bsfc;
3635

    
3636
    return 0;
3637
}
3638

    
3639
static const OptionDef options[] = {
3640
    /* main options */
3641
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3642
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3643
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3644
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3645
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3646
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3647
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3648
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3649
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3650
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3651
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3652
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3653
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3654
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3655
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3656
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3657
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3658
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3659
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3660
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3661
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3662
      "add timings for benchmarking" },
3663
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3664
      "dump each input packet" },
3665
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3666
      "when dumping packets, also dump the payload" },
3667
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3668
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3669
    { "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)", "" },
3670
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3671
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3672
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3673
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3674
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3675
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3676
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3677
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3678
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3679
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3680
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3681

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

    
3729
    /* audio options */
3730
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3731
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3732
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3733
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3734
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3735
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3736
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3737
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3738
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3739
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3740
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3741

    
3742
    /* subtitle options */
3743
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3744
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3745
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3746
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3747

    
3748
    /* grab options */
3749
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3750
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3751
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3752

    
3753
    /* muxer options */
3754
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3755
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3756

    
3757
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3758
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3759
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3760

    
3761
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3762
    { NULL, },
3763
};
3764

    
3765
int main(int argc, char **argv)
3766
{
3767
    int i;
3768
    int64_t ti;
3769

    
3770
    avcodec_register_all();
3771
    avdevice_register_all();
3772
    av_register_all();
3773

    
3774
    for(i=0; i<CODEC_TYPE_NB; i++){
3775
        avctx_opts[i]= avcodec_alloc_context2(i);
3776
    }
3777
    avformat_opts = av_alloc_format_context();
3778
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3779

    
3780
    show_banner();
3781
    if (argc <= 1) {
3782
        show_help();
3783
        av_exit(1);
3784
    }
3785

    
3786
    /* parse options */
3787
    parse_options(argc, argv, options, opt_output_file);
3788

    
3789
    /* file converter / grab */
3790
    if (nb_output_files <= 0) {
3791
        fprintf(stderr, "Must supply at least one output file\n");
3792
        av_exit(1);
3793
    }
3794

    
3795
    if (nb_input_files == 0) {
3796
        fprintf(stderr, "Must supply at least one input file\n");
3797
        av_exit(1);
3798
    }
3799

    
3800
    ti = getutime();
3801
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3802
              stream_maps, nb_stream_maps);
3803
    ti = getutime() - ti;
3804
    if (do_benchmark) {
3805
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3806
    }
3807

    
3808
    return av_exit(0);
3809
}