Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ dbedf2aa

History | View | Annotate | Download (134 KB)

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

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

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

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

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

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

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

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

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

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

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

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

    
495
        bsfc= bsfc->next;
496
    }
497

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

    
505
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
506

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
799
    *frame_size = 0;
800

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1013

    
1014
    oc = output_files[0];
1015

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

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

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

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

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

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

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

    
1095
        fflush(stderr);
1096
    }
1097

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

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

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

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

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

    
1141
    len = pkt->size;
1142
    ptr = pkt->data;
1143
    while (len > 0) {
1144
    handle_eof:
1145
        ist->pts= ist->next_pts;
1146

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

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

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

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

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

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

    
1260
            ist->frame++;
1261
        }
1262

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

    
1282
                ost = ost_table[i];
1283
                if (ost->source_index == ist_index) {
1284
                    os = output_files[ost->file_index];
1285

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

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

    
1318
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1319
                            continue;
1320

    
1321
                        /* no reencoding needed : output the packet directly */
1322
                        /* force the input stream PTS */
1323

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

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

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

    
1341
                            if (pkt->dts == AV_NOPTS_VALUE)
1342
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1343
                            else
1344
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1345

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

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

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

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

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

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

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

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

    
1440
    return 0;
1441
 fail_decode:
1442
    return -1;
1443
}
1444

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

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

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

    
1476
    return -1;
1477
}
1478

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1660
        codec = ost->st->codec;
1661
        icodec = ist->st->codec;
1662

    
1663
        if (!ost->st->language[0])
1664
            av_strlcpy(ost->st->language, ist->st->language,
1665
                       sizeof(ost->st->language));
1666

    
1667
        ost->st->disposition = ist->st->disposition;
1668

    
1669
        if (ost->st->stream_copy) {
1670
            /* if stream_copy is selected, no need to decode or encode */
1671
            codec->codec_id = icodec->codec_id;
1672
            codec->codec_type = icodec->codec_type;
1673

    
1674
            if(!codec->codec_tag){
1675
                if(   !os->oformat->codec_tag
1676
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1677
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1678
                    codec->codec_tag = icodec->codec_tag;
1679
            }
1680

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

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

    
1829
    if (!bit_buffer)
1830
        bit_buffer = av_malloc(bit_buffer_size);
1831
    if (!bit_buffer)
1832
        goto fail;
1833

    
1834
    /* dump the file output parameters - cannot be done before in case
1835
       of stream copy */
1836
    for(i=0;i<nb_output_files;i++) {
1837
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1838
    }
1839

    
1840
    /* dump the stream mapping */
1841
    if (verbose >= 0) {
1842
        fprintf(stderr, "Stream mapping:\n");
1843
        for(i=0;i<nb_ostreams;i++) {
1844
            ost = ost_table[i];
1845
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1846
                    ist_table[ost->source_index]->file_index,
1847
                    ist_table[ost->source_index]->index,
1848
                    ost->file_index,
1849
                    ost->index);
1850
            if (ost->sync_ist != ist_table[ost->source_index])
1851
                fprintf(stderr, " [sync #%d.%d]",
1852
                        ost->sync_ist->file_index,
1853
                        ost->sync_ist->index);
1854
            fprintf(stderr, "\n");
1855
        }
1856
    }
1857

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

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

    
1899
    /* init pts */
1900
    for(i=0;i<nb_istreams;i++) {
1901
        ist = ist_table[i];
1902
        is = input_files[ist->file_index];
1903
        ist->pts = 0;
1904
        ist->next_pts = AV_NOPTS_VALUE;
1905
        ist->is_start = 1;
1906
    }
1907

    
1908
    /* set meta data information from input file if required */
1909
    for (i=0;i<nb_meta_data_maps;i++) {
1910
        AVFormatContext *out_file;
1911
        AVFormatContext *in_file;
1912

    
1913
        int out_file_index = meta_data_maps[i].out_file;
1914
        int in_file_index = meta_data_maps[i].in_file;
1915
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1916
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1917
            ret = AVERROR(EINVAL);
1918
            goto fail;
1919
        }
1920
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1921
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1922
            ret = AVERROR(EINVAL);
1923
            goto fail;
1924
        }
1925

    
1926
        out_file = output_files[out_file_index];
1927
        in_file = input_files[in_file_index];
1928

    
1929
        strcpy(out_file->title, in_file->title);
1930
        strcpy(out_file->author, in_file->author);
1931
        strcpy(out_file->copyright, in_file->copyright);
1932
        strcpy(out_file->comment, in_file->comment);
1933
        strcpy(out_file->album, in_file->album);
1934
        out_file->year = in_file->year;
1935
        out_file->track = in_file->track;
1936
        strcpy(out_file->genre, in_file->genre);
1937
    }
1938

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

    
1955
    if (!using_stdin && verbose >= 0) {
1956
        fprintf(stderr, "Press [q] to stop encoding\n");
1957
        url_set_interrupt_cb(decode_interrupt_cb);
1958
    }
1959
    term_init();
1960

    
1961
    key = -1;
1962
    timer_start = av_gettime();
1963

    
1964
    for(; received_sigterm == 0;) {
1965
        int file_index, ist_index;
1966
        AVPacket pkt;
1967
        double ipts_min;
1968
        double opts_min;
1969

    
1970
    redo:
1971
        ipts_min= 1e100;
1972
        opts_min= 1e100;
1973
        /* if 'q' pressed, exits */
1974
        if (!using_stdin) {
1975
            if (q_pressed)
1976
                break;
1977
            /* read_key() returns 0 on EOF */
1978
            key = read_key();
1979
            if (key == 'q')
1980
                break;
1981
        }
1982

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

    
2016
        /* finish if recording time exhausted */
2017
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2018
            break;
2019

    
2020
        /* finish if limit size exhausted */
2021
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2022
            break;
2023

    
2024
        /* read a frame from it and output it in the fifo */
2025
        is = input_files[file_index];
2026
        if (av_read_frame(is, &pkt) < 0) {
2027
            file_table[file_index].eof_reached = 1;
2028
            if (opt_shortest)
2029
                break;
2030
            else
2031
                continue;
2032
        }
2033

    
2034
        if (do_pkt_dump) {
2035
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2036
        }
2037
        /* the following test is needed in case new streams appear
2038
           dynamically in stream : we ignore them */
2039
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2040
            goto discard_packet;
2041
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2042
        ist = ist_table[ist_index];
2043
        if (ist->discard)
2044
            goto discard_packet;
2045

    
2046
        if (pkt.dts != AV_NOPTS_VALUE)
2047
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2048
        if (pkt.pts != AV_NOPTS_VALUE)
2049
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2050

    
2051
//        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);
2052
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2053
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2054
            int64_t delta= pkt_dts - ist->next_pts;
2055
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2056
                input_files_ts_offset[ist->file_index]-= delta;
2057
                if (verbose > 2)
2058
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2059
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2060
                if(pkt.pts != AV_NOPTS_VALUE)
2061
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2062
            }
2063
        }
2064

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

    
2068
            if (verbose >= 0)
2069
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2070
                        ist->file_index, ist->index);
2071

    
2072
            av_free_packet(&pkt);
2073
            goto redo;
2074
        }
2075

    
2076
    discard_packet:
2077
        av_free_packet(&pkt);
2078

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

    
2083
    /* at the end of stream, we must flush the decoder buffers */
2084
    for(i=0;i<nb_istreams;i++) {
2085
        ist = ist_table[i];
2086
        if (ist->decoding_needed) {
2087
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2088
        }
2089
    }
2090

    
2091
    term_exit();
2092

    
2093
    /* write the trailer if needed and close file */
2094
    for(i=0;i<nb_output_files;i++) {
2095
        os = output_files[i];
2096
        av_write_trailer(os);
2097
    }
2098

    
2099
    /* dump report by using the first video and audio streams */
2100
    print_report(output_files, ost_table, nb_ostreams, 1);
2101

    
2102
    /* close each encoder */
2103
    for(i=0;i<nb_ostreams;i++) {
2104
        ost = ost_table[i];
2105
        if (ost->encoding_needed) {
2106
            av_freep(&ost->st->codec->stats_in);
2107
            avcodec_close(ost->st->codec);
2108
        }
2109
    }
2110

    
2111
    /* close each decoder */
2112
    for(i=0;i<nb_istreams;i++) {
2113
        ist = ist_table[i];
2114
        if (ist->decoding_needed) {
2115
            avcodec_close(ist->st->codec);
2116
        }
2117
    }
2118

    
2119
    /* finished ! */
2120

    
2121
    ret = 0;
2122
 fail1:
2123
    av_freep(&bit_buffer);
2124
    av_free(file_table);
2125

    
2126
    if (ist_table) {
2127
        for(i=0;i<nb_istreams;i++) {
2128
            ist = ist_table[i];
2129
            av_free(ist);
2130
        }
2131
        av_free(ist_table);
2132
    }
2133
    if (ost_table) {
2134
        for(i=0;i<nb_ostreams;i++) {
2135
            ost = ost_table[i];
2136
            if (ost) {
2137
                if (ost->logfile) {
2138
                    fclose(ost->logfile);
2139
                    ost->logfile = NULL;
2140
                }
2141
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2142
                                             initialized but set to zero */
2143
                av_free(ost->pict_tmp.data[0]);
2144
                if (ost->video_resample)
2145
                    sws_freeContext(ost->img_resample_ctx);
2146
                if (ost->resample)
2147
                    audio_resample_close(ost->resample);
2148
                av_free(ost);
2149
            }
2150
        }
2151
        av_free(ost_table);
2152
    }
2153
    return ret;
2154
 fail:
2155
    ret = AVERROR(ENOMEM);
2156
    goto fail1;
2157
}
2158

    
2159
#if 0
2160
int file_read(const char *filename)
2161
{
2162
    URLContext *h;
2163
    unsigned char buffer[1024];
2164
    int len, i;
2165

2166
    if (url_open(&h, filename, O_RDONLY) < 0) {
2167
        printf("could not open '%s'\n", filename);
2168
        return -1;
2169
    }
2170
    for(;;) {
2171
        len = url_read(h, buffer, sizeof(buffer));
2172
        if (len <= 0)
2173
            break;
2174
        for(i=0;i<len;i++) putchar(buffer[i]);
2175
    }
2176
    url_close(h);
2177
    return 0;
2178
}
2179
#endif
2180

    
2181
static void opt_format(const char *arg)
2182
{
2183
    /* compatibility stuff for pgmyuv */
2184
    if (!strcmp(arg, "pgmyuv")) {
2185
        pgmyuv_compatibility_hack=1;
2186
//        opt_image_format(arg);
2187
        arg = "image2";
2188
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2189
    }
2190

    
2191
    file_iformat = av_find_input_format(arg);
2192
    file_oformat = guess_format(arg, NULL, NULL);
2193
    if (!file_iformat && !file_oformat) {
2194
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2195
        av_exit(1);
2196
    }
2197
}
2198

    
2199
static int opt_default(const char *opt, const char *arg){
2200
    int type;
2201
    const AVOption *o= NULL;
2202
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2203

    
2204
    for(type=0; type<CODEC_TYPE_NB; type++){
2205
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2206
        if(o2)
2207
            o = av_set_string(avctx_opts[type], opt, arg);
2208
    }
2209
    if(!o)
2210
        o = av_set_string(avformat_opts, opt, arg);
2211
    if(!o)
2212
        o = av_set_string(sws_opts, opt, arg);
2213
    if(!o){
2214
        if(opt[0] == 'a')
2215
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2216
        else if(opt[0] == 'v')
2217
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2218
        else if(opt[0] == 's')
2219
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2220
    }
2221
    if(!o)
2222
        return -1;
2223

    
2224
//    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));
2225

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

    
2230
    if(avctx_opts[0]->debug || avformat_opts->debug)
2231
        av_log_set_level(AV_LOG_DEBUG);
2232
    return 0;
2233
}
2234

    
2235
static void opt_video_rc_override_string(const char *arg)
2236
{
2237
    video_rc_override_string = arg;
2238
}
2239

    
2240
static int opt_me_threshold(const char *opt, const char *arg)
2241
{
2242
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2243
    return 0;
2244
}
2245

    
2246
static int opt_verbose(const char *opt, const char *arg)
2247
{
2248
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2249
    av_log_set_level(verbose);
2250
    return 0;
2251
}
2252

    
2253
static void opt_frame_rate(const char *arg)
2254
{
2255
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2256
        fprintf(stderr, "Incorrect frame rate\n");
2257
        av_exit(1);
2258
    }
2259
}
2260

    
2261
static int opt_bitrate(const char *opt, const char *arg)
2262
{
2263
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2264

    
2265
    opt_default(opt, arg);
2266

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

    
2270
    return 0;
2271
}
2272

    
2273
static void opt_frame_crop_top(const char *arg)
2274
{
2275
    frame_topBand = atoi(arg);
2276
    if (frame_topBand < 0) {
2277
        fprintf(stderr, "Incorrect top crop size\n");
2278
        av_exit(1);
2279
    }
2280
    if ((frame_topBand % 2) != 0) {
2281
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2282
        av_exit(1);
2283
    }
2284
    if ((frame_topBand) >= frame_height){
2285
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2286
        av_exit(1);
2287
    }
2288
    frame_height -= frame_topBand;
2289
}
2290

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

    
2309
static void opt_frame_crop_left(const char *arg)
2310
{
2311
    frame_leftBand = atoi(arg);
2312
    if (frame_leftBand < 0) {
2313
        fprintf(stderr, "Incorrect left crop size\n");
2314
        av_exit(1);
2315
    }
2316
    if ((frame_leftBand % 2) != 0) {
2317
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2318
        av_exit(1);
2319
    }
2320
    if ((frame_leftBand) >= frame_width){
2321
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2322
        av_exit(1);
2323
    }
2324
    frame_width -= frame_leftBand;
2325
}
2326

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

    
2345
static void opt_frame_size(const char *arg)
2346
{
2347
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2348
        fprintf(stderr, "Incorrect frame size\n");
2349
        av_exit(1);
2350
    }
2351
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2352
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2353
        av_exit(1);
2354
    }
2355
}
2356

    
2357

    
2358
#define SCALEBITS 10
2359
#define ONE_HALF  (1 << (SCALEBITS - 1))
2360
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2361

    
2362
#define RGB_TO_Y(r, g, b) \
2363
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2364
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2365

    
2366
#define RGB_TO_U(r1, g1, b1, shift)\
2367
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2368
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2369

    
2370
#define RGB_TO_V(r1, g1, b1, shift)\
2371
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2372
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2373

    
2374
static void opt_pad_color(const char *arg) {
2375
    /* Input is expected to be six hex digits similar to
2376
       how colors are expressed in html tags (but without the #) */
2377
    int rgb = strtol(arg, NULL, 16);
2378
    int r,g,b;
2379

    
2380
    r = (rgb >> 16);
2381
    g = ((rgb >> 8) & 255);
2382
    b = (rgb & 255);
2383

    
2384
    padcolor[0] = RGB_TO_Y(r,g,b);
2385
    padcolor[1] = RGB_TO_U(r,g,b,0);
2386
    padcolor[2] = RGB_TO_V(r,g,b,0);
2387
}
2388

    
2389
static void opt_frame_pad_top(const char *arg)
2390
{
2391
    frame_padtop = atoi(arg);
2392
    if (frame_padtop < 0) {
2393
        fprintf(stderr, "Incorrect top pad size\n");
2394
        av_exit(1);
2395
    }
2396
    if ((frame_padtop % 2) != 0) {
2397
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2398
        av_exit(1);
2399
    }
2400
}
2401

    
2402
static void opt_frame_pad_bottom(const char *arg)
2403
{
2404
    frame_padbottom = atoi(arg);
2405
    if (frame_padbottom < 0) {
2406
        fprintf(stderr, "Incorrect bottom pad size\n");
2407
        av_exit(1);
2408
    }
2409
    if ((frame_padbottom % 2) != 0) {
2410
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2411
        av_exit(1);
2412
    }
2413
}
2414

    
2415

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

    
2429

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

    
2443
static void list_pix_fmts(void)
2444
{
2445
    int i;
2446
    char pix_fmt_str[128];
2447
    for (i=-1; i < PIX_FMT_NB; i++) {
2448
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2449
        fprintf(stdout, "%s\n", pix_fmt_str);
2450
    }
2451
}
2452

    
2453
static void opt_frame_pix_fmt(const char *arg)
2454
{
2455
    if (strcmp(arg, "list"))
2456
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2457
    else {
2458
        list_pix_fmts();
2459
        av_exit(0);
2460
    }
2461
}
2462

    
2463
static void opt_frame_aspect_ratio(const char *arg)
2464
{
2465
    int x = 0, y = 0;
2466
    double ar = 0;
2467
    const char *p;
2468
    char *end;
2469

    
2470
    p = strchr(arg, ':');
2471
    if (p) {
2472
        x = strtol(arg, &end, 10);
2473
        if (end == p)
2474
            y = strtol(end+1, &end, 10);
2475
        if (x > 0 && y > 0)
2476
            ar = (double)x / (double)y;
2477
    } else
2478
        ar = strtod(arg, NULL);
2479

    
2480
    if (!ar) {
2481
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2482
        av_exit(1);
2483
    }
2484
    frame_aspect_ratio = ar;
2485
}
2486

    
2487
static void opt_qscale(const char *arg)
2488
{
2489
    video_qscale = atof(arg);
2490
    if (video_qscale <= 0 ||
2491
        video_qscale > 255) {
2492
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2493
        av_exit(1);
2494
    }
2495
}
2496

    
2497
static void opt_qdiff(const char *arg)
2498
{
2499
    video_qdiff = atoi(arg);
2500
    if (video_qdiff < 0 ||
2501
        video_qdiff > 31) {
2502
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2503
        av_exit(1);
2504
    }
2505
}
2506

    
2507
static void opt_strict(const char *arg)
2508
{
2509
    strict= atoi(arg);
2510
}
2511

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2591
    using_vhook = 1;
2592

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

    
2597
    i = frame_hook_add(argc, argv);
2598

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

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

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

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

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

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

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

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

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

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

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

    
2654
static int opt_recording_time(const char *opt, const char *arg)
2655
{
2656
    recording_time = parse_time_or_die(opt, arg, 1);
2657
    return 0;
2658
}
2659

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

    
2666
static int opt_rec_timestamp(const char *opt, const char *arg)
2667
{
2668
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2669
    return 0;
2670
}
2671

    
2672
static int opt_input_ts_offset(const char *opt, const char *arg)
2673
{
2674
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2675
    return 0;
2676
}
2677

    
2678
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2679
{
2680
    const char *codec_string = encoder ? "encoder" : "decoder";
2681
    AVCodec *codec;
2682

    
2683
    if(!name)
2684
        return CODEC_ID_NONE;
2685
    codec = encoder ?
2686
        avcodec_find_encoder_by_name(name) :
2687
        avcodec_find_decoder_by_name(name);
2688
    if(!codec) {
2689
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2690
        av_exit(1);
2691
    }
2692
    if(codec->type != type) {
2693
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2694
        av_exit(1);
2695
    }
2696
    return codec->id;
2697
}
2698

    
2699
static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2700
{
2701
    int i;
2702
    for(i=0; i<opt_name_count; i++){
2703
        char buf[256];
2704
        const AVOption *opt;
2705
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2706
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2707
        if(str && ((opt->flags & flags) == flags))
2708
            av_set_string(ctx, opt_names[i], str);
2709
    }
2710
}
2711

    
2712
static void opt_input_file(const char *filename)
2713
{
2714
    AVFormatContext *ic;
2715
    AVFormatParameters params, *ap = &params;
2716
    int err, i, ret, rfps, rfps_base;
2717
    int64_t timestamp;
2718

    
2719
    if (!strcmp(filename, "-"))
2720
        filename = "pipe:";
2721

    
2722
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2723
                    !strcmp(filename, "/dev/stdin");
2724

    
2725
    /* get default parameters from command line */
2726
    ic = av_alloc_format_context();
2727

    
2728
    memset(ap, 0, sizeof(*ap));
2729
    ap->prealloced_context = 1;
2730
    ap->sample_rate = audio_sample_rate;
2731
    ap->channels = audio_channels;
2732
    ap->time_base.den = frame_rate.num;
2733
    ap->time_base.num = frame_rate.den;
2734
    ap->width = frame_width + frame_padleft + frame_padright;
2735
    ap->height = frame_height + frame_padtop + frame_padbottom;
2736
    ap->pix_fmt = frame_pix_fmt;
2737
    ap->channel = video_channel;
2738
    ap->standard = video_standard;
2739
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2740
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2741
    if(pgmyuv_compatibility_hack)
2742
        ap->video_codec_id= CODEC_ID_PGMYUV;
2743

    
2744
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2745

    
2746
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2747
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2748
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2749

    
2750
    /* open the input file with generic libav function */
2751
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2752
    if (err < 0) {
2753
        print_error(filename, err);
2754
        av_exit(1);
2755
    }
2756
    if(opt_programid) {
2757
        int i;
2758
        for(i=0; i<ic->nb_programs; i++)
2759
            if(ic->programs[i]->id != opt_programid)
2760
                ic->programs[i]->discard = AVDISCARD_ALL;
2761
    }
2762

    
2763
    ic->loop_input = loop_input;
2764

    
2765
    /* If not enough info to get the stream parameters, we decode the
2766
       first frames to get it. (used in mpeg case for example) */
2767
    ret = av_find_stream_info(ic);
2768
    if (ret < 0 && verbose >= 0) {
2769
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2770
        av_exit(1);
2771
    }
2772

    
2773
    timestamp = start_time;
2774
    /* add the stream start time */
2775
    if (ic->start_time != AV_NOPTS_VALUE)
2776
        timestamp += ic->start_time;
2777

    
2778
    /* if seeking requested, we execute it */
2779
    if (start_time != 0) {
2780
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2781
        if (ret < 0) {
2782
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2783
                    filename, (double)timestamp / AV_TIME_BASE);
2784
        }
2785
        /* reset seek info */
2786
        start_time = 0;
2787
    }
2788

    
2789
    /* update the current parameters so that they match the one of the input stream */
2790
    for(i=0;i<ic->nb_streams;i++) {
2791
        AVCodecContext *enc = ic->streams[i]->codec;
2792
        if(thread_count>1)
2793
            avcodec_thread_init(enc, thread_count);
2794
        enc->thread_count= thread_count;
2795
        switch(enc->codec_type) {
2796
        case CODEC_TYPE_AUDIO:
2797
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2798
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2799
            audio_channels = enc->channels;
2800
            audio_sample_rate = enc->sample_rate;
2801
            if(audio_disable)
2802
                ic->streams[i]->discard= AVDISCARD_ALL;
2803
            break;
2804
        case CODEC_TYPE_VIDEO:
2805
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2806
            frame_height = enc->height;
2807
            frame_width = enc->width;
2808
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2809
            frame_pix_fmt = enc->pix_fmt;
2810
            rfps      = ic->streams[i]->r_frame_rate.num;
2811
            rfps_base = ic->streams[i]->r_frame_rate.den;
2812
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2813
            if(me_threshold)
2814
                enc->debug |= FF_DEBUG_MV;
2815

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

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

    
2822
                    (float)rfps / rfps_base, rfps, rfps_base);
2823
            }
2824
            /* update the current frame rate to match the stream frame rate */
2825
            frame_rate.num = rfps;
2826
            frame_rate.den = rfps_base;
2827

    
2828
            enc->rate_emu = rate_emu;
2829
            if(video_disable)
2830
                ic->streams[i]->discard= AVDISCARD_ALL;
2831
            else if(video_discard)
2832
                ic->streams[i]->discard= video_discard;
2833
            break;
2834
        case CODEC_TYPE_DATA:
2835
            break;
2836
        case CODEC_TYPE_SUBTITLE:
2837
            if(subtitle_disable)
2838
                ic->streams[i]->discard = AVDISCARD_ALL;
2839
            break;
2840
        case CODEC_TYPE_ATTACHMENT:
2841
        case CODEC_TYPE_UNKNOWN:
2842
            break;
2843
        default:
2844
            abort();
2845
        }
2846
    }
2847

    
2848
    input_files[nb_input_files] = ic;
2849
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2850
    /* dump the file content */
2851
    if (verbose >= 0)
2852
        dump_format(ic, nb_input_files, filename, 0);
2853

    
2854
    nb_input_files++;
2855
    file_iformat = NULL;
2856
    file_oformat = NULL;
2857

    
2858
    video_channel = 0;
2859

    
2860
    rate_emu = 0;
2861
    av_freep(&video_codec_name);
2862
    av_freep(&audio_codec_name);
2863
    av_freep(&subtitle_codec_name);
2864
}
2865

    
2866
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2867
                                         int *has_subtitle_ptr)
2868
{
2869
    int has_video, has_audio, has_subtitle, i, j;
2870
    AVFormatContext *ic;
2871

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

    
2903
static void new_video_stream(AVFormatContext *oc)
2904
{
2905
    AVStream *st;
2906
    AVCodecContext *video_enc;
2907
    int codec_id;
2908

    
2909
    st = av_new_stream(oc, oc->nb_streams);
2910
    if (!st) {
2911
        fprintf(stderr, "Could not alloc stream\n");
2912
        av_exit(1);
2913
    }
2914
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2915
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2916
    video_bitstream_filters= NULL;
2917

    
2918
    if(thread_count>1)
2919
        avcodec_thread_init(st->codec, thread_count);
2920

    
2921
    video_enc = st->codec;
2922

    
2923
    if(video_codec_tag)
2924
        video_enc->codec_tag= video_codec_tag;
2925

    
2926
    if(   (video_global_header&1)
2927
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2928
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2929
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2930
    }
2931
    if(video_global_header&2){
2932
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2933
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2934
    }
2935

    
2936
    if (video_stream_copy) {
2937
        st->stream_copy = 1;
2938
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2939
    } else {
2940
        const char *p;
2941
        int i;
2942
        AVCodec *codec;
2943
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2944

    
2945
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2946
        if (video_codec_name)
2947
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2948

    
2949
        video_enc->codec_id = codec_id;
2950
        codec = avcodec_find_encoder(codec_id);
2951

    
2952
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
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;
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
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3089

    
3090
        if (audio_codec_name)
3091
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3092
        audio_enc->codec_id = codec_id;
3093

    
3094
        if (audio_qscale > QSCALE_NONE) {
3095
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3096
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3097
        }
3098
        audio_enc->thread_count = thread_count;
3099
        audio_enc->channels = audio_channels;
3100
    }
3101
    audio_enc->sample_rate = audio_sample_rate;
3102
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3103
    if (audio_language) {
3104
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3105
        av_free(audio_language);
3106
        audio_language = NULL;
3107
    }
3108

    
3109
    /* reset some key parameters */
3110
    audio_disable = 0;
3111
    av_freep(&audio_codec_name);
3112
    audio_stream_copy = 0;
3113
}
3114

    
3115
static void new_subtitle_stream(AVFormatContext *oc)
3116
{
3117
    AVStream *st;
3118
    AVCodecContext *subtitle_enc;
3119

    
3120
    st = av_new_stream(oc, oc->nb_streams);
3121
    if (!st) {
3122
        fprintf(stderr, "Could not alloc stream\n");
3123
        av_exit(1);
3124
    }
3125
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3126

    
3127
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3128
    subtitle_bitstream_filters= NULL;
3129

    
3130
    subtitle_enc = st->codec;
3131
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3132
    if (subtitle_stream_copy) {
3133
        st->stream_copy = 1;
3134
    } else {
3135
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3136
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3137
    }
3138

    
3139
    if (subtitle_language) {
3140
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3141
        av_free(subtitle_language);
3142
        subtitle_language = NULL;
3143
    }
3144

    
3145
    subtitle_disable = 0;
3146
    av_freep(&subtitle_codec_name);
3147
    subtitle_stream_copy = 0;
3148
}
3149

    
3150
static void opt_new_audio_stream(void)
3151
{
3152
    AVFormatContext *oc;
3153
    if (nb_output_files <= 0) {
3154
        fprintf(stderr, "At least one output file must be specified\n");
3155
        av_exit(1);
3156
    }
3157
    oc = output_files[nb_output_files - 1];
3158
    new_audio_stream(oc);
3159
}
3160

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

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

    
3183
static void opt_output_file(const char *filename)
3184
{
3185
    AVFormatContext *oc;
3186
    int use_video, use_audio, use_subtitle;
3187
    int input_has_video, input_has_audio, input_has_subtitle;
3188
    AVFormatParameters params, *ap = &params;
3189

    
3190
    if (!strcmp(filename, "-"))
3191
        filename = "pipe:";
3192

    
3193
    oc = av_alloc_format_context();
3194

    
3195
    if (!file_oformat) {
3196
        file_oformat = guess_format(NULL, filename, NULL);
3197
        if (!file_oformat) {
3198
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3199
                    filename);
3200
            av_exit(1);
3201
        }
3202
    }
3203

    
3204
    oc->oformat = file_oformat;
3205
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3206

    
3207
    if (!strcmp(file_oformat->name, "ffm") &&
3208
        av_strstart(filename, "http:", NULL)) {
3209
        /* special case for files sent to ffserver: we get the stream
3210
           parameters from ffserver */
3211
        int err = read_ffserver_streams(oc, filename);
3212
        if (err < 0) {
3213
            print_error(filename, err);
3214
            av_exit(1);
3215
        }
3216
    } else {
3217
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3218
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3219
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3220

    
3221
        /* disable if no corresponding type found and at least one
3222
           input file */
3223
        if (nb_input_files > 0) {
3224
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3225
                                         &input_has_subtitle);
3226
            if (!input_has_video)
3227
                use_video = 0;
3228
            if (!input_has_audio)
3229
                use_audio = 0;
3230
            if (!input_has_subtitle)
3231
                use_subtitle = 0;
3232
        }
3233

    
3234
        /* manual disable */
3235
        if (audio_disable) {
3236
            use_audio = 0;
3237
        }
3238
        if (video_disable) {
3239
            use_video = 0;
3240
        }
3241
        if (subtitle_disable) {
3242
            use_subtitle = 0;
3243
        }
3244

    
3245
        if (use_video) {
3246
            new_video_stream(oc);
3247
        }
3248

    
3249
        if (use_audio) {
3250
            new_audio_stream(oc);
3251
        }
3252

    
3253
        if (use_subtitle) {
3254
            new_subtitle_stream(oc);
3255
        }
3256

    
3257
        oc->timestamp = rec_timestamp;
3258

    
3259
        if (str_title)
3260
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3261
        if (str_author)
3262
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3263
        if (str_copyright)
3264
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3265
        if (str_comment)
3266
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3267
        if (str_album)
3268
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3269
        if (str_genre)
3270
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3271
    }
3272

    
3273
    output_files[nb_output_files++] = oc;
3274

    
3275
    /* check filename in case of an image number is expected */
3276
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3277
        if (!av_filename_number_test(oc->filename)) {
3278
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3279
            av_exit(1);
3280
        }
3281
    }
3282

    
3283
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3284
        /* test if it already exists to avoid loosing precious files */
3285
        if (!file_overwrite &&
3286
            (strchr(filename, ':') == NULL ||
3287
             filename[1] == ':' ||
3288
             av_strstart(filename, "file:", NULL))) {
3289
            if (url_exist(filename)) {
3290
                int c;
3291

    
3292
                if (!using_stdin) {
3293
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3294
                    fflush(stderr);
3295
                    c = getchar();
3296
                    if (toupper(c) != 'Y') {
3297
                        fprintf(stderr, "Not overwriting - exiting\n");
3298
                        av_exit(1);
3299
                    }
3300
                }
3301
                else {
3302
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3303
                    av_exit(1);
3304
                }
3305
            }
3306
        }
3307

    
3308
        /* open the file */
3309
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3310
            fprintf(stderr, "Could not open '%s'\n", filename);
3311
            av_exit(1);
3312
        }
3313
    }
3314

    
3315
    memset(ap, 0, sizeof(*ap));
3316
    if (av_set_parameters(oc, ap) < 0) {
3317
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3318
                oc->filename);
3319
        av_exit(1);
3320
    }
3321

    
3322
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3323
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3324
    oc->loop_output = loop_output;
3325

    
3326
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3327

    
3328
    /* reset some options */
3329
    file_oformat = NULL;
3330
    file_iformat = NULL;
3331
}
3332

    
3333
/* same option as mencoder */
3334
static void opt_pass(const char *pass_str)
3335
{
3336
    int pass;
3337
    pass = atoi(pass_str);
3338
    if (pass != 1 && pass != 2) {
3339
        fprintf(stderr, "pass number can be only 1 or 2\n");
3340
        av_exit(1);
3341
    }
3342
    do_pass = pass;
3343
}
3344

    
3345
static int64_t getutime(void)
3346
{
3347
#ifdef HAVE_GETRUSAGE
3348
    struct rusage rusage;
3349

    
3350
    getrusage(RUSAGE_SELF, &rusage);
3351
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3352
#elif defined(HAVE_GETPROCESSTIMES)
3353
    HANDLE proc;
3354
    FILETIME c, e, k, u;
3355
    proc = GetCurrentProcess();
3356
    GetProcessTimes(proc, &c, &e, &k, &u);
3357
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3358
#else
3359
    return av_gettime();
3360
#endif
3361
}
3362

    
3363
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3364
{
3365
    int i;
3366
    const char *p = str;
3367
    for(i = 0;; i++) {
3368
        dest[i] = atoi(p);
3369
        if(i == 63)
3370
            break;
3371
        p = strchr(p, ',');
3372
        if(!p) {
3373
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3374
            av_exit(1);
3375
        }
3376
        p++;
3377
    }
3378
}
3379

    
3380
static void opt_inter_matrix(const char *arg)
3381
{
3382
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3383
    parse_matrix_coeffs(inter_matrix, arg);
3384
}
3385

    
3386
static void opt_intra_matrix(const char *arg)
3387
{
3388
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3389
    parse_matrix_coeffs(intra_matrix, arg);
3390
}
3391

    
3392
/**
3393
 * Trivial log callback.
3394
 * Only suitable for show_help and similar since it lacks prefix handling.
3395
 */
3396
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3397
{
3398
    vfprintf(stdout, fmt, vl);
3399
}
3400

    
3401
static void show_help(void)
3402
{
3403
    av_log_set_callback(log_callback_help);
3404
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3405
           "Hyper fast Audio and Video encoder\n");
3406
    printf("\n");
3407
    show_help_options(options, "Main options:\n",
3408
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3409
    show_help_options(options, "\nAdvanced options:\n",
3410
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3411
                      OPT_EXPERT);
3412
    show_help_options(options, "\nVideo options:\n",
3413
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3414
                      OPT_VIDEO);
3415
    show_help_options(options, "\nAdvanced Video options:\n",
3416
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3417
                      OPT_VIDEO | OPT_EXPERT);
3418
    show_help_options(options, "\nAudio options:\n",
3419
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3420
                      OPT_AUDIO);
3421
    show_help_options(options, "\nAdvanced Audio options:\n",
3422
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3423
                      OPT_AUDIO | OPT_EXPERT);
3424
    show_help_options(options, "\nSubtitle options:\n",
3425
                      OPT_SUBTITLE | OPT_GRAB,
3426
                      OPT_SUBTITLE);
3427
    show_help_options(options, "\nAudio/Video grab options:\n",
3428
                      OPT_GRAB,
3429
                      OPT_GRAB);
3430
    printf("\n");
3431
    av_opt_show(avctx_opts[0], NULL);
3432
    printf("\n");
3433
    av_opt_show(avformat_opts, NULL);
3434
    printf("\n");
3435
    av_opt_show(sws_opts, NULL);
3436
}
3437

    
3438
static void opt_target(const char *arg)
3439
{
3440
    int norm = -1;
3441
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3442

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

    
3487
    if(norm < 0) {
3488
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3489
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3490
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3491
        av_exit(1);
3492
    }
3493

    
3494
    if(!strcmp(arg, "vcd")) {
3495

    
3496
        opt_video_codec("mpeg1video");
3497
        opt_audio_codec("mp2");
3498
        opt_format("vcd");
3499

    
3500
        opt_frame_size(norm ? "352x240" : "352x288");
3501
        opt_frame_rate(frame_rates[norm]);
3502
        opt_default("gop", norm ? "18" : "15");
3503

    
3504
        opt_default("b", "1150000");
3505
        opt_default("maxrate", "1150000");
3506
        opt_default("minrate", "1150000");
3507
        opt_default("bufsize", "327680"); // 40*1024*8;
3508

    
3509
        opt_default("ab", "224000");
3510
        audio_sample_rate = 44100;
3511
        audio_channels = 2;
3512

    
3513
        opt_default("packetsize", "2324");
3514
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3515

    
3516
        /* We have to offset the PTS, so that it is consistent with the SCR.
3517
           SCR starts at 36000, but the first two packs contain only padding
3518
           and the first pack from the other stream, respectively, may also have
3519
           been written before.
3520
           So the real data starts at SCR 36000+3*1200. */
3521
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3522
    } else if(!strcmp(arg, "svcd")) {
3523

    
3524
        opt_video_codec("mpeg2video");
3525
        opt_audio_codec("mp2");
3526
        opt_format("svcd");
3527

    
3528
        opt_frame_size(norm ? "480x480" : "480x576");
3529
        opt_frame_rate(frame_rates[norm]);
3530
        opt_default("gop", norm ? "18" : "15");
3531

    
3532
        opt_default("b", "2040000");
3533
        opt_default("maxrate", "2516000");
3534
        opt_default("minrate", "0"); //1145000;
3535
        opt_default("bufsize", "1835008"); //224*1024*8;
3536
        opt_default("flags", "+SCAN_OFFSET");
3537

    
3538

    
3539
        opt_default("ab", "224000");
3540
        audio_sample_rate = 44100;
3541

    
3542
        opt_default("packetsize", "2324");
3543

    
3544
    } else if(!strcmp(arg, "dvd")) {
3545

    
3546
        opt_video_codec("mpeg2video");
3547
        opt_audio_codec("ac3");
3548
        opt_format("dvd");
3549

    
3550
        opt_frame_size(norm ? "720x480" : "720x576");
3551
        opt_frame_rate(frame_rates[norm]);
3552
        opt_default("gop", norm ? "18" : "15");
3553

    
3554
        opt_default("b", "6000000");
3555
        opt_default("maxrate", "9000000");
3556
        opt_default("minrate", "0"); //1500000;
3557
        opt_default("bufsize", "1835008"); //224*1024*8;
3558

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

    
3562
        opt_default("ab", "448000");
3563
        audio_sample_rate = 48000;
3564

    
3565
    } else if(!strncmp(arg, "dv", 2)) {
3566

    
3567
        opt_format("dv");
3568

    
3569
        opt_frame_size(norm ? "720x480" : "720x576");
3570
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3571
                                             (norm ? "yuv411p" : "yuv420p"));
3572
        opt_frame_rate(frame_rates[norm]);
3573

    
3574
        audio_sample_rate = 48000;
3575
        audio_channels = 2;
3576

    
3577
    } else {
3578
        fprintf(stderr, "Unknown target: %s\n", arg);
3579
        av_exit(1);
3580
    }
3581
}
3582

    
3583
static void opt_vstats_file (const char *arg)
3584
{
3585
    av_free (vstats_filename);
3586
    vstats_filename=av_strdup (arg);
3587
}
3588

    
3589
static void opt_vstats (void)
3590
{
3591
    char filename[40];
3592
    time_t today2 = time(NULL);
3593
    struct tm *today = localtime(&today2);
3594

    
3595
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3596
             today->tm_sec);
3597
    opt_vstats_file(filename);
3598
}
3599

    
3600
static int opt_bsf(const char *opt, const char *arg)
3601
{
3602
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3603
    AVBitStreamFilterContext **bsfp;
3604

    
3605
    if(!bsfc){
3606
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3607
        av_exit(1);
3608
    }
3609

    
3610
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3611
          *opt == 'a' ? &audio_bitstream_filters :
3612
                        &subtitle_bitstream_filters;
3613
    while(*bsfp)
3614
        bsfp= &(*bsfp)->next;
3615

    
3616
    *bsfp= bsfc;
3617

    
3618
    return 0;
3619
}
3620

    
3621
static int opt_preset(const char *opt, const char *arg)
3622
{
3623
    FILE *f=NULL;
3624
    char tmp[1000], tmp2[1000];
3625
    int i;
3626
    const char *base[3]= { getenv("HOME"),
3627
                           "/usr/local/share",
3628
                           "/usr/share",
3629
                         };
3630

    
3631
    for(i=!base[0]; i<3 && !f; i++){
3632
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3633
        f= fopen(tmp, "r");
3634
        if(!f){
3635
            char *codec_name= *opt == 'v' ? video_codec_name :
3636
                              *opt == 'a' ? audio_codec_name :
3637
                                            subtitle_codec_name;
3638
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3639
            f= fopen(tmp, "r");
3640
        }
3641
    }
3642

    
3643
    if(!f){
3644
        fprintf(stderr, "Preset file not found\n");
3645
        av_exit(1);
3646
    }
3647

    
3648
    while(!feof(f)){
3649
        int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3650
        if(e!=2){
3651
            fprintf(stderr, "Preset file invalid\n");
3652
            av_exit(1);
3653
        }
3654
        opt_default(tmp, tmp2);
3655
    }
3656

    
3657
    fclose(f);
3658

    
3659
    return 0;
3660
}
3661

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

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

    
3752
    /* audio options */
3753
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3754
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3755
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3756
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3757
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3758
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3759
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3760
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3761
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3762
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3763
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3764

    
3765
    /* subtitle options */
3766
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3767
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3768
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3769
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3770

    
3771
    /* grab options */
3772
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3773
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3774
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3775

    
3776
    /* muxer options */
3777
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3778
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3779

    
3780
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3781
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3782
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3783

    
3784
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3785
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3786
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3787

    
3788
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3789
    { NULL, },
3790
};
3791

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

    
3797
    avcodec_register_all();
3798
    avdevice_register_all();
3799
    av_register_all();
3800

    
3801
    for(i=0; i<CODEC_TYPE_NB; i++){
3802
        avctx_opts[i]= avcodec_alloc_context2(i);
3803
    }
3804
    avformat_opts = av_alloc_format_context();
3805
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3806

    
3807
    show_banner();
3808
    if (argc <= 1) {
3809
        show_help();
3810
        av_exit(1);
3811
    }
3812

    
3813
    /* parse options */
3814
    parse_options(argc, argv, options, opt_output_file);
3815

    
3816
    /* file converter / grab */
3817
    if (nb_output_files <= 0) {
3818
        fprintf(stderr, "Must supply at least one output file\n");
3819
        av_exit(1);
3820
    }
3821

    
3822
    if (nb_input_files == 0) {
3823
        fprintf(stderr, "Must supply at least one input file\n");
3824
        av_exit(1);
3825
    }
3826

    
3827
    ti = getutime();
3828
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3829
              stream_maps, nb_stream_maps);
3830
    ti = getutime() - ti;
3831
    if (do_benchmark) {
3832
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3833
    }
3834

    
3835
    return av_exit(0);
3836
}