Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4e72f129

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

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

    
219
static unsigned int sws_flags = SWS_BICUBIC;
220

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

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

    
233
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
234

    
235
struct AVInputStream;
236

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

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

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

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

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

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

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

    
297
#ifdef HAVE_TERMIOS_H
298

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

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

    
310
static volatile sig_atomic_t received_sigterm = 0;
311

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
413
    av_free(opt_names);
414

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

    
419
    av_free(video_standard);
420

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
508
        bsfc= bsfc->next;
509
    }
510

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

    
518
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
519

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
843
    *frame_size = 0;
844

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1062

    
1063
    oc = output_files[0];
1064

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

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

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

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

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

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

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

    
1144
        fflush(stderr);
1145
    }
1146

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1314
            ist->frame++;
1315
        }
1316

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1529
    return -1;
1530
}
1531

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2144
    discard_packet:
2145
        av_free_packet(&pkt);
2146

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

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

    
2159
    term_exit();
2160

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

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

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

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

    
2187
    /* finished ! */
2188

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2336
    opt_default(opt, arg);
2337

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

    
2341
    return 0;
2342
}
2343

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

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

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

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

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

    
2428

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

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

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

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

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

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

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

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

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

    
2486

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

    
2500

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2657
    using_vhook = 1;
2658

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

    
2663
    i = frame_hook_add(argc, argv);
2664

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2828
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2829

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

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

    
2847
    ic->loop_input = loop_input;
2848

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

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

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

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

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

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

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

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

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

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

    
2947
    video_channel = 0;
2948

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

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

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

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

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

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

    
3010
    video_enc = st->codec;
3011

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

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

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

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

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

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

    
3044
        video_enc->time_base.den = fps.num;
3045
        video_enc->time_base.num = fps.den;
3046
        if(codec && codec->supported_framerates){
3047
            const AVRational *p= codec->supported_framerates;
3048
            const AVRational *best=NULL;
3049
            AVRational best_error= (AVRational){INT_MAX, 1};
3050
            for(; p->den!=0; p++){
3051
                AVRational error= av_sub_q(fps, *p);
3052
                if(error.num <0) error.num *= -1;
3053
                if(av_cmp_q(error, best_error) < 0){
3054
                    best_error= error;
3055
                    best= p;
3056
                }
3057
            }
3058
            video_enc->time_base.den= best->num;
3059
            video_enc->time_base.num= best->den;
3060
        }
3061

    
3062
        video_enc->width = frame_width + frame_padright + frame_padleft;
3063
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3064
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3065
        video_enc->pix_fmt = frame_pix_fmt;
3066
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3067

    
3068
        if(codec && codec->pix_fmts){
3069
            const enum PixelFormat *p= codec->pix_fmts;
3070
            for(; *p!=-1; p++){
3071
                if(*p == video_enc->pix_fmt)
3072
                    break;
3073
            }
3074
            if(*p == -1)
3075
                video_enc->pix_fmt = codec->pix_fmts[0];
3076
        }
3077

    
3078
        if (intra_only)
3079
            video_enc->gop_size = 0;
3080
        if (video_qscale || same_quality) {
3081
            video_enc->flags |= CODEC_FLAG_QSCALE;
3082
            video_enc->global_quality=
3083
                st->quality = FF_QP2LAMBDA * video_qscale;
3084
        }
3085

    
3086
        if(intra_matrix)
3087
            video_enc->intra_matrix = intra_matrix;
3088
        if(inter_matrix)
3089
            video_enc->inter_matrix = inter_matrix;
3090

    
3091
        video_enc->thread_count = thread_count;
3092
        p= video_rc_override_string;
3093
        for(i=0; p; i++){
3094
            int start, end, q;
3095
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3096
            if(e!=3){
3097
                fprintf(stderr, "error parsing rc_override\n");
3098
                av_exit(1);
3099
            }
3100
            video_enc->rc_override=
3101
                av_realloc(video_enc->rc_override,
3102
                           sizeof(RcOverride)*(i+1));
3103
            video_enc->rc_override[i].start_frame= start;
3104
            video_enc->rc_override[i].end_frame  = end;
3105
            if(q>0){
3106
                video_enc->rc_override[i].qscale= q;
3107
                video_enc->rc_override[i].quality_factor= 1.0;
3108
            }
3109
            else{
3110
                video_enc->rc_override[i].qscale= 0;
3111
                video_enc->rc_override[i].quality_factor= -q/100.0;
3112
            }
3113
            p= strchr(p, '/');
3114
            if(p) p++;
3115
        }
3116
        video_enc->rc_override_count=i;
3117
        if (!video_enc->rc_initial_buffer_occupancy)
3118
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3119
        video_enc->me_threshold= me_threshold;
3120
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3121

    
3122
        if (do_psnr)
3123
            video_enc->flags|= CODEC_FLAG_PSNR;
3124

    
3125
        /* two pass mode */
3126
        if (do_pass) {
3127
            if (do_pass == 1) {
3128
                video_enc->flags |= CODEC_FLAG_PASS1;
3129
            } else {
3130
                video_enc->flags |= CODEC_FLAG_PASS2;
3131
            }
3132
        }
3133
    }
3134

    
3135
    /* reset some key parameters */
3136
    video_disable = 0;
3137
    av_freep(&video_codec_name);
3138
    video_stream_copy = 0;
3139
}
3140

    
3141
static void new_audio_stream(AVFormatContext *oc)
3142
{
3143
    AVStream *st;
3144
    AVCodecContext *audio_enc;
3145
    int codec_id;
3146

    
3147
    st = av_new_stream(oc, oc->nb_streams);
3148
    if (!st) {
3149
        fprintf(stderr, "Could not alloc stream\n");
3150
        av_exit(1);
3151
    }
3152
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3153

    
3154
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3155
    audio_bitstream_filters= NULL;
3156

    
3157
    if(thread_count>1)
3158
        avcodec_thread_init(st->codec, thread_count);
3159

    
3160
    audio_enc = st->codec;
3161
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3162

    
3163
    if(audio_codec_tag)
3164
        audio_enc->codec_tag= audio_codec_tag;
3165

    
3166
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3167
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3168
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3169
    }
3170
    if (audio_stream_copy) {
3171
        st->stream_copy = 1;
3172
        audio_enc->channels = audio_channels;
3173
    } else {
3174
        AVCodec *codec;
3175
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3176

    
3177
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3178

    
3179
        if (audio_codec_name)
3180
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3181
        audio_enc->codec_id = codec_id;
3182
        codec = avcodec_find_encoder(codec_id);
3183

    
3184
        if (audio_qscale > QSCALE_NONE) {
3185
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3186
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3187
        }
3188
        audio_enc->thread_count = thread_count;
3189
        audio_enc->channels = audio_channels;
3190
        audio_enc->sample_fmt = audio_sample_fmt;
3191

    
3192
        if(codec && codec->sample_fmts){
3193
            const enum SampleFormat *p= codec->sample_fmts;
3194
            for(; *p!=-1; p++){
3195
                if(*p == audio_enc->sample_fmt)
3196
                    break;
3197
            }
3198
            if(*p == -1)
3199
                audio_enc->sample_fmt = codec->sample_fmts[0];
3200
        }
3201
    }
3202
    audio_enc->sample_rate = audio_sample_rate;
3203
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3204
    if (audio_language) {
3205
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3206
        av_free(audio_language);
3207
        audio_language = NULL;
3208
    }
3209

    
3210
    /* reset some key parameters */
3211
    audio_disable = 0;
3212
    av_freep(&audio_codec_name);
3213
    audio_stream_copy = 0;
3214
}
3215

    
3216
static void new_subtitle_stream(AVFormatContext *oc)
3217
{
3218
    AVStream *st;
3219
    AVCodecContext *subtitle_enc;
3220

    
3221
    st = av_new_stream(oc, oc->nb_streams);
3222
    if (!st) {
3223
        fprintf(stderr, "Could not alloc stream\n");
3224
        av_exit(1);
3225
    }
3226
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3227

    
3228
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3229
    subtitle_bitstream_filters= NULL;
3230

    
3231
    subtitle_enc = st->codec;
3232
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3233
    if (subtitle_stream_copy) {
3234
        st->stream_copy = 1;
3235
    } else {
3236
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3237
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3238
    }
3239

    
3240
    if (subtitle_language) {
3241
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3242
        av_free(subtitle_language);
3243
        subtitle_language = NULL;
3244
    }
3245

    
3246
    subtitle_disable = 0;
3247
    av_freep(&subtitle_codec_name);
3248
    subtitle_stream_copy = 0;
3249
}
3250

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

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

    
3273
static void opt_new_subtitle_stream(void)
3274
{
3275
    AVFormatContext *oc;
3276
    if (nb_output_files <= 0) {
3277
        fprintf(stderr, "At least one output file must be specified\n");
3278
        av_exit(1);
3279
    }
3280
    oc = output_files[nb_output_files - 1];
3281
    new_subtitle_stream(oc);
3282
}
3283

    
3284
static void opt_output_file(const char *filename)
3285
{
3286
    AVFormatContext *oc;
3287
    int use_video, use_audio, use_subtitle;
3288
    int input_has_video, input_has_audio, input_has_subtitle;
3289
    AVFormatParameters params, *ap = &params;
3290

    
3291
    if (!strcmp(filename, "-"))
3292
        filename = "pipe:";
3293

    
3294
    oc = av_alloc_format_context();
3295

    
3296
    if (!file_oformat) {
3297
        file_oformat = guess_format(NULL, filename, NULL);
3298
        if (!file_oformat) {
3299
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3300
                    filename);
3301
            av_exit(1);
3302
        }
3303
    }
3304

    
3305
    oc->oformat = file_oformat;
3306
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3307

    
3308
    if (!strcmp(file_oformat->name, "ffm") &&
3309
        av_strstart(filename, "http:", NULL)) {
3310
        /* special case for files sent to ffserver: we get the stream
3311
           parameters from ffserver */
3312
        int err = read_ffserver_streams(oc, filename);
3313
        if (err < 0) {
3314
            print_error(filename, err);
3315
            av_exit(1);
3316
        }
3317
    } else {
3318
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3319
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3320
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3321

    
3322
        /* disable if no corresponding type found and at least one
3323
           input file */
3324
        if (nb_input_files > 0) {
3325
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3326
                                         &input_has_subtitle);
3327
            if (!input_has_video)
3328
                use_video = 0;
3329
            if (!input_has_audio)
3330
                use_audio = 0;
3331
            if (!input_has_subtitle)
3332
                use_subtitle = 0;
3333
        }
3334

    
3335
        /* manual disable */
3336
        if (audio_disable) {
3337
            use_audio = 0;
3338
        }
3339
        if (video_disable) {
3340
            use_video = 0;
3341
        }
3342
        if (subtitle_disable) {
3343
            use_subtitle = 0;
3344
        }
3345

    
3346
        if (use_video) {
3347
            new_video_stream(oc);
3348
        }
3349

    
3350
        if (use_audio) {
3351
            new_audio_stream(oc);
3352
        }
3353

    
3354
        if (use_subtitle) {
3355
            new_subtitle_stream(oc);
3356
        }
3357

    
3358
        oc->timestamp = rec_timestamp;
3359

    
3360
        if (str_title)
3361
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3362
        if (str_author)
3363
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3364
        if (str_copyright)
3365
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3366
        if (str_comment)
3367
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3368
        if (str_album)
3369
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3370
        if (str_genre)
3371
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3372
    }
3373

    
3374
    output_files[nb_output_files++] = oc;
3375

    
3376
    /* check filename in case of an image number is expected */
3377
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3378
        if (!av_filename_number_test(oc->filename)) {
3379
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3380
            av_exit(1);
3381
        }
3382
    }
3383

    
3384
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3385
        /* test if it already exists to avoid loosing precious files */
3386
        if (!file_overwrite &&
3387
            (strchr(filename, ':') == NULL ||
3388
             filename[1] == ':' ||
3389
             av_strstart(filename, "file:", NULL))) {
3390
            if (url_exist(filename)) {
3391
                int c;
3392

    
3393
                if (!using_stdin) {
3394
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3395
                    fflush(stderr);
3396
                    c = getchar();
3397
                    if (toupper(c) != 'Y') {
3398
                        fprintf(stderr, "Not overwriting - exiting\n");
3399
                        av_exit(1);
3400
                    }
3401
                }
3402
                else {
3403
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3404
                    av_exit(1);
3405
                }
3406
            }
3407
        }
3408

    
3409
        /* open the file */
3410
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3411
            fprintf(stderr, "Could not open '%s'\n", filename);
3412
            av_exit(1);
3413
        }
3414
    }
3415

    
3416
    memset(ap, 0, sizeof(*ap));
3417
    if (av_set_parameters(oc, ap) < 0) {
3418
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3419
                oc->filename);
3420
        av_exit(1);
3421
    }
3422

    
3423
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3424
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3425
    oc->loop_output = loop_output;
3426

    
3427
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3428

    
3429
    /* reset some options */
3430
    file_oformat = NULL;
3431
    file_iformat = NULL;
3432
}
3433

    
3434
/* same option as mencoder */
3435
static void opt_pass(const char *pass_str)
3436
{
3437
    int pass;
3438
    pass = atoi(pass_str);
3439
    if (pass != 1 && pass != 2) {
3440
        fprintf(stderr, "pass number can be only 1 or 2\n");
3441
        av_exit(1);
3442
    }
3443
    do_pass = pass;
3444
}
3445

    
3446
static int64_t getutime(void)
3447
{
3448
#ifdef HAVE_GETRUSAGE
3449
    struct rusage rusage;
3450

    
3451
    getrusage(RUSAGE_SELF, &rusage);
3452
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3453
#elif defined(HAVE_GETPROCESSTIMES)
3454
    HANDLE proc;
3455
    FILETIME c, e, k, u;
3456
    proc = GetCurrentProcess();
3457
    GetProcessTimes(proc, &c, &e, &k, &u);
3458
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3459
#else
3460
    return av_gettime();
3461
#endif
3462
}
3463

    
3464
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3465
{
3466
    int i;
3467
    const char *p = str;
3468
    for(i = 0;; i++) {
3469
        dest[i] = atoi(p);
3470
        if(i == 63)
3471
            break;
3472
        p = strchr(p, ',');
3473
        if(!p) {
3474
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3475
            av_exit(1);
3476
        }
3477
        p++;
3478
    }
3479
}
3480

    
3481
static void opt_inter_matrix(const char *arg)
3482
{
3483
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3484
    parse_matrix_coeffs(inter_matrix, arg);
3485
}
3486

    
3487
static void opt_intra_matrix(const char *arg)
3488
{
3489
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3490
    parse_matrix_coeffs(intra_matrix, arg);
3491
}
3492

    
3493
/**
3494
 * Trivial log callback.
3495
 * Only suitable for show_help and similar since it lacks prefix handling.
3496
 */
3497
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3498
{
3499
    vfprintf(stdout, fmt, vl);
3500
}
3501

    
3502
static void show_help(void)
3503
{
3504
    av_log_set_callback(log_callback_help);
3505
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3506
           "Hyper fast Audio and Video encoder\n");
3507
    printf("\n");
3508
    show_help_options(options, "Main options:\n",
3509
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3510
    show_help_options(options, "\nAdvanced options:\n",
3511
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3512
                      OPT_EXPERT);
3513
    show_help_options(options, "\nVideo options:\n",
3514
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3515
                      OPT_VIDEO);
3516
    show_help_options(options, "\nAdvanced Video options:\n",
3517
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3518
                      OPT_VIDEO | OPT_EXPERT);
3519
    show_help_options(options, "\nAudio options:\n",
3520
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3521
                      OPT_AUDIO);
3522
    show_help_options(options, "\nAdvanced Audio options:\n",
3523
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3524
                      OPT_AUDIO | OPT_EXPERT);
3525
    show_help_options(options, "\nSubtitle options:\n",
3526
                      OPT_SUBTITLE | OPT_GRAB,
3527
                      OPT_SUBTITLE);
3528
    show_help_options(options, "\nAudio/Video grab options:\n",
3529
                      OPT_GRAB,
3530
                      OPT_GRAB);
3531
    printf("\n");
3532
    av_opt_show(avctx_opts[0], NULL);
3533
    printf("\n");
3534
    av_opt_show(avformat_opts, NULL);
3535
    printf("\n");
3536
    av_opt_show(sws_opts, NULL);
3537
}
3538

    
3539
static void opt_target(const char *arg)
3540
{
3541
    int norm = -1;
3542
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3543

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

    
3588
    if(norm < 0) {
3589
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3590
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3591
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3592
        av_exit(1);
3593
    }
3594

    
3595
    if(!strcmp(arg, "vcd")) {
3596

    
3597
        opt_video_codec("mpeg1video");
3598
        opt_audio_codec("mp2");
3599
        opt_format("vcd");
3600

    
3601
        opt_frame_size(norm ? "352x240" : "352x288");
3602
        opt_frame_rate(NULL, frame_rates[norm]);
3603
        opt_default("gop", norm ? "18" : "15");
3604

    
3605
        opt_default("b", "1150000");
3606
        opt_default("maxrate", "1150000");
3607
        opt_default("minrate", "1150000");
3608
        opt_default("bufsize", "327680"); // 40*1024*8;
3609

    
3610
        opt_default("ab", "224000");
3611
        audio_sample_rate = 44100;
3612
        audio_channels = 2;
3613

    
3614
        opt_default("packetsize", "2324");
3615
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3616

    
3617
        /* We have to offset the PTS, so that it is consistent with the SCR.
3618
           SCR starts at 36000, but the first two packs contain only padding
3619
           and the first pack from the other stream, respectively, may also have
3620
           been written before.
3621
           So the real data starts at SCR 36000+3*1200. */
3622
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3623
    } else if(!strcmp(arg, "svcd")) {
3624

    
3625
        opt_video_codec("mpeg2video");
3626
        opt_audio_codec("mp2");
3627
        opt_format("svcd");
3628

    
3629
        opt_frame_size(norm ? "480x480" : "480x576");
3630
        opt_frame_rate(NULL, frame_rates[norm]);
3631
        opt_default("gop", norm ? "18" : "15");
3632

    
3633
        opt_default("b", "2040000");
3634
        opt_default("maxrate", "2516000");
3635
        opt_default("minrate", "0"); //1145000;
3636
        opt_default("bufsize", "1835008"); //224*1024*8;
3637
        opt_default("flags", "+scan_offset");
3638

    
3639

    
3640
        opt_default("ab", "224000");
3641
        audio_sample_rate = 44100;
3642

    
3643
        opt_default("packetsize", "2324");
3644

    
3645
    } else if(!strcmp(arg, "dvd")) {
3646

    
3647
        opt_video_codec("mpeg2video");
3648
        opt_audio_codec("ac3");
3649
        opt_format("dvd");
3650

    
3651
        opt_frame_size(norm ? "720x480" : "720x576");
3652
        opt_frame_rate(NULL, frame_rates[norm]);
3653
        opt_default("gop", norm ? "18" : "15");
3654

    
3655
        opt_default("b", "6000000");
3656
        opt_default("maxrate", "9000000");
3657
        opt_default("minrate", "0"); //1500000;
3658
        opt_default("bufsize", "1835008"); //224*1024*8;
3659

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

    
3663
        opt_default("ab", "448000");
3664
        audio_sample_rate = 48000;
3665

    
3666
    } else if(!strncmp(arg, "dv", 2)) {
3667

    
3668
        opt_format("dv");
3669

    
3670
        opt_frame_size(norm ? "720x480" : "720x576");
3671
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3672
                                             (norm ? "yuv411p" : "yuv420p"));
3673
        opt_frame_rate(NULL, frame_rates[norm]);
3674

    
3675
        audio_sample_rate = 48000;
3676
        audio_channels = 2;
3677

    
3678
    } else {
3679
        fprintf(stderr, "Unknown target: %s\n", arg);
3680
        av_exit(1);
3681
    }
3682
}
3683

    
3684
static void opt_vstats_file (const char *arg)
3685
{
3686
    av_free (vstats_filename);
3687
    vstats_filename=av_strdup (arg);
3688
}
3689

    
3690
static void opt_vstats (void)
3691
{
3692
    char filename[40];
3693
    time_t today2 = time(NULL);
3694
    struct tm *today = localtime(&today2);
3695

    
3696
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3697
             today->tm_sec);
3698
    opt_vstats_file(filename);
3699
}
3700

    
3701
static int opt_bsf(const char *opt, const char *arg)
3702
{
3703
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3704
    AVBitStreamFilterContext **bsfp;
3705

    
3706
    if(!bsfc){
3707
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3708
        av_exit(1);
3709
    }
3710

    
3711
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3712
          *opt == 'a' ? &audio_bitstream_filters :
3713
                        &subtitle_bitstream_filters;
3714
    while(*bsfp)
3715
        bsfp= &(*bsfp)->next;
3716

    
3717
    *bsfp= bsfc;
3718

    
3719
    return 0;
3720
}
3721

    
3722
static int opt_preset(const char *opt, const char *arg)
3723
{
3724
    FILE *f=NULL;
3725
    char tmp[1000], tmp2[1000], line[1000];
3726
    int i;
3727
    const char *base[3]= { getenv("HOME"),
3728
                           "/usr/local/share",
3729
                           "/usr/share",
3730
                         };
3731

    
3732
    for(i=!base[0]; i<3 && !f; i++){
3733
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3734
        f= fopen(tmp, "r");
3735
        if(!f){
3736
            char *codec_name= *opt == 'v' ? video_codec_name :
3737
                              *opt == 'a' ? audio_codec_name :
3738
                                            subtitle_codec_name;
3739
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3740
            f= fopen(tmp, "r");
3741
        }
3742
    }
3743
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/')){
3744
        f= fopen(arg, "r");
3745
    }
3746

    
3747
    if(!f){
3748
        fprintf(stderr, "Preset file not found\n");
3749
        av_exit(1);
3750
    }
3751

    
3752
    while(!feof(f)){
3753
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3754
        if(line[0] == '#' && !e)
3755
            continue;
3756
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3757
        if(e){
3758
            fprintf(stderr, "Preset file invalid\n");
3759
            av_exit(1);
3760
        }
3761
        if(!strcmp(tmp, "acodec")){
3762
            opt_audio_codec(tmp2);
3763
        }else if(!strcmp(tmp, "vcodec")){
3764
            opt_video_codec(tmp2);
3765
        }else if(!strcmp(tmp, "scodec")){
3766
            opt_subtitle_codec(tmp2);
3767
        }else
3768
            opt_default(tmp, tmp2);
3769
    }
3770

    
3771
    fclose(f);
3772

    
3773
    return 0;
3774
}
3775

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

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

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

    
3880
    /* subtitle options */
3881
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3882
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3883
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3884
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3885

    
3886
    /* grab options */
3887
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3888
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3889
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3890

    
3891
    /* muxer options */
3892
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3893
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3894

    
3895
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3896
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3897
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3898

    
3899
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3900
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3901
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3902

    
3903
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3904
    { NULL, },
3905
};
3906

    
3907
int main(int argc, char **argv)
3908
{
3909
    int i;
3910
    int64_t ti;
3911

    
3912
    avcodec_register_all();
3913
    avdevice_register_all();
3914
    av_register_all();
3915

    
3916
    if(isatty(STDIN_FILENO))
3917
        url_set_interrupt_cb(decode_interrupt_cb);
3918

    
3919
    for(i=0; i<CODEC_TYPE_NB; i++){
3920
        avctx_opts[i]= avcodec_alloc_context2(i);
3921
    }
3922
    avformat_opts = av_alloc_format_context();
3923
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3924

    
3925
    show_banner();
3926
    if (argc <= 1) {
3927
        show_help();
3928
        av_exit(1);
3929
    }
3930

    
3931
    /* parse options */
3932
    parse_options(argc, argv, options, opt_output_file);
3933

    
3934
    /* file converter / grab */
3935
    if (nb_output_files <= 0) {
3936
        fprintf(stderr, "Must supply at least one output file\n");
3937
        av_exit(1);
3938
    }
3939

    
3940
    if (nb_input_files == 0) {
3941
        fprintf(stderr, "Must supply at least one input file\n");
3942
        av_exit(1);
3943
    }
3944

    
3945
    ti = getutime();
3946
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3947
              stream_maps, nb_stream_maps);
3948
    ti = getutime() - ti;
3949
    if (do_benchmark) {
3950
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3951
    }
3952

    
3953
    return av_exit(0);
3954
}