Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ d2845b75

History | View | Annotate | Download (139 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
/* needed for usleep() */
23
#define _XOPEN_SOURCE 500
24

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

    
44
#ifdef HAVE_SYS_RESOURCE_H
45
#include <sys/types.h>
46
#include <sys/resource.h>
47
#elif defined(HAVE_GETPROCESSTIMES)
48
#include <windows.h>
49
#endif
50

    
51
#ifdef HAVE_SYS_SELECT_H
52
#include <sys/select.h>
53
#endif
54

    
55
#if defined(HAVE_TERMIOS_H)
56
#include <fcntl.h>
57
#include <sys/ioctl.h>
58
#include <sys/time.h>
59
#include <termios.h>
60
#elif defined(HAVE_CONIO_H)
61
#include <conio.h>
62
#endif
63
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
64
#include <time.h>
65

    
66
#include "cmdutils.h"
67

    
68
#undef NDEBUG
69
#include <assert.h>
70

    
71
#undef exit
72

    
73
const char program_name[] = "FFmpeg";
74
const int program_birth_year = 2000;
75

    
76
/* select an input stream for an output stream */
77
typedef struct AVStreamMap {
78
    int file_index;
79
    int stream_index;
80
    int sync_file_index;
81
    int sync_stream_index;
82
} AVStreamMap;
83

    
84
/** select an input file for an output file */
85
typedef struct AVMetaDataMap {
86
    int out_file;
87
    int in_file;
88
} AVMetaDataMap;
89

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

    
94
static AVFormatContext *input_files[MAX_FILES];
95
static int64_t input_files_ts_offset[MAX_FILES];
96
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
97
static int nb_input_files = 0;
98

    
99
static AVFormatContext *output_files[MAX_FILES];
100
static int nb_output_files = 0;
101

    
102
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
103
static int nb_stream_maps;
104

    
105
static AVMetaDataMap meta_data_maps[MAX_FILES];
106
static int nb_meta_data_maps;
107

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

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

    
158
static int subtitle_disable = 0;
159
static char *subtitle_codec_name = NULL;
160
static char *subtitle_language = NULL;
161

    
162
static float mux_preload= 0.5;
163
static float mux_max_delay= 0.7;
164

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

    
195
static int rate_emu = 0;
196

    
197
static int  video_channel = 0;
198
static char *video_standard;
199

    
200
static int audio_volume = 256;
201

    
202
static int exit_on_error = 0;
203
static int using_stdin = 0;
204
static int using_vhook = 0;
205
static int verbose = 1;
206
static int thread_count= 1;
207
static int q_pressed = 0;
208
static int64_t video_size = 0;
209
static int64_t audio_size = 0;
210
static int64_t extra_size = 0;
211
static int nb_frames_dup = 0;
212
static int nb_frames_drop = 0;
213
static int input_sync;
214
static uint64_t limit_filesize = 0; //
215
static int force_fps = 0;
216

    
217
static int pgmyuv_compatibility_hack=0;
218
static float dts_delta_threshold = 10;
219

    
220
static unsigned int sws_flags = SWS_BICUBIC;
221

    
222
static const char **opt_names;
223
static int opt_name_count;
224
static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
225
static AVFormatContext *avformat_opts;
226
static struct SwsContext *sws_opts;
227
static int64_t timer_start;
228

    
229
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
230
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
231
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
232
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
233

    
234
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
235

    
236
struct AVInputStream;
237

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

    
256
    int video_crop;
257
    int topBand;             /* cropping area sizes */
258
    int leftBand;
259

    
260
    int video_pad;
261
    int padtop;              /* padding area sizes */
262
    int padbottom;
263
    int padleft;
264
    int padright;
265

    
266
    /* audio only */
267
    int audio_resample;
268
    ReSampleContext *resample; /* for audio resampling */
269
    int reformat_pair;
270
    AVAudioConvert *reformat_ctx;
271
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
272
    FILE *logfile;
273
} AVOutputStream;
274

    
275
typedef struct AVInputStream {
276
    int file_index;
277
    int index;
278
    AVStream *st;
279
    int discard;             /* true if stream data should be discarded */
280
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
281
    int64_t sample_index;      /* current sample */
282

    
283
    int64_t       start;     /* time when read started */
284
    unsigned long frame;     /* current frame */
285
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
286
                                is not defined */
287
    int64_t       pts;       /* current pts */
288
    int is_start;            /* is 1 at the start and after a discontinuity */
289
} AVInputStream;
290

    
291
typedef struct AVInputFile {
292
    int eof_reached;      /* true if eof reached */
293
    int ist_index;        /* index of first stream in ist_table */
294
    int buffer_size;      /* current total buffer size */
295
    int nb_streams;       /* nb streams we are aware of */
296
} AVInputFile;
297

    
298
#ifdef HAVE_TERMIOS_H
299

    
300
/* init terminal so that we can grab keys */
301
static struct termios oldtty;
302
#endif
303

    
304
static void term_exit(void)
305
{
306
#ifdef HAVE_TERMIOS_H
307
    tcsetattr (0, TCSANOW, &oldtty);
308
#endif
309
}
310

    
311
static volatile sig_atomic_t received_sigterm = 0;
312

    
313
static void
314
sigterm_handler(int sig)
315
{
316
    received_sigterm = sig;
317
    term_exit();
318
}
319

    
320
static void term_init(void)
321
{
322
#ifdef HAVE_TERMIOS_H
323
    struct termios tty;
324

    
325
    tcgetattr (0, &tty);
326
    oldtty = tty;
327

    
328
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
329
                          |INLCR|IGNCR|ICRNL|IXON);
330
    tty.c_oflag |= OPOST;
331
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
332
    tty.c_cflag &= ~(CSIZE|PARENB);
333
    tty.c_cflag |= CS8;
334
    tty.c_cc[VMIN] = 1;
335
    tty.c_cc[VTIME] = 0;
336

    
337
    tcsetattr (0, TCSANOW, &tty);
338
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
339
#endif
340

    
341
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
342
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
343
    /*
344
    register a function to be called at normal program termination
345
    */
346
    atexit(term_exit);
347
#ifdef CONFIG_BEOS_NETSERVER
348
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
349
#endif
350
}
351

    
352
/* read a key without blocking */
353
static int read_key(void)
354
{
355
#if defined(HAVE_TERMIOS_H)
356
    int n = 1;
357
    unsigned char ch;
358
#ifndef CONFIG_BEOS_NETSERVER
359
    struct timeval tv;
360
    fd_set rfds;
361

    
362
    FD_ZERO(&rfds);
363
    FD_SET(0, &rfds);
364
    tv.tv_sec = 0;
365
    tv.tv_usec = 0;
366
    n = select(1, &rfds, NULL, NULL, &tv);
367
#endif
368
    if (n > 0) {
369
        n = read(0, &ch, 1);
370
        if (n == 1)
371
            return ch;
372

    
373
        return n;
374
    }
375
#elif defined(HAVE_CONIO_H)
376
    if(kbhit())
377
        return(getch());
378
#endif
379
    return -1;
380
}
381

    
382
static int decode_interrupt_cb(void)
383
{
384
    return q_pressed || (q_pressed = read_key() == 'q');
385
}
386

    
387
static int av_exit(int ret)
388
{
389
    int i;
390

    
391
    /* close files */
392
    for(i=0;i<nb_output_files;i++) {
393
        /* maybe av_close_output_file ??? */
394
        AVFormatContext *s = output_files[i];
395
        int j;
396
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
397
            url_fclose(s->pb);
398
        for(j=0;j<s->nb_streams;j++) {
399
            av_free(s->streams[j]->codec);
400
            av_free(s->streams[j]);
401
        }
402
        av_free(s);
403
    }
404
    for(i=0;i<nb_input_files;i++)
405
        av_close_input_file(input_files[i]);
406

    
407
    av_free(intra_matrix);
408
    av_free(inter_matrix);
409

    
410
    if (vstats_file)
411
        fclose(vstats_file);
412
    av_free(vstats_filename);
413

    
414
    av_free(opt_names);
415

    
416
    av_free(video_codec_name);
417
    av_free(audio_codec_name);
418
    av_free(subtitle_codec_name);
419

    
420
    av_free(video_standard);
421

    
422
#ifdef CONFIG_POWERPC_PERF
423
    extern void powerpc_display_perf_report(void);
424
    powerpc_display_perf_report();
425
#endif /* CONFIG_POWERPC_PERF */
426

    
427
    if (received_sigterm) {
428
        fprintf(stderr,
429
            "Received signal %d: terminating.\n",
430
            (int) received_sigterm);
431
        exit (255);
432
    }
433

    
434
    exit(ret); /* not all OS-es handle main() return value */
435
    return ret;
436
}
437

    
438
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
439
{
440
    int i, err;
441
    AVFormatContext *ic;
442
    int nopts = 0;
443

    
444
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
445
    if (err < 0)
446
        return err;
447
    /* copy stream format */
448
    s->nb_streams = ic->nb_streams;
449
    for(i=0;i<ic->nb_streams;i++) {
450
        AVStream *st;
451

    
452
        // FIXME: a more elegant solution is needed
453
        st = av_mallocz(sizeof(AVStream));
454
        memcpy(st, ic->streams[i], sizeof(AVStream));
455
        st->codec = avcodec_alloc_context();
456
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
457
        s->streams[i] = st;
458

    
459
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
460
            st->stream_copy = 1;
461
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
462
            st->stream_copy = 1;
463

    
464
        if(!st->codec->thread_count)
465
            st->codec->thread_count = 1;
466
        if(st->codec->thread_count>1)
467
            avcodec_thread_init(st->codec, st->codec->thread_count);
468

    
469
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
470
            nopts = 1;
471
    }
472

    
473
    if (!nopts)
474
        s->timestamp = av_gettime();
475

    
476
    av_close_input_file(ic);
477
    return 0;
478
}
479

    
480
static double
481
get_sync_ipts(const AVOutputStream *ost)
482
{
483
    const AVInputStream *ist = ost->sync_ist;
484
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
485
}
486

    
487
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
488
    int ret;
489

    
490
    while(bsfc){
491
        AVPacket new_pkt= *pkt;
492
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
493
                                          &new_pkt.data, &new_pkt.size,
494
                                          pkt->data, pkt->size,
495
                                          pkt->flags & PKT_FLAG_KEY);
496
        if(a>0){
497
            av_free_packet(pkt);
498
            new_pkt.destruct= av_destruct_packet;
499
        } else if(a<0){
500
            fprintf(stderr, "%s failed for stream %d, codec %s",
501
                    bsfc->filter->name, pkt->stream_index,
502
                    avctx->codec ? avctx->codec->name : "copy");
503
            print_error("", a);
504
            if (exit_on_error)
505
                av_exit(1);
506
        }
507
        *pkt= new_pkt;
508

    
509
        bsfc= bsfc->next;
510
    }
511

    
512
    ret= av_interleaved_write_frame(s, pkt);
513
    if(ret < 0){
514
        print_error("av_interleaved_write_frame()", ret);
515
        av_exit(1);
516
    }
517
}
518

    
519
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
520

    
521
static void do_audio_out(AVFormatContext *s,
522
                         AVOutputStream *ost,
523
                         AVInputStream *ist,
524
                         unsigned char *buf, int size)
525
{
526
    uint8_t *buftmp;
527
    static uint8_t *audio_buf = NULL;
528
    static uint8_t *audio_out = NULL;
529
    static uint8_t *audio_out2 = NULL;
530
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
531

    
532
    int size_out, frame_bytes, ret;
533
    AVCodecContext *enc= ost->st->codec;
534
    AVCodecContext *dec= ist->st->codec;
535
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
536
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
537

    
538
    /* SC: dynamic allocation of buffers */
539
    if (!audio_buf)
540
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
541
    if (!audio_out)
542
        audio_out = av_malloc(audio_out_size);
543
    if (!audio_buf || !audio_out)
544
        return;               /* Should signal an error ! */
545

    
546
    if (enc->channels != dec->channels)
547
        ost->audio_resample = 1;
548

    
549
    if (ost->audio_resample && !ost->resample) {
550
        if (dec->sample_fmt != SAMPLE_FMT_S16) {
551
            fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
552
            av_exit(1);
553
        }
554
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
555
                                            enc->sample_rate, dec->sample_rate);
556
        if (!ost->resample) {
557
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
558
                    dec->channels, dec->sample_rate,
559
                    enc->channels, enc->sample_rate);
560
            av_exit(1);
561
        }
562
    }
563

    
564
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
565
    if (dec->sample_fmt!=enc->sample_fmt &&
566
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
567
        if (!audio_out2)
568
            audio_out2 = av_malloc(audio_out_size);
569
        if (!audio_out2)
570
            av_exit(1);
571
        if (ost->reformat_ctx)
572
            av_audio_convert_free(ost->reformat_ctx);
573
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
574
                                                   dec->sample_fmt, 1, NULL, 0);
575
        if (!ost->reformat_ctx) {
576
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
577
                avcodec_get_sample_fmt_name(dec->sample_fmt),
578
                avcodec_get_sample_fmt_name(enc->sample_fmt));
579
            av_exit(1);
580
        }
581
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
582
    }
583

    
584
    if(audio_sync_method){
585
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
586
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
587
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
588
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
589

    
590
        //FIXME resample delay
591
        if(fabs(delta) > 50){
592
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
593
                if(byte_delta < 0){
594
                    byte_delta= FFMAX(byte_delta, -size);
595
                    size += byte_delta;
596
                    buf  -= byte_delta;
597
                    if(verbose > 2)
598
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
599
                    if(!size)
600
                        return;
601
                    ist->is_start=0;
602
                }else{
603
                    static uint8_t *input_tmp= NULL;
604
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
605

    
606
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
607
                        ist->is_start=0;
608
                    else
609
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
610

    
611
                    memset(input_tmp, 0, byte_delta);
612
                    memcpy(input_tmp + byte_delta, buf, size);
613
                    buf= input_tmp;
614
                    size += byte_delta;
615
                    if(verbose > 2)
616
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
617
                }
618
            }else if(audio_sync_method>1){
619
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
620
                assert(ost->audio_resample);
621
                if(verbose > 2)
622
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
623
//                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));
624
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
625
            }
626
        }
627
    }else
628
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
629
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
630

    
631
    if (ost->audio_resample) {
632
        buftmp = audio_buf;
633
        size_out = audio_resample(ost->resample,
634
                                  (short *)buftmp, (short *)buf,
635
                                  size / (ist->st->codec->channels * isize));
636
        size_out = size_out * enc->channels * osize;
637
    } else {
638
        buftmp = buf;
639
        size_out = size;
640
    }
641

    
642
    if (dec->sample_fmt!=enc->sample_fmt) {
643
        const void *ibuf[6]= {buftmp};
644
        void *obuf[6]= {audio_out2};
645
        int istride[6]= {isize};
646
        int ostride[6]= {osize};
647
        int len= size_out/istride[0];
648
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
649
            printf("av_audio_convert() failed\n");
650
            if (exit_on_error)
651
                av_exit(1);
652
            return;
653
        }
654
        buftmp = audio_out2;
655
        size_out = len*osize;
656
    }
657

    
658
    /* now encode as many frames as possible */
659
    if (enc->frame_size > 1) {
660
        /* output resampled raw samples */
661
        if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
662
            fprintf(stderr, "av_fifo_realloc2() failed\n");
663
            av_exit(1);
664
        }
665
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
666

    
667
        frame_bytes = enc->frame_size * osize * enc->channels;
668

    
669
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
670
            AVPacket pkt;
671
            av_init_packet(&pkt);
672

    
673
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
674

    
675
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
676

    
677
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
678
                                       (short *)audio_buf);
679
            audio_size += ret;
680
            pkt.stream_index= ost->index;
681
            pkt.data= audio_out;
682
            pkt.size= ret;
683
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
684
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
685
            pkt.flags |= PKT_FLAG_KEY;
686
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
687

    
688
            ost->sync_opts += enc->frame_size;
689
        }
690
    } else {
691
        AVPacket pkt;
692
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
693
        av_init_packet(&pkt);
694

    
695
        ost->sync_opts += size_out / (osize * enc->channels);
696

    
697
        /* output a pcm frame */
698
        /* determine the size of the coded buffer */
699
        size_out /= osize;
700
        if (coded_bps)
701
            size_out *= coded_bps;
702

    
703
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
704
        ret = avcodec_encode_audio(enc, audio_out, size_out,
705
                                   (short *)buftmp);
706
        audio_size += ret;
707
        pkt.stream_index= ost->index;
708
        pkt.data= audio_out;
709
        pkt.size= ret;
710
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
711
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
712
        pkt.flags |= PKT_FLAG_KEY;
713
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
714
    }
715
}
716

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

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

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

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

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

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

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

    
759
    if (picture != picture2)
760
        *picture = *picture2;
761
    *bufp = buf;
762
}
763

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

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

    
779
    if (pts == AV_NOPTS_VALUE) {
780
        fprintf(stderr, "Subtitle packets must have a pts\n");
781
        if (exit_on_error)
782
            av_exit(1);
783
        return;
784
    }
785

    
786
    enc = ost->st->codec;
787

    
788
    if (!subtitle_out) {
789
        subtitle_out = av_malloc(subtitle_out_max_size);
790
    }
791

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

    
800
    for(i = 0; i < nb; i++) {
801
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
802
                                                    subtitle_out_max_size, sub);
803

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

    
821
static int bit_buffer_size= 1024*256;
822
static uint8_t *bit_buffer= NULL;
823

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

    
835
    avcodec_get_frame_defaults(&picture_crop_temp);
836
    avcodec_get_frame_defaults(&picture_pad_temp);
837

    
838
    enc = ost->st->codec;
839
    dec = ist->st->codec;
840

    
841
    /* by default, we output a single frame */
842
    nb_frames = 1;
843

    
844
    *frame_size = 0;
845

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

    
869
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
870
    if (nb_frames <= 0)
871
        return;
872

    
873
    if (ost->video_crop) {
874
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
875
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
876
            if (exit_on_error)
877
                av_exit(1);
878
            return;
879
        }
880
        formatted_picture = &picture_crop_temp;
881
    } else {
882
        formatted_picture = in_picture;
883
    }
884

    
885
    final_picture = formatted_picture;
886
    padding_src = formatted_picture;
887
    resampling_dst = &ost->pict_tmp;
888
    if (ost->video_pad) {
889
        final_picture = &ost->pict_tmp;
890
        if (ost->video_resample) {
891
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
892
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
893
                if (exit_on_error)
894
                    av_exit(1);
895
                return;
896
            }
897
            resampling_dst = &picture_pad_temp;
898
        }
899
    }
900

    
901
    if (ost->video_resample) {
902
        padding_src = NULL;
903
        final_picture = &ost->pict_tmp;
904
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
905
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
906
    }
907

    
908
    if (ost->video_pad) {
909
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
910
                enc->height, enc->width, enc->pix_fmt,
911
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
912
    }
913

    
914
    /* duplicates frame if needed */
915
    for(i=0;i<nb_frames;i++) {
916
        AVPacket pkt;
917
        av_init_packet(&pkt);
918
        pkt.stream_index= ost->index;
919

    
920
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
921
            /* raw pictures are written as AVPicture structure to
922
               avoid any copies. We support temorarily the older
923
               method. */
924
            AVFrame* old_frame = enc->coded_frame;
925
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
926
            pkt.data= (uint8_t *)final_picture;
927
            pkt.size=  sizeof(AVPicture);
928
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
929
            pkt.flags |= PKT_FLAG_KEY;
930

    
931
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
932
            enc->coded_frame = old_frame;
933
        } else {
934
            AVFrame big_picture;
935

    
936
            big_picture= *final_picture;
937
            /* better than nothing: use input picture interlaced
938
               settings */
939
            big_picture.interlaced_frame = in_picture->interlaced_frame;
940
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
941
                if(top_field_first == -1)
942
                    big_picture.top_field_first = in_picture->top_field_first;
943
                else
944
                    big_picture.top_field_first = top_field_first;
945
            }
946

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

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

    
995
static double psnr(double d){
996
    return -10.0*log(d)/log(10.0);
997
}
998

    
999
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1000
                           int frame_size)
1001
{
1002
    AVCodecContext *enc;
1003
    int frame_number;
1004
    double ti1, bitrate, avg_bitrate;
1005

    
1006
    /* this is executed just the first time do_video_stats is called */
1007
    if (!vstats_file) {
1008
        vstats_file = fopen(vstats_filename, "w");
1009
        if (!vstats_file) {
1010
            perror("fopen");
1011
            av_exit(1);
1012
        }
1013
    }
1014

    
1015
    enc = ost->st->codec;
1016
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1017
        frame_number = ost->frame_number;
1018
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1019
        if (enc->flags&CODEC_FLAG_PSNR)
1020
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1021

    
1022
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1023
        /* compute pts value */
1024
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1025
        if (ti1 < 0.01)
1026
            ti1 = 0.01;
1027

    
1028
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1029
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1030
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1031
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1032
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1033
    }
1034
}
1035

    
1036
static void print_report(AVFormatContext **output_files,
1037
                         AVOutputStream **ost_table, int nb_ostreams,
1038
                         int is_last_report)
1039
{
1040
    char buf[1024];
1041
    AVOutputStream *ost;
1042
    AVFormatContext *oc, *os;
1043
    int64_t total_size;
1044
    AVCodecContext *enc;
1045
    int frame_number, vid, i;
1046
    double bitrate, ti1, pts;
1047
    static int64_t last_time = -1;
1048
    static int qp_histogram[52];
1049

    
1050
    if (!is_last_report) {
1051
        int64_t cur_time;
1052
        /* display the report every 0.5 seconds */
1053
        cur_time = av_gettime();
1054
        if (last_time == -1) {
1055
            last_time = cur_time;
1056
            return;
1057
        }
1058
        if ((cur_time - last_time) < 500000)
1059
            return;
1060
        last_time = cur_time;
1061
    }
1062

    
1063

    
1064
    oc = output_files[0];
1065

    
1066
    total_size = url_fsize(oc->pb);
1067
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1068
        total_size= url_ftell(oc->pb);
1069

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

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

    
1131
    if (verbose || is_last_report) {
1132
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1133

    
1134
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1135
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1136
            (double)total_size / 1024, ti1, bitrate);
1137

    
1138
        if (verbose > 1)
1139
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1140
                  nb_frames_dup, nb_frames_drop);
1141

    
1142
        if (verbose >= 0)
1143
            fprintf(stderr, "%s    \r", buf);
1144

    
1145
        fflush(stderr);
1146
    }
1147

    
1148
    if (is_last_report && verbose >= 0){
1149
        int64_t raw= audio_size + video_size + extra_size;
1150
        fprintf(stderr, "\n");
1151
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1152
                video_size/1024.0,
1153
                audio_size/1024.0,
1154
                extra_size/1024.0,
1155
                100.0*(total_size - raw)/raw
1156
        );
1157
    }
1158
}
1159

    
1160
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1161
static int output_packet(AVInputStream *ist, int ist_index,
1162
                         AVOutputStream **ost_table, int nb_ostreams,
1163
                         const AVPacket *pkt)
1164
{
1165
    AVFormatContext *os;
1166
    AVOutputStream *ost;
1167
    uint8_t *ptr;
1168
    int len, ret, i;
1169
    uint8_t *data_buf;
1170
    int data_size, got_picture;
1171
    AVFrame picture;
1172
    void *buffer_to_free;
1173
    static unsigned int samples_size= 0;
1174
    static short *samples= NULL;
1175
    AVSubtitle subtitle, *subtitle_to_free;
1176
    int got_subtitle;
1177

    
1178
    if(ist->next_pts == AV_NOPTS_VALUE)
1179
        ist->next_pts= ist->pts;
1180

    
1181
    if (pkt == NULL) {
1182
        /* EOF handling */
1183
        ptr = NULL;
1184
        len = 0;
1185
        goto handle_eof;
1186
    }
1187

    
1188
    if(pkt->dts != AV_NOPTS_VALUE)
1189
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1190

    
1191
    len = pkt->size;
1192
    ptr = pkt->data;
1193

    
1194
    //while we have more to decode or while the decoder did output something on EOF
1195
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1196
    handle_eof:
1197
        ist->pts= ist->next_pts;
1198

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

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

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

    
1288
        buffer_to_free = NULL;
1289
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1290
            pre_process_video_frame(ist, (AVPicture *)&picture,
1291
                                    &buffer_to_free);
1292
        }
1293

    
1294
        // preprocess audio (volume)
1295
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1296
            if (audio_volume != 256) {
1297
                short *volp;
1298
                volp = samples;
1299
                for(i=0;i<(data_size / sizeof(short));i++) {
1300
                    int v = ((*volp) * audio_volume + 128) >> 8;
1301
                    if (v < -32768) v = -32768;
1302
                    if (v >  32767) v = 32767;
1303
                    *volp++ = v;
1304
                }
1305
            }
1306
        }
1307

    
1308
        /* frame rate emulation */
1309
        if (ist->st->codec->rate_emu) {
1310
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1311
            int64_t now = av_gettime() - ist->start;
1312
            if (pts > now)
1313
                usleep(pts - now);
1314

    
1315
            ist->frame++;
1316
        }
1317

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

    
1337
                ost = ost_table[i];
1338
                if (ost->source_index == ist_index) {
1339
                    os = output_files[ost->file_index];
1340

    
1341
#if 0
1342
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1343
                           (double)pkt->pts / AV_TIME_BASE,
1344
                           ((double)ist->pts / AV_TIME_BASE) -
1345
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1346
#endif
1347
                    /* set the input output pts pairs */
1348
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1349

    
1350
                    if (ost->encoding_needed) {
1351
                        switch(ost->st->codec->codec_type) {
1352
                        case CODEC_TYPE_AUDIO:
1353
                            do_audio_out(os, ost, ist, data_buf, data_size);
1354
                            break;
1355
                        case CODEC_TYPE_VIDEO:
1356
                            do_video_out(os, ost, ist, &picture, &frame_size);
1357
                            if (vstats_filename && frame_size)
1358
                                do_video_stats(os, ost, frame_size);
1359
                            break;
1360
                        case CODEC_TYPE_SUBTITLE:
1361
                            do_subtitle_out(os, ost, ist, &subtitle,
1362
                                            pkt->pts);
1363
                            break;
1364
                        default:
1365
                            abort();
1366
                        }
1367
                    } else {
1368
                        AVFrame avframe; //FIXME/XXX remove this
1369
                        AVPacket opkt;
1370
                        av_init_packet(&opkt);
1371

    
1372
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1373
                            continue;
1374

    
1375
                        /* no reencoding needed : output the packet directly */
1376
                        /* force the input stream PTS */
1377

    
1378
                        avcodec_get_frame_defaults(&avframe);
1379
                        ost->st->codec->coded_frame= &avframe;
1380
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1381

    
1382
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1383
                            audio_size += data_size;
1384
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1385
                            video_size += data_size;
1386
                            ost->sync_opts++;
1387
                        }
1388

    
1389
                        opkt.stream_index= ost->index;
1390
                        if(pkt->pts != AV_NOPTS_VALUE)
1391
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1392
                        else
1393
                            opkt.pts= AV_NOPTS_VALUE;
1394

    
1395
                        if (pkt->dts == AV_NOPTS_VALUE)
1396
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1397
                        else
1398
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1399

    
1400
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1401
                        opkt.flags= pkt->flags;
1402

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

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

    
1432
        for(i=0;i<nb_ostreams;i++) {
1433
            ost = ost_table[i];
1434
            if (ost->source_index == ist_index) {
1435
                AVCodecContext *enc= ost->st->codec;
1436
                os = output_files[ost->file_index];
1437

    
1438
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1439
                    continue;
1440
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1441
                    continue;
1442

    
1443
                if (ost->encoding_needed) {
1444
                    for(;;) {
1445
                        AVPacket pkt;
1446
                        int fifo_bytes;
1447
                        av_init_packet(&pkt);
1448
                        pkt.stream_index= ost->index;
1449

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

    
1481
                        if(ret<=0)
1482
                            break;
1483
                        pkt.data= bit_buffer;
1484
                        pkt.size= ret;
1485
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1486
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1487
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1488
                    }
1489
                }
1490
            }
1491
        }
1492
    }
1493

    
1494
    return 0;
1495
 fail_decode:
1496
    return -1;
1497
}
1498

    
1499
static void print_sdp(AVFormatContext **avc, int n)
1500
{
1501
    char sdp[2048];
1502

    
1503
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1504
    printf("SDP:\n%s\n", sdp);
1505
}
1506

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

    
1530
    return -1;
1531
}
1532

    
1533
/*
1534
 * The following code is the main loop of the file converter
1535
 */
1536
static int av_encode(AVFormatContext **output_files,
1537
                     int nb_output_files,
1538
                     AVFormatContext **input_files,
1539
                     int nb_input_files,
1540
                     AVStreamMap *stream_maps, int nb_stream_maps)
1541
{
1542
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1543
    AVFormatContext *is, *os;
1544
    AVCodecContext *codec, *icodec;
1545
    AVOutputStream *ost, **ost_table = NULL;
1546
    AVInputStream *ist, **ist_table = NULL;
1547
    AVInputFile *file_table;
1548
    int key;
1549
    int want_sdp = 1;
1550

    
1551
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1552
    if (!file_table)
1553
        goto fail;
1554

    
1555
    /* input stream init */
1556
    j = 0;
1557
    for(i=0;i<nb_input_files;i++) {
1558
        is = input_files[i];
1559
        file_table[i].ist_index = j;
1560
        file_table[i].nb_streams = is->nb_streams;
1561
        j += is->nb_streams;
1562
    }
1563
    nb_istreams = j;
1564

    
1565
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1566
    if (!ist_table)
1567
        goto fail;
1568

    
1569
    for(i=0;i<nb_istreams;i++) {
1570
        ist = av_mallocz(sizeof(AVInputStream));
1571
        if (!ist)
1572
            goto fail;
1573
        ist_table[i] = ist;
1574
    }
1575
    j = 0;
1576
    for(i=0;i<nb_input_files;i++) {
1577
        is = input_files[i];
1578
        for(k=0;k<is->nb_streams;k++) {
1579
            ist = ist_table[j++];
1580
            ist->st = is->streams[k];
1581
            ist->file_index = i;
1582
            ist->index = k;
1583
            ist->discard = 1; /* the stream is discarded by default
1584
                                 (changed later) */
1585

    
1586
            if (ist->st->codec->rate_emu) {
1587
                ist->start = av_gettime();
1588
                ist->frame = 0;
1589
            }
1590
        }
1591
    }
1592

    
1593
    /* output stream init */
1594
    nb_ostreams = 0;
1595
    for(i=0;i<nb_output_files;i++) {
1596
        os = output_files[i];
1597
        if (!os->nb_streams) {
1598
            fprintf(stderr, "Output file does not contain any stream\n");
1599
            av_exit(1);
1600
        }
1601
        nb_ostreams += os->nb_streams;
1602
    }
1603
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1604
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1605
        av_exit(1);
1606
    }
1607

    
1608
    /* Sanity check the mapping args -- do the input files & streams exist? */
1609
    for(i=0;i<nb_stream_maps;i++) {
1610
        int fi = stream_maps[i].file_index;
1611
        int si = stream_maps[i].stream_index;
1612

    
1613
        if (fi < 0 || fi > nb_input_files - 1 ||
1614
            si < 0 || si > file_table[fi].nb_streams - 1) {
1615
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1616
            av_exit(1);
1617
        }
1618
        fi = stream_maps[i].sync_file_index;
1619
        si = stream_maps[i].sync_stream_index;
1620
        if (fi < 0 || fi > nb_input_files - 1 ||
1621
            si < 0 || si > file_table[fi].nb_streams - 1) {
1622
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1623
            av_exit(1);
1624
        }
1625
    }
1626

    
1627
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1628
    if (!ost_table)
1629
        goto fail;
1630
    for(i=0;i<nb_ostreams;i++) {
1631
        ost = av_mallocz(sizeof(AVOutputStream));
1632
        if (!ost)
1633
            goto fail;
1634
        ost_table[i] = ost;
1635
    }
1636

    
1637
    n = 0;
1638
    for(k=0;k<nb_output_files;k++) {
1639
        os = output_files[k];
1640
        for(i=0;i<os->nb_streams;i++,n++) {
1641
            int found;
1642
            ost = ost_table[n];
1643
            ost->file_index = k;
1644
            ost->index = i;
1645
            ost->st = os->streams[i];
1646
            if (nb_stream_maps > 0) {
1647
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1648
                    stream_maps[n].stream_index;
1649

    
1650
                /* Sanity check that the stream types match */
1651
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1652
                    int i= ost->file_index;
1653
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1654
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1655
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1656
                        ost->file_index, ost->index);
1657
                    av_exit(1);
1658
                }
1659

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

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

    
1710
    /* for each output stream, we compute the right encoding parameters */
1711
    for(i=0;i<nb_ostreams;i++) {
1712
        ost = ost_table[i];
1713
        os = output_files[ost->file_index];
1714
        ist = ist_table[ost->source_index];
1715

    
1716
        codec = ost->st->codec;
1717
        icodec = ist->st->codec;
1718

    
1719
        if (!ost->st->language[0])
1720
            av_strlcpy(ost->st->language, ist->st->language,
1721
                       sizeof(ost->st->language));
1722

    
1723
        ost->st->disposition = ist->st->disposition;
1724

    
1725
        if (ost->st->stream_copy) {
1726
            /* if stream_copy is selected, no need to decode or encode */
1727
            codec->codec_id = icodec->codec_id;
1728
            codec->codec_type = icodec->codec_type;
1729

    
1730
            if(!codec->codec_tag){
1731
                if(   !os->oformat->codec_tag
1732
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1733
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1734
                    codec->codec_tag = icodec->codec_tag;
1735
            }
1736

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

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

    
1890
    if (!bit_buffer)
1891
        bit_buffer = av_malloc(bit_buffer_size);
1892
    if (!bit_buffer)
1893
        goto fail;
1894

    
1895
    /* dump the file output parameters - cannot be done before in case
1896
       of stream copy */
1897
    for(i=0;i<nb_output_files;i++) {
1898
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1899
    }
1900

    
1901
    /* dump the stream mapping */
1902
    if (verbose >= 0) {
1903
        fprintf(stderr, "Stream mapping:\n");
1904
        for(i=0;i<nb_ostreams;i++) {
1905
            ost = ost_table[i];
1906
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1907
                    ist_table[ost->source_index]->file_index,
1908
                    ist_table[ost->source_index]->index,
1909
                    ost->file_index,
1910
                    ost->index);
1911
            if (ost->sync_ist != ist_table[ost->source_index])
1912
                fprintf(stderr, " [sync #%d.%d]",
1913
                        ost->sync_ist->file_index,
1914
                        ost->sync_ist->index);
1915
            fprintf(stderr, "\n");
1916
        }
1917
    }
1918

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

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

    
1960
    /* init pts */
1961
    for(i=0;i<nb_istreams;i++) {
1962
        ist = ist_table[i];
1963
        is = input_files[ist->file_index];
1964
        ist->pts = 0;
1965
        ist->next_pts = AV_NOPTS_VALUE;
1966
        ist->is_start = 1;
1967
    }
1968

    
1969
    /* set meta data information from input file if required */
1970
    for (i=0;i<nb_meta_data_maps;i++) {
1971
        AVFormatContext *out_file;
1972
        AVFormatContext *in_file;
1973

    
1974
        int out_file_index = meta_data_maps[i].out_file;
1975
        int in_file_index = meta_data_maps[i].in_file;
1976
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1977
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1978
            ret = AVERROR(EINVAL);
1979
            goto fail;
1980
        }
1981
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1982
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1983
            ret = AVERROR(EINVAL);
1984
            goto fail;
1985
        }
1986

    
1987
        out_file = output_files[out_file_index];
1988
        in_file = input_files[in_file_index];
1989

    
1990
        strcpy(out_file->title, in_file->title);
1991
        strcpy(out_file->author, in_file->author);
1992
        strcpy(out_file->copyright, in_file->copyright);
1993
        strcpy(out_file->comment, in_file->comment);
1994
        strcpy(out_file->album, in_file->album);
1995
        out_file->year = in_file->year;
1996
        out_file->track = in_file->track;
1997
        strcpy(out_file->genre, in_file->genre);
1998
    }
1999

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

    
2016
    if (!using_stdin && verbose >= 0) {
2017
        fprintf(stderr, "Press [q] to stop encoding\n");
2018
        url_set_interrupt_cb(decode_interrupt_cb);
2019
    }
2020
    term_init();
2021

    
2022
    key = -1;
2023
    timer_start = av_gettime();
2024

    
2025
    for(; received_sigterm == 0;) {
2026
        int file_index, ist_index;
2027
        AVPacket pkt;
2028
        double ipts_min;
2029
        double opts_min;
2030

    
2031
    redo:
2032
        ipts_min= 1e100;
2033
        opts_min= 1e100;
2034
        /* if 'q' pressed, exits */
2035
        if (!using_stdin) {
2036
            if (q_pressed)
2037
                break;
2038
            /* read_key() returns 0 on EOF */
2039
            key = read_key();
2040
            if (key == 'q')
2041
                break;
2042
        }
2043

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

    
2077
        /* finish if recording time exhausted */
2078
        if (opts_min >= (recording_time / 1000000.0))
2079
            break;
2080

    
2081
        /* finish if limit size exhausted */
2082
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2083
            break;
2084

    
2085
        /* read a frame from it and output it in the fifo */
2086
        is = input_files[file_index];
2087
        if (av_read_frame(is, &pkt) < 0) {
2088
            file_table[file_index].eof_reached = 1;
2089
            if (opt_shortest)
2090
                break;
2091
            else
2092
                continue;
2093
        }
2094

    
2095
        if (do_pkt_dump) {
2096
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2097
        }
2098
        /* the following test is needed in case new streams appear
2099
           dynamically in stream : we ignore them */
2100
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2101
            goto discard_packet;
2102
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2103
        ist = ist_table[ist_index];
2104
        if (ist->discard)
2105
            goto discard_packet;
2106

    
2107
        if (pkt.dts != AV_NOPTS_VALUE)
2108
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2109
        if (pkt.pts != AV_NOPTS_VALUE)
2110
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2111

    
2112
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2113
            if(pkt.pts != AV_NOPTS_VALUE)
2114
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2115
            if(pkt.dts != AV_NOPTS_VALUE)
2116
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2117
        }
2118

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

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

    
2136
            if (verbose >= 0)
2137
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2138
                        ist->file_index, ist->index);
2139
            if (exit_on_error)
2140
                av_exit(1);
2141
            av_free_packet(&pkt);
2142
            goto redo;
2143
        }
2144

    
2145
    discard_packet:
2146
        av_free_packet(&pkt);
2147

    
2148
        /* dump report by using the output first video and audio streams */
2149
        print_report(output_files, ost_table, nb_ostreams, 0);
2150
    }
2151

    
2152
    /* at the end of stream, we must flush the decoder buffers */
2153
    for(i=0;i<nb_istreams;i++) {
2154
        ist = ist_table[i];
2155
        if (ist->decoding_needed) {
2156
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2157
        }
2158
    }
2159

    
2160
    term_exit();
2161

    
2162
    /* write the trailer if needed and close file */
2163
    for(i=0;i<nb_output_files;i++) {
2164
        os = output_files[i];
2165
        av_write_trailer(os);
2166
    }
2167

    
2168
    /* dump report by using the first video and audio streams */
2169
    print_report(output_files, ost_table, nb_ostreams, 1);
2170

    
2171
    /* close each encoder */
2172
    for(i=0;i<nb_ostreams;i++) {
2173
        ost = ost_table[i];
2174
        if (ost->encoding_needed) {
2175
            av_freep(&ost->st->codec->stats_in);
2176
            avcodec_close(ost->st->codec);
2177
        }
2178
    }
2179

    
2180
    /* close each decoder */
2181
    for(i=0;i<nb_istreams;i++) {
2182
        ist = ist_table[i];
2183
        if (ist->decoding_needed) {
2184
            avcodec_close(ist->st->codec);
2185
        }
2186
    }
2187

    
2188
    /* finished ! */
2189

    
2190
    ret = 0;
2191
 fail1:
2192
    av_freep(&bit_buffer);
2193
    av_free(file_table);
2194

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

    
2230
#if 0
2231
int file_read(const char *filename)
2232
{
2233
    URLContext *h;
2234
    unsigned char buffer[1024];
2235
    int len, i;
2236

2237
    if (url_open(&h, filename, O_RDONLY) < 0) {
2238
        printf("could not open '%s'\n", filename);
2239
        return -1;
2240
    }
2241
    for(;;) {
2242
        len = url_read(h, buffer, sizeof(buffer));
2243
        if (len <= 0)
2244
            break;
2245
        for(i=0;i<len;i++) putchar(buffer[i]);
2246
    }
2247
    url_close(h);
2248
    return 0;
2249
}
2250
#endif
2251

    
2252
static void opt_format(const char *arg)
2253
{
2254
    /* compatibility stuff for pgmyuv */
2255
    if (!strcmp(arg, "pgmyuv")) {
2256
        pgmyuv_compatibility_hack=1;
2257
//        opt_image_format(arg);
2258
        arg = "image2";
2259
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2260
    }
2261

    
2262
    file_iformat = av_find_input_format(arg);
2263
    file_oformat = guess_format(arg, NULL, NULL);
2264
    if (!file_iformat && !file_oformat) {
2265
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2266
        av_exit(1);
2267
    }
2268
}
2269

    
2270
static int opt_default(const char *opt, const char *arg){
2271
    int type;
2272
    const AVOption *o= NULL;
2273
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2274

    
2275
    for(type=0; type<CODEC_TYPE_NB; type++){
2276
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2277
        if(o2)
2278
            o = av_set_string2(avctx_opts[type], opt, arg, 1);
2279
    }
2280
    if(!o)
2281
        o = av_set_string2(avformat_opts, opt, arg, 1);
2282
    if(!o)
2283
        o = av_set_string2(sws_opts, opt, arg, 1);
2284
    if(!o){
2285
        if(opt[0] == 'a')
2286
            o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2287
        else if(opt[0] == 'v')
2288
            o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2289
        else if(opt[0] == 's')
2290
            o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2291
    }
2292
    if(!o)
2293
        return -1;
2294

    
2295
//    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));
2296

    
2297
    //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
2298
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2299
    opt_names[opt_name_count++]= o->name;
2300

    
2301
    if(avctx_opts[0]->debug || avformat_opts->debug)
2302
        av_log_set_level(AV_LOG_DEBUG);
2303
    return 0;
2304
}
2305

    
2306
static void opt_video_rc_override_string(const char *arg)
2307
{
2308
    video_rc_override_string = arg;
2309
}
2310

    
2311
static int opt_me_threshold(const char *opt, const char *arg)
2312
{
2313
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2314
    return 0;
2315
}
2316

    
2317
static int opt_verbose(const char *opt, const char *arg)
2318
{
2319
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2320
    av_log_set_level(verbose);
2321
    return 0;
2322
}
2323

    
2324
static int opt_frame_rate(const char *opt, const char *arg)
2325
{
2326
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2327
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2328
        av_exit(1);
2329
    }
2330
    return 0;
2331
}
2332

    
2333
static int opt_bitrate(const char *opt, const char *arg)
2334
{
2335
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2336

    
2337
    opt_default(opt, arg);
2338

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

    
2342
    return 0;
2343
}
2344

    
2345
static void opt_frame_crop_top(const char *arg)
2346
{
2347
    frame_topBand = atoi(arg);
2348
    if (frame_topBand < 0) {
2349
        fprintf(stderr, "Incorrect top crop size\n");
2350
        av_exit(1);
2351
    }
2352
    if ((frame_topBand % 2) != 0) {
2353
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2354
        av_exit(1);
2355
    }
2356
    if ((frame_topBand) >= frame_height){
2357
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2358
        av_exit(1);
2359
    }
2360
    frame_height -= frame_topBand;
2361
}
2362

    
2363
static void opt_frame_crop_bottom(const char *arg)
2364
{
2365
    frame_bottomBand = atoi(arg);
2366
    if (frame_bottomBand < 0) {
2367
        fprintf(stderr, "Incorrect bottom crop size\n");
2368
        av_exit(1);
2369
    }
2370
    if ((frame_bottomBand % 2) != 0) {
2371
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2372
        av_exit(1);
2373
    }
2374
    if ((frame_bottomBand) >= frame_height){
2375
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2376
        av_exit(1);
2377
    }
2378
    frame_height -= frame_bottomBand;
2379
}
2380

    
2381
static void opt_frame_crop_left(const char *arg)
2382
{
2383
    frame_leftBand = atoi(arg);
2384
    if (frame_leftBand < 0) {
2385
        fprintf(stderr, "Incorrect left crop size\n");
2386
        av_exit(1);
2387
    }
2388
    if ((frame_leftBand % 2) != 0) {
2389
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2390
        av_exit(1);
2391
    }
2392
    if ((frame_leftBand) >= frame_width){
2393
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2394
        av_exit(1);
2395
    }
2396
    frame_width -= frame_leftBand;
2397
}
2398

    
2399
static void opt_frame_crop_right(const char *arg)
2400
{
2401
    frame_rightBand = atoi(arg);
2402
    if (frame_rightBand < 0) {
2403
        fprintf(stderr, "Incorrect right crop size\n");
2404
        av_exit(1);
2405
    }
2406
    if ((frame_rightBand % 2) != 0) {
2407
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2408
        av_exit(1);
2409
    }
2410
    if ((frame_rightBand) >= frame_width){
2411
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2412
        av_exit(1);
2413
    }
2414
    frame_width -= frame_rightBand;
2415
}
2416

    
2417
static void opt_frame_size(const char *arg)
2418
{
2419
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2420
        fprintf(stderr, "Incorrect frame size\n");
2421
        av_exit(1);
2422
    }
2423
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2424
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2425
        av_exit(1);
2426
    }
2427
}
2428

    
2429

    
2430
#define SCALEBITS 10
2431
#define ONE_HALF  (1 << (SCALEBITS - 1))
2432
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2433

    
2434
#define RGB_TO_Y(r, g, b) \
2435
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2436
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2437

    
2438
#define RGB_TO_U(r1, g1, b1, shift)\
2439
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2440
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2441

    
2442
#define RGB_TO_V(r1, g1, b1, shift)\
2443
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2444
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2445

    
2446
static void opt_pad_color(const char *arg) {
2447
    /* Input is expected to be six hex digits similar to
2448
       how colors are expressed in html tags (but without the #) */
2449
    int rgb = strtol(arg, NULL, 16);
2450
    int r,g,b;
2451

    
2452
    r = (rgb >> 16);
2453
    g = ((rgb >> 8) & 255);
2454
    b = (rgb & 255);
2455

    
2456
    padcolor[0] = RGB_TO_Y(r,g,b);
2457
    padcolor[1] = RGB_TO_U(r,g,b,0);
2458
    padcolor[2] = RGB_TO_V(r,g,b,0);
2459
}
2460

    
2461
static void opt_frame_pad_top(const char *arg)
2462
{
2463
    frame_padtop = atoi(arg);
2464
    if (frame_padtop < 0) {
2465
        fprintf(stderr, "Incorrect top pad size\n");
2466
        av_exit(1);
2467
    }
2468
    if ((frame_padtop % 2) != 0) {
2469
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2470
        av_exit(1);
2471
    }
2472
}
2473

    
2474
static void opt_frame_pad_bottom(const char *arg)
2475
{
2476
    frame_padbottom = atoi(arg);
2477
    if (frame_padbottom < 0) {
2478
        fprintf(stderr, "Incorrect bottom pad size\n");
2479
        av_exit(1);
2480
    }
2481
    if ((frame_padbottom % 2) != 0) {
2482
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2483
        av_exit(1);
2484
    }
2485
}
2486

    
2487

    
2488
static void opt_frame_pad_left(const char *arg)
2489
{
2490
    frame_padleft = atoi(arg);
2491
    if (frame_padleft < 0) {
2492
        fprintf(stderr, "Incorrect left pad size\n");
2493
        av_exit(1);
2494
    }
2495
    if ((frame_padleft % 2) != 0) {
2496
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2497
        av_exit(1);
2498
    }
2499
}
2500

    
2501

    
2502
static void opt_frame_pad_right(const char *arg)
2503
{
2504
    frame_padright = atoi(arg);
2505
    if (frame_padright < 0) {
2506
        fprintf(stderr, "Incorrect right pad size\n");
2507
        av_exit(1);
2508
    }
2509
    if ((frame_padright % 2) != 0) {
2510
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2511
        av_exit(1);
2512
    }
2513
}
2514

    
2515
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2516
{
2517
    int i;
2518
    char fmt_str[128];
2519
    for (i=-1; i < nb_fmts; i++) {
2520
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2521
        fprintf(stdout, "%s\n", fmt_str);
2522
    }
2523
}
2524

    
2525
static void opt_frame_pix_fmt(const char *arg)
2526
{
2527
    if (strcmp(arg, "list"))
2528
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2529
    else {
2530
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2531
        av_exit(0);
2532
    }
2533
}
2534

    
2535
static void opt_frame_aspect_ratio(const char *arg)
2536
{
2537
    int x = 0, y = 0;
2538
    double ar = 0;
2539
    const char *p;
2540
    char *end;
2541

    
2542
    p = strchr(arg, ':');
2543
    if (p) {
2544
        x = strtol(arg, &end, 10);
2545
        if (end == p)
2546
            y = strtol(end+1, &end, 10);
2547
        if (x > 0 && y > 0)
2548
            ar = (double)x / (double)y;
2549
    } else
2550
        ar = strtod(arg, NULL);
2551

    
2552
    if (!ar) {
2553
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2554
        av_exit(1);
2555
    }
2556
    frame_aspect_ratio = ar;
2557
}
2558

    
2559
static void opt_qscale(const char *arg)
2560
{
2561
    video_qscale = atof(arg);
2562
    if (video_qscale <= 0 ||
2563
        video_qscale > 255) {
2564
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2565
        av_exit(1);
2566
    }
2567
}
2568

    
2569
static void opt_top_field_first(const char *arg)
2570
{
2571
    top_field_first= atoi(arg);
2572
}
2573

    
2574
static int opt_thread_count(const char *opt, const char *arg)
2575
{
2576
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2577
#if !defined(HAVE_THREADS)
2578
    if (verbose >= 0)
2579
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2580
#endif
2581
    return 0;
2582
}
2583

    
2584
static void opt_audio_sample_fmt(const char *arg)
2585
{
2586
    if (strcmp(arg, "list"))
2587
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2588
    else {
2589
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2590
        av_exit(0);
2591
    }
2592
}
2593

    
2594
static int opt_audio_rate(const char *opt, const char *arg)
2595
{
2596
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2597
    return 0;
2598
}
2599

    
2600
static int opt_audio_channels(const char *opt, const char *arg)
2601
{
2602
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2603
    return 0;
2604
}
2605

    
2606
static void opt_video_channel(const char *arg)
2607
{
2608
    video_channel = strtol(arg, NULL, 0);
2609
}
2610

    
2611
static void opt_video_standard(const char *arg)
2612
{
2613
    video_standard = av_strdup(arg);
2614
}
2615

    
2616
static void opt_codec(int *pstream_copy, char **pcodec_name,
2617
                      int codec_type, const char *arg)
2618
{
2619
    av_freep(pcodec_name);
2620
    if (!strcmp(arg, "copy")) {
2621
        *pstream_copy = 1;
2622
    } else {
2623
        *pcodec_name = av_strdup(arg);
2624
    }
2625
}
2626

    
2627
static void opt_audio_codec(const char *arg)
2628
{
2629
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2630
}
2631

    
2632
static void opt_audio_tag(const char *arg)
2633
{
2634
    char *tail;
2635
    audio_codec_tag= strtol(arg, &tail, 0);
2636

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

    
2641
static void opt_video_tag(const char *arg)
2642
{
2643
    char *tail;
2644
    video_codec_tag= strtol(arg, &tail, 0);
2645

    
2646
    if(!tail || *tail)
2647
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2648
}
2649

    
2650
#ifdef CONFIG_VHOOK
2651
static void add_frame_hooker(const char *arg)
2652
{
2653
    int argc = 0;
2654
    char *argv[64];
2655
    int i;
2656
    char *args = av_strdup(arg);
2657

    
2658
    using_vhook = 1;
2659

    
2660
    argv[0] = strtok(args, " ");
2661
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2662
    }
2663

    
2664
    i = frame_hook_add(argc, argv);
2665

    
2666
    if (i != 0) {
2667
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2668
        av_exit(1);
2669
    }
2670
}
2671
#endif
2672

    
2673
static void opt_video_codec(const char *arg)
2674
{
2675
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2676
}
2677

    
2678
static void opt_subtitle_codec(const char *arg)
2679
{
2680
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2681
}
2682

    
2683
static void opt_map(const char *arg)
2684
{
2685
    AVStreamMap *m;
2686
    char *p;
2687

    
2688
    m = &stream_maps[nb_stream_maps++];
2689

    
2690
    m->file_index = strtol(arg, &p, 0);
2691
    if (*p)
2692
        p++;
2693

    
2694
    m->stream_index = strtol(p, &p, 0);
2695
    if (*p) {
2696
        p++;
2697
        m->sync_file_index = strtol(p, &p, 0);
2698
        if (*p)
2699
            p++;
2700
        m->sync_stream_index = strtol(p, &p, 0);
2701
    } else {
2702
        m->sync_file_index = m->file_index;
2703
        m->sync_stream_index = m->stream_index;
2704
    }
2705
}
2706

    
2707
static void opt_map_meta_data(const char *arg)
2708
{
2709
    AVMetaDataMap *m;
2710
    char *p;
2711

    
2712
    m = &meta_data_maps[nb_meta_data_maps++];
2713

    
2714
    m->out_file = strtol(arg, &p, 0);
2715
    if (*p)
2716
        p++;
2717

    
2718
    m->in_file = strtol(p, &p, 0);
2719
}
2720

    
2721
static void opt_input_ts_scale(const char *arg)
2722
{
2723
    unsigned int stream;
2724
    double scale;
2725
    char *p;
2726

    
2727
    stream = strtol(arg, &p, 0);
2728
    if (*p)
2729
        p++;
2730
    scale= strtod(p, &p);
2731

    
2732
    if(stream >= MAX_STREAMS)
2733
        av_exit(1);
2734

    
2735
    input_files_ts_scale[nb_input_files][stream]= scale;
2736
}
2737

    
2738
static int opt_recording_time(const char *opt, const char *arg)
2739
{
2740
    recording_time = parse_time_or_die(opt, arg, 1);
2741
    return 0;
2742
}
2743

    
2744
static int opt_start_time(const char *opt, const char *arg)
2745
{
2746
    start_time = parse_time_or_die(opt, arg, 1);
2747
    return 0;
2748
}
2749

    
2750
static int opt_rec_timestamp(const char *opt, const char *arg)
2751
{
2752
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2753
    return 0;
2754
}
2755

    
2756
static int opt_input_ts_offset(const char *opt, const char *arg)
2757
{
2758
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2759
    return 0;
2760
}
2761

    
2762
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2763
{
2764
    const char *codec_string = encoder ? "encoder" : "decoder";
2765
    AVCodec *codec;
2766

    
2767
    if(!name)
2768
        return CODEC_ID_NONE;
2769
    codec = encoder ?
2770
        avcodec_find_encoder_by_name(name) :
2771
        avcodec_find_decoder_by_name(name);
2772
    if(!codec) {
2773
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2774
        av_exit(1);
2775
    }
2776
    if(codec->type != type) {
2777
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2778
        av_exit(1);
2779
    }
2780
    return codec->id;
2781
}
2782

    
2783
static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2784
{
2785
    int i;
2786
    for(i=0; i<opt_name_count; i++){
2787
        char buf[256];
2788
        const AVOption *opt;
2789
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2790
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2791
        if(str && ((opt->flags & flags) == flags))
2792
            av_set_string2(ctx, opt_names[i], str, 1);
2793
    }
2794
}
2795

    
2796
static void opt_input_file(const char *filename)
2797
{
2798
    AVFormatContext *ic;
2799
    AVFormatParameters params, *ap = &params;
2800
    int err, i, ret, rfps, rfps_base;
2801
    int64_t timestamp;
2802

    
2803
    if (!strcmp(filename, "-"))
2804
        filename = "pipe:";
2805

    
2806
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2807
                    !strcmp(filename, "/dev/stdin");
2808

    
2809
    /* get default parameters from command line */
2810
    ic = av_alloc_format_context();
2811

    
2812
    memset(ap, 0, sizeof(*ap));
2813
    ap->prealloced_context = 1;
2814
    ap->sample_rate = audio_sample_rate;
2815
    ap->channels = audio_channels;
2816
    ap->time_base.den = frame_rate.num;
2817
    ap->time_base.num = frame_rate.den;
2818
    ap->width = frame_width + frame_padleft + frame_padright;
2819
    ap->height = frame_height + frame_padtop + frame_padbottom;
2820
    ap->pix_fmt = frame_pix_fmt;
2821
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2822
    ap->channel = video_channel;
2823
    ap->standard = video_standard;
2824
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2825
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2826
    if(pgmyuv_compatibility_hack)
2827
        ap->video_codec_id= CODEC_ID_PGMYUV;
2828

    
2829
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2830

    
2831
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2832
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2833
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2834

    
2835
    /* open the input file with generic libav function */
2836
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2837
    if (err < 0) {
2838
        print_error(filename, err);
2839
        av_exit(1);
2840
    }
2841
    if(opt_programid) {
2842
        int i;
2843
        for(i=0; i<ic->nb_programs; i++)
2844
            if(ic->programs[i]->id != opt_programid)
2845
                ic->programs[i]->discard = AVDISCARD_ALL;
2846
    }
2847

    
2848
    ic->loop_input = loop_input;
2849

    
2850
    /* If not enough info to get the stream parameters, we decode the
2851
       first frames to get it. (used in mpeg case for example) */
2852
    ret = av_find_stream_info(ic);
2853
    if (ret < 0 && verbose >= 0) {
2854
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2855
        av_exit(1);
2856
    }
2857

    
2858
    timestamp = start_time;
2859
    /* add the stream start time */
2860
    if (ic->start_time != AV_NOPTS_VALUE)
2861
        timestamp += ic->start_time;
2862

    
2863
    /* if seeking requested, we execute it */
2864
    if (start_time != 0) {
2865
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2866
        if (ret < 0) {
2867
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2868
                    filename, (double)timestamp / AV_TIME_BASE);
2869
        }
2870
        /* reset seek info */
2871
        start_time = 0;
2872
    }
2873

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

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

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

    
2912
                    (float)rfps / rfps_base, rfps, rfps_base);
2913
            }
2914
            /* update the current frame rate to match the stream frame rate */
2915
            frame_rate.num = rfps;
2916
            frame_rate.den = rfps_base;
2917

    
2918
            enc->rate_emu = rate_emu;
2919
            if(video_disable)
2920
                ic->streams[i]->discard= AVDISCARD_ALL;
2921
            else if(video_discard)
2922
                ic->streams[i]->discard= video_discard;
2923
            break;
2924
        case CODEC_TYPE_DATA:
2925
            break;
2926
        case CODEC_TYPE_SUBTITLE:
2927
            if(subtitle_disable)
2928
                ic->streams[i]->discard = AVDISCARD_ALL;
2929
            break;
2930
        case CODEC_TYPE_ATTACHMENT:
2931
        case CODEC_TYPE_UNKNOWN:
2932
            break;
2933
        default:
2934
            abort();
2935
        }
2936
    }
2937

    
2938
    input_files[nb_input_files] = ic;
2939
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2940
    /* dump the file content */
2941
    if (verbose >= 0)
2942
        dump_format(ic, nb_input_files, filename, 0);
2943

    
2944
    nb_input_files++;
2945
    file_iformat = NULL;
2946
    file_oformat = NULL;
2947

    
2948
    video_channel = 0;
2949

    
2950
    rate_emu = 0;
2951
    av_freep(&video_codec_name);
2952
    av_freep(&audio_codec_name);
2953
    av_freep(&subtitle_codec_name);
2954
}
2955

    
2956
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2957
                                         int *has_subtitle_ptr)
2958
{
2959
    int has_video, has_audio, has_subtitle, i, j;
2960
    AVFormatContext *ic;
2961

    
2962
    has_video = 0;
2963
    has_audio = 0;
2964
    has_subtitle = 0;
2965
    for(j=0;j<nb_input_files;j++) {
2966
        ic = input_files[j];
2967
        for(i=0;i<ic->nb_streams;i++) {
2968
            AVCodecContext *enc = ic->streams[i]->codec;
2969
            switch(enc->codec_type) {
2970
            case CODEC_TYPE_AUDIO:
2971
                has_audio = 1;
2972
                break;
2973
            case CODEC_TYPE_VIDEO:
2974
                has_video = 1;
2975
                break;
2976
            case CODEC_TYPE_SUBTITLE:
2977
                has_subtitle = 1;
2978
                break;
2979
            case CODEC_TYPE_DATA:
2980
            case CODEC_TYPE_ATTACHMENT:
2981
            case CODEC_TYPE_UNKNOWN:
2982
                break;
2983
            default:
2984
                abort();
2985
            }
2986
        }
2987
    }
2988
    *has_video_ptr = has_video;
2989
    *has_audio_ptr = has_audio;
2990
    *has_subtitle_ptr = has_subtitle;
2991
}
2992

    
2993
static void new_video_stream(AVFormatContext *oc)
2994
{
2995
    AVStream *st;
2996
    AVCodecContext *video_enc;
2997
    int codec_id;
2998

    
2999
    st = av_new_stream(oc, oc->nb_streams);
3000
    if (!st) {
3001
        fprintf(stderr, "Could not alloc stream\n");
3002
        av_exit(1);
3003
    }
3004
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3005
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3006
    video_bitstream_filters= NULL;
3007

    
3008
    if(thread_count>1)
3009
        avcodec_thread_init(st->codec, thread_count);
3010

    
3011
    video_enc = st->codec;
3012

    
3013
    if(video_codec_tag)
3014
        video_enc->codec_tag= video_codec_tag;
3015

    
3016
    if(   (video_global_header&1)
3017
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3018
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3019
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3020
    }
3021
    if(video_global_header&2){
3022
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3023
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3024
    }
3025

    
3026
    if (video_stream_copy) {
3027
        st->stream_copy = 1;
3028
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3029
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3030
    } else {
3031
        const char *p;
3032
        int i;
3033
        AVCodec *codec;
3034
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3035

    
3036
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3037
        if (video_codec_name)
3038
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3039

    
3040
        video_enc->codec_id = codec_id;
3041
        codec = avcodec_find_encoder(codec_id);
3042

    
3043
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3044

    
3045
        if (codec && codec->supported_framerates && !force_fps)
3046
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3047
        video_enc->time_base.den = fps.num;
3048
        video_enc->time_base.num = fps.den;
3049

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

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

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

    
3074
        if(intra_matrix)
3075
            video_enc->intra_matrix = intra_matrix;
3076
        if(inter_matrix)
3077
            video_enc->inter_matrix = inter_matrix;
3078

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

    
3110
        if (do_psnr)
3111
            video_enc->flags|= CODEC_FLAG_PSNR;
3112

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

    
3123
    /* reset some key parameters */
3124
    video_disable = 0;
3125
    av_freep(&video_codec_name);
3126
    video_stream_copy = 0;
3127
}
3128

    
3129
static void new_audio_stream(AVFormatContext *oc)
3130
{
3131
    AVStream *st;
3132
    AVCodecContext *audio_enc;
3133
    int codec_id;
3134

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

    
3142
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3143
    audio_bitstream_filters= NULL;
3144

    
3145
    if(thread_count>1)
3146
        avcodec_thread_init(st->codec, thread_count);
3147

    
3148
    audio_enc = st->codec;
3149
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3150

    
3151
    if(audio_codec_tag)
3152
        audio_enc->codec_tag= audio_codec_tag;
3153

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

    
3165
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3166

    
3167
        if (audio_codec_name)
3168
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3169
        audio_enc->codec_id = codec_id;
3170
        codec = avcodec_find_encoder(codec_id);
3171

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

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

    
3198
    /* reset some key parameters */
3199
    audio_disable = 0;
3200
    av_freep(&audio_codec_name);
3201
    audio_stream_copy = 0;
3202
}
3203

    
3204
static void new_subtitle_stream(AVFormatContext *oc)
3205
{
3206
    AVStream *st;
3207
    AVCodecContext *subtitle_enc;
3208

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

    
3216
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3217
    subtitle_bitstream_filters= NULL;
3218

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

    
3228
    if (subtitle_language) {
3229
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3230
        av_free(subtitle_language);
3231
        subtitle_language = NULL;
3232
    }
3233

    
3234
    subtitle_disable = 0;
3235
    av_freep(&subtitle_codec_name);
3236
    subtitle_stream_copy = 0;
3237
}
3238

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

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

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

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

    
3279
    if (!strcmp(filename, "-"))
3280
        filename = "pipe:";
3281

    
3282
    oc = av_alloc_format_context();
3283

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

    
3293
    oc->oformat = file_oformat;
3294
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3295

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

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

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

    
3334
        if (use_video) {
3335
            new_video_stream(oc);
3336
        }
3337

    
3338
        if (use_audio) {
3339
            new_audio_stream(oc);
3340
        }
3341

    
3342
        if (use_subtitle) {
3343
            new_subtitle_stream(oc);
3344
        }
3345

    
3346
        oc->timestamp = rec_timestamp;
3347

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

    
3362
    output_files[nb_output_files++] = oc;
3363

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

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

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

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

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

    
3411
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3412
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3413
    oc->loop_output = loop_output;
3414

    
3415
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3416

    
3417
    /* reset some options */
3418
    file_oformat = NULL;
3419
    file_iformat = NULL;
3420
}
3421

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

    
3434
static int64_t getutime(void)
3435
{
3436
#ifdef HAVE_GETRUSAGE
3437
    struct rusage rusage;
3438

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

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

    
3469
static void opt_inter_matrix(const char *arg)
3470
{
3471
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3472
    parse_matrix_coeffs(inter_matrix, arg);
3473
}
3474

    
3475
static void opt_intra_matrix(const char *arg)
3476
{
3477
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3478
    parse_matrix_coeffs(intra_matrix, arg);
3479
}
3480

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

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

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

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

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

    
3583
    if(!strcmp(arg, "vcd")) {
3584

    
3585
        opt_video_codec("mpeg1video");
3586
        opt_audio_codec("mp2");
3587
        opt_format("vcd");
3588

    
3589
        opt_frame_size(norm ? "352x240" : "352x288");
3590
        opt_frame_rate(NULL, frame_rates[norm]);
3591
        opt_default("gop", norm ? "18" : "15");
3592

    
3593
        opt_default("b", "1150000");
3594
        opt_default("maxrate", "1150000");
3595
        opt_default("minrate", "1150000");
3596
        opt_default("bufsize", "327680"); // 40*1024*8;
3597

    
3598
        opt_default("ab", "224000");
3599
        audio_sample_rate = 44100;
3600
        audio_channels = 2;
3601

    
3602
        opt_default("packetsize", "2324");
3603
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3604

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

    
3613
        opt_video_codec("mpeg2video");
3614
        opt_audio_codec("mp2");
3615
        opt_format("svcd");
3616

    
3617
        opt_frame_size(norm ? "480x480" : "480x576");
3618
        opt_frame_rate(NULL, frame_rates[norm]);
3619
        opt_default("gop", norm ? "18" : "15");
3620

    
3621
        opt_default("b", "2040000");
3622
        opt_default("maxrate", "2516000");
3623
        opt_default("minrate", "0"); //1145000;
3624
        opt_default("bufsize", "1835008"); //224*1024*8;
3625
        opt_default("flags", "+scan_offset");
3626

    
3627

    
3628
        opt_default("ab", "224000");
3629
        audio_sample_rate = 44100;
3630

    
3631
        opt_default("packetsize", "2324");
3632

    
3633
    } else if(!strcmp(arg, "dvd")) {
3634

    
3635
        opt_video_codec("mpeg2video");
3636
        opt_audio_codec("ac3");
3637
        opt_format("dvd");
3638

    
3639
        opt_frame_size(norm ? "720x480" : "720x576");
3640
        opt_frame_rate(NULL, frame_rates[norm]);
3641
        opt_default("gop", norm ? "18" : "15");
3642

    
3643
        opt_default("b", "6000000");
3644
        opt_default("maxrate", "9000000");
3645
        opt_default("minrate", "0"); //1500000;
3646
        opt_default("bufsize", "1835008"); //224*1024*8;
3647

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

    
3651
        opt_default("ab", "448000");
3652
        audio_sample_rate = 48000;
3653

    
3654
    } else if(!strncmp(arg, "dv", 2)) {
3655

    
3656
        opt_format("dv");
3657

    
3658
        opt_frame_size(norm ? "720x480" : "720x576");
3659
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3660
                                             (norm ? "yuv411p" : "yuv420p"));
3661
        opt_frame_rate(NULL, frame_rates[norm]);
3662

    
3663
        audio_sample_rate = 48000;
3664
        audio_channels = 2;
3665

    
3666
    } else {
3667
        fprintf(stderr, "Unknown target: %s\n", arg);
3668
        av_exit(1);
3669
    }
3670
}
3671

    
3672
static void opt_vstats_file (const char *arg)
3673
{
3674
    av_free (vstats_filename);
3675
    vstats_filename=av_strdup (arg);
3676
}
3677

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

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

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

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

    
3699
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3700
          *opt == 'a' ? &audio_bitstream_filters :
3701
                        &subtitle_bitstream_filters;
3702
    while(*bsfp)
3703
        bsfp= &(*bsfp)->next;
3704

    
3705
    *bsfp= bsfc;
3706

    
3707
    return 0;
3708
}
3709

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

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

    
3735
    if(!f){
3736
        fprintf(stderr, "Preset file not found\n");
3737
        av_exit(1);
3738
    }
3739

    
3740
    while(!feof(f)){
3741
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3742
        if(line[0] == '#' && !e)
3743
            continue;
3744
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3745
        if(e){
3746
            fprintf(stderr, "Preset file invalid\n");
3747
            av_exit(1);
3748
        }
3749
        if(!strcmp(tmp, "acodec")){
3750
            opt_audio_codec(tmp2);
3751
        }else if(!strcmp(tmp, "vcodec")){
3752
            opt_video_codec(tmp2);
3753
        }else if(!strcmp(tmp, "scodec")){
3754
            opt_subtitle_codec(tmp2);
3755
        }else
3756
            opt_default(tmp, tmp2);
3757
    }
3758

    
3759
    fclose(f);
3760

    
3761
    return 0;
3762
}
3763

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

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

    
3855
    /* audio options */
3856
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3857
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3858
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3859
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3860
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3861
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3862
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3863
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3864
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3865
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3866
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3867
    { "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" },
3868

    
3869
    /* subtitle options */
3870
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3871
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3872
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3873
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3874

    
3875
    /* grab options */
3876
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3877
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3878
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3879

    
3880
    /* muxer options */
3881
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3882
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3883

    
3884
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3885
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3886
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3887

    
3888
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3889
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3890
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3891

    
3892
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3893
    { NULL, },
3894
};
3895

    
3896
int main(int argc, char **argv)
3897
{
3898
    int i;
3899
    int64_t ti;
3900

    
3901
    avcodec_register_all();
3902
    avdevice_register_all();
3903
    av_register_all();
3904

    
3905
    if(isatty(STDIN_FILENO))
3906
        url_set_interrupt_cb(decode_interrupt_cb);
3907

    
3908
    for(i=0; i<CODEC_TYPE_NB; i++){
3909
        avctx_opts[i]= avcodec_alloc_context2(i);
3910
    }
3911
    avformat_opts = av_alloc_format_context();
3912
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3913

    
3914
    show_banner();
3915
    if (argc <= 1) {
3916
        show_help();
3917
        av_exit(1);
3918
    }
3919

    
3920
    /* parse options */
3921
    parse_options(argc, argv, options, opt_output_file);
3922

    
3923
    /* file converter / grab */
3924
    if (nb_output_files <= 0) {
3925
        fprintf(stderr, "Must supply at least one output file\n");
3926
        av_exit(1);
3927
    }
3928

    
3929
    if (nb_input_files == 0) {
3930
        fprintf(stderr, "Must supply at least one input file\n");
3931
        av_exit(1);
3932
    }
3933

    
3934
    ti = getutime();
3935
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3936
              stream_maps, nb_stream_maps);
3937
    ti = getutime() - ti;
3938
    if (do_benchmark) {
3939
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3940
    }
3941

    
3942
    return av_exit(0);
3943
}