Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 81b060fa

History | View | Annotate | Download (138 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 "libavcodec/audioconvert.h"
36
#include "libavutil/fifo.h"
37
#include "libavutil/avstring.h"
38
#include "libavformat/os_support.h"
39

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

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

    
59
#include "cmdutils.h"
60

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

    
64
#undef exit
65

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

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

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

    
83
static const OptionDef options[];
84

    
85
#define MAX_FILES 20
86

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

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

    
95
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
96
static int nb_stream_maps;
97

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

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

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

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

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

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

    
188
static int rate_emu = 0;
189

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

    
193
static int audio_volume = 256;
194

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

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

    
211
static unsigned int sws_flags = SWS_BICUBIC;
212

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

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

    
225
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226

    
227
struct AVInputStream;
228

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

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

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

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

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

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

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

    
289
#ifdef HAVE_TERMIOS_H
290

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

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

    
302
static volatile sig_atomic_t received_sigterm = 0;
303

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

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

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

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

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

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

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

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

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

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

    
378
static int av_exit(int ret)
379
{
380
    int i;
381

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

    
398
    av_free(intra_matrix);
399
    av_free(inter_matrix);
400

    
401
    if (vstats_file)
402
        fclose(vstats_file);
403
    av_free(vstats_filename);
404

    
405
    av_free(opt_names);
406

    
407
    av_free(video_codec_name);
408
    av_free(audio_codec_name);
409
    av_free(subtitle_codec_name);
410

    
411
    av_free(video_standard);
412

    
413
#ifdef CONFIG_POWERPC_PERF
414
    extern void powerpc_display_perf_report(void);
415
    powerpc_display_perf_report();
416
#endif /* CONFIG_POWERPC_PERF */
417

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

    
425
    exit(ret); /* not all OS-es handle main() return value */
426
    return ret;
427
}
428

    
429
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
430
{
431
    int i, err;
432
    AVFormatContext *ic;
433
    int nopts = 0;
434

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

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

    
450
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
451
            st->stream_copy = 1;
452
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
453
            st->stream_copy = 1;
454

    
455
        if(!st->codec->thread_count)
456
            st->codec->thread_count = 1;
457
        if(st->codec->thread_count>1)
458
            avcodec_thread_init(st->codec, st->codec->thread_count);
459

    
460
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
461
            nopts = 1;
462
    }
463

    
464
    if (!nopts)
465
        s->timestamp = av_gettime();
466

    
467
    av_close_input_file(ic);
468
    return 0;
469
}
470

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

    
478
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
479
    int ret;
480

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

    
498
        bsfc= bsfc->next;
499
    }
500

    
501
    ret= av_interleaved_write_frame(s, pkt);
502
    if(ret < 0){
503
        print_error("av_interleaved_write_frame()", ret);
504
        av_exit(1);
505
    }
506
}
507

    
508
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
509

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

    
521
    int size_out, frame_bytes, ret;
522
    AVCodecContext *enc= ost->st->codec;
523
    AVCodecContext *dec= ist->st->codec;
524

    
525
    /* SC: dynamic allocation of buffers */
526
    if (!audio_buf)
527
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
528
    if (!audio_out)
529
        audio_out = av_malloc(audio_out_size);
530
    if (!audio_buf || !audio_out)
531
        return;               /* Should signal an error ! */
532

    
533
    if (enc->channels != dec->channels)
534
        ost->audio_resample = 1;
535

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

    
547
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
548
    if (dec->sample_fmt!=enc->sample_fmt &&
549
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
550
        if (!audio_out2)
551
            audio_out2 = av_malloc(audio_out_size);
552
        if (!audio_out2)
553
            av_exit(1);
554
        if (ost->reformat_ctx)
555
            av_audio_convert_free(ost->reformat_ctx);
556
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
557
                                                   dec->sample_fmt, 1, NULL, 0);
558
        if (!ost->reformat_ctx) {
559
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
560
                avcodec_get_sample_fmt_name(dec->sample_fmt),
561
                avcodec_get_sample_fmt_name(enc->sample_fmt));
562
            av_exit(1);
563
        }
564
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
565
    }
566

    
567
    if(audio_sync_method){
568
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
569
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
570
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
571
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
572

    
573
        //FIXME resample delay
574
        if(fabs(delta) > 50){
575
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
576
                if(byte_delta < 0){
577
                    byte_delta= FFMAX(byte_delta, -size);
578
                    size += byte_delta;
579
                    buf  -= byte_delta;
580
                    if(verbose > 2)
581
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
582
                    if(!size)
583
                        return;
584
                    ist->is_start=0;
585
                }else{
586
                    static uint8_t *input_tmp= NULL;
587
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
588

    
589
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
590
                        ist->is_start=0;
591
                    else
592
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
593

    
594
                    memset(input_tmp, 0, byte_delta);
595
                    memcpy(input_tmp + byte_delta, buf, size);
596
                    buf= input_tmp;
597
                    size += byte_delta;
598
                    if(verbose > 2)
599
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
600
                }
601
            }else if(audio_sync_method>1){
602
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
603
                assert(ost->audio_resample);
604
                if(verbose > 2)
605
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
606
//                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));
607
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
608
            }
609
        }
610
    }else
611
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
612
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
613

    
614
    if (ost->audio_resample) {
615
        buftmp = audio_buf;
616
        size_out = audio_resample(ost->resample,
617
                                  (short *)buftmp, (short *)buf,
618
                                  size / (ist->st->codec->channels * 2));
619
        size_out = size_out * enc->channels * 2;
620
    } else {
621
        buftmp = buf;
622
        size_out = size;
623
    }
624

    
625
    if (dec->sample_fmt!=enc->sample_fmt) {
626
        const void *ibuf[6]= {buftmp};
627
        void *obuf[6]= {audio_out2};
628
        int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};
629
        int ostride[6]= {av_get_bits_per_sample_format(enc->sample_fmt)/8};
630
        int len= size_out/istride[0];
631
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
632
            printf("av_audio_convert() failed\n");
633
            return;
634
        }
635
        buftmp = audio_out2;
636
        /* FIXME: existing code assume that size_out equals framesize*channels*2
637
                  remove this legacy cruft */
638
        size_out = len*2;
639
    }
640

    
641
    /* now encode as many frames as possible */
642
    if (enc->frame_size > 1) {
643
        /* output resampled raw samples */
644
        av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
645
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
646

    
647
        frame_bytes = enc->frame_size * 2 * enc->channels;
648

    
649
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
650
            AVPacket pkt;
651
            av_init_packet(&pkt);
652

    
653
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
654

    
655
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
656

    
657
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
658
                                       (short *)audio_buf);
659
            audio_size += ret;
660
            pkt.stream_index= ost->index;
661
            pkt.data= audio_out;
662
            pkt.size= ret;
663
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
664
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
665
            pkt.flags |= PKT_FLAG_KEY;
666
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
667

    
668
            ost->sync_opts += enc->frame_size;
669
        }
670
    } else {
671
        AVPacket pkt;
672
        av_init_packet(&pkt);
673

    
674
        ost->sync_opts += size_out / (2 * enc->channels);
675

    
676
        /* output a pcm frame */
677
        /* XXX: change encoding codec API to avoid this ? */
678
        switch(enc->codec->id) {
679
        case CODEC_ID_PCM_S32LE:
680
        case CODEC_ID_PCM_S32BE:
681
        case CODEC_ID_PCM_U32LE:
682
        case CODEC_ID_PCM_U32BE:
683
        case CODEC_ID_PCM_F32BE:
684
            size_out = size_out << 1;
685
            break;
686
        case CODEC_ID_PCM_S24LE:
687
        case CODEC_ID_PCM_S24BE:
688
        case CODEC_ID_PCM_U24LE:
689
        case CODEC_ID_PCM_U24BE:
690
        case CODEC_ID_PCM_S24DAUD:
691
            size_out = size_out / 2 * 3;
692
            break;
693
        case CODEC_ID_PCM_S16LE:
694
        case CODEC_ID_PCM_S16BE:
695
        case CODEC_ID_PCM_U16LE:
696
        case CODEC_ID_PCM_U16BE:
697
            break;
698
        default:
699
            size_out = size_out >> 1;
700
            break;
701
        }
702
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
703
        ret = avcodec_encode_audio(enc, audio_out, size_out,
704
                                   (short *)buftmp);
705
        audio_size += ret;
706
        pkt.stream_index= ost->index;
707
        pkt.data= audio_out;
708
        pkt.size= ret;
709
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
710
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
711
        pkt.flags |= PKT_FLAG_KEY;
712
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
713
    }
714
}
715

    
716
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
717
{
718
    AVCodecContext *dec;
719
    AVPicture *picture2;
720
    AVPicture picture_tmp;
721
    uint8_t *buf = 0;
722

    
723
    dec = ist->st->codec;
724

    
725
    /* deinterlace : must be done before any resize */
726
    if (do_deinterlace || using_vhook) {
727
        int size;
728

    
729
        /* create temporary picture */
730
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
731
        buf = av_malloc(size);
732
        if (!buf)
733
            return;
734

    
735
        picture2 = &picture_tmp;
736
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
737

    
738
        if (do_deinterlace){
739
            if(avpicture_deinterlace(picture2, picture,
740
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
741
                /* if error, do not deinterlace */
742
                av_free(buf);
743
                buf = NULL;
744
                picture2 = picture;
745
            }
746
        } else {
747
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
748
        }
749
    } else {
750
        picture2 = picture;
751
    }
752

    
753
    if (ENABLE_VHOOK)
754
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
755
                           1000000 * ist->pts / AV_TIME_BASE);
756

    
757
    if (picture != picture2)
758
        *picture = *picture2;
759
    *bufp = buf;
760
}
761

    
762
/* we begin to correct av delay at this threshold */
763
#define AV_DELAY_MAX 0.100
764

    
765
static void do_subtitle_out(AVFormatContext *s,
766
                            AVOutputStream *ost,
767
                            AVInputStream *ist,
768
                            AVSubtitle *sub,
769
                            int64_t pts)
770
{
771
    static uint8_t *subtitle_out = NULL;
772
    int subtitle_out_max_size = 65536;
773
    int subtitle_out_size, nb, i;
774
    AVCodecContext *enc;
775
    AVPacket pkt;
776

    
777
    if (pts == AV_NOPTS_VALUE) {
778
        fprintf(stderr, "Subtitle packets must have a pts\n");
779
        return;
780
    }
781

    
782
    enc = ost->st->codec;
783

    
784
    if (!subtitle_out) {
785
        subtitle_out = av_malloc(subtitle_out_max_size);
786
    }
787

    
788
    /* Note: DVB subtitle need one packet to draw them and one other
789
       packet to clear them */
790
    /* XXX: signal it in the codec context ? */
791
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
792
        nb = 2;
793
    else
794
        nb = 1;
795

    
796
    for(i = 0; i < nb; i++) {
797
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
798
                                                    subtitle_out_max_size, sub);
799

    
800
        av_init_packet(&pkt);
801
        pkt.stream_index = ost->index;
802
        pkt.data = subtitle_out;
803
        pkt.size = subtitle_out_size;
804
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
805
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
806
            /* XXX: the pts correction is handled here. Maybe handling
807
               it in the codec would be better */
808
            if (i == 0)
809
                pkt.pts += 90 * sub->start_display_time;
810
            else
811
                pkt.pts += 90 * sub->end_display_time;
812
        }
813
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
814
    }
815
}
816

    
817
static int bit_buffer_size= 1024*256;
818
static uint8_t *bit_buffer= NULL;
819

    
820
static void do_video_out(AVFormatContext *s,
821
                         AVOutputStream *ost,
822
                         AVInputStream *ist,
823
                         AVFrame *in_picture,
824
                         int *frame_size)
825
{
826
    int nb_frames, i, ret;
827
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
828
    AVFrame picture_crop_temp, picture_pad_temp;
829
    AVCodecContext *enc, *dec;
830

    
831
    avcodec_get_frame_defaults(&picture_crop_temp);
832
    avcodec_get_frame_defaults(&picture_pad_temp);
833

    
834
    enc = ost->st->codec;
835
    dec = ist->st->codec;
836

    
837
    /* by default, we output a single frame */
838
    nb_frames = 1;
839

    
840
    *frame_size = 0;
841

    
842
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
843
        double vdelta;
844
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
845
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
846
        if (vdelta < -1.1)
847
            nb_frames = 0;
848
        else if (video_sync_method == 2)
849
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
850
        else if (vdelta > 1.1)
851
            nb_frames = lrintf(vdelta);
852
//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);
853
        if (nb_frames == 0){
854
            ++nb_frames_drop;
855
            if (verbose>2)
856
                fprintf(stderr, "*** drop!\n");
857
        }else if (nb_frames > 1) {
858
            nb_frames_dup += nb_frames;
859
            if (verbose>2)
860
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
861
        }
862
    }else
863
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
864

    
865
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
866
    if (nb_frames <= 0)
867
        return;
868

    
869
    if (ost->video_crop) {
870
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
871
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
872
            return;
873
        }
874
        formatted_picture = &picture_crop_temp;
875
    } else {
876
        formatted_picture = in_picture;
877
    }
878

    
879
    final_picture = formatted_picture;
880
    padding_src = formatted_picture;
881
    resampling_dst = &ost->pict_tmp;
882
    if (ost->video_pad) {
883
        final_picture = &ost->pict_tmp;
884
        if (ost->video_resample) {
885
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
886
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
887
                return;
888
            }
889
            resampling_dst = &picture_pad_temp;
890
        }
891
    }
892

    
893
    if (ost->video_resample) {
894
        padding_src = NULL;
895
        final_picture = &ost->pict_tmp;
896
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
897
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
898
    }
899

    
900
    if (ost->video_pad) {
901
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
902
                enc->height, enc->width, enc->pix_fmt,
903
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
904
    }
905

    
906
    /* duplicates frame if needed */
907
    for(i=0;i<nb_frames;i++) {
908
        AVPacket pkt;
909
        av_init_packet(&pkt);
910
        pkt.stream_index= ost->index;
911

    
912
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
913
            /* raw pictures are written as AVPicture structure to
914
               avoid any copies. We support temorarily the older
915
               method. */
916
            AVFrame* old_frame = enc->coded_frame;
917
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
918
            pkt.data= (uint8_t *)final_picture;
919
            pkt.size=  sizeof(AVPicture);
920
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
921
            pkt.flags |= PKT_FLAG_KEY;
922

    
923
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
924
            enc->coded_frame = old_frame;
925
        } else {
926
            AVFrame big_picture;
927

    
928
            big_picture= *final_picture;
929
            /* better than nothing: use input picture interlaced
930
               settings */
931
            big_picture.interlaced_frame = in_picture->interlaced_frame;
932
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
933
                if(top_field_first == -1)
934
                    big_picture.top_field_first = in_picture->top_field_first;
935
                else
936
                    big_picture.top_field_first = top_field_first;
937
            }
938

    
939
            /* handles sameq here. This is not correct because it may
940
               not be a global option */
941
            if (same_quality) {
942
                big_picture.quality = ist->st->quality;
943
            }else
944
                big_picture.quality = ost->st->quality;
945
            if(!me_threshold)
946
                big_picture.pict_type = 0;
947
//            big_picture.pts = AV_NOPTS_VALUE;
948
            big_picture.pts= ost->sync_opts;
949
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
950
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
951
            ret = avcodec_encode_video(enc,
952
                                       bit_buffer, bit_buffer_size,
953
                                       &big_picture);
954
            if (ret == -1) {
955
                fprintf(stderr, "Video encoding failed\n");
956
                av_exit(1);
957
            }
958
            //enc->frame_number = enc->real_pict_num;
959
            if(ret>0){
960
                pkt.data= bit_buffer;
961
                pkt.size= ret;
962
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
963
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
964
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
965
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
966
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
967

    
968
                if(enc->coded_frame->key_frame)
969
                    pkt.flags |= PKT_FLAG_KEY;
970
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
971
                *frame_size = ret;
972
                video_size += ret;
973
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
974
                //        enc->frame_number-1, enc->real_pict_num, ret,
975
                //        enc->pict_type);
976
                /* if two pass, output log */
977
                if (ost->logfile && enc->stats_out) {
978
                    fprintf(ost->logfile, "%s", enc->stats_out);
979
                }
980
            }
981
        }
982
        ost->sync_opts++;
983
        ost->frame_number++;
984
    }
985
}
986

    
987
static double psnr(double d){
988
    return -10.0*log(d)/log(10.0);
989
}
990

    
991
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
992
                           int frame_size)
993
{
994
    AVCodecContext *enc;
995
    int frame_number;
996
    double ti1, bitrate, avg_bitrate;
997

    
998
    /* this is executed just the first time do_video_stats is called */
999
    if (!vstats_file) {
1000
        vstats_file = fopen(vstats_filename, "w");
1001
        if (!vstats_file) {
1002
            perror("fopen");
1003
            av_exit(1);
1004
        }
1005
    }
1006

    
1007
    enc = ost->st->codec;
1008
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1009
        frame_number = ost->frame_number;
1010
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1011
        if (enc->flags&CODEC_FLAG_PSNR)
1012
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1013

    
1014
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1015
        /* compute pts value */
1016
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1017
        if (ti1 < 0.01)
1018
            ti1 = 0.01;
1019

    
1020
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1021
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1022
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1023
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1024
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1025
    }
1026
}
1027

    
1028
static void print_report(AVFormatContext **output_files,
1029
                         AVOutputStream **ost_table, int nb_ostreams,
1030
                         int is_last_report)
1031
{
1032
    char buf[1024];
1033
    AVOutputStream *ost;
1034
    AVFormatContext *oc, *os;
1035
    int64_t total_size;
1036
    AVCodecContext *enc;
1037
    int frame_number, vid, i;
1038
    double bitrate, ti1, pts;
1039
    static int64_t last_time = -1;
1040
    static int qp_histogram[52];
1041

    
1042
    if (!is_last_report) {
1043
        int64_t cur_time;
1044
        /* display the report every 0.5 seconds */
1045
        cur_time = av_gettime();
1046
        if (last_time == -1) {
1047
            last_time = cur_time;
1048
            return;
1049
        }
1050
        if ((cur_time - last_time) < 500000)
1051
            return;
1052
        last_time = cur_time;
1053
    }
1054

    
1055

    
1056
    oc = output_files[0];
1057

    
1058
    total_size = url_fsize(oc->pb);
1059
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1060
        total_size= url_ftell(oc->pb);
1061

    
1062
    buf[0] = '\0';
1063
    ti1 = 1e10;
1064
    vid = 0;
1065
    for(i=0;i<nb_ostreams;i++) {
1066
        ost = ost_table[i];
1067
        os = output_files[ost->file_index];
1068
        enc = ost->st->codec;
1069
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1070
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1071
                     !ost->st->stream_copy ?
1072
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1073
        }
1074
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1075
            float t = (av_gettime()-timer_start) / 1000000.0;
1076

    
1077
            frame_number = ost->frame_number;
1078
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1079
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1080
                     !ost->st->stream_copy ?
1081
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1082
            if(is_last_report)
1083
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1084
            if(qp_hist){
1085
                int j;
1086
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1087
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1088
                    qp_histogram[qp]++;
1089
                for(j=0; j<32; j++)
1090
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1091
            }
1092
            if (enc->flags&CODEC_FLAG_PSNR){
1093
                int j;
1094
                double error, error_sum=0;
1095
                double scale, scale_sum=0;
1096
                char type[3]= {'Y','U','V'};
1097
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1098
                for(j=0; j<3; j++){
1099
                    if(is_last_report){
1100
                        error= enc->error[j];
1101
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1102
                    }else{
1103
                        error= enc->coded_frame->error[j];
1104
                        scale= enc->width*enc->height*255.0*255.0;
1105
                    }
1106
                    if(j) scale/=4;
1107
                    error_sum += error;
1108
                    scale_sum += scale;
1109
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1110
                }
1111
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1112
            }
1113
            vid = 1;
1114
        }
1115
        /* compute min output value */
1116
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1117
        if ((pts < ti1) && (pts > 0))
1118
            ti1 = pts;
1119
    }
1120
    if (ti1 < 0.01)
1121
        ti1 = 0.01;
1122

    
1123
    if (verbose || is_last_report) {
1124
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1125

    
1126
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1127
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1128
            (double)total_size / 1024, ti1, bitrate);
1129

    
1130
        if (verbose > 1)
1131
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1132
                  nb_frames_dup, nb_frames_drop);
1133

    
1134
        if (verbose >= 0)
1135
            fprintf(stderr, "%s    \r", buf);
1136

    
1137
        fflush(stderr);
1138
    }
1139

    
1140
    if (is_last_report && verbose >= 0){
1141
        int64_t raw= audio_size + video_size + extra_size;
1142
        fprintf(stderr, "\n");
1143
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1144
                video_size/1024.0,
1145
                audio_size/1024.0,
1146
                extra_size/1024.0,
1147
                100.0*(total_size - raw)/raw
1148
        );
1149
    }
1150
}
1151

    
1152
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1153
static int output_packet(AVInputStream *ist, int ist_index,
1154
                         AVOutputStream **ost_table, int nb_ostreams,
1155
                         const AVPacket *pkt)
1156
{
1157
    AVFormatContext *os;
1158
    AVOutputStream *ost;
1159
    uint8_t *ptr;
1160
    int len, ret, i;
1161
    uint8_t *data_buf;
1162
    int data_size, got_picture;
1163
    AVFrame picture;
1164
    void *buffer_to_free;
1165
    static unsigned int samples_size= 0;
1166
    static short *samples= NULL;
1167
    AVSubtitle subtitle, *subtitle_to_free;
1168
    int got_subtitle;
1169

    
1170
    if(ist->next_pts == AV_NOPTS_VALUE)
1171
        ist->next_pts= ist->pts;
1172

    
1173
    if (pkt == NULL) {
1174
        /* EOF handling */
1175
        ptr = NULL;
1176
        len = 0;
1177
        goto handle_eof;
1178
    }
1179

    
1180
    if(pkt->dts != AV_NOPTS_VALUE)
1181
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1182

    
1183
    len = pkt->size;
1184
    ptr = pkt->data;
1185

    
1186
    //while we have more to decode or while the decoder did output something on EOF
1187
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1188
    handle_eof:
1189
        ist->pts= ist->next_pts;
1190

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

    
1194
        /* decode the packet if needed */
1195
        data_buf = NULL; /* fail safe */
1196
        data_size = 0;
1197
        subtitle_to_free = NULL;
1198
        if (ist->decoding_needed) {
1199
            switch(ist->st->codec->codec_type) {
1200
            case CODEC_TYPE_AUDIO:{
1201
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1202
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1203
                    av_free(samples);
1204
                    samples= av_malloc(samples_size);
1205
                }
1206
                data_size= samples_size;
1207
                    /* XXX: could avoid copy if PCM 16 bits with same
1208
                       endianness as CPU */
1209
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1210
                                           ptr, len);
1211
                if (ret < 0)
1212
                    goto fail_decode;
1213
                ptr += ret;
1214
                len -= ret;
1215
                /* Some bug in mpeg audio decoder gives */
1216
                /* data_size < 0, it seems they are overflows */
1217
                if (data_size <= 0) {
1218
                    /* no audio frame */
1219
                    continue;
1220
                }
1221
                data_buf = (uint8_t *)samples;
1222
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1223
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1224
                break;}
1225
            case CODEC_TYPE_VIDEO:
1226
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1227
                    /* XXX: allocate picture correctly */
1228
                    avcodec_get_frame_defaults(&picture);
1229

    
1230
                    ret = avcodec_decode_video(ist->st->codec,
1231
                                               &picture, &got_picture, ptr, len);
1232
                    ist->st->quality= picture.quality;
1233
                    if (ret < 0)
1234
                        goto fail_decode;
1235
                    if (!got_picture) {
1236
                        /* no picture yet */
1237
                        goto discard_packet;
1238
                    }
1239
                    if (ist->st->codec->time_base.num != 0) {
1240
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1241
                                          ist->st->codec->time_base.num) /
1242
                            ist->st->codec->time_base.den;
1243
                    }
1244
                    len = 0;
1245
                    break;
1246
            case CODEC_TYPE_SUBTITLE:
1247
                ret = avcodec_decode_subtitle(ist->st->codec,
1248
                                              &subtitle, &got_subtitle, ptr, len);
1249
                if (ret < 0)
1250
                    goto fail_decode;
1251
                if (!got_subtitle) {
1252
                    goto discard_packet;
1253
                }
1254
                subtitle_to_free = &subtitle;
1255
                len = 0;
1256
                break;
1257
            default:
1258
                goto fail_decode;
1259
            }
1260
        } else {
1261
            switch(ist->st->codec->codec_type) {
1262
            case CODEC_TYPE_AUDIO:
1263
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1264
                    ist->st->codec->sample_rate;
1265
                break;
1266
            case CODEC_TYPE_VIDEO:
1267
                if (ist->st->codec->time_base.num != 0) {
1268
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1269
                                      ist->st->codec->time_base.num) /
1270
                        ist->st->codec->time_base.den;
1271
                }
1272
                break;
1273
            }
1274
            data_buf = ptr;
1275
            data_size = len;
1276
            ret = len;
1277
            len = 0;
1278
        }
1279

    
1280
        buffer_to_free = NULL;
1281
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1282
            pre_process_video_frame(ist, (AVPicture *)&picture,
1283
                                    &buffer_to_free);
1284
        }
1285

    
1286
        // preprocess audio (volume)
1287
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1288
            if (audio_volume != 256) {
1289
                short *volp;
1290
                volp = samples;
1291
                for(i=0;i<(data_size / sizeof(short));i++) {
1292
                    int v = ((*volp) * audio_volume + 128) >> 8;
1293
                    if (v < -32768) v = -32768;
1294
                    if (v >  32767) v = 32767;
1295
                    *volp++ = v;
1296
                }
1297
            }
1298
        }
1299

    
1300
        /* frame rate emulation */
1301
        if (ist->st->codec->rate_emu) {
1302
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1303
            int64_t now = av_gettime() - ist->start;
1304
            if (pts > now)
1305
                usleep(pts - now);
1306

    
1307
            ist->frame++;
1308
        }
1309

    
1310
#if 0
1311
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1312
           is the one of the next displayed one */
1313
        /* XXX: add mpeg4 too ? */
1314
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1315
            if (ist->st->codec->pict_type != B_TYPE) {
1316
                int64_t tmp;
1317
                tmp = ist->last_ip_pts;
1318
                ist->last_ip_pts  = ist->frac_pts.val;
1319
                ist->frac_pts.val = tmp;
1320
            }
1321
        }
1322
#endif
1323
        /* if output time reached then transcode raw format,
1324
           encode packets and output them */
1325
        if (start_time == 0 || ist->pts >= start_time)
1326
            for(i=0;i<nb_ostreams;i++) {
1327
                int frame_size;
1328

    
1329
                ost = ost_table[i];
1330
                if (ost->source_index == ist_index) {
1331
                    os = output_files[ost->file_index];
1332

    
1333
#if 0
1334
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1335
                           (double)pkt->pts / AV_TIME_BASE,
1336
                           ((double)ist->pts / AV_TIME_BASE) -
1337
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1338
#endif
1339
                    /* set the input output pts pairs */
1340
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1341

    
1342
                    if (ost->encoding_needed) {
1343
                        switch(ost->st->codec->codec_type) {
1344
                        case CODEC_TYPE_AUDIO:
1345
                            do_audio_out(os, ost, ist, data_buf, data_size);
1346
                            break;
1347
                        case CODEC_TYPE_VIDEO:
1348
                            do_video_out(os, ost, ist, &picture, &frame_size);
1349
                            if (vstats_filename && frame_size)
1350
                                do_video_stats(os, ost, frame_size);
1351
                            break;
1352
                        case CODEC_TYPE_SUBTITLE:
1353
                            do_subtitle_out(os, ost, ist, &subtitle,
1354
                                            pkt->pts);
1355
                            break;
1356
                        default:
1357
                            abort();
1358
                        }
1359
                    } else {
1360
                        AVFrame avframe; //FIXME/XXX remove this
1361
                        AVPacket opkt;
1362
                        av_init_packet(&opkt);
1363

    
1364
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1365
                            continue;
1366

    
1367
                        /* no reencoding needed : output the packet directly */
1368
                        /* force the input stream PTS */
1369

    
1370
                        avcodec_get_frame_defaults(&avframe);
1371
                        ost->st->codec->coded_frame= &avframe;
1372
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1373

    
1374
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1375
                            audio_size += data_size;
1376
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1377
                            video_size += data_size;
1378
                            ost->sync_opts++;
1379
                        }
1380

    
1381
                        opkt.stream_index= ost->index;
1382
                        if(pkt->pts != AV_NOPTS_VALUE)
1383
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1384
                        else
1385
                            opkt.pts= AV_NOPTS_VALUE;
1386

    
1387
                        if (pkt->dts == AV_NOPTS_VALUE)
1388
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1389
                        else
1390
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1391

    
1392
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1393
                        opkt.flags= pkt->flags;
1394

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

    
1399
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1400
                        ost->st->codec->frame_number++;
1401
                        ost->frame_number++;
1402
                        av_free_packet(&opkt);
1403
                    }
1404
                }
1405
            }
1406
        av_free(buffer_to_free);
1407
        /* XXX: allocate the subtitles in the codec ? */
1408
        if (subtitle_to_free) {
1409
            if (subtitle_to_free->rects != NULL) {
1410
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1411
                    av_free(subtitle_to_free->rects[i].bitmap);
1412
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1413
                }
1414
                av_freep(&subtitle_to_free->rects);
1415
            }
1416
            subtitle_to_free->num_rects = 0;
1417
            subtitle_to_free = NULL;
1418
        }
1419
    }
1420
 discard_packet:
1421
    if (pkt == NULL) {
1422
        /* EOF handling */
1423

    
1424
        for(i=0;i<nb_ostreams;i++) {
1425
            ost = ost_table[i];
1426
            if (ost->source_index == ist_index) {
1427
                AVCodecContext *enc= ost->st->codec;
1428
                os = output_files[ost->file_index];
1429

    
1430
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1431
                    continue;
1432
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1433
                    continue;
1434

    
1435
                if (ost->encoding_needed) {
1436
                    for(;;) {
1437
                        AVPacket pkt;
1438
                        int fifo_bytes;
1439
                        av_init_packet(&pkt);
1440
                        pkt.stream_index= ost->index;
1441

    
1442
                        switch(ost->st->codec->codec_type) {
1443
                        case CODEC_TYPE_AUDIO:
1444
                            fifo_bytes = av_fifo_size(&ost->fifo);
1445
                            ret = 0;
1446
                            /* encode any samples remaining in fifo */
1447
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1448
                                int fs_tmp = enc->frame_size;
1449
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1450
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1451
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1452
                                enc->frame_size = fs_tmp;
1453
                            }
1454
                            if(ret <= 0) {
1455
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1456
                            }
1457
                            audio_size += ret;
1458
                            pkt.flags |= PKT_FLAG_KEY;
1459
                            break;
1460
                        case CODEC_TYPE_VIDEO:
1461
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1462
                            video_size += ret;
1463
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1464
                                pkt.flags |= PKT_FLAG_KEY;
1465
                            if (ost->logfile && enc->stats_out) {
1466
                                fprintf(ost->logfile, "%s", enc->stats_out);
1467
                            }
1468
                            break;
1469
                        default:
1470
                            ret=-1;
1471
                        }
1472

    
1473
                        if(ret<=0)
1474
                            break;
1475
                        pkt.data= bit_buffer;
1476
                        pkt.size= ret;
1477
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1478
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1479
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1480
                    }
1481
                }
1482
            }
1483
        }
1484
    }
1485

    
1486
    return 0;
1487
 fail_decode:
1488
    return -1;
1489
}
1490

    
1491
static void print_sdp(AVFormatContext **avc, int n)
1492
{
1493
    char sdp[2048];
1494

    
1495
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1496
    printf("SDP:\n%s\n", sdp);
1497
}
1498

    
1499
static int stream_index_from_inputs(AVFormatContext **input_files,
1500
                                    int nb_input_files,
1501
                                    AVInputFile *file_table,
1502
                                    AVInputStream **ist_table,
1503
                                    enum CodecType type,
1504
                                    int programid)
1505
{
1506
    int p, q, z;
1507
    for(z=0; z<nb_input_files; z++) {
1508
        AVFormatContext *ic = input_files[z];
1509
        for(p=0; p<ic->nb_programs; p++) {
1510
            AVProgram *program = ic->programs[p];
1511
            if(program->id != programid)
1512
                continue;
1513
            for(q=0; q<program->nb_stream_indexes; q++) {
1514
                int sidx = program->stream_index[q];
1515
                int ris = file_table[z].ist_index + sidx;
1516
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1517
                    return ris;
1518
            }
1519
        }
1520
    }
1521

    
1522
    return -1;
1523
}
1524

    
1525
/*
1526
 * The following code is the main loop of the file converter
1527
 */
1528
static int av_encode(AVFormatContext **output_files,
1529
                     int nb_output_files,
1530
                     AVFormatContext **input_files,
1531
                     int nb_input_files,
1532
                     AVStreamMap *stream_maps, int nb_stream_maps)
1533
{
1534
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1535
    AVFormatContext *is, *os;
1536
    AVCodecContext *codec, *icodec;
1537
    AVOutputStream *ost, **ost_table = NULL;
1538
    AVInputStream *ist, **ist_table = NULL;
1539
    AVInputFile *file_table;
1540
    int key;
1541
    int want_sdp = 1;
1542

    
1543
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1544
    if (!file_table)
1545
        goto fail;
1546

    
1547
    /* input stream init */
1548
    j = 0;
1549
    for(i=0;i<nb_input_files;i++) {
1550
        is = input_files[i];
1551
        file_table[i].ist_index = j;
1552
        file_table[i].nb_streams = is->nb_streams;
1553
        j += is->nb_streams;
1554
    }
1555
    nb_istreams = j;
1556

    
1557
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1558
    if (!ist_table)
1559
        goto fail;
1560

    
1561
    for(i=0;i<nb_istreams;i++) {
1562
        ist = av_mallocz(sizeof(AVInputStream));
1563
        if (!ist)
1564
            goto fail;
1565
        ist_table[i] = ist;
1566
    }
1567
    j = 0;
1568
    for(i=0;i<nb_input_files;i++) {
1569
        is = input_files[i];
1570
        for(k=0;k<is->nb_streams;k++) {
1571
            ist = ist_table[j++];
1572
            ist->st = is->streams[k];
1573
            ist->file_index = i;
1574
            ist->index = k;
1575
            ist->discard = 1; /* the stream is discarded by default
1576
                                 (changed later) */
1577

    
1578
            if (ist->st->codec->rate_emu) {
1579
                ist->start = av_gettime();
1580
                ist->frame = 0;
1581
            }
1582
        }
1583
    }
1584

    
1585
    /* output stream init */
1586
    nb_ostreams = 0;
1587
    for(i=0;i<nb_output_files;i++) {
1588
        os = output_files[i];
1589
        if (!os->nb_streams) {
1590
            fprintf(stderr, "Output file does not contain any stream\n");
1591
            av_exit(1);
1592
        }
1593
        nb_ostreams += os->nb_streams;
1594
    }
1595
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1596
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1597
        av_exit(1);
1598
    }
1599

    
1600
    /* Sanity check the mapping args -- do the input files & streams exist? */
1601
    for(i=0;i<nb_stream_maps;i++) {
1602
        int fi = stream_maps[i].file_index;
1603
        int si = stream_maps[i].stream_index;
1604

    
1605
        if (fi < 0 || fi > nb_input_files - 1 ||
1606
            si < 0 || si > file_table[fi].nb_streams - 1) {
1607
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1608
            av_exit(1);
1609
        }
1610
        fi = stream_maps[i].sync_file_index;
1611
        si = stream_maps[i].sync_stream_index;
1612
        if (fi < 0 || fi > nb_input_files - 1 ||
1613
            si < 0 || si > file_table[fi].nb_streams - 1) {
1614
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1615
            av_exit(1);
1616
        }
1617
    }
1618

    
1619
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1620
    if (!ost_table)
1621
        goto fail;
1622
    for(i=0;i<nb_ostreams;i++) {
1623
        ost = av_mallocz(sizeof(AVOutputStream));
1624
        if (!ost)
1625
            goto fail;
1626
        ost_table[i] = ost;
1627
    }
1628

    
1629
    n = 0;
1630
    for(k=0;k<nb_output_files;k++) {
1631
        os = output_files[k];
1632
        for(i=0;i<os->nb_streams;i++) {
1633
            int found;
1634
            ost = ost_table[n++];
1635
            ost->file_index = k;
1636
            ost->index = i;
1637
            ost->st = os->streams[i];
1638
            if (nb_stream_maps > 0) {
1639
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1640
                    stream_maps[n-1].stream_index;
1641

    
1642
                /* Sanity check that the stream types match */
1643
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1644
                    int i= ost->file_index;
1645
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1646
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1647
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1648
                        ost->file_index, ost->index);
1649
                    av_exit(1);
1650
                }
1651

    
1652
            } else {
1653
                if(opt_programid) {
1654
                    found = 0;
1655
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1656
                    if(j != -1) {
1657
                        ost->source_index = j;
1658
                        found = 1;
1659
                    }
1660
                } else {
1661
                    /* get corresponding input stream index : we select the first one with the right type */
1662
                    found = 0;
1663
                    for(j=0;j<nb_istreams;j++) {
1664
                        ist = ist_table[j];
1665
                        if (ist->discard &&
1666
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1667
                            ost->source_index = j;
1668
                            found = 1;
1669
                            break;
1670
                        }
1671
                    }
1672
                }
1673

    
1674
                if (!found) {
1675
                    if(! opt_programid) {
1676
                        /* try again and reuse existing stream */
1677
                        for(j=0;j<nb_istreams;j++) {
1678
                            ist = ist_table[j];
1679
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1680
                                ost->source_index = j;
1681
                                found = 1;
1682
                            }
1683
                        }
1684
                    }
1685
                    if (!found) {
1686
                        int i= ost->file_index;
1687
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1688
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1689
                                ost->file_index, ost->index);
1690
                        av_exit(1);
1691
                    }
1692
                }
1693
            }
1694
            ist = ist_table[ost->source_index];
1695
            ist->discard = 0;
1696
            ost->sync_ist = (nb_stream_maps > 0) ?
1697
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1698
                         stream_maps[n-1].sync_stream_index] : ist;
1699
        }
1700
    }
1701

    
1702
    /* for each output stream, we compute the right encoding parameters */
1703
    for(i=0;i<nb_ostreams;i++) {
1704
        ost = ost_table[i];
1705
        os = output_files[ost->file_index];
1706
        ist = ist_table[ost->source_index];
1707

    
1708
        codec = ost->st->codec;
1709
        icodec = ist->st->codec;
1710

    
1711
        if (!ost->st->language[0])
1712
            av_strlcpy(ost->st->language, ist->st->language,
1713
                       sizeof(ost->st->language));
1714

    
1715
        ost->st->disposition = ist->st->disposition;
1716

    
1717
        if (ost->st->stream_copy) {
1718
            /* if stream_copy is selected, no need to decode or encode */
1719
            codec->codec_id = icodec->codec_id;
1720
            codec->codec_type = icodec->codec_type;
1721

    
1722
            if(!codec->codec_tag){
1723
                if(   !os->oformat->codec_tag
1724
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1725
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1726
                    codec->codec_tag = icodec->codec_tag;
1727
            }
1728

    
1729
            codec->bit_rate = icodec->bit_rate;
1730
            codec->extradata= icodec->extradata;
1731
            codec->extradata_size= icodec->extradata_size;
1732
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1733
                codec->time_base = icodec->time_base;
1734
            else
1735
                codec->time_base = ist->st->time_base;
1736
            switch(codec->codec_type) {
1737
            case CODEC_TYPE_AUDIO:
1738
                if(audio_volume != 256) {
1739
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1740
                    av_exit(1);
1741
                }
1742
                codec->sample_rate = icodec->sample_rate;
1743
                codec->channels = icodec->channels;
1744
                codec->frame_size = icodec->frame_size;
1745
                codec->block_align= icodec->block_align;
1746
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1747
                    codec->block_align= 0;
1748
                if(codec->codec_id == CODEC_ID_AC3)
1749
                    codec->block_align= 0;
1750
                break;
1751
            case CODEC_TYPE_VIDEO:
1752
                if(using_vhook) {
1753
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1754
                    av_exit(1);
1755
                }
1756
                codec->pix_fmt = icodec->pix_fmt;
1757
                codec->width = icodec->width;
1758
                codec->height = icodec->height;
1759
                codec->has_b_frames = icodec->has_b_frames;
1760
                break;
1761
            case CODEC_TYPE_SUBTITLE:
1762
                break;
1763
            default:
1764
                abort();
1765
            }
1766
        } else {
1767
            switch(codec->codec_type) {
1768
            case CODEC_TYPE_AUDIO:
1769
                if (av_fifo_init(&ost->fifo, 1024))
1770
                    goto fail;
1771
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1772
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1773
                icodec->request_channels = codec->channels;
1774
                ist->decoding_needed = 1;
1775
                ost->encoding_needed = 1;
1776
                break;
1777
            case CODEC_TYPE_VIDEO:
1778
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1779
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1780
                ost->video_resample = ((codec->width != icodec->width -
1781
                                (frame_leftBand + frame_rightBand) +
1782
                                (frame_padleft + frame_padright)) ||
1783
                        (codec->height != icodec->height -
1784
                                (frame_topBand  + frame_bottomBand) +
1785
                                (frame_padtop + frame_padbottom)) ||
1786
                        (codec->pix_fmt != icodec->pix_fmt));
1787
                if (ost->video_crop) {
1788
                    ost->topBand = frame_topBand;
1789
                    ost->leftBand = frame_leftBand;
1790
                }
1791
                if (ost->video_pad) {
1792
                    ost->padtop = frame_padtop;
1793
                    ost->padleft = frame_padleft;
1794
                    ost->padbottom = frame_padbottom;
1795
                    ost->padright = frame_padright;
1796
                    if (!ost->video_resample) {
1797
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1798
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1799
                                         codec->width, codec->height))
1800
                            goto fail;
1801
                    }
1802
                }
1803
                if (ost->video_resample) {
1804
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1805
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1806
                                         codec->width, codec->height)) {
1807
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1808
                        av_exit(1);
1809
                    }
1810
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1811
                    ost->img_resample_ctx = sws_getContext(
1812
                            icodec->width - (frame_leftBand + frame_rightBand),
1813
                            icodec->height - (frame_topBand + frame_bottomBand),
1814
                            icodec->pix_fmt,
1815
                            codec->width - (frame_padleft + frame_padright),
1816
                            codec->height - (frame_padtop + frame_padbottom),
1817
                            codec->pix_fmt,
1818
                            sws_flags, NULL, NULL, NULL);
1819
                    if (ost->img_resample_ctx == NULL) {
1820
                        fprintf(stderr, "Cannot get resampling context\n");
1821
                        av_exit(1);
1822
                    }
1823
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1824
                }
1825
                ost->encoding_needed = 1;
1826
                ist->decoding_needed = 1;
1827
                break;
1828
            case CODEC_TYPE_SUBTITLE:
1829
                ost->encoding_needed = 1;
1830
                ist->decoding_needed = 1;
1831
                break;
1832
            default:
1833
                abort();
1834
                break;
1835
            }
1836
            /* two pass mode */
1837
            if (ost->encoding_needed &&
1838
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1839
                char logfilename[1024];
1840
                FILE *f;
1841
                int size;
1842
                char *logbuffer;
1843

    
1844
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1845
                         pass_logfilename ?
1846
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1847
                if (codec->flags & CODEC_FLAG_PASS1) {
1848
                    f = fopen(logfilename, "w");
1849
                    if (!f) {
1850
                        perror(logfilename);
1851
                        av_exit(1);
1852
                    }
1853
                    ost->logfile = f;
1854
                } else {
1855
                    /* read the log file */
1856
                    f = fopen(logfilename, "r");
1857
                    if (!f) {
1858
                        perror(logfilename);
1859
                        av_exit(1);
1860
                    }
1861
                    fseek(f, 0, SEEK_END);
1862
                    size = ftell(f);
1863
                    fseek(f, 0, SEEK_SET);
1864
                    logbuffer = av_malloc(size + 1);
1865
                    if (!logbuffer) {
1866
                        fprintf(stderr, "Could not allocate log buffer\n");
1867
                        av_exit(1);
1868
                    }
1869
                    size = fread(logbuffer, 1, size, f);
1870
                    fclose(f);
1871
                    logbuffer[size] = '\0';
1872
                    codec->stats_in = logbuffer;
1873
                }
1874
            }
1875
        }
1876
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1877
            int size= codec->width * codec->height;
1878
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1879
        }
1880
    }
1881

    
1882
    if (!bit_buffer)
1883
        bit_buffer = av_malloc(bit_buffer_size);
1884
    if (!bit_buffer)
1885
        goto fail;
1886

    
1887
    /* dump the file output parameters - cannot be done before in case
1888
       of stream copy */
1889
    for(i=0;i<nb_output_files;i++) {
1890
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1891
    }
1892

    
1893
    /* dump the stream mapping */
1894
    if (verbose >= 0) {
1895
        fprintf(stderr, "Stream mapping:\n");
1896
        for(i=0;i<nb_ostreams;i++) {
1897
            ost = ost_table[i];
1898
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1899
                    ist_table[ost->source_index]->file_index,
1900
                    ist_table[ost->source_index]->index,
1901
                    ost->file_index,
1902
                    ost->index);
1903
            if (ost->sync_ist != ist_table[ost->source_index])
1904
                fprintf(stderr, " [sync #%d.%d]",
1905
                        ost->sync_ist->file_index,
1906
                        ost->sync_ist->index);
1907
            fprintf(stderr, "\n");
1908
        }
1909
    }
1910

    
1911
    /* open each encoder */
1912
    for(i=0;i<nb_ostreams;i++) {
1913
        ost = ost_table[i];
1914
        if (ost->encoding_needed) {
1915
            AVCodec *codec;
1916
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1917
            if (!codec) {
1918
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1919
                        ost->file_index, ost->index);
1920
                av_exit(1);
1921
            }
1922
            if (avcodec_open(ost->st->codec, codec) < 0) {
1923
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1924
                        ost->file_index, ost->index);
1925
                av_exit(1);
1926
            }
1927
            extra_size += ost->st->codec->extradata_size;
1928
        }
1929
    }
1930

    
1931
    /* open each decoder */
1932
    for(i=0;i<nb_istreams;i++) {
1933
        ist = ist_table[i];
1934
        if (ist->decoding_needed) {
1935
            AVCodec *codec;
1936
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1937
            if (!codec) {
1938
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1939
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1940
                av_exit(1);
1941
            }
1942
            if (avcodec_open(ist->st->codec, codec) < 0) {
1943
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1944
                        ist->file_index, ist->index);
1945
                av_exit(1);
1946
            }
1947
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1948
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1949
        }
1950
    }
1951

    
1952
    /* init pts */
1953
    for(i=0;i<nb_istreams;i++) {
1954
        ist = ist_table[i];
1955
        is = input_files[ist->file_index];
1956
        ist->pts = 0;
1957
        ist->next_pts = AV_NOPTS_VALUE;
1958
        ist->is_start = 1;
1959
    }
1960

    
1961
    /* set meta data information from input file if required */
1962
    for (i=0;i<nb_meta_data_maps;i++) {
1963
        AVFormatContext *out_file;
1964
        AVFormatContext *in_file;
1965

    
1966
        int out_file_index = meta_data_maps[i].out_file;
1967
        int in_file_index = meta_data_maps[i].in_file;
1968
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1969
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1970
            ret = AVERROR(EINVAL);
1971
            goto fail;
1972
        }
1973
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1974
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1975
            ret = AVERROR(EINVAL);
1976
            goto fail;
1977
        }
1978

    
1979
        out_file = output_files[out_file_index];
1980
        in_file = input_files[in_file_index];
1981

    
1982
        strcpy(out_file->title, in_file->title);
1983
        strcpy(out_file->author, in_file->author);
1984
        strcpy(out_file->copyright, in_file->copyright);
1985
        strcpy(out_file->comment, in_file->comment);
1986
        strcpy(out_file->album, in_file->album);
1987
        out_file->year = in_file->year;
1988
        out_file->track = in_file->track;
1989
        strcpy(out_file->genre, in_file->genre);
1990
    }
1991

    
1992
    /* open files and write file headers */
1993
    for(i=0;i<nb_output_files;i++) {
1994
        os = output_files[i];
1995
        if (av_write_header(os) < 0) {
1996
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1997
            ret = AVERROR(EINVAL);
1998
            goto fail;
1999
        }
2000
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2001
            want_sdp = 0;
2002
        }
2003
    }
2004
    if (want_sdp) {
2005
        print_sdp(output_files, nb_output_files);
2006
    }
2007

    
2008
    if (!using_stdin && verbose >= 0) {
2009
        fprintf(stderr, "Press [q] to stop encoding\n");
2010
        url_set_interrupt_cb(decode_interrupt_cb);
2011
    }
2012
    term_init();
2013

    
2014
    key = -1;
2015
    timer_start = av_gettime();
2016

    
2017
    for(; received_sigterm == 0;) {
2018
        int file_index, ist_index;
2019
        AVPacket pkt;
2020
        double ipts_min;
2021
        double opts_min;
2022

    
2023
    redo:
2024
        ipts_min= 1e100;
2025
        opts_min= 1e100;
2026
        /* if 'q' pressed, exits */
2027
        if (!using_stdin) {
2028
            if (q_pressed)
2029
                break;
2030
            /* read_key() returns 0 on EOF */
2031
            key = read_key();
2032
            if (key == 'q')
2033
                break;
2034
        }
2035

    
2036
        /* select the stream that we must read now by looking at the
2037
           smallest output pts */
2038
        file_index = -1;
2039
        for(i=0;i<nb_ostreams;i++) {
2040
            double ipts, opts;
2041
            ost = ost_table[i];
2042
            os = output_files[ost->file_index];
2043
            ist = ist_table[ost->source_index];
2044
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2045
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2046
            else
2047
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2048
            ipts = (double)ist->pts;
2049
            if (!file_table[ist->file_index].eof_reached){
2050
                if(ipts < ipts_min) {
2051
                    ipts_min = ipts;
2052
                    if(input_sync ) file_index = ist->file_index;
2053
                }
2054
                if(opts < opts_min) {
2055
                    opts_min = opts;
2056
                    if(!input_sync) file_index = ist->file_index;
2057
                }
2058
            }
2059
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2060
                file_index= -1;
2061
                break;
2062
            }
2063
        }
2064
        /* if none, if is finished */
2065
        if (file_index < 0) {
2066
            break;
2067
        }
2068

    
2069
        /* finish if recording time exhausted */
2070
        if (opts_min >= (recording_time / 1000000.0))
2071
            break;
2072

    
2073
        /* finish if limit size exhausted */
2074
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2075
            break;
2076

    
2077
        /* read a frame from it and output it in the fifo */
2078
        is = input_files[file_index];
2079
        if (av_read_frame(is, &pkt) < 0) {
2080
            file_table[file_index].eof_reached = 1;
2081
            if (opt_shortest)
2082
                break;
2083
            else
2084
                continue;
2085
        }
2086

    
2087
        if (do_pkt_dump) {
2088
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2089
        }
2090
        /* the following test is needed in case new streams appear
2091
           dynamically in stream : we ignore them */
2092
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2093
            goto discard_packet;
2094
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2095
        ist = ist_table[ist_index];
2096
        if (ist->discard)
2097
            goto discard_packet;
2098

    
2099
        if (pkt.dts != AV_NOPTS_VALUE)
2100
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2101
        if (pkt.pts != AV_NOPTS_VALUE)
2102
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2103

    
2104
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2105
            if(pkt.pts != AV_NOPTS_VALUE)
2106
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2107
            if(pkt.dts != AV_NOPTS_VALUE)
2108
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2109
        }
2110

    
2111
//        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);
2112
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2113
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2114
            int64_t delta= pkt_dts - ist->next_pts;
2115
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2116
                input_files_ts_offset[ist->file_index]-= delta;
2117
                if (verbose > 2)
2118
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2119
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2120
                if(pkt.pts != AV_NOPTS_VALUE)
2121
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2122
            }
2123
        }
2124

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

    
2128
            if (verbose >= 0)
2129
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2130
                        ist->file_index, ist->index);
2131

    
2132
            av_free_packet(&pkt);
2133
            goto redo;
2134
        }
2135

    
2136
    discard_packet:
2137
        av_free_packet(&pkt);
2138

    
2139
        /* dump report by using the output first video and audio streams */
2140
        print_report(output_files, ost_table, nb_ostreams, 0);
2141
    }
2142

    
2143
    /* at the end of stream, we must flush the decoder buffers */
2144
    for(i=0;i<nb_istreams;i++) {
2145
        ist = ist_table[i];
2146
        if (ist->decoding_needed) {
2147
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2148
        }
2149
    }
2150

    
2151
    term_exit();
2152

    
2153
    /* write the trailer if needed and close file */
2154
    for(i=0;i<nb_output_files;i++) {
2155
        os = output_files[i];
2156
        av_write_trailer(os);
2157
    }
2158

    
2159
    /* dump report by using the first video and audio streams */
2160
    print_report(output_files, ost_table, nb_ostreams, 1);
2161

    
2162
    /* close each encoder */
2163
    for(i=0;i<nb_ostreams;i++) {
2164
        ost = ost_table[i];
2165
        if (ost->encoding_needed) {
2166
            av_freep(&ost->st->codec->stats_in);
2167
            avcodec_close(ost->st->codec);
2168
        }
2169
    }
2170

    
2171
    /* close each decoder */
2172
    for(i=0;i<nb_istreams;i++) {
2173
        ist = ist_table[i];
2174
        if (ist->decoding_needed) {
2175
            avcodec_close(ist->st->codec);
2176
        }
2177
    }
2178

    
2179
    /* finished ! */
2180

    
2181
    ret = 0;
2182
 fail1:
2183
    av_freep(&bit_buffer);
2184
    av_free(file_table);
2185

    
2186
    if (ist_table) {
2187
        for(i=0;i<nb_istreams;i++) {
2188
            ist = ist_table[i];
2189
            av_free(ist);
2190
        }
2191
        av_free(ist_table);
2192
    }
2193
    if (ost_table) {
2194
        for(i=0;i<nb_ostreams;i++) {
2195
            ost = ost_table[i];
2196
            if (ost) {
2197
                if (ost->logfile) {
2198
                    fclose(ost->logfile);
2199
                    ost->logfile = NULL;
2200
                }
2201
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2202
                                             initialized but set to zero */
2203
                av_free(ost->pict_tmp.data[0]);
2204
                if (ost->video_resample)
2205
                    sws_freeContext(ost->img_resample_ctx);
2206
                if (ost->resample)
2207
                    audio_resample_close(ost->resample);
2208
                if (ost->reformat_ctx)
2209
                    av_audio_convert_free(ost->reformat_ctx);
2210
                av_free(ost);
2211
            }
2212
        }
2213
        av_free(ost_table);
2214
    }
2215
    return ret;
2216
 fail:
2217
    ret = AVERROR(ENOMEM);
2218
    goto fail1;
2219
}
2220

    
2221
#if 0
2222
int file_read(const char *filename)
2223
{
2224
    URLContext *h;
2225
    unsigned char buffer[1024];
2226
    int len, i;
2227

2228
    if (url_open(&h, filename, O_RDONLY) < 0) {
2229
        printf("could not open '%s'\n", filename);
2230
        return -1;
2231
    }
2232
    for(;;) {
2233
        len = url_read(h, buffer, sizeof(buffer));
2234
        if (len <= 0)
2235
            break;
2236
        for(i=0;i<len;i++) putchar(buffer[i]);
2237
    }
2238
    url_close(h);
2239
    return 0;
2240
}
2241
#endif
2242

    
2243
static void opt_format(const char *arg)
2244
{
2245
    /* compatibility stuff for pgmyuv */
2246
    if (!strcmp(arg, "pgmyuv")) {
2247
        pgmyuv_compatibility_hack=1;
2248
//        opt_image_format(arg);
2249
        arg = "image2";
2250
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2251
    }
2252

    
2253
    file_iformat = av_find_input_format(arg);
2254
    file_oformat = guess_format(arg, NULL, NULL);
2255
    if (!file_iformat && !file_oformat) {
2256
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2257
        av_exit(1);
2258
    }
2259
}
2260

    
2261
static int opt_default(const char *opt, const char *arg){
2262
    int type;
2263
    const AVOption *o= NULL;
2264
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2265

    
2266
    for(type=0; type<CODEC_TYPE_NB; type++){
2267
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2268
        if(o2)
2269
            o = av_set_string2(avctx_opts[type], opt, arg, 1);
2270
    }
2271
    if(!o)
2272
        o = av_set_string2(avformat_opts, opt, arg, 1);
2273
    if(!o)
2274
        o = av_set_string2(sws_opts, opt, arg, 1);
2275
    if(!o){
2276
        if(opt[0] == 'a')
2277
            o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2278
        else if(opt[0] == 'v')
2279
            o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2280
        else if(opt[0] == 's')
2281
            o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2282
    }
2283
    if(!o)
2284
        return -1;
2285

    
2286
//    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));
2287

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

    
2292
    if(avctx_opts[0]->debug || avformat_opts->debug)
2293
        av_log_set_level(AV_LOG_DEBUG);
2294
    return 0;
2295
}
2296

    
2297
static void opt_video_rc_override_string(const char *arg)
2298
{
2299
    video_rc_override_string = arg;
2300
}
2301

    
2302
static int opt_me_threshold(const char *opt, const char *arg)
2303
{
2304
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2305
    return 0;
2306
}
2307

    
2308
static int opt_verbose(const char *opt, const char *arg)
2309
{
2310
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2311
    av_log_set_level(verbose);
2312
    return 0;
2313
}
2314

    
2315
static void opt_frame_rate(const char *arg)
2316
{
2317
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2318
        fprintf(stderr, "Incorrect frame rate\n");
2319
        av_exit(1);
2320
    }
2321
}
2322

    
2323
static int opt_bitrate(const char *opt, const char *arg)
2324
{
2325
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2326

    
2327
    opt_default(opt, arg);
2328

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

    
2332
    return 0;
2333
}
2334

    
2335
static void opt_frame_crop_top(const char *arg)
2336
{
2337
    frame_topBand = atoi(arg);
2338
    if (frame_topBand < 0) {
2339
        fprintf(stderr, "Incorrect top crop size\n");
2340
        av_exit(1);
2341
    }
2342
    if ((frame_topBand % 2) != 0) {
2343
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2344
        av_exit(1);
2345
    }
2346
    if ((frame_topBand) >= frame_height){
2347
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2348
        av_exit(1);
2349
    }
2350
    frame_height -= frame_topBand;
2351
}
2352

    
2353
static void opt_frame_crop_bottom(const char *arg)
2354
{
2355
    frame_bottomBand = atoi(arg);
2356
    if (frame_bottomBand < 0) {
2357
        fprintf(stderr, "Incorrect bottom crop size\n");
2358
        av_exit(1);
2359
    }
2360
    if ((frame_bottomBand % 2) != 0) {
2361
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2362
        av_exit(1);
2363
    }
2364
    if ((frame_bottomBand) >= frame_height){
2365
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2366
        av_exit(1);
2367
    }
2368
    frame_height -= frame_bottomBand;
2369
}
2370

    
2371
static void opt_frame_crop_left(const char *arg)
2372
{
2373
    frame_leftBand = atoi(arg);
2374
    if (frame_leftBand < 0) {
2375
        fprintf(stderr, "Incorrect left crop size\n");
2376
        av_exit(1);
2377
    }
2378
    if ((frame_leftBand % 2) != 0) {
2379
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2380
        av_exit(1);
2381
    }
2382
    if ((frame_leftBand) >= frame_width){
2383
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2384
        av_exit(1);
2385
    }
2386
    frame_width -= frame_leftBand;
2387
}
2388

    
2389
static void opt_frame_crop_right(const char *arg)
2390
{
2391
    frame_rightBand = atoi(arg);
2392
    if (frame_rightBand < 0) {
2393
        fprintf(stderr, "Incorrect right crop size\n");
2394
        av_exit(1);
2395
    }
2396
    if ((frame_rightBand % 2) != 0) {
2397
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2398
        av_exit(1);
2399
    }
2400
    if ((frame_rightBand) >= frame_width){
2401
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2402
        av_exit(1);
2403
    }
2404
    frame_width -= frame_rightBand;
2405
}
2406

    
2407
static void opt_frame_size(const char *arg)
2408
{
2409
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2410
        fprintf(stderr, "Incorrect frame size\n");
2411
        av_exit(1);
2412
    }
2413
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2414
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2415
        av_exit(1);
2416
    }
2417
}
2418

    
2419

    
2420
#define SCALEBITS 10
2421
#define ONE_HALF  (1 << (SCALEBITS - 1))
2422
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2423

    
2424
#define RGB_TO_Y(r, g, b) \
2425
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2426
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2427

    
2428
#define RGB_TO_U(r1, g1, b1, shift)\
2429
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2430
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2431

    
2432
#define RGB_TO_V(r1, g1, b1, shift)\
2433
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2434
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2435

    
2436
static void opt_pad_color(const char *arg) {
2437
    /* Input is expected to be six hex digits similar to
2438
       how colors are expressed in html tags (but without the #) */
2439
    int rgb = strtol(arg, NULL, 16);
2440
    int r,g,b;
2441

    
2442
    r = (rgb >> 16);
2443
    g = ((rgb >> 8) & 255);
2444
    b = (rgb & 255);
2445

    
2446
    padcolor[0] = RGB_TO_Y(r,g,b);
2447
    padcolor[1] = RGB_TO_U(r,g,b,0);
2448
    padcolor[2] = RGB_TO_V(r,g,b,0);
2449
}
2450

    
2451
static void opt_frame_pad_top(const char *arg)
2452
{
2453
    frame_padtop = atoi(arg);
2454
    if (frame_padtop < 0) {
2455
        fprintf(stderr, "Incorrect top pad size\n");
2456
        av_exit(1);
2457
    }
2458
    if ((frame_padtop % 2) != 0) {
2459
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2460
        av_exit(1);
2461
    }
2462
}
2463

    
2464
static void opt_frame_pad_bottom(const char *arg)
2465
{
2466
    frame_padbottom = atoi(arg);
2467
    if (frame_padbottom < 0) {
2468
        fprintf(stderr, "Incorrect bottom pad size\n");
2469
        av_exit(1);
2470
    }
2471
    if ((frame_padbottom % 2) != 0) {
2472
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2473
        av_exit(1);
2474
    }
2475
}
2476

    
2477

    
2478
static void opt_frame_pad_left(const char *arg)
2479
{
2480
    frame_padleft = atoi(arg);
2481
    if (frame_padleft < 0) {
2482
        fprintf(stderr, "Incorrect left pad size\n");
2483
        av_exit(1);
2484
    }
2485
    if ((frame_padleft % 2) != 0) {
2486
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2487
        av_exit(1);
2488
    }
2489
}
2490

    
2491

    
2492
static void opt_frame_pad_right(const char *arg)
2493
{
2494
    frame_padright = atoi(arg);
2495
    if (frame_padright < 0) {
2496
        fprintf(stderr, "Incorrect right pad size\n");
2497
        av_exit(1);
2498
    }
2499
    if ((frame_padright % 2) != 0) {
2500
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2501
        av_exit(1);
2502
    }
2503
}
2504

    
2505
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2506
{
2507
    int i;
2508
    char fmt_str[128];
2509
    for (i=-1; i < nb_fmts; i++) {
2510
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2511
        fprintf(stdout, "%s\n", fmt_str);
2512
    }
2513
}
2514

    
2515
static void opt_frame_pix_fmt(const char *arg)
2516
{
2517
    if (strcmp(arg, "list"))
2518
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2519
    else {
2520
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2521
        av_exit(0);
2522
    }
2523
}
2524

    
2525
static void opt_frame_aspect_ratio(const char *arg)
2526
{
2527
    int x = 0, y = 0;
2528
    double ar = 0;
2529
    const char *p;
2530
    char *end;
2531

    
2532
    p = strchr(arg, ':');
2533
    if (p) {
2534
        x = strtol(arg, &end, 10);
2535
        if (end == p)
2536
            y = strtol(end+1, &end, 10);
2537
        if (x > 0 && y > 0)
2538
            ar = (double)x / (double)y;
2539
    } else
2540
        ar = strtod(arg, NULL);
2541

    
2542
    if (!ar) {
2543
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2544
        av_exit(1);
2545
    }
2546
    frame_aspect_ratio = ar;
2547
}
2548

    
2549
static void opt_qscale(const char *arg)
2550
{
2551
    video_qscale = atof(arg);
2552
    if (video_qscale <= 0 ||
2553
        video_qscale > 255) {
2554
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2555
        av_exit(1);
2556
    }
2557
}
2558

    
2559
static void opt_top_field_first(const char *arg)
2560
{
2561
    top_field_first= atoi(arg);
2562
}
2563

    
2564
static int opt_thread_count(const char *opt, const char *arg)
2565
{
2566
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2567
#if !defined(HAVE_THREADS)
2568
    if (verbose >= 0)
2569
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2570
#endif
2571
    return 0;
2572
}
2573

    
2574
static void opt_audio_sample_fmt(const char *arg)
2575
{
2576
    if (strcmp(arg, "list"))
2577
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2578
    else {
2579
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2580
        av_exit(0);
2581
    }
2582
}
2583

    
2584
static int opt_audio_rate(const char *opt, const char *arg)
2585
{
2586
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2587
    return 0;
2588
}
2589

    
2590
static int opt_audio_channels(const char *opt, const char *arg)
2591
{
2592
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2593
    return 0;
2594
}
2595

    
2596
static void opt_video_channel(const char *arg)
2597
{
2598
    video_channel = strtol(arg, NULL, 0);
2599
}
2600

    
2601
static void opt_video_standard(const char *arg)
2602
{
2603
    video_standard = av_strdup(arg);
2604
}
2605

    
2606
static void opt_codec(int *pstream_copy, char **pcodec_name,
2607
                      int codec_type, const char *arg)
2608
{
2609
    av_freep(pcodec_name);
2610
    if (!strcmp(arg, "copy")) {
2611
        *pstream_copy = 1;
2612
    } else {
2613
        *pcodec_name = av_strdup(arg);
2614
    }
2615
}
2616

    
2617
static void opt_audio_codec(const char *arg)
2618
{
2619
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2620
}
2621

    
2622
static void opt_audio_tag(const char *arg)
2623
{
2624
    char *tail;
2625
    audio_codec_tag= strtol(arg, &tail, 0);
2626

    
2627
    if(!tail || *tail)
2628
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2629
}
2630

    
2631
static void opt_video_tag(const char *arg)
2632
{
2633
    char *tail;
2634
    video_codec_tag= strtol(arg, &tail, 0);
2635

    
2636
    if(!tail || *tail)
2637
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2638
}
2639

    
2640
#ifdef CONFIG_VHOOK
2641
static void add_frame_hooker(const char *arg)
2642
{
2643
    int argc = 0;
2644
    char *argv[64];
2645
    int i;
2646
    char *args = av_strdup(arg);
2647

    
2648
    using_vhook = 1;
2649

    
2650
    argv[0] = strtok(args, " ");
2651
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2652
    }
2653

    
2654
    i = frame_hook_add(argc, argv);
2655

    
2656
    if (i != 0) {
2657
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2658
        av_exit(1);
2659
    }
2660
}
2661
#endif
2662

    
2663
static void opt_video_codec(const char *arg)
2664
{
2665
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2666
}
2667

    
2668
static void opt_subtitle_codec(const char *arg)
2669
{
2670
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2671
}
2672

    
2673
static void opt_map(const char *arg)
2674
{
2675
    AVStreamMap *m;
2676
    char *p;
2677

    
2678
    m = &stream_maps[nb_stream_maps++];
2679

    
2680
    m->file_index = strtol(arg, &p, 0);
2681
    if (*p)
2682
        p++;
2683

    
2684
    m->stream_index = strtol(p, &p, 0);
2685
    if (*p) {
2686
        p++;
2687
        m->sync_file_index = strtol(p, &p, 0);
2688
        if (*p)
2689
            p++;
2690
        m->sync_stream_index = strtol(p, &p, 0);
2691
    } else {
2692
        m->sync_file_index = m->file_index;
2693
        m->sync_stream_index = m->stream_index;
2694
    }
2695
}
2696

    
2697
static void opt_map_meta_data(const char *arg)
2698
{
2699
    AVMetaDataMap *m;
2700
    char *p;
2701

    
2702
    m = &meta_data_maps[nb_meta_data_maps++];
2703

    
2704
    m->out_file = strtol(arg, &p, 0);
2705
    if (*p)
2706
        p++;
2707

    
2708
    m->in_file = strtol(p, &p, 0);
2709
}
2710

    
2711
static void opt_input_ts_scale(const char *arg)
2712
{
2713
    unsigned int stream;
2714
    double scale;
2715
    char *p;
2716

    
2717
    stream = strtol(arg, &p, 0);
2718
    if (*p)
2719
        p++;
2720
    scale= strtod(p, &p);
2721

    
2722
    if(stream >= MAX_STREAMS)
2723
        av_exit(1);
2724

    
2725
    input_files_ts_scale[nb_input_files][stream]= scale;
2726
}
2727

    
2728
static int opt_recording_time(const char *opt, const char *arg)
2729
{
2730
    recording_time = parse_time_or_die(opt, arg, 1);
2731
    return 0;
2732
}
2733

    
2734
static int opt_start_time(const char *opt, const char *arg)
2735
{
2736
    start_time = parse_time_or_die(opt, arg, 1);
2737
    return 0;
2738
}
2739

    
2740
static int opt_rec_timestamp(const char *opt, const char *arg)
2741
{
2742
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2743
    return 0;
2744
}
2745

    
2746
static int opt_input_ts_offset(const char *opt, const char *arg)
2747
{
2748
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2749
    return 0;
2750
}
2751

    
2752
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2753
{
2754
    const char *codec_string = encoder ? "encoder" : "decoder";
2755
    AVCodec *codec;
2756

    
2757
    if(!name)
2758
        return CODEC_ID_NONE;
2759
    codec = encoder ?
2760
        avcodec_find_encoder_by_name(name) :
2761
        avcodec_find_decoder_by_name(name);
2762
    if(!codec) {
2763
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2764
        av_exit(1);
2765
    }
2766
    if(codec->type != type) {
2767
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2768
        av_exit(1);
2769
    }
2770
    return codec->id;
2771
}
2772

    
2773
static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2774
{
2775
    int i;
2776
    for(i=0; i<opt_name_count; i++){
2777
        char buf[256];
2778
        const AVOption *opt;
2779
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2780
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2781
        if(str && ((opt->flags & flags) == flags))
2782
            av_set_string2(ctx, opt_names[i], str, 1);
2783
    }
2784
}
2785

    
2786
static void opt_input_file(const char *filename)
2787
{
2788
    AVFormatContext *ic;
2789
    AVFormatParameters params, *ap = &params;
2790
    int err, i, ret, rfps, rfps_base;
2791
    int64_t timestamp;
2792

    
2793
    if (!strcmp(filename, "-"))
2794
        filename = "pipe:";
2795

    
2796
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2797
                    !strcmp(filename, "/dev/stdin");
2798

    
2799
    /* get default parameters from command line */
2800
    ic = av_alloc_format_context();
2801

    
2802
    memset(ap, 0, sizeof(*ap));
2803
    ap->prealloced_context = 1;
2804
    ap->sample_rate = audio_sample_rate;
2805
    ap->channels = audio_channels;
2806
    ap->time_base.den = frame_rate.num;
2807
    ap->time_base.num = frame_rate.den;
2808
    ap->width = frame_width + frame_padleft + frame_padright;
2809
    ap->height = frame_height + frame_padtop + frame_padbottom;
2810
    ap->pix_fmt = frame_pix_fmt;
2811
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2812
    ap->channel = video_channel;
2813
    ap->standard = video_standard;
2814
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2815
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2816
    if(pgmyuv_compatibility_hack)
2817
        ap->video_codec_id= CODEC_ID_PGMYUV;
2818

    
2819
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2820

    
2821
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2822
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2823
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2824

    
2825
    /* open the input file with generic libav function */
2826
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2827
    if (err < 0) {
2828
        print_error(filename, err);
2829
        av_exit(1);
2830
    }
2831
    if(opt_programid) {
2832
        int i;
2833
        for(i=0; i<ic->nb_programs; i++)
2834
            if(ic->programs[i]->id != opt_programid)
2835
                ic->programs[i]->discard = AVDISCARD_ALL;
2836
    }
2837

    
2838
    ic->loop_input = loop_input;
2839

    
2840
    /* If not enough info to get the stream parameters, we decode the
2841
       first frames to get it. (used in mpeg case for example) */
2842
    ret = av_find_stream_info(ic);
2843
    if (ret < 0 && verbose >= 0) {
2844
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2845
        av_exit(1);
2846
    }
2847

    
2848
    timestamp = start_time;
2849
    /* add the stream start time */
2850
    if (ic->start_time != AV_NOPTS_VALUE)
2851
        timestamp += ic->start_time;
2852

    
2853
    /* if seeking requested, we execute it */
2854
    if (start_time != 0) {
2855
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2856
        if (ret < 0) {
2857
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2858
                    filename, (double)timestamp / AV_TIME_BASE);
2859
        }
2860
        /* reset seek info */
2861
        start_time = 0;
2862
    }
2863

    
2864
    /* update the current parameters so that they match the one of the input stream */
2865
    for(i=0;i<ic->nb_streams;i++) {
2866
        AVCodecContext *enc = ic->streams[i]->codec;
2867
        if(thread_count>1)
2868
            avcodec_thread_init(enc, thread_count);
2869
        enc->thread_count= thread_count;
2870
        switch(enc->codec_type) {
2871
        case CODEC_TYPE_AUDIO:
2872
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2873
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2874
            audio_channels = enc->channels;
2875
            audio_sample_rate = enc->sample_rate;
2876
            audio_sample_fmt = enc->sample_fmt;
2877
            if(audio_disable)
2878
                ic->streams[i]->discard= AVDISCARD_ALL;
2879
            break;
2880
        case CODEC_TYPE_VIDEO:
2881
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2882
            frame_height = enc->height;
2883
            frame_width = enc->width;
2884
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2885
            frame_pix_fmt = enc->pix_fmt;
2886
            rfps      = ic->streams[i]->r_frame_rate.num;
2887
            rfps_base = ic->streams[i]->r_frame_rate.den;
2888
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2889
            if(me_threshold)
2890
                enc->debug |= FF_DEBUG_MV;
2891

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

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

    
2898
                    (float)rfps / rfps_base, rfps, rfps_base);
2899
            }
2900
            /* update the current frame rate to match the stream frame rate */
2901
            frame_rate.num = rfps;
2902
            frame_rate.den = rfps_base;
2903

    
2904
            enc->rate_emu = rate_emu;
2905
            if(video_disable)
2906
                ic->streams[i]->discard= AVDISCARD_ALL;
2907
            else if(video_discard)
2908
                ic->streams[i]->discard= video_discard;
2909
            break;
2910
        case CODEC_TYPE_DATA:
2911
            break;
2912
        case CODEC_TYPE_SUBTITLE:
2913
            if(subtitle_disable)
2914
                ic->streams[i]->discard = AVDISCARD_ALL;
2915
            break;
2916
        case CODEC_TYPE_ATTACHMENT:
2917
        case CODEC_TYPE_UNKNOWN:
2918
            break;
2919
        default:
2920
            abort();
2921
        }
2922
    }
2923

    
2924
    input_files[nb_input_files] = ic;
2925
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2926
    /* dump the file content */
2927
    if (verbose >= 0)
2928
        dump_format(ic, nb_input_files, filename, 0);
2929

    
2930
    nb_input_files++;
2931
    file_iformat = NULL;
2932
    file_oformat = NULL;
2933

    
2934
    video_channel = 0;
2935

    
2936
    rate_emu = 0;
2937
    av_freep(&video_codec_name);
2938
    av_freep(&audio_codec_name);
2939
    av_freep(&subtitle_codec_name);
2940
}
2941

    
2942
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2943
                                         int *has_subtitle_ptr)
2944
{
2945
    int has_video, has_audio, has_subtitle, i, j;
2946
    AVFormatContext *ic;
2947

    
2948
    has_video = 0;
2949
    has_audio = 0;
2950
    has_subtitle = 0;
2951
    for(j=0;j<nb_input_files;j++) {
2952
        ic = input_files[j];
2953
        for(i=0;i<ic->nb_streams;i++) {
2954
            AVCodecContext *enc = ic->streams[i]->codec;
2955
            switch(enc->codec_type) {
2956
            case CODEC_TYPE_AUDIO:
2957
                has_audio = 1;
2958
                break;
2959
            case CODEC_TYPE_VIDEO:
2960
                has_video = 1;
2961
                break;
2962
            case CODEC_TYPE_SUBTITLE:
2963
                has_subtitle = 1;
2964
                break;
2965
            case CODEC_TYPE_DATA:
2966
            case CODEC_TYPE_ATTACHMENT:
2967
            case CODEC_TYPE_UNKNOWN:
2968
                break;
2969
            default:
2970
                abort();
2971
            }
2972
        }
2973
    }
2974
    *has_video_ptr = has_video;
2975
    *has_audio_ptr = has_audio;
2976
    *has_subtitle_ptr = has_subtitle;
2977
}
2978

    
2979
static void new_video_stream(AVFormatContext *oc)
2980
{
2981
    AVStream *st;
2982
    AVCodecContext *video_enc;
2983
    int codec_id;
2984

    
2985
    st = av_new_stream(oc, oc->nb_streams);
2986
    if (!st) {
2987
        fprintf(stderr, "Could not alloc stream\n");
2988
        av_exit(1);
2989
    }
2990
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2991
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2992
    video_bitstream_filters= NULL;
2993

    
2994
    if(thread_count>1)
2995
        avcodec_thread_init(st->codec, thread_count);
2996

    
2997
    video_enc = st->codec;
2998

    
2999
    if(video_codec_tag)
3000
        video_enc->codec_tag= video_codec_tag;
3001

    
3002
    if(   (video_global_header&1)
3003
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3004
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3005
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3006
    }
3007
    if(video_global_header&2){
3008
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3009
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3010
    }
3011

    
3012
    if (video_stream_copy) {
3013
        st->stream_copy = 1;
3014
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3015
    } else {
3016
        const char *p;
3017
        int i;
3018
        AVCodec *codec;
3019
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3020

    
3021
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3022
        if (video_codec_name)
3023
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3024

    
3025
        video_enc->codec_id = codec_id;
3026
        codec = avcodec_find_encoder(codec_id);
3027

    
3028
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3029

    
3030
        video_enc->time_base.den = fps.num;
3031
        video_enc->time_base.num = fps.den;
3032
        if(codec && codec->supported_framerates){
3033
            const AVRational *p= codec->supported_framerates;
3034
            const AVRational *best=NULL;
3035
            AVRational best_error= (AVRational){INT_MAX, 1};
3036
            for(; p->den!=0; p++){
3037
                AVRational error= av_sub_q(fps, *p);
3038
                if(error.num <0) error.num *= -1;
3039
                if(av_cmp_q(error, best_error) < 0){
3040
                    best_error= error;
3041
                    best= p;
3042
                }
3043
            }
3044
            video_enc->time_base.den= best->num;
3045
            video_enc->time_base.num= best->den;
3046
        }
3047

    
3048
        video_enc->width = frame_width + frame_padright + frame_padleft;
3049
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3050
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3051
        video_enc->pix_fmt = frame_pix_fmt;
3052

    
3053
        if(codec && codec->pix_fmts){
3054
            const enum PixelFormat *p= codec->pix_fmts;
3055
            for(; *p!=-1; p++){
3056
                if(*p == video_enc->pix_fmt)
3057
                    break;
3058
            }
3059
            if(*p == -1)
3060
                video_enc->pix_fmt = codec->pix_fmts[0];
3061
        }
3062

    
3063
        if (intra_only)
3064
            video_enc->gop_size = 0;
3065
        if (video_qscale || same_quality) {
3066
            video_enc->flags |= CODEC_FLAG_QSCALE;
3067
            video_enc->global_quality=
3068
                st->quality = FF_QP2LAMBDA * video_qscale;
3069
        }
3070

    
3071
        if(intra_matrix)
3072
            video_enc->intra_matrix = intra_matrix;
3073
        if(inter_matrix)
3074
            video_enc->inter_matrix = inter_matrix;
3075

    
3076
        video_enc->thread_count = thread_count;
3077
        p= video_rc_override_string;
3078
        for(i=0; p; i++){
3079
            int start, end, q;
3080
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3081
            if(e!=3){
3082
                fprintf(stderr, "error parsing rc_override\n");
3083
                av_exit(1);
3084
            }
3085
            video_enc->rc_override=
3086
                av_realloc(video_enc->rc_override,
3087
                           sizeof(RcOverride)*(i+1));
3088
            video_enc->rc_override[i].start_frame= start;
3089
            video_enc->rc_override[i].end_frame  = end;
3090
            if(q>0){
3091
                video_enc->rc_override[i].qscale= q;
3092
                video_enc->rc_override[i].quality_factor= 1.0;
3093
            }
3094
            else{
3095
                video_enc->rc_override[i].qscale= 0;
3096
                video_enc->rc_override[i].quality_factor= -q/100.0;
3097
            }
3098
            p= strchr(p, '/');
3099
            if(p) p++;
3100
        }
3101
        video_enc->rc_override_count=i;
3102
        if (!video_enc->rc_initial_buffer_occupancy)
3103
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3104
        video_enc->me_threshold= me_threshold;
3105
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3106

    
3107
        if (do_psnr)
3108
            video_enc->flags|= CODEC_FLAG_PSNR;
3109

    
3110
        /* two pass mode */
3111
        if (do_pass) {
3112
            if (do_pass == 1) {
3113
                video_enc->flags |= CODEC_FLAG_PASS1;
3114
            } else {
3115
                video_enc->flags |= CODEC_FLAG_PASS2;
3116
            }
3117
        }
3118
    }
3119

    
3120
    /* reset some key parameters */
3121
    video_disable = 0;
3122
    av_freep(&video_codec_name);
3123
    video_stream_copy = 0;
3124
}
3125

    
3126
static void new_audio_stream(AVFormatContext *oc)
3127
{
3128
    AVStream *st;
3129
    AVCodecContext *audio_enc;
3130
    int codec_id;
3131

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

    
3139
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3140
    audio_bitstream_filters= NULL;
3141

    
3142
    if(thread_count>1)
3143
        avcodec_thread_init(st->codec, thread_count);
3144

    
3145
    audio_enc = st->codec;
3146
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3147

    
3148
    if(audio_codec_tag)
3149
        audio_enc->codec_tag= audio_codec_tag;
3150

    
3151
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3152
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3153
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3154
    }
3155
    if (audio_stream_copy) {
3156
        st->stream_copy = 1;
3157
        audio_enc->channels = audio_channels;
3158
    } else {
3159
        AVCodec *codec;
3160
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3161

    
3162
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3163

    
3164
        if (audio_codec_name)
3165
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3166
        audio_enc->codec_id = codec_id;
3167
        codec = avcodec_find_encoder(codec_id);
3168

    
3169
        if (audio_qscale > QSCALE_NONE) {
3170
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3171
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3172
        }
3173
        audio_enc->thread_count = thread_count;
3174
        audio_enc->channels = audio_channels;
3175
        audio_enc->sample_fmt = audio_sample_fmt;
3176

    
3177
        if(codec && codec->sample_fmts){
3178
            const enum SampleFormat *p= codec->sample_fmts;
3179
            for(; *p!=-1; p++){
3180
                if(*p == audio_enc->sample_fmt)
3181
                    break;
3182
            }
3183
            if(*p == -1)
3184
                audio_enc->sample_fmt = codec->sample_fmts[0];
3185
        }
3186
    }
3187
    audio_enc->sample_rate = audio_sample_rate;
3188
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3189
    if (audio_language) {
3190
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3191
        av_free(audio_language);
3192
        audio_language = NULL;
3193
    }
3194

    
3195
    /* reset some key parameters */
3196
    audio_disable = 0;
3197
    av_freep(&audio_codec_name);
3198
    audio_stream_copy = 0;
3199
}
3200

    
3201
static void new_subtitle_stream(AVFormatContext *oc)
3202
{
3203
    AVStream *st;
3204
    AVCodecContext *subtitle_enc;
3205

    
3206
    st = av_new_stream(oc, oc->nb_streams);
3207
    if (!st) {
3208
        fprintf(stderr, "Could not alloc stream\n");
3209
        av_exit(1);
3210
    }
3211
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3212

    
3213
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3214
    subtitle_bitstream_filters= NULL;
3215

    
3216
    subtitle_enc = st->codec;
3217
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3218
    if (subtitle_stream_copy) {
3219
        st->stream_copy = 1;
3220
    } else {
3221
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3222
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3223
    }
3224

    
3225
    if (subtitle_language) {
3226
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3227
        av_free(subtitle_language);
3228
        subtitle_language = NULL;
3229
    }
3230

    
3231
    subtitle_disable = 0;
3232
    av_freep(&subtitle_codec_name);
3233
    subtitle_stream_copy = 0;
3234
}
3235

    
3236
static void opt_new_audio_stream(void)
3237
{
3238
    AVFormatContext *oc;
3239
    if (nb_output_files <= 0) {
3240
        fprintf(stderr, "At least one output file must be specified\n");
3241
        av_exit(1);
3242
    }
3243
    oc = output_files[nb_output_files - 1];
3244
    new_audio_stream(oc);
3245
}
3246

    
3247
static void opt_new_video_stream(void)
3248
{
3249
    AVFormatContext *oc;
3250
    if (nb_output_files <= 0) {
3251
        fprintf(stderr, "At least one output file must be specified\n");
3252
        av_exit(1);
3253
    }
3254
    oc = output_files[nb_output_files - 1];
3255
    new_video_stream(oc);
3256
}
3257

    
3258
static void opt_new_subtitle_stream(void)
3259
{
3260
    AVFormatContext *oc;
3261
    if (nb_output_files <= 0) {
3262
        fprintf(stderr, "At least one output file must be specified\n");
3263
        av_exit(1);
3264
    }
3265
    oc = output_files[nb_output_files - 1];
3266
    new_subtitle_stream(oc);
3267
}
3268

    
3269
static void opt_output_file(const char *filename)
3270
{
3271
    AVFormatContext *oc;
3272
    int use_video, use_audio, use_subtitle;
3273
    int input_has_video, input_has_audio, input_has_subtitle;
3274
    AVFormatParameters params, *ap = &params;
3275

    
3276
    if (!strcmp(filename, "-"))
3277
        filename = "pipe:";
3278

    
3279
    oc = av_alloc_format_context();
3280

    
3281
    if (!file_oformat) {
3282
        file_oformat = guess_format(NULL, filename, NULL);
3283
        if (!file_oformat) {
3284
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3285
                    filename);
3286
            av_exit(1);
3287
        }
3288
    }
3289

    
3290
    oc->oformat = file_oformat;
3291
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3292

    
3293
    if (!strcmp(file_oformat->name, "ffm") &&
3294
        av_strstart(filename, "http:", NULL)) {
3295
        /* special case for files sent to ffserver: we get the stream
3296
           parameters from ffserver */
3297
        int err = read_ffserver_streams(oc, filename);
3298
        if (err < 0) {
3299
            print_error(filename, err);
3300
            av_exit(1);
3301
        }
3302
    } else {
3303
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3304
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3305
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3306

    
3307
        /* disable if no corresponding type found and at least one
3308
           input file */
3309
        if (nb_input_files > 0) {
3310
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3311
                                         &input_has_subtitle);
3312
            if (!input_has_video)
3313
                use_video = 0;
3314
            if (!input_has_audio)
3315
                use_audio = 0;
3316
            if (!input_has_subtitle)
3317
                use_subtitle = 0;
3318
        }
3319

    
3320
        /* manual disable */
3321
        if (audio_disable) {
3322
            use_audio = 0;
3323
        }
3324
        if (video_disable) {
3325
            use_video = 0;
3326
        }
3327
        if (subtitle_disable) {
3328
            use_subtitle = 0;
3329
        }
3330

    
3331
        if (use_video) {
3332
            new_video_stream(oc);
3333
        }
3334

    
3335
        if (use_audio) {
3336
            new_audio_stream(oc);
3337
        }
3338

    
3339
        if (use_subtitle) {
3340
            new_subtitle_stream(oc);
3341
        }
3342

    
3343
        oc->timestamp = rec_timestamp;
3344

    
3345
        if (str_title)
3346
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3347
        if (str_author)
3348
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3349
        if (str_copyright)
3350
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3351
        if (str_comment)
3352
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3353
        if (str_album)
3354
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3355
        if (str_genre)
3356
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3357
    }
3358

    
3359
    output_files[nb_output_files++] = oc;
3360

    
3361
    /* check filename in case of an image number is expected */
3362
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3363
        if (!av_filename_number_test(oc->filename)) {
3364
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3365
            av_exit(1);
3366
        }
3367
    }
3368

    
3369
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3370
        /* test if it already exists to avoid loosing precious files */
3371
        if (!file_overwrite &&
3372
            (strchr(filename, ':') == NULL ||
3373
             filename[1] == ':' ||
3374
             av_strstart(filename, "file:", NULL))) {
3375
            if (url_exist(filename)) {
3376
                int c;
3377

    
3378
                if (!using_stdin) {
3379
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3380
                    fflush(stderr);
3381
                    c = getchar();
3382
                    if (toupper(c) != 'Y') {
3383
                        fprintf(stderr, "Not overwriting - exiting\n");
3384
                        av_exit(1);
3385
                    }
3386
                }
3387
                else {
3388
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3389
                    av_exit(1);
3390
                }
3391
            }
3392
        }
3393

    
3394
        /* open the file */
3395
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3396
            fprintf(stderr, "Could not open '%s'\n", filename);
3397
            av_exit(1);
3398
        }
3399
    }
3400

    
3401
    memset(ap, 0, sizeof(*ap));
3402
    if (av_set_parameters(oc, ap) < 0) {
3403
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3404
                oc->filename);
3405
        av_exit(1);
3406
    }
3407

    
3408
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3409
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3410
    oc->loop_output = loop_output;
3411

    
3412
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3413

    
3414
    /* reset some options */
3415
    file_oformat = NULL;
3416
    file_iformat = NULL;
3417
}
3418

    
3419
/* same option as mencoder */
3420
static void opt_pass(const char *pass_str)
3421
{
3422
    int pass;
3423
    pass = atoi(pass_str);
3424
    if (pass != 1 && pass != 2) {
3425
        fprintf(stderr, "pass number can be only 1 or 2\n");
3426
        av_exit(1);
3427
    }
3428
    do_pass = pass;
3429
}
3430

    
3431
static int64_t getutime(void)
3432
{
3433
#ifdef HAVE_GETRUSAGE
3434
    struct rusage rusage;
3435

    
3436
    getrusage(RUSAGE_SELF, &rusage);
3437
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3438
#elif defined(HAVE_GETPROCESSTIMES)
3439
    HANDLE proc;
3440
    FILETIME c, e, k, u;
3441
    proc = GetCurrentProcess();
3442
    GetProcessTimes(proc, &c, &e, &k, &u);
3443
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3444
#else
3445
    return av_gettime();
3446
#endif
3447
}
3448

    
3449
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3450
{
3451
    int i;
3452
    const char *p = str;
3453
    for(i = 0;; i++) {
3454
        dest[i] = atoi(p);
3455
        if(i == 63)
3456
            break;
3457
        p = strchr(p, ',');
3458
        if(!p) {
3459
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3460
            av_exit(1);
3461
        }
3462
        p++;
3463
    }
3464
}
3465

    
3466
static void opt_inter_matrix(const char *arg)
3467
{
3468
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3469
    parse_matrix_coeffs(inter_matrix, arg);
3470
}
3471

    
3472
static void opt_intra_matrix(const char *arg)
3473
{
3474
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3475
    parse_matrix_coeffs(intra_matrix, arg);
3476
}
3477

    
3478
/**
3479
 * Trivial log callback.
3480
 * Only suitable for show_help and similar since it lacks prefix handling.
3481
 */
3482
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3483
{
3484
    vfprintf(stdout, fmt, vl);
3485
}
3486

    
3487
static void show_help(void)
3488
{
3489
    av_log_set_callback(log_callback_help);
3490
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3491
           "Hyper fast Audio and Video encoder\n");
3492
    printf("\n");
3493
    show_help_options(options, "Main options:\n",
3494
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3495
    show_help_options(options, "\nAdvanced options:\n",
3496
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3497
                      OPT_EXPERT);
3498
    show_help_options(options, "\nVideo options:\n",
3499
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3500
                      OPT_VIDEO);
3501
    show_help_options(options, "\nAdvanced Video options:\n",
3502
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3503
                      OPT_VIDEO | OPT_EXPERT);
3504
    show_help_options(options, "\nAudio options:\n",
3505
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3506
                      OPT_AUDIO);
3507
    show_help_options(options, "\nAdvanced Audio options:\n",
3508
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3509
                      OPT_AUDIO | OPT_EXPERT);
3510
    show_help_options(options, "\nSubtitle options:\n",
3511
                      OPT_SUBTITLE | OPT_GRAB,
3512
                      OPT_SUBTITLE);
3513
    show_help_options(options, "\nAudio/Video grab options:\n",
3514
                      OPT_GRAB,
3515
                      OPT_GRAB);
3516
    printf("\n");
3517
    av_opt_show(avctx_opts[0], NULL);
3518
    printf("\n");
3519
    av_opt_show(avformat_opts, NULL);
3520
    printf("\n");
3521
    av_opt_show(sws_opts, NULL);
3522
}
3523

    
3524
static void opt_target(const char *arg)
3525
{
3526
    int norm = -1;
3527
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3528

    
3529
    if(!strncmp(arg, "pal-", 4)) {
3530
        norm = 0;
3531
        arg += 4;
3532
    } else if(!strncmp(arg, "ntsc-", 5)) {
3533
        norm = 1;
3534
        arg += 5;
3535
    } else if(!strncmp(arg, "film-", 5)) {
3536
        norm = 2;
3537
        arg += 5;
3538
    } else {
3539
        int fr;
3540
        /* Calculate FR via float to avoid int overflow */
3541
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3542
        if(fr == 25000) {
3543
            norm = 0;
3544
        } else if((fr == 29970) || (fr == 23976)) {
3545
            norm = 1;
3546
        } else {
3547
            /* Try to determine PAL/NTSC by peeking in the input files */
3548
            if(nb_input_files) {
3549
                int i, j;
3550
                for(j = 0; j < nb_input_files; j++) {
3551
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3552
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3553
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3554
                            continue;
3555
                        fr = c->time_base.den * 1000 / c->time_base.num;
3556
                        if(fr == 25000) {
3557
                            norm = 0;
3558
                            break;
3559
                        } else if((fr == 29970) || (fr == 23976)) {
3560
                            norm = 1;
3561
                            break;
3562
                        }
3563
                    }
3564
                    if(norm >= 0)
3565
                        break;
3566
                }
3567
            }
3568
        }
3569
        if(verbose && norm >= 0)
3570
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3571
    }
3572

    
3573
    if(norm < 0) {
3574
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3575
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3576
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3577
        av_exit(1);
3578
    }
3579

    
3580
    if(!strcmp(arg, "vcd")) {
3581

    
3582
        opt_video_codec("mpeg1video");
3583
        opt_audio_codec("mp2");
3584
        opt_format("vcd");
3585

    
3586
        opt_frame_size(norm ? "352x240" : "352x288");
3587
        opt_frame_rate(frame_rates[norm]);
3588
        opt_default("gop", norm ? "18" : "15");
3589

    
3590
        opt_default("b", "1150000");
3591
        opt_default("maxrate", "1150000");
3592
        opt_default("minrate", "1150000");
3593
        opt_default("bufsize", "327680"); // 40*1024*8;
3594

    
3595
        opt_default("ab", "224000");
3596
        audio_sample_rate = 44100;
3597
        audio_channels = 2;
3598

    
3599
        opt_default("packetsize", "2324");
3600
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3601

    
3602
        /* We have to offset the PTS, so that it is consistent with the SCR.
3603
           SCR starts at 36000, but the first two packs contain only padding
3604
           and the first pack from the other stream, respectively, may also have
3605
           been written before.
3606
           So the real data starts at SCR 36000+3*1200. */
3607
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3608
    } else if(!strcmp(arg, "svcd")) {
3609

    
3610
        opt_video_codec("mpeg2video");
3611
        opt_audio_codec("mp2");
3612
        opt_format("svcd");
3613

    
3614
        opt_frame_size(norm ? "480x480" : "480x576");
3615
        opt_frame_rate(frame_rates[norm]);
3616
        opt_default("gop", norm ? "18" : "15");
3617

    
3618
        opt_default("b", "2040000");
3619
        opt_default("maxrate", "2516000");
3620
        opt_default("minrate", "0"); //1145000;
3621
        opt_default("bufsize", "1835008"); //224*1024*8;
3622
        opt_default("flags", "+SCAN_OFFSET");
3623

    
3624

    
3625
        opt_default("ab", "224000");
3626
        audio_sample_rate = 44100;
3627

    
3628
        opt_default("packetsize", "2324");
3629

    
3630
    } else if(!strcmp(arg, "dvd")) {
3631

    
3632
        opt_video_codec("mpeg2video");
3633
        opt_audio_codec("ac3");
3634
        opt_format("dvd");
3635

    
3636
        opt_frame_size(norm ? "720x480" : "720x576");
3637
        opt_frame_rate(frame_rates[norm]);
3638
        opt_default("gop", norm ? "18" : "15");
3639

    
3640
        opt_default("b", "6000000");
3641
        opt_default("maxrate", "9000000");
3642
        opt_default("minrate", "0"); //1500000;
3643
        opt_default("bufsize", "1835008"); //224*1024*8;
3644

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

    
3648
        opt_default("ab", "448000");
3649
        audio_sample_rate = 48000;
3650

    
3651
    } else if(!strncmp(arg, "dv", 2)) {
3652

    
3653
        opt_format("dv");
3654

    
3655
        opt_frame_size(norm ? "720x480" : "720x576");
3656
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3657
                                             (norm ? "yuv411p" : "yuv420p"));
3658
        opt_frame_rate(frame_rates[norm]);
3659

    
3660
        audio_sample_rate = 48000;
3661
        audio_channels = 2;
3662

    
3663
    } else {
3664
        fprintf(stderr, "Unknown target: %s\n", arg);
3665
        av_exit(1);
3666
    }
3667
}
3668

    
3669
static void opt_vstats_file (const char *arg)
3670
{
3671
    av_free (vstats_filename);
3672
    vstats_filename=av_strdup (arg);
3673
}
3674

    
3675
static void opt_vstats (void)
3676
{
3677
    char filename[40];
3678
    time_t today2 = time(NULL);
3679
    struct tm *today = localtime(&today2);
3680

    
3681
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3682
             today->tm_sec);
3683
    opt_vstats_file(filename);
3684
}
3685

    
3686
static int opt_bsf(const char *opt, const char *arg)
3687
{
3688
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3689
    AVBitStreamFilterContext **bsfp;
3690

    
3691
    if(!bsfc){
3692
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3693
        av_exit(1);
3694
    }
3695

    
3696
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3697
          *opt == 'a' ? &audio_bitstream_filters :
3698
                        &subtitle_bitstream_filters;
3699
    while(*bsfp)
3700
        bsfp= &(*bsfp)->next;
3701

    
3702
    *bsfp= bsfc;
3703

    
3704
    return 0;
3705
}
3706

    
3707
static int opt_preset(const char *opt, const char *arg)
3708
{
3709
    FILE *f=NULL;
3710
    char tmp[1000], tmp2[1000];
3711
    int i;
3712
    const char *base[3]= { getenv("HOME"),
3713
                           "/usr/local/share",
3714
                           "/usr/share",
3715
                         };
3716

    
3717
    for(i=!base[0]; i<3 && !f; i++){
3718
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3719
        f= fopen(tmp, "r");
3720
        if(!f){
3721
            char *codec_name= *opt == 'v' ? video_codec_name :
3722
                              *opt == 'a' ? audio_codec_name :
3723
                                            subtitle_codec_name;
3724
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3725
            f= fopen(tmp, "r");
3726
        }
3727
    }
3728

    
3729
    if(!f){
3730
        fprintf(stderr, "Preset file not found\n");
3731
        av_exit(1);
3732
    }
3733

    
3734
    while(!feof(f)){
3735
        int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3736
        if(e!=2){
3737
            fprintf(stderr, "Preset file invalid\n");
3738
            av_exit(1);
3739
        }
3740
        if(!strcmp(tmp, "acodec")){
3741
            opt_audio_codec(tmp2);
3742
        }else if(!strcmp(tmp, "vcodec")){
3743
            opt_video_codec(tmp2);
3744
        }else if(!strcmp(tmp, "scodec")){
3745
            opt_subtitle_codec(tmp2);
3746
        }else
3747
            opt_default(tmp, tmp2);
3748
    }
3749

    
3750
    fclose(f);
3751

    
3752
    return 0;
3753
}
3754

    
3755
static const OptionDef options[] = {
3756
    /* main options */
3757
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3758
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3759
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3760
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3761
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3762
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3763
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3764
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3765
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3766
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3767
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3768
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3769
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3770
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3771
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3772
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3773
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3774
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3775
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3776
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3777
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3778
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3779
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3780
      "add timings for benchmarking" },
3781
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3782
      "dump each input packet" },
3783
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3784
      "when dumping packets, also dump the payload" },
3785
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3786
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3787
    { "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)", "" },
3788
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3789
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3790
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3791
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3792
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3793
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3794
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3795
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3796
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3797
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3798
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3799

    
3800
    /* video options */
3801
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3802
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3803
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3804
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3805
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3806
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3807
    { "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" },
3808
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3809
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3810
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3811
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3812
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3813
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3814
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3815
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3816
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3817
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3818
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3819
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3820
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3821
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3822
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3823
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3824
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3825
      "use same video quality as source (implies VBR)" },
3826
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3827
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3828
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3829
      "deinterlace pictures" },
3830
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3831
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3832
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3833
#ifdef CONFIG_VHOOK
3834
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3835
#endif
3836
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3837
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3838
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3839
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3840
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3841
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3842
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3843

    
3844
    /* audio options */
3845
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3846
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3847
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3848
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3849
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3850
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3851
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3852
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3853
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3854
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3855
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3856
    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3857

    
3858
    /* subtitle options */
3859
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3860
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3861
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3862
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3863

    
3864
    /* grab options */
3865
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3866
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3867
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3868

    
3869
    /* muxer options */
3870
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3871
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3872

    
3873
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3874
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3875
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3876

    
3877
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3878
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3879
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3880

    
3881
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3882
    { NULL, },
3883
};
3884

    
3885
int main(int argc, char **argv)
3886
{
3887
    int i;
3888
    int64_t ti;
3889

    
3890
    avcodec_register_all();
3891
    avdevice_register_all();
3892
    av_register_all();
3893

    
3894
    if(isatty(STDIN_FILENO))
3895
        url_set_interrupt_cb(decode_interrupt_cb);
3896

    
3897
    for(i=0; i<CODEC_TYPE_NB; i++){
3898
        avctx_opts[i]= avcodec_alloc_context2(i);
3899
    }
3900
    avformat_opts = av_alloc_format_context();
3901
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3902

    
3903
    show_banner();
3904
    if (argc <= 1) {
3905
        show_help();
3906
        av_exit(1);
3907
    }
3908

    
3909
    /* parse options */
3910
    parse_options(argc, argv, options, opt_output_file);
3911

    
3912
    /* file converter / grab */
3913
    if (nb_output_files <= 0) {
3914
        fprintf(stderr, "Must supply at least one output file\n");
3915
        av_exit(1);
3916
    }
3917

    
3918
    if (nb_input_files == 0) {
3919
        fprintf(stderr, "Must supply at least one input file\n");
3920
        av_exit(1);
3921
    }
3922

    
3923
    ti = getutime();
3924
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3925
              stream_maps, nb_stream_maps);
3926
    ti = getutime() - ti;
3927
    if (do_benchmark) {
3928
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3929
    }
3930

    
3931
    return av_exit(0);
3932
}