Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 470bce2b

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 600
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
#ifdef 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 AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
98
static int nb_input_files = 0;
99
static int nb_icodecs;
100

    
101
static AVFormatContext *output_files[MAX_FILES];
102
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
103
static int nb_output_files = 0;
104
static int nb_ocodecs;
105

    
106
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
107
static int nb_stream_maps;
108

    
109
static AVMetaDataMap meta_data_maps[MAX_FILES];
110
static int nb_meta_data_maps;
111

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

    
152
static int intra_only = 0;
153
static int audio_sample_rate = 44100;
154
static int64_t channel_layout = 0;
155
#define QSCALE_NONE -99999
156
static float audio_qscale = QSCALE_NONE;
157
static int audio_disable = 0;
158
static int audio_channels = 1;
159
static char  *audio_codec_name = NULL;
160
static int audio_codec_tag = 0;
161
static char *audio_language = NULL;
162

    
163
static int subtitle_disable = 0;
164
static char *subtitle_codec_name = NULL;
165
static char *subtitle_language = NULL;
166

    
167
static float mux_preload= 0.5;
168
static float mux_max_delay= 0.7;
169

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

    
201
static int rate_emu = 0;
202

    
203
static int  video_channel = 0;
204
static char *video_standard;
205

    
206
static int audio_volume = 256;
207

    
208
static int exit_on_error = 0;
209
static int using_stdin = 0;
210
static int using_vhook = 0;
211
static int verbose = 1;
212
static int thread_count= 1;
213
static int q_pressed = 0;
214
static int64_t video_size = 0;
215
static int64_t audio_size = 0;
216
static int64_t extra_size = 0;
217
static int nb_frames_dup = 0;
218
static int nb_frames_drop = 0;
219
static int input_sync;
220
static uint64_t limit_filesize = 0;
221
static int force_fps = 0;
222

    
223
static int pgmyuv_compatibility_hack=0;
224
static float dts_delta_threshold = 10;
225

    
226
static unsigned int sws_flags = SWS_BICUBIC;
227

    
228
static int64_t timer_start;
229

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

    
235
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
236

    
237
struct AVInputStream;
238

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

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

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

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

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

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

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

    
298
#ifdef HAVE_TERMIOS_H
299

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

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

    
311
static volatile sig_atomic_t received_sigterm = 0;
312

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

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

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

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

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

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

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

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

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

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

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

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

    
415
    av_free(intra_matrix);
416
    av_free(inter_matrix);
417

    
418
    if (vstats_file)
419
        fclose(vstats_file);
420
    av_free(vstats_filename);
421

    
422
    av_free(opt_names);
423

    
424
    av_free(video_codec_name);
425
    av_free(audio_codec_name);
426
    av_free(subtitle_codec_name);
427

    
428
    av_free(video_standard);
429

    
430
#ifdef CONFIG_POWERPC_PERF
431
    void powerpc_display_perf_report(void);
432
    powerpc_display_perf_report();
433
#endif /* CONFIG_POWERPC_PERF */
434

    
435
    if (received_sigterm) {
436
        fprintf(stderr,
437
            "Received signal %d: terminating.\n",
438
            (int) received_sigterm);
439
        exit (255);
440
    }
441

    
442
    exit(ret); /* not all OS-es handle main() return value */
443
    return ret;
444
}
445

    
446
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
447
{
448
    int i, err;
449
    AVFormatContext *ic;
450
    int nopts = 0;
451

    
452
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
453
    if (err < 0)
454
        return err;
455
    /* copy stream format */
456
    s->nb_streams = ic->nb_streams;
457
    for(i=0;i<ic->nb_streams;i++) {
458
        AVStream *st;
459

    
460
        // FIXME: a more elegant solution is needed
461
        st = av_mallocz(sizeof(AVStream));
462
        memcpy(st, ic->streams[i], sizeof(AVStream));
463
        st->codec = avcodec_alloc_context();
464
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
465
        s->streams[i] = st;
466

    
467
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
468
            st->stream_copy = 1;
469
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
470
            st->stream_copy = 1;
471

    
472
        if(!st->codec->thread_count)
473
            st->codec->thread_count = 1;
474
        if(st->codec->thread_count>1)
475
            avcodec_thread_init(st->codec, st->codec->thread_count);
476

    
477
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
478
            nopts = 1;
479
    }
480

    
481
    if (!nopts)
482
        s->timestamp = av_gettime();
483

    
484
    av_close_input_file(ic);
485
    return 0;
486
}
487

    
488
static double
489
get_sync_ipts(const AVOutputStream *ost)
490
{
491
    const AVInputStream *ist = ost->sync_ist;
492
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
493
}
494

    
495
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
496
    int ret;
497

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

    
517
        bsfc= bsfc->next;
518
    }
519

    
520
    ret= av_interleaved_write_frame(s, pkt);
521
    if(ret < 0){
522
        print_error("av_interleaved_write_frame()", ret);
523
        av_exit(1);
524
    }
525
}
526

    
527
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
528

    
529
static void do_audio_out(AVFormatContext *s,
530
                         AVOutputStream *ost,
531
                         AVInputStream *ist,
532
                         unsigned char *buf, int size)
533
{
534
    uint8_t *buftmp;
535
    static uint8_t *audio_buf = NULL;
536
    static uint8_t *audio_out = NULL;
537
    static uint8_t *audio_out2 = NULL;
538
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
539

    
540
    int size_out, frame_bytes, ret;
541
    AVCodecContext *enc= ost->st->codec;
542
    AVCodecContext *dec= ist->st->codec;
543
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
544
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
545

    
546
    /* SC: dynamic allocation of buffers */
547
    if (!audio_buf)
548
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
549
    if (!audio_out)
550
        audio_out = av_malloc(audio_out_size);
551
    if (!audio_buf || !audio_out)
552
        return;               /* Should signal an error ! */
553

    
554
    if (enc->channels != dec->channels)
555
        ost->audio_resample = 1;
556

    
557
    if (ost->audio_resample && !ost->resample) {
558
        if (dec->sample_fmt != SAMPLE_FMT_S16) {
559
            fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
560
            av_exit(1);
561
        }
562
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
563
                                            enc->sample_rate, dec->sample_rate);
564
        if (!ost->resample) {
565
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
566
                    dec->channels, dec->sample_rate,
567
                    enc->channels, enc->sample_rate);
568
            av_exit(1);
569
        }
570
    }
571

    
572
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
573
    if (dec->sample_fmt!=enc->sample_fmt &&
574
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
575
        if (!audio_out2)
576
            audio_out2 = av_malloc(audio_out_size);
577
        if (!audio_out2)
578
            av_exit(1);
579
        if (ost->reformat_ctx)
580
            av_audio_convert_free(ost->reformat_ctx);
581
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
582
                                                   dec->sample_fmt, 1, NULL, 0);
583
        if (!ost->reformat_ctx) {
584
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
585
                avcodec_get_sample_fmt_name(dec->sample_fmt),
586
                avcodec_get_sample_fmt_name(enc->sample_fmt));
587
            av_exit(1);
588
        }
589
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
590
    }
591

    
592
    if(audio_sync_method){
593
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
594
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
595
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
596
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
597

    
598
        //FIXME resample delay
599
        if(fabs(delta) > 50){
600
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
601
                if(byte_delta < 0){
602
                    byte_delta= FFMAX(byte_delta, -size);
603
                    size += byte_delta;
604
                    buf  -= byte_delta;
605
                    if(verbose > 2)
606
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
607
                    if(!size)
608
                        return;
609
                    ist->is_start=0;
610
                }else{
611
                    static uint8_t *input_tmp= NULL;
612
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
613

    
614
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
615
                        ist->is_start=0;
616
                    else
617
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
618

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

    
639
    if (ost->audio_resample) {
640
        buftmp = audio_buf;
641
        size_out = audio_resample(ost->resample,
642
                                  (short *)buftmp, (short *)buf,
643
                                  size / (ist->st->codec->channels * isize));
644
        size_out = size_out * enc->channels * osize;
645
    } else {
646
        buftmp = buf;
647
        size_out = size;
648
    }
649

    
650
    if (dec->sample_fmt!=enc->sample_fmt) {
651
        const void *ibuf[6]= {buftmp};
652
        void *obuf[6]= {audio_out2};
653
        int istride[6]= {isize};
654
        int ostride[6]= {osize};
655
        int len= size_out/istride[0];
656
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
657
            printf("av_audio_convert() failed\n");
658
            if (exit_on_error)
659
                av_exit(1);
660
            return;
661
        }
662
        buftmp = audio_out2;
663
        size_out = len*osize;
664
    }
665

    
666
    /* now encode as many frames as possible */
667
    if (enc->frame_size > 1) {
668
        /* output resampled raw samples */
669
        if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
670
            fprintf(stderr, "av_fifo_realloc2() failed\n");
671
            av_exit(1);
672
        }
673
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
674

    
675
        frame_bytes = enc->frame_size * osize * enc->channels;
676

    
677
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
678
            AVPacket pkt;
679
            av_init_packet(&pkt);
680

    
681
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
682

    
683
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
684

    
685
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
686
                                       (short *)audio_buf);
687
            if (ret < 0) {
688
                fprintf(stderr, "Audio encoding failed\n");
689
                av_exit(1);
690
            }
691
            audio_size += ret;
692
            pkt.stream_index= ost->index;
693
            pkt.data= audio_out;
694
            pkt.size= ret;
695
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
696
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
697
            pkt.flags |= PKT_FLAG_KEY;
698
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
699

    
700
            ost->sync_opts += enc->frame_size;
701
        }
702
    } else {
703
        AVPacket pkt;
704
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
705
        av_init_packet(&pkt);
706

    
707
        ost->sync_opts += size_out / (osize * enc->channels);
708

    
709
        /* output a pcm frame */
710
        /* determine the size of the coded buffer */
711
        size_out /= osize;
712
        if (coded_bps)
713
            size_out *= coded_bps;
714

    
715
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
716
        ret = avcodec_encode_audio(enc, audio_out, size_out,
717
                                   (short *)buftmp);
718
        if (ret < 0) {
719
            fprintf(stderr, "Audio encoding failed\n");
720
            av_exit(1);
721
        }
722
        audio_size += ret;
723
        pkt.stream_index= ost->index;
724
        pkt.data= audio_out;
725
        pkt.size= ret;
726
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
727
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
728
        pkt.flags |= PKT_FLAG_KEY;
729
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
730
    }
731
}
732

    
733
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
734
{
735
    AVCodecContext *dec;
736
    AVPicture *picture2;
737
    AVPicture picture_tmp;
738
    uint8_t *buf = 0;
739

    
740
    dec = ist->st->codec;
741

    
742
    /* deinterlace : must be done before any resize */
743
    if (do_deinterlace || using_vhook) {
744
        int size;
745

    
746
        /* create temporary picture */
747
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
748
        buf = av_malloc(size);
749
        if (!buf)
750
            return;
751

    
752
        picture2 = &picture_tmp;
753
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
754

    
755
        if (do_deinterlace){
756
            if(avpicture_deinterlace(picture2, picture,
757
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
758
                /* if error, do not deinterlace */
759
                fprintf(stderr, "Deinterlacing failed\n");
760
                av_free(buf);
761
                buf = NULL;
762
                picture2 = picture;
763
            }
764
        } else {
765
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
766
        }
767
    } else {
768
        picture2 = picture;
769
    }
770

    
771
    if (ENABLE_VHOOK)
772
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
773
                           1000000 * ist->pts / AV_TIME_BASE);
774

    
775
    if (picture != picture2)
776
        *picture = *picture2;
777
    *bufp = buf;
778
}
779

    
780
/* we begin to correct av delay at this threshold */
781
#define AV_DELAY_MAX 0.100
782

    
783
static void do_subtitle_out(AVFormatContext *s,
784
                            AVOutputStream *ost,
785
                            AVInputStream *ist,
786
                            AVSubtitle *sub,
787
                            int64_t pts)
788
{
789
    static uint8_t *subtitle_out = NULL;
790
    int subtitle_out_max_size = 65536;
791
    int subtitle_out_size, nb, i;
792
    AVCodecContext *enc;
793
    AVPacket pkt;
794

    
795
    if (pts == AV_NOPTS_VALUE) {
796
        fprintf(stderr, "Subtitle packets must have a pts\n");
797
        if (exit_on_error)
798
            av_exit(1);
799
        return;
800
    }
801

    
802
    enc = ost->st->codec;
803

    
804
    if (!subtitle_out) {
805
        subtitle_out = av_malloc(subtitle_out_max_size);
806
    }
807

    
808
    /* Note: DVB subtitle need one packet to draw them and one other
809
       packet to clear them */
810
    /* XXX: signal it in the codec context ? */
811
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
812
        nb = 2;
813
    else
814
        nb = 1;
815

    
816
    for(i = 0; i < nb; i++) {
817
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
818
                                                    subtitle_out_max_size, sub);
819

    
820
        av_init_packet(&pkt);
821
        pkt.stream_index = ost->index;
822
        pkt.data = subtitle_out;
823
        pkt.size = subtitle_out_size;
824
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
825
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
826
            /* XXX: the pts correction is handled here. Maybe handling
827
               it in the codec would be better */
828
            if (i == 0)
829
                pkt.pts += 90 * sub->start_display_time;
830
            else
831
                pkt.pts += 90 * sub->end_display_time;
832
        }
833
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
834
    }
835
}
836

    
837
static int bit_buffer_size= 1024*256;
838
static uint8_t *bit_buffer= NULL;
839

    
840
static void do_video_out(AVFormatContext *s,
841
                         AVOutputStream *ost,
842
                         AVInputStream *ist,
843
                         AVFrame *in_picture,
844
                         int *frame_size)
845
{
846
    int nb_frames, i, ret;
847
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
848
    AVFrame picture_crop_temp, picture_pad_temp;
849
    AVCodecContext *enc, *dec;
850

    
851
    avcodec_get_frame_defaults(&picture_crop_temp);
852
    avcodec_get_frame_defaults(&picture_pad_temp);
853

    
854
    enc = ost->st->codec;
855
    dec = ist->st->codec;
856

    
857
    /* by default, we output a single frame */
858
    nb_frames = 1;
859

    
860
    *frame_size = 0;
861

    
862
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
863
        double vdelta;
864
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
865
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
866
        if (vdelta < -1.1)
867
            nb_frames = 0;
868
        else if (video_sync_method == 2)
869
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
870
        else if (vdelta > 1.1)
871
            nb_frames = lrintf(vdelta);
872
//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);
873
        if (nb_frames == 0){
874
            ++nb_frames_drop;
875
            if (verbose>2)
876
                fprintf(stderr, "*** drop!\n");
877
        }else if (nb_frames > 1) {
878
            nb_frames_dup += nb_frames;
879
            if (verbose>2)
880
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
881
        }
882
    }else
883
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
884

    
885
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
886
    if (nb_frames <= 0)
887
        return;
888

    
889
    if (ost->video_crop) {
890
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
891
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
892
            if (exit_on_error)
893
                av_exit(1);
894
            return;
895
        }
896
        formatted_picture = &picture_crop_temp;
897
    } else {
898
        formatted_picture = in_picture;
899
    }
900

    
901
    final_picture = formatted_picture;
902
    padding_src = formatted_picture;
903
    resampling_dst = &ost->pict_tmp;
904
    if (ost->video_pad) {
905
        final_picture = &ost->pict_tmp;
906
        if (ost->video_resample) {
907
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
908
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
909
                if (exit_on_error)
910
                    av_exit(1);
911
                return;
912
            }
913
            resampling_dst = &picture_pad_temp;
914
        }
915
    }
916

    
917
    if (ost->video_resample) {
918
        padding_src = NULL;
919
        final_picture = &ost->pict_tmp;
920
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
921
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
922
    }
923

    
924
    if (ost->video_pad) {
925
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
926
                enc->height, enc->width, enc->pix_fmt,
927
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
928
    }
929

    
930
    /* duplicates frame if needed */
931
    for(i=0;i<nb_frames;i++) {
932
        AVPacket pkt;
933
        av_init_packet(&pkt);
934
        pkt.stream_index= ost->index;
935

    
936
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
937
            /* raw pictures are written as AVPicture structure to
938
               avoid any copies. We support temorarily the older
939
               method. */
940
            AVFrame* old_frame = enc->coded_frame;
941
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
942
            pkt.data= (uint8_t *)final_picture;
943
            pkt.size=  sizeof(AVPicture);
944
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
945
            pkt.flags |= PKT_FLAG_KEY;
946

    
947
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
948
            enc->coded_frame = old_frame;
949
        } else {
950
            AVFrame big_picture;
951

    
952
            big_picture= *final_picture;
953
            /* better than nothing: use input picture interlaced
954
               settings */
955
            big_picture.interlaced_frame = in_picture->interlaced_frame;
956
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
957
                if(top_field_first == -1)
958
                    big_picture.top_field_first = in_picture->top_field_first;
959
                else
960
                    big_picture.top_field_first = top_field_first;
961
            }
962

    
963
            /* handles sameq here. This is not correct because it may
964
               not be a global option */
965
            if (same_quality) {
966
                big_picture.quality = ist->st->quality;
967
            }else
968
                big_picture.quality = ost->st->quality;
969
            if(!me_threshold)
970
                big_picture.pict_type = 0;
971
//            big_picture.pts = AV_NOPTS_VALUE;
972
            big_picture.pts= ost->sync_opts;
973
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
974
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
975
            ret = avcodec_encode_video(enc,
976
                                       bit_buffer, bit_buffer_size,
977
                                       &big_picture);
978
            if (ret < 0) {
979
                fprintf(stderr, "Video encoding failed\n");
980
                av_exit(1);
981
            }
982
            //enc->frame_number = enc->real_pict_num;
983
            if(ret>0){
984
                pkt.data= bit_buffer;
985
                pkt.size= ret;
986
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
987
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
988
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
989
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
990
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
991

    
992
                if(enc->coded_frame->key_frame)
993
                    pkt.flags |= PKT_FLAG_KEY;
994
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
995
                *frame_size = ret;
996
                video_size += ret;
997
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
998
                //        enc->frame_number-1, enc->real_pict_num, ret,
999
                //        enc->pict_type);
1000
                /* if two pass, output log */
1001
                if (ost->logfile && enc->stats_out) {
1002
                    fprintf(ost->logfile, "%s", enc->stats_out);
1003
                }
1004
            }
1005
        }
1006
        ost->sync_opts++;
1007
        ost->frame_number++;
1008
    }
1009
}
1010

    
1011
static double psnr(double d){
1012
    return -10.0*log(d)/log(10.0);
1013
}
1014

    
1015
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1016
                           int frame_size)
1017
{
1018
    AVCodecContext *enc;
1019
    int frame_number;
1020
    double ti1, bitrate, avg_bitrate;
1021

    
1022
    /* this is executed just the first time do_video_stats is called */
1023
    if (!vstats_file) {
1024
        vstats_file = fopen(vstats_filename, "w");
1025
        if (!vstats_file) {
1026
            perror("fopen");
1027
            av_exit(1);
1028
        }
1029
    }
1030

    
1031
    enc = ost->st->codec;
1032
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1033
        frame_number = ost->frame_number;
1034
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1035
        if (enc->flags&CODEC_FLAG_PSNR)
1036
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1037

    
1038
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1039
        /* compute pts value */
1040
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1041
        if (ti1 < 0.01)
1042
            ti1 = 0.01;
1043

    
1044
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1045
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1046
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1047
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1048
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1049
    }
1050
}
1051

    
1052
static void print_report(AVFormatContext **output_files,
1053
                         AVOutputStream **ost_table, int nb_ostreams,
1054
                         int is_last_report)
1055
{
1056
    char buf[1024];
1057
    AVOutputStream *ost;
1058
    AVFormatContext *oc, *os;
1059
    int64_t total_size;
1060
    AVCodecContext *enc;
1061
    int frame_number, vid, i;
1062
    double bitrate, ti1, pts;
1063
    static int64_t last_time = -1;
1064
    static int qp_histogram[52];
1065

    
1066
    if (!is_last_report) {
1067
        int64_t cur_time;
1068
        /* display the report every 0.5 seconds */
1069
        cur_time = av_gettime();
1070
        if (last_time == -1) {
1071
            last_time = cur_time;
1072
            return;
1073
        }
1074
        if ((cur_time - last_time) < 500000)
1075
            return;
1076
        last_time = cur_time;
1077
    }
1078

    
1079

    
1080
    oc = output_files[0];
1081

    
1082
    total_size = url_fsize(oc->pb);
1083
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1084
        total_size= url_ftell(oc->pb);
1085

    
1086
    buf[0] = '\0';
1087
    ti1 = 1e10;
1088
    vid = 0;
1089
    for(i=0;i<nb_ostreams;i++) {
1090
        ost = ost_table[i];
1091
        os = output_files[ost->file_index];
1092
        enc = ost->st->codec;
1093
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1094
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1095
                     !ost->st->stream_copy ?
1096
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1097
        }
1098
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1099
            float t = (av_gettime()-timer_start) / 1000000.0;
1100

    
1101
            frame_number = ost->frame_number;
1102
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1103
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1104
                     !ost->st->stream_copy ?
1105
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1106
            if(is_last_report)
1107
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1108
            if(qp_hist){
1109
                int j;
1110
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1111
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1112
                    qp_histogram[qp]++;
1113
                for(j=0; j<32; j++)
1114
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1115
            }
1116
            if (enc->flags&CODEC_FLAG_PSNR){
1117
                int j;
1118
                double error, error_sum=0;
1119
                double scale, scale_sum=0;
1120
                char type[3]= {'Y','U','V'};
1121
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1122
                for(j=0; j<3; j++){
1123
                    if(is_last_report){
1124
                        error= enc->error[j];
1125
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1126
                    }else{
1127
                        error= enc->coded_frame->error[j];
1128
                        scale= enc->width*enc->height*255.0*255.0;
1129
                    }
1130
                    if(j) scale/=4;
1131
                    error_sum += error;
1132
                    scale_sum += scale;
1133
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1134
                }
1135
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1136
            }
1137
            vid = 1;
1138
        }
1139
        /* compute min output value */
1140
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1141
        if ((pts < ti1) && (pts > 0))
1142
            ti1 = pts;
1143
    }
1144
    if (ti1 < 0.01)
1145
        ti1 = 0.01;
1146

    
1147
    if (verbose || is_last_report) {
1148
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1149

    
1150
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1151
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1152
            (double)total_size / 1024, ti1, bitrate);
1153

    
1154
        if (verbose > 1)
1155
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1156
                  nb_frames_dup, nb_frames_drop);
1157

    
1158
        if (verbose >= 0)
1159
            fprintf(stderr, "%s    \r", buf);
1160

    
1161
        fflush(stderr);
1162
    }
1163

    
1164
    if (is_last_report && verbose >= 0){
1165
        int64_t raw= audio_size + video_size + extra_size;
1166
        fprintf(stderr, "\n");
1167
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1168
                video_size/1024.0,
1169
                audio_size/1024.0,
1170
                extra_size/1024.0,
1171
                100.0*(total_size - raw)/raw
1172
        );
1173
    }
1174
}
1175

    
1176
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1177
static int output_packet(AVInputStream *ist, int ist_index,
1178
                         AVOutputStream **ost_table, int nb_ostreams,
1179
                         const AVPacket *pkt)
1180
{
1181
    AVFormatContext *os;
1182
    AVOutputStream *ost;
1183
    uint8_t *ptr;
1184
    int len, ret, i;
1185
    uint8_t *data_buf;
1186
    int data_size, got_picture;
1187
    AVFrame picture;
1188
    void *buffer_to_free;
1189
    static unsigned int samples_size= 0;
1190
    static short *samples= NULL;
1191
    AVSubtitle subtitle, *subtitle_to_free;
1192
    int got_subtitle;
1193

    
1194
    if(ist->next_pts == AV_NOPTS_VALUE)
1195
        ist->next_pts= ist->pts;
1196

    
1197
    if (pkt == NULL) {
1198
        /* EOF handling */
1199
        ptr = NULL;
1200
        len = 0;
1201
        goto handle_eof;
1202
    }
1203

    
1204
    if(pkt->dts != AV_NOPTS_VALUE)
1205
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1206

    
1207
    len = pkt->size;
1208
    ptr = pkt->data;
1209

    
1210
    //while we have more to decode or while the decoder did output something on EOF
1211
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1212
    handle_eof:
1213
        ist->pts= ist->next_pts;
1214

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

    
1218
        /* decode the packet if needed */
1219
        data_buf = NULL; /* fail safe */
1220
        data_size = 0;
1221
        subtitle_to_free = NULL;
1222
        if (ist->decoding_needed) {
1223
            switch(ist->st->codec->codec_type) {
1224
            case CODEC_TYPE_AUDIO:{
1225
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1226
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1227
                    av_free(samples);
1228
                    samples= av_malloc(samples_size);
1229
                }
1230
                data_size= samples_size;
1231
                    /* XXX: could avoid copy if PCM 16 bits with same
1232
                       endianness as CPU */
1233
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1234
                                           ptr, len);
1235
                if (ret < 0)
1236
                    goto fail_decode;
1237
                ptr += ret;
1238
                len -= ret;
1239
                /* Some bug in mpeg audio decoder gives */
1240
                /* data_size < 0, it seems they are overflows */
1241
                if (data_size <= 0) {
1242
                    /* no audio frame */
1243
                    continue;
1244
                }
1245
                data_buf = (uint8_t *)samples;
1246
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1247
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1248
                break;}
1249
            case CODEC_TYPE_VIDEO:
1250
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1251
                    /* XXX: allocate picture correctly */
1252
                    avcodec_get_frame_defaults(&picture);
1253

    
1254
                    ret = avcodec_decode_video(ist->st->codec,
1255
                                               &picture, &got_picture, ptr, len);
1256
                    ist->st->quality= picture.quality;
1257
                    if (ret < 0)
1258
                        goto fail_decode;
1259
                    if (!got_picture) {
1260
                        /* no picture yet */
1261
                        goto discard_packet;
1262
                    }
1263
                    if (ist->st->codec->time_base.num != 0) {
1264
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1265
                                          ist->st->codec->time_base.num) /
1266
                            ist->st->codec->time_base.den;
1267
                    }
1268
                    len = 0;
1269
                    break;
1270
            case CODEC_TYPE_SUBTITLE:
1271
                ret = avcodec_decode_subtitle(ist->st->codec,
1272
                                              &subtitle, &got_subtitle, ptr, len);
1273
                if (ret < 0)
1274
                    goto fail_decode;
1275
                if (!got_subtitle) {
1276
                    goto discard_packet;
1277
                }
1278
                subtitle_to_free = &subtitle;
1279
                len = 0;
1280
                break;
1281
            default:
1282
                goto fail_decode;
1283
            }
1284
        } else {
1285
            switch(ist->st->codec->codec_type) {
1286
            case CODEC_TYPE_AUDIO:
1287
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1288
                    ist->st->codec->sample_rate;
1289
                break;
1290
            case CODEC_TYPE_VIDEO:
1291
                if (ist->st->codec->time_base.num != 0) {
1292
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1293
                                      ist->st->codec->time_base.num) /
1294
                        ist->st->codec->time_base.den;
1295
                }
1296
                break;
1297
            }
1298
            data_buf = ptr;
1299
            data_size = len;
1300
            ret = len;
1301
            len = 0;
1302
        }
1303

    
1304
        buffer_to_free = NULL;
1305
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1306
            pre_process_video_frame(ist, (AVPicture *)&picture,
1307
                                    &buffer_to_free);
1308
        }
1309

    
1310
        // preprocess audio (volume)
1311
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1312
            if (audio_volume != 256) {
1313
                short *volp;
1314
                volp = samples;
1315
                for(i=0;i<(data_size / sizeof(short));i++) {
1316
                    int v = ((*volp) * audio_volume + 128) >> 8;
1317
                    if (v < -32768) v = -32768;
1318
                    if (v >  32767) v = 32767;
1319
                    *volp++ = v;
1320
                }
1321
            }
1322
        }
1323

    
1324
        /* frame rate emulation */
1325
        if (rate_emu) {
1326
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1327
            int64_t now = av_gettime() - ist->start;
1328
            if (pts > now)
1329
                usleep(pts - now);
1330
        }
1331

    
1332
        /* if output time reached then transcode raw format,
1333
           encode packets and output them */
1334
        if (start_time == 0 || ist->pts >= start_time)
1335
            for(i=0;i<nb_ostreams;i++) {
1336
                int frame_size;
1337

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1491
                        if(ret<=0)
1492
                            break;
1493
                        pkt.data= bit_buffer;
1494
                        pkt.size= ret;
1495
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1496
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1497
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1498
                    }
1499
                }
1500
            }
1501
        }
1502
    }
1503

    
1504
    return 0;
1505
 fail_decode:
1506
    return -1;
1507
}
1508

    
1509
static void print_sdp(AVFormatContext **avc, int n)
1510
{
1511
    char sdp[2048];
1512

    
1513
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1514
    printf("SDP:\n%s\n", sdp);
1515
    fflush(stdout);
1516
}
1517

    
1518
static int stream_index_from_inputs(AVFormatContext **input_files,
1519
                                    int nb_input_files,
1520
                                    AVInputFile *file_table,
1521
                                    AVInputStream **ist_table,
1522
                                    enum CodecType type,
1523
                                    int programid)
1524
{
1525
    int p, q, z;
1526
    for(z=0; z<nb_input_files; z++) {
1527
        AVFormatContext *ic = input_files[z];
1528
        for(p=0; p<ic->nb_programs; p++) {
1529
            AVProgram *program = ic->programs[p];
1530
            if(program->id != programid)
1531
                continue;
1532
            for(q=0; q<program->nb_stream_indexes; q++) {
1533
                int sidx = program->stream_index[q];
1534
                int ris = file_table[z].ist_index + sidx;
1535
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1536
                    return ris;
1537
            }
1538
        }
1539
    }
1540

    
1541
    return -1;
1542
}
1543

    
1544
/*
1545
 * The following code is the main loop of the file converter
1546
 */
1547
static int av_encode(AVFormatContext **output_files,
1548
                     int nb_output_files,
1549
                     AVFormatContext **input_files,
1550
                     int nb_input_files,
1551
                     AVStreamMap *stream_maps, int nb_stream_maps)
1552
{
1553
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1554
    AVFormatContext *is, *os;
1555
    AVCodecContext *codec, *icodec;
1556
    AVOutputStream *ost, **ost_table = NULL;
1557
    AVInputStream *ist, **ist_table = NULL;
1558
    AVInputFile *file_table;
1559
    int key;
1560
    int want_sdp = 1;
1561

    
1562
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1563
    if (!file_table)
1564
        goto fail;
1565

    
1566
    /* input stream init */
1567
    j = 0;
1568
    for(i=0;i<nb_input_files;i++) {
1569
        is = input_files[i];
1570
        file_table[i].ist_index = j;
1571
        file_table[i].nb_streams = is->nb_streams;
1572
        j += is->nb_streams;
1573
    }
1574
    nb_istreams = j;
1575

    
1576
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1577
    if (!ist_table)
1578
        goto fail;
1579

    
1580
    for(i=0;i<nb_istreams;i++) {
1581
        ist = av_mallocz(sizeof(AVInputStream));
1582
        if (!ist)
1583
            goto fail;
1584
        ist_table[i] = ist;
1585
    }
1586
    j = 0;
1587
    for(i=0;i<nb_input_files;i++) {
1588
        is = input_files[i];
1589
        for(k=0;k<is->nb_streams;k++) {
1590
            ist = ist_table[j++];
1591
            ist->st = is->streams[k];
1592
            ist->file_index = i;
1593
            ist->index = k;
1594
            ist->discard = 1; /* the stream is discarded by default
1595
                                 (changed later) */
1596

    
1597
            if (rate_emu) {
1598
                ist->start = av_gettime();
1599
            }
1600
        }
1601
    }
1602

    
1603
    /* output stream init */
1604
    nb_ostreams = 0;
1605
    for(i=0;i<nb_output_files;i++) {
1606
        os = output_files[i];
1607
        if (!os->nb_streams) {
1608
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1609
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1610
            av_exit(1);
1611
        }
1612
        nb_ostreams += os->nb_streams;
1613
    }
1614
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1615
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1616
        av_exit(1);
1617
    }
1618

    
1619
    /* Sanity check the mapping args -- do the input files & streams exist? */
1620
    for(i=0;i<nb_stream_maps;i++) {
1621
        int fi = stream_maps[i].file_index;
1622
        int si = stream_maps[i].stream_index;
1623

    
1624
        if (fi < 0 || fi > nb_input_files - 1 ||
1625
            si < 0 || si > file_table[fi].nb_streams - 1) {
1626
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1627
            av_exit(1);
1628
        }
1629
        fi = stream_maps[i].sync_file_index;
1630
        si = stream_maps[i].sync_stream_index;
1631
        if (fi < 0 || fi > nb_input_files - 1 ||
1632
            si < 0 || si > file_table[fi].nb_streams - 1) {
1633
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1634
            av_exit(1);
1635
        }
1636
    }
1637

    
1638
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1639
    if (!ost_table)
1640
        goto fail;
1641
    for(i=0;i<nb_ostreams;i++) {
1642
        ost = av_mallocz(sizeof(AVOutputStream));
1643
        if (!ost)
1644
            goto fail;
1645
        ost_table[i] = ost;
1646
    }
1647

    
1648
    n = 0;
1649
    for(k=0;k<nb_output_files;k++) {
1650
        os = output_files[k];
1651
        for(i=0;i<os->nb_streams;i++,n++) {
1652
            int found;
1653
            ost = ost_table[n];
1654
            ost->file_index = k;
1655
            ost->index = i;
1656
            ost->st = os->streams[i];
1657
            if (nb_stream_maps > 0) {
1658
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1659
                    stream_maps[n].stream_index;
1660

    
1661
                /* Sanity check that the stream types match */
1662
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1663
                    int i= ost->file_index;
1664
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1665
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1666
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1667
                        ost->file_index, ost->index);
1668
                    av_exit(1);
1669
                }
1670

    
1671
            } else {
1672
                if(opt_programid) {
1673
                    found = 0;
1674
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1675
                    if(j != -1) {
1676
                        ost->source_index = j;
1677
                        found = 1;
1678
                    }
1679
                } else {
1680
                    /* get corresponding input stream index : we select the first one with the right type */
1681
                    found = 0;
1682
                    for(j=0;j<nb_istreams;j++) {
1683
                        ist = ist_table[j];
1684
                        if (ist->discard &&
1685
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1686
                            ost->source_index = j;
1687
                            found = 1;
1688
                            break;
1689
                        }
1690
                    }
1691
                }
1692

    
1693
                if (!found) {
1694
                    if(! opt_programid) {
1695
                        /* try again and reuse existing stream */
1696
                        for(j=0;j<nb_istreams;j++) {
1697
                            ist = ist_table[j];
1698
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1699
                                ost->source_index = j;
1700
                                found = 1;
1701
                            }
1702
                        }
1703
                    }
1704
                    if (!found) {
1705
                        int i= ost->file_index;
1706
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1707
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1708
                                ost->file_index, ost->index);
1709
                        av_exit(1);
1710
                    }
1711
                }
1712
            }
1713
            ist = ist_table[ost->source_index];
1714
            ist->discard = 0;
1715
            ost->sync_ist = (nb_stream_maps > 0) ?
1716
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1717
                         stream_maps[n].sync_stream_index] : ist;
1718
        }
1719
    }
1720

    
1721
    /* for each output stream, we compute the right encoding parameters */
1722
    for(i=0;i<nb_ostreams;i++) {
1723
        ost = ost_table[i];
1724
        os = output_files[ost->file_index];
1725
        ist = ist_table[ost->source_index];
1726

    
1727
        codec = ost->st->codec;
1728
        icodec = ist->st->codec;
1729

    
1730
        if (!ost->st->language[0])
1731
            av_strlcpy(ost->st->language, ist->st->language,
1732
                       sizeof(ost->st->language));
1733

    
1734
        ost->st->disposition = ist->st->disposition;
1735

    
1736
        if (ost->st->stream_copy) {
1737
            /* if stream_copy is selected, no need to decode or encode */
1738
            codec->codec_id = icodec->codec_id;
1739
            codec->codec_type = icodec->codec_type;
1740

    
1741
            if(!codec->codec_tag){
1742
                if(   !os->oformat->codec_tag
1743
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1744
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1745
                    codec->codec_tag = icodec->codec_tag;
1746
            }
1747

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

    
1864
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1865
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1866
                         i);
1867
                if (codec->flags & CODEC_FLAG_PASS1) {
1868
                    f = fopen(logfilename, "w");
1869
                    if (!f) {
1870
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1871
                        av_exit(1);
1872
                    }
1873
                    ost->logfile = f;
1874
                } else {
1875
                    /* read the log file */
1876
                    f = fopen(logfilename, "r");
1877
                    if (!f) {
1878
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1879
                        av_exit(1);
1880
                    }
1881
                    fseek(f, 0, SEEK_END);
1882
                    size = ftell(f);
1883
                    fseek(f, 0, SEEK_SET);
1884
                    logbuffer = av_malloc(size + 1);
1885
                    if (!logbuffer) {
1886
                        fprintf(stderr, "Could not allocate log buffer\n");
1887
                        av_exit(1);
1888
                    }
1889
                    size = fread(logbuffer, 1, size, f);
1890
                    fclose(f);
1891
                    logbuffer[size] = '\0';
1892
                    codec->stats_in = logbuffer;
1893
                }
1894
            }
1895
        }
1896
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1897
            int size= codec->width * codec->height;
1898
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1899
        }
1900
    }
1901

    
1902
    if (!bit_buffer)
1903
        bit_buffer = av_malloc(bit_buffer_size);
1904
    if (!bit_buffer)
1905
        goto fail;
1906

    
1907
    /* dump the file output parameters - cannot be done before in case
1908
       of stream copy */
1909
    for(i=0;i<nb_output_files;i++) {
1910
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1911
    }
1912

    
1913
    /* dump the stream mapping */
1914
    if (verbose >= 0) {
1915
        fprintf(stderr, "Stream mapping:\n");
1916
        for(i=0;i<nb_ostreams;i++) {
1917
            ost = ost_table[i];
1918
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1919
                    ist_table[ost->source_index]->file_index,
1920
                    ist_table[ost->source_index]->index,
1921
                    ost->file_index,
1922
                    ost->index);
1923
            if (ost->sync_ist != ist_table[ost->source_index])
1924
                fprintf(stderr, " [sync #%d.%d]",
1925
                        ost->sync_ist->file_index,
1926
                        ost->sync_ist->index);
1927
            fprintf(stderr, "\n");
1928
        }
1929
    }
1930

    
1931
    /* open each encoder */
1932
    for(i=0;i<nb_ostreams;i++) {
1933
        ost = ost_table[i];
1934
        if (ost->encoding_needed) {
1935
            AVCodec *codec = output_codecs[i];
1936
            if (!codec)
1937
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1938
            if (!codec) {
1939
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1940
                        ost->file_index, ost->index);
1941
                av_exit(1);
1942
            }
1943
            if (avcodec_open(ost->st->codec, codec) < 0) {
1944
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1945
                        ost->file_index, ost->index);
1946
                av_exit(1);
1947
            }
1948
            extra_size += ost->st->codec->extradata_size;
1949
        }
1950
    }
1951

    
1952
    /* open each decoder */
1953
    for(i=0;i<nb_istreams;i++) {
1954
        ist = ist_table[i];
1955
        if (ist->decoding_needed) {
1956
            AVCodec *codec = input_codecs[i];
1957
            if (!codec)
1958
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1959
            if (!codec) {
1960
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1961
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1962
                av_exit(1);
1963
            }
1964
            if (avcodec_open(ist->st->codec, codec) < 0) {
1965
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1966
                        ist->file_index, ist->index);
1967
                av_exit(1);
1968
            }
1969
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1970
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1971
        }
1972
    }
1973

    
1974
    /* init pts */
1975
    for(i=0;i<nb_istreams;i++) {
1976
        ist = ist_table[i];
1977
        is = input_files[ist->file_index];
1978
        ist->pts = 0;
1979
        ist->next_pts = AV_NOPTS_VALUE;
1980
        ist->is_start = 1;
1981
    }
1982

    
1983
    /* set meta data information from input file if required */
1984
    for (i=0;i<nb_meta_data_maps;i++) {
1985
        AVFormatContext *out_file;
1986
        AVFormatContext *in_file;
1987

    
1988
        int out_file_index = meta_data_maps[i].out_file;
1989
        int in_file_index = meta_data_maps[i].in_file;
1990
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1991
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1992
            ret = AVERROR(EINVAL);
1993
            goto fail;
1994
        }
1995
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1996
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1997
            ret = AVERROR(EINVAL);
1998
            goto fail;
1999
        }
2000

    
2001
        out_file = output_files[out_file_index];
2002
        in_file = input_files[in_file_index];
2003

    
2004
        strcpy(out_file->title, in_file->title);
2005
        strcpy(out_file->author, in_file->author);
2006
        strcpy(out_file->copyright, in_file->copyright);
2007
        strcpy(out_file->comment, in_file->comment);
2008
        strcpy(out_file->album, in_file->album);
2009
        out_file->year = in_file->year;
2010
        out_file->track = in_file->track;
2011
        strcpy(out_file->genre, in_file->genre);
2012
    }
2013

    
2014
    /* open files and write file headers */
2015
    for(i=0;i<nb_output_files;i++) {
2016
        os = output_files[i];
2017
        if (av_write_header(os) < 0) {
2018
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
2019
            ret = AVERROR(EINVAL);
2020
            goto fail;
2021
        }
2022
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2023
            want_sdp = 0;
2024
        }
2025
    }
2026
    if (want_sdp) {
2027
        print_sdp(output_files, nb_output_files);
2028
    }
2029

    
2030
    if (!using_stdin && verbose >= 0) {
2031
        fprintf(stderr, "Press [q] to stop encoding\n");
2032
        url_set_interrupt_cb(decode_interrupt_cb);
2033
    }
2034
    term_init();
2035

    
2036
    key = -1;
2037
    timer_start = av_gettime();
2038

    
2039
    for(; received_sigterm == 0;) {
2040
        int file_index, ist_index;
2041
        AVPacket pkt;
2042
        double ipts_min;
2043
        double opts_min;
2044

    
2045
    redo:
2046
        ipts_min= 1e100;
2047
        opts_min= 1e100;
2048
        /* if 'q' pressed, exits */
2049
        if (!using_stdin) {
2050
            if (q_pressed)
2051
                break;
2052
            /* read_key() returns 0 on EOF */
2053
            key = read_key();
2054
            if (key == 'q')
2055
                break;
2056
        }
2057

    
2058
        /* select the stream that we must read now by looking at the
2059
           smallest output pts */
2060
        file_index = -1;
2061
        for(i=0;i<nb_ostreams;i++) {
2062
            double ipts, opts;
2063
            ost = ost_table[i];
2064
            os = output_files[ost->file_index];
2065
            ist = ist_table[ost->source_index];
2066
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2067
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2068
            else
2069
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2070
            ipts = (double)ist->pts;
2071
            if (!file_table[ist->file_index].eof_reached){
2072
                if(ipts < ipts_min) {
2073
                    ipts_min = ipts;
2074
                    if(input_sync ) file_index = ist->file_index;
2075
                }
2076
                if(opts < opts_min) {
2077
                    opts_min = opts;
2078
                    if(!input_sync) file_index = ist->file_index;
2079
                }
2080
            }
2081
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2082
                file_index= -1;
2083
                break;
2084
            }
2085
        }
2086
        /* if none, if is finished */
2087
        if (file_index < 0) {
2088
            break;
2089
        }
2090

    
2091
        /* finish if recording time exhausted */
2092
        if (opts_min >= (recording_time / 1000000.0))
2093
            break;
2094

    
2095
        /* finish if limit size exhausted */
2096
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2097
            break;
2098

    
2099
        /* read a frame from it and output it in the fifo */
2100
        is = input_files[file_index];
2101
        if (av_read_frame(is, &pkt) < 0) {
2102
            file_table[file_index].eof_reached = 1;
2103
            if (opt_shortest)
2104
                break;
2105
            else
2106
                continue;
2107
        }
2108

    
2109
        if (do_pkt_dump) {
2110
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2111
        }
2112
        /* the following test is needed in case new streams appear
2113
           dynamically in stream : we ignore them */
2114
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2115
            goto discard_packet;
2116
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2117
        ist = ist_table[ist_index];
2118
        if (ist->discard)
2119
            goto discard_packet;
2120

    
2121
        if (pkt.dts != AV_NOPTS_VALUE)
2122
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2123
        if (pkt.pts != AV_NOPTS_VALUE)
2124
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2125

    
2126
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2127
            if(pkt.pts != AV_NOPTS_VALUE)
2128
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2129
            if(pkt.dts != AV_NOPTS_VALUE)
2130
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2131
        }
2132

    
2133
//        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);
2134
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2135
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2136
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2137
            int64_t delta= pkt_dts - ist->next_pts;
2138
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2139
                input_files_ts_offset[ist->file_index]-= delta;
2140
                if (verbose > 2)
2141
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2142
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2143
                if(pkt.pts != AV_NOPTS_VALUE)
2144
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2145
            }
2146
        }
2147

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

    
2151
            if (verbose >= 0)
2152
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2153
                        ist->file_index, ist->index);
2154
            if (exit_on_error)
2155
                av_exit(1);
2156
            av_free_packet(&pkt);
2157
            goto redo;
2158
        }
2159

    
2160
    discard_packet:
2161
        av_free_packet(&pkt);
2162

    
2163
        /* dump report by using the output first video and audio streams */
2164
        print_report(output_files, ost_table, nb_ostreams, 0);
2165
    }
2166

    
2167
    /* at the end of stream, we must flush the decoder buffers */
2168
    for(i=0;i<nb_istreams;i++) {
2169
        ist = ist_table[i];
2170
        if (ist->decoding_needed) {
2171
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2172
        }
2173
    }
2174

    
2175
    term_exit();
2176

    
2177
    /* write the trailer if needed and close file */
2178
    for(i=0;i<nb_output_files;i++) {
2179
        os = output_files[i];
2180
        av_write_trailer(os);
2181
    }
2182

    
2183
    /* dump report by using the first video and audio streams */
2184
    print_report(output_files, ost_table, nb_ostreams, 1);
2185

    
2186
    /* close each encoder */
2187
    for(i=0;i<nb_ostreams;i++) {
2188
        ost = ost_table[i];
2189
        if (ost->encoding_needed) {
2190
            av_freep(&ost->st->codec->stats_in);
2191
            avcodec_close(ost->st->codec);
2192
        }
2193
    }
2194

    
2195
    /* close each decoder */
2196
    for(i=0;i<nb_istreams;i++) {
2197
        ist = ist_table[i];
2198
        if (ist->decoding_needed) {
2199
            avcodec_close(ist->st->codec);
2200
        }
2201
    }
2202

    
2203
    /* finished ! */
2204

    
2205
    ret = 0;
2206
 fail1:
2207
    av_freep(&bit_buffer);
2208
    av_free(file_table);
2209

    
2210
    if (ist_table) {
2211
        for(i=0;i<nb_istreams;i++) {
2212
            ist = ist_table[i];
2213
            av_free(ist);
2214
        }
2215
        av_free(ist_table);
2216
    }
2217
    if (ost_table) {
2218
        for(i=0;i<nb_ostreams;i++) {
2219
            ost = ost_table[i];
2220
            if (ost) {
2221
                if (ost->logfile) {
2222
                    fclose(ost->logfile);
2223
                    ost->logfile = NULL;
2224
                }
2225
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2226
                                             initialized but set to zero */
2227
                av_free(ost->pict_tmp.data[0]);
2228
                if (ost->video_resample)
2229
                    sws_freeContext(ost->img_resample_ctx);
2230
                if (ost->resample)
2231
                    audio_resample_close(ost->resample);
2232
                if (ost->reformat_ctx)
2233
                    av_audio_convert_free(ost->reformat_ctx);
2234
                av_free(ost);
2235
            }
2236
        }
2237
        av_free(ost_table);
2238
    }
2239
    return ret;
2240
 fail:
2241
    ret = AVERROR(ENOMEM);
2242
    goto fail1;
2243
}
2244

    
2245
#if 0
2246
int file_read(const char *filename)
2247
{
2248
    URLContext *h;
2249
    unsigned char buffer[1024];
2250
    int len, i;
2251

2252
    if (url_open(&h, filename, O_RDONLY) < 0) {
2253
        printf("could not open '%s'\n", filename);
2254
        return -1;
2255
    }
2256
    for(;;) {
2257
        len = url_read(h, buffer, sizeof(buffer));
2258
        if (len <= 0)
2259
            break;
2260
        for(i=0;i<len;i++) putchar(buffer[i]);
2261
    }
2262
    url_close(h);
2263
    return 0;
2264
}
2265
#endif
2266

    
2267
static void opt_format(const char *arg)
2268
{
2269
    /* compatibility stuff for pgmyuv */
2270
    if (!strcmp(arg, "pgmyuv")) {
2271
        pgmyuv_compatibility_hack=1;
2272
//        opt_image_format(arg);
2273
        arg = "image2";
2274
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2275
    }
2276

    
2277
    file_iformat = av_find_input_format(arg);
2278
    file_oformat = guess_format(arg, NULL, NULL);
2279
    if (!file_iformat && !file_oformat) {
2280
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2281
        av_exit(1);
2282
    }
2283
}
2284

    
2285
static void opt_video_rc_override_string(const char *arg)
2286
{
2287
    video_rc_override_string = arg;
2288
}
2289

    
2290
static int opt_me_threshold(const char *opt, const char *arg)
2291
{
2292
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2293
    return 0;
2294
}
2295

    
2296
static int opt_verbose(const char *opt, const char *arg)
2297
{
2298
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2299
    av_log_set_level(verbose);
2300
    return 0;
2301
}
2302

    
2303
static int opt_frame_rate(const char *opt, const char *arg)
2304
{
2305
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2306
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2307
        av_exit(1);
2308
    }
2309
    return 0;
2310
}
2311

    
2312
static int opt_bitrate(const char *opt, const char *arg)
2313
{
2314
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2315

    
2316
    opt_default(opt, arg);
2317

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

    
2321
    return 0;
2322
}
2323

    
2324
static void opt_frame_crop_top(const char *arg)
2325
{
2326
    frame_topBand = atoi(arg);
2327
    if (frame_topBand < 0) {
2328
        fprintf(stderr, "Incorrect top crop size\n");
2329
        av_exit(1);
2330
    }
2331
    if ((frame_topBand % 2) != 0) {
2332
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2333
        av_exit(1);
2334
    }
2335
    if ((frame_topBand) >= frame_height){
2336
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2337
        av_exit(1);
2338
    }
2339
    frame_height -= frame_topBand;
2340
}
2341

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

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

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

    
2396
static void opt_frame_size(const char *arg)
2397
{
2398
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2399
        fprintf(stderr, "Incorrect frame size\n");
2400
        av_exit(1);
2401
    }
2402
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2403
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2404
        av_exit(1);
2405
    }
2406
}
2407

    
2408

    
2409
#define SCALEBITS 10
2410
#define ONE_HALF  (1 << (SCALEBITS - 1))
2411
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2412

    
2413
#define RGB_TO_Y(r, g, b) \
2414
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2415
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2416

    
2417
#define RGB_TO_U(r1, g1, b1, shift)\
2418
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2419
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2420

    
2421
#define RGB_TO_V(r1, g1, b1, shift)\
2422
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2423
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2424

    
2425
static void opt_pad_color(const char *arg) {
2426
    /* Input is expected to be six hex digits similar to
2427
       how colors are expressed in html tags (but without the #) */
2428
    int rgb = strtol(arg, NULL, 16);
2429
    int r,g,b;
2430

    
2431
    r = (rgb >> 16);
2432
    g = ((rgb >> 8) & 255);
2433
    b = (rgb & 255);
2434

    
2435
    padcolor[0] = RGB_TO_Y(r,g,b);
2436
    padcolor[1] = RGB_TO_U(r,g,b,0);
2437
    padcolor[2] = RGB_TO_V(r,g,b,0);
2438
}
2439

    
2440
static void opt_frame_pad_top(const char *arg)
2441
{
2442
    frame_padtop = atoi(arg);
2443
    if (frame_padtop < 0) {
2444
        fprintf(stderr, "Incorrect top pad size\n");
2445
        av_exit(1);
2446
    }
2447
    if ((frame_padtop % 2) != 0) {
2448
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2449
        av_exit(1);
2450
    }
2451
}
2452

    
2453
static void opt_frame_pad_bottom(const char *arg)
2454
{
2455
    frame_padbottom = atoi(arg);
2456
    if (frame_padbottom < 0) {
2457
        fprintf(stderr, "Incorrect bottom pad size\n");
2458
        av_exit(1);
2459
    }
2460
    if ((frame_padbottom % 2) != 0) {
2461
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2462
        av_exit(1);
2463
    }
2464
}
2465

    
2466

    
2467
static void opt_frame_pad_left(const char *arg)
2468
{
2469
    frame_padleft = atoi(arg);
2470
    if (frame_padleft < 0) {
2471
        fprintf(stderr, "Incorrect left pad size\n");
2472
        av_exit(1);
2473
    }
2474
    if ((frame_padleft % 2) != 0) {
2475
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2476
        av_exit(1);
2477
    }
2478
}
2479

    
2480

    
2481
static void opt_frame_pad_right(const char *arg)
2482
{
2483
    frame_padright = atoi(arg);
2484
    if (frame_padright < 0) {
2485
        fprintf(stderr, "Incorrect right pad size\n");
2486
        av_exit(1);
2487
    }
2488
    if ((frame_padright % 2) != 0) {
2489
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2490
        av_exit(1);
2491
    }
2492
}
2493

    
2494
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2495
{
2496
    int i;
2497
    char fmt_str[128];
2498
    for (i=-1; i < nb_fmts; i++) {
2499
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2500
        fprintf(stdout, "%s\n", fmt_str);
2501
    }
2502
}
2503

    
2504
static void opt_frame_pix_fmt(const char *arg)
2505
{
2506
    if (strcmp(arg, "list"))
2507
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2508
    else {
2509
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2510
        av_exit(0);
2511
    }
2512
}
2513

    
2514
static void opt_frame_aspect_ratio(const char *arg)
2515
{
2516
    int x = 0, y = 0;
2517
    double ar = 0;
2518
    const char *p;
2519
    char *end;
2520

    
2521
    p = strchr(arg, ':');
2522
    if (p) {
2523
        x = strtol(arg, &end, 10);
2524
        if (end == p)
2525
            y = strtol(end+1, &end, 10);
2526
        if (x > 0 && y > 0)
2527
            ar = (double)x / (double)y;
2528
    } else
2529
        ar = strtod(arg, NULL);
2530

    
2531
    if (!ar) {
2532
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2533
        av_exit(1);
2534
    }
2535
    frame_aspect_ratio = ar;
2536
}
2537

    
2538
static void opt_qscale(const char *arg)
2539
{
2540
    video_qscale = atof(arg);
2541
    if (video_qscale <= 0 ||
2542
        video_qscale > 255) {
2543
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2544
        av_exit(1);
2545
    }
2546
}
2547

    
2548
static void opt_top_field_first(const char *arg)
2549
{
2550
    top_field_first= atoi(arg);
2551
}
2552

    
2553
static int opt_thread_count(const char *opt, const char *arg)
2554
{
2555
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2556
#if !defined(HAVE_THREADS)
2557
    if (verbose >= 0)
2558
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2559
#endif
2560
    return 0;
2561
}
2562

    
2563
static void opt_audio_sample_fmt(const char *arg)
2564
{
2565
    if (strcmp(arg, "list"))
2566
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2567
    else {
2568
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2569
        av_exit(0);
2570
    }
2571
}
2572

    
2573
static int opt_audio_rate(const char *opt, const char *arg)
2574
{
2575
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2576
    return 0;
2577
}
2578

    
2579
static int opt_audio_channels(const char *opt, const char *arg)
2580
{
2581
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2582
    return 0;
2583
}
2584

    
2585
static void opt_video_channel(const char *arg)
2586
{
2587
    video_channel = strtol(arg, NULL, 0);
2588
}
2589

    
2590
static void opt_video_standard(const char *arg)
2591
{
2592
    video_standard = av_strdup(arg);
2593
}
2594

    
2595
static void opt_codec(int *pstream_copy, char **pcodec_name,
2596
                      int codec_type, const char *arg)
2597
{
2598
    av_freep(pcodec_name);
2599
    if (!strcmp(arg, "copy")) {
2600
        *pstream_copy = 1;
2601
    } else {
2602
        *pcodec_name = av_strdup(arg);
2603
    }
2604
}
2605

    
2606
static void opt_audio_codec(const char *arg)
2607
{
2608
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2609
}
2610

    
2611
static void opt_audio_tag(const char *arg)
2612
{
2613
    char *tail;
2614
    audio_codec_tag= strtol(arg, &tail, 0);
2615

    
2616
    if(!tail || *tail)
2617
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2618
}
2619

    
2620
static void opt_video_tag(const char *arg)
2621
{
2622
    char *tail;
2623
    video_codec_tag= strtol(arg, &tail, 0);
2624

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

    
2629
#ifdef CONFIG_VHOOK
2630
static void add_frame_hooker(const char *arg)
2631
{
2632
    int argc = 0;
2633
    char *argv[64];
2634
    int i;
2635
    char *args = av_strdup(arg);
2636

    
2637
    using_vhook = 1;
2638

    
2639
    argv[0] = strtok(args, " ");
2640
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2641
    }
2642

    
2643
    i = frame_hook_add(argc, argv);
2644

    
2645
    if (i != 0) {
2646
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2647
        av_exit(1);
2648
    }
2649
}
2650
#endif
2651

    
2652
static void opt_video_codec(const char *arg)
2653
{
2654
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2655
}
2656

    
2657
static void opt_subtitle_codec(const char *arg)
2658
{
2659
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2660
}
2661

    
2662
static void opt_map(const char *arg)
2663
{
2664
    AVStreamMap *m;
2665
    char *p;
2666

    
2667
    m = &stream_maps[nb_stream_maps++];
2668

    
2669
    m->file_index = strtol(arg, &p, 0);
2670
    if (*p)
2671
        p++;
2672

    
2673
    m->stream_index = strtol(p, &p, 0);
2674
    if (*p) {
2675
        p++;
2676
        m->sync_file_index = strtol(p, &p, 0);
2677
        if (*p)
2678
            p++;
2679
        m->sync_stream_index = strtol(p, &p, 0);
2680
    } else {
2681
        m->sync_file_index = m->file_index;
2682
        m->sync_stream_index = m->stream_index;
2683
    }
2684
}
2685

    
2686
static void opt_map_meta_data(const char *arg)
2687
{
2688
    AVMetaDataMap *m;
2689
    char *p;
2690

    
2691
    m = &meta_data_maps[nb_meta_data_maps++];
2692

    
2693
    m->out_file = strtol(arg, &p, 0);
2694
    if (*p)
2695
        p++;
2696

    
2697
    m->in_file = strtol(p, &p, 0);
2698
}
2699

    
2700
static void opt_input_ts_scale(const char *arg)
2701
{
2702
    unsigned int stream;
2703
    double scale;
2704
    char *p;
2705

    
2706
    stream = strtol(arg, &p, 0);
2707
    if (*p)
2708
        p++;
2709
    scale= strtod(p, &p);
2710

    
2711
    if(stream >= MAX_STREAMS)
2712
        av_exit(1);
2713

    
2714
    input_files_ts_scale[nb_input_files][stream]= scale;
2715
}
2716

    
2717
static int opt_recording_time(const char *opt, const char *arg)
2718
{
2719
    recording_time = parse_time_or_die(opt, arg, 1);
2720
    return 0;
2721
}
2722

    
2723
static int opt_start_time(const char *opt, const char *arg)
2724
{
2725
    start_time = parse_time_or_die(opt, arg, 1);
2726
    return 0;
2727
}
2728

    
2729
static int opt_rec_timestamp(const char *opt, const char *arg)
2730
{
2731
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2732
    return 0;
2733
}
2734

    
2735
static int opt_input_ts_offset(const char *opt, const char *arg)
2736
{
2737
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2738
    return 0;
2739
}
2740

    
2741
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2742
{
2743
    const char *codec_string = encoder ? "encoder" : "decoder";
2744
    AVCodec *codec;
2745

    
2746
    if(!name)
2747
        return CODEC_ID_NONE;
2748
    codec = encoder ?
2749
        avcodec_find_encoder_by_name(name) :
2750
        avcodec_find_decoder_by_name(name);
2751
    if(!codec) {
2752
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2753
        av_exit(1);
2754
    }
2755
    if(codec->type != type) {
2756
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2757
        av_exit(1);
2758
    }
2759
    return codec->id;
2760
}
2761

    
2762
static void opt_input_file(const char *filename)
2763
{
2764
    AVFormatContext *ic;
2765
    AVFormatParameters params, *ap = &params;
2766
    int err, i, ret, rfps, rfps_base;
2767
    int64_t timestamp;
2768

    
2769
    if (!strcmp(filename, "-"))
2770
        filename = "pipe:";
2771

    
2772
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2773
                    !strcmp(filename, "/dev/stdin");
2774

    
2775
    /* get default parameters from command line */
2776
    ic = av_alloc_format_context();
2777

    
2778
    memset(ap, 0, sizeof(*ap));
2779
    ap->prealloced_context = 1;
2780
    ap->sample_rate = audio_sample_rate;
2781
    ap->channels = audio_channels;
2782
    ap->time_base.den = frame_rate.num;
2783
    ap->time_base.num = frame_rate.den;
2784
    ap->width = frame_width + frame_padleft + frame_padright;
2785
    ap->height = frame_height + frame_padtop + frame_padbottom;
2786
    ap->pix_fmt = frame_pix_fmt;
2787
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2788
    ap->channel = video_channel;
2789
    ap->standard = video_standard;
2790
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2791
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2792
    if(pgmyuv_compatibility_hack)
2793
        ap->video_codec_id= CODEC_ID_PGMYUV;
2794

    
2795
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2796

    
2797
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2798
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2799
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2800

    
2801
    /* open the input file with generic libav function */
2802
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2803
    if (err < 0) {
2804
        print_error(filename, err);
2805
        av_exit(1);
2806
    }
2807
    if(opt_programid) {
2808
        int i;
2809
        for(i=0; i<ic->nb_programs; i++)
2810
            if(ic->programs[i]->id != opt_programid)
2811
                ic->programs[i]->discard = AVDISCARD_ALL;
2812
    }
2813

    
2814
    ic->loop_input = loop_input;
2815

    
2816
    /* If not enough info to get the stream parameters, we decode the
2817
       first frames to get it. (used in mpeg case for example) */
2818
    ret = av_find_stream_info(ic);
2819
    if (ret < 0 && verbose >= 0) {
2820
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2821
        av_exit(1);
2822
    }
2823

    
2824
    timestamp = start_time;
2825
    /* add the stream start time */
2826
    if (ic->start_time != AV_NOPTS_VALUE)
2827
        timestamp += ic->start_time;
2828

    
2829
    /* if seeking requested, we execute it */
2830
    if (start_time != 0) {
2831
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2832
        if (ret < 0) {
2833
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2834
                    filename, (double)timestamp / AV_TIME_BASE);
2835
        }
2836
        /* reset seek info */
2837
        start_time = 0;
2838
    }
2839

    
2840
    /* update the current parameters so that they match the one of the input stream */
2841
    for(i=0;i<ic->nb_streams;i++) {
2842
        AVCodecContext *enc = ic->streams[i]->codec;
2843
        if(thread_count>1)
2844
            avcodec_thread_init(enc, thread_count);
2845
        enc->thread_count= thread_count;
2846
        switch(enc->codec_type) {
2847
        case CODEC_TYPE_AUDIO:
2848
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2849
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2850
            channel_layout = enc->channel_layout;
2851
            audio_channels = enc->channels;
2852
            audio_sample_rate = enc->sample_rate;
2853
            audio_sample_fmt = enc->sample_fmt;
2854
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2855
            if(audio_disable)
2856
                ic->streams[i]->discard= AVDISCARD_ALL;
2857
            break;
2858
        case CODEC_TYPE_VIDEO:
2859
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2860
            frame_height = enc->height;
2861
            frame_width = enc->width;
2862
            if(ic->streams[i]->sample_aspect_ratio.num)
2863
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2864
            else
2865
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2866
            frame_aspect_ratio *= (float) enc->width / enc->height;
2867
            frame_pix_fmt = enc->pix_fmt;
2868
            rfps      = ic->streams[i]->r_frame_rate.num;
2869
            rfps_base = ic->streams[i]->r_frame_rate.den;
2870
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2871
            if(me_threshold)
2872
                enc->debug |= FF_DEBUG_MV;
2873

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

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

    
2880
                    (float)rfps / rfps_base, rfps, rfps_base);
2881
            }
2882
            /* update the current frame rate to match the stream frame rate */
2883
            frame_rate.num = rfps;
2884
            frame_rate.den = rfps_base;
2885

    
2886
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2887
            if(video_disable)
2888
                ic->streams[i]->discard= AVDISCARD_ALL;
2889
            else if(video_discard)
2890
                ic->streams[i]->discard= video_discard;
2891
            break;
2892
        case CODEC_TYPE_DATA:
2893
            break;
2894
        case CODEC_TYPE_SUBTITLE:
2895
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2896
            if(subtitle_disable)
2897
                ic->streams[i]->discard = AVDISCARD_ALL;
2898
            break;
2899
        case CODEC_TYPE_ATTACHMENT:
2900
        case CODEC_TYPE_UNKNOWN:
2901
            nb_icodecs++;
2902
            break;
2903
        default:
2904
            abort();
2905
        }
2906
    }
2907

    
2908
    input_files[nb_input_files] = ic;
2909
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2910
    /* dump the file content */
2911
    if (verbose >= 0)
2912
        dump_format(ic, nb_input_files, filename, 0);
2913

    
2914
    nb_input_files++;
2915
    file_iformat = NULL;
2916
    file_oformat = NULL;
2917

    
2918
    video_channel = 0;
2919

    
2920
    av_freep(&video_codec_name);
2921
    av_freep(&audio_codec_name);
2922
    av_freep(&subtitle_codec_name);
2923
}
2924

    
2925
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2926
                                         int *has_subtitle_ptr)
2927
{
2928
    int has_video, has_audio, has_subtitle, i, j;
2929
    AVFormatContext *ic;
2930

    
2931
    has_video = 0;
2932
    has_audio = 0;
2933
    has_subtitle = 0;
2934
    for(j=0;j<nb_input_files;j++) {
2935
        ic = input_files[j];
2936
        for(i=0;i<ic->nb_streams;i++) {
2937
            AVCodecContext *enc = ic->streams[i]->codec;
2938
            switch(enc->codec_type) {
2939
            case CODEC_TYPE_AUDIO:
2940
                has_audio = 1;
2941
                break;
2942
            case CODEC_TYPE_VIDEO:
2943
                has_video = 1;
2944
                break;
2945
            case CODEC_TYPE_SUBTITLE:
2946
                has_subtitle = 1;
2947
                break;
2948
            case CODEC_TYPE_DATA:
2949
            case CODEC_TYPE_ATTACHMENT:
2950
            case CODEC_TYPE_UNKNOWN:
2951
                break;
2952
            default:
2953
                abort();
2954
            }
2955
        }
2956
    }
2957
    *has_video_ptr = has_video;
2958
    *has_audio_ptr = has_audio;
2959
    *has_subtitle_ptr = has_subtitle;
2960
}
2961

    
2962
static void new_video_stream(AVFormatContext *oc)
2963
{
2964
    AVStream *st;
2965
    AVCodecContext *video_enc;
2966
    int codec_id;
2967

    
2968
    st = av_new_stream(oc, oc->nb_streams);
2969
    if (!st) {
2970
        fprintf(stderr, "Could not alloc stream\n");
2971
        av_exit(1);
2972
    }
2973
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2974
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2975
    video_bitstream_filters= NULL;
2976

    
2977
    if(thread_count>1)
2978
        avcodec_thread_init(st->codec, thread_count);
2979

    
2980
    video_enc = st->codec;
2981

    
2982
    if(video_codec_tag)
2983
        video_enc->codec_tag= video_codec_tag;
2984

    
2985
    if(   (video_global_header&1)
2986
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2987
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2988
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2989
    }
2990
    if(video_global_header&2){
2991
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2992
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2993
    }
2994

    
2995
    if (video_stream_copy) {
2996
        st->stream_copy = 1;
2997
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2998
        video_enc->sample_aspect_ratio =
2999
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3000
    } else {
3001
        const char *p;
3002
        int i;
3003
        AVCodec *codec;
3004
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3005

    
3006
        if (video_codec_name) {
3007
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3008
            codec = avcodec_find_encoder_by_name(video_codec_name);
3009
            output_codecs[nb_ocodecs] = codec;
3010
        } else {
3011
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3012
            codec = avcodec_find_encoder(codec_id);
3013
        }
3014

    
3015
        video_enc->codec_id = codec_id;
3016

    
3017
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3018

    
3019
        if (codec && codec->supported_framerates && !force_fps)
3020
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3021
        video_enc->time_base.den = fps.num;
3022
        video_enc->time_base.num = fps.den;
3023

    
3024
        video_enc->width = frame_width + frame_padright + frame_padleft;
3025
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3026
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3027
        video_enc->pix_fmt = frame_pix_fmt;
3028
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3029

    
3030
        if(codec && codec->pix_fmts){
3031
            const enum PixelFormat *p= codec->pix_fmts;
3032
            for(; *p!=-1; p++){
3033
                if(*p == video_enc->pix_fmt)
3034
                    break;
3035
            }
3036
            if(*p == -1)
3037
                video_enc->pix_fmt = codec->pix_fmts[0];
3038
        }
3039

    
3040
        if (intra_only)
3041
            video_enc->gop_size = 0;
3042
        if (video_qscale || same_quality) {
3043
            video_enc->flags |= CODEC_FLAG_QSCALE;
3044
            video_enc->global_quality=
3045
                st->quality = FF_QP2LAMBDA * video_qscale;
3046
        }
3047

    
3048
        if(intra_matrix)
3049
            video_enc->intra_matrix = intra_matrix;
3050
        if(inter_matrix)
3051
            video_enc->inter_matrix = inter_matrix;
3052

    
3053
        video_enc->thread_count = thread_count;
3054
        p= video_rc_override_string;
3055
        for(i=0; p; i++){
3056
            int start, end, q;
3057
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3058
            if(e!=3){
3059
                fprintf(stderr, "error parsing rc_override\n");
3060
                av_exit(1);
3061
            }
3062
            video_enc->rc_override=
3063
                av_realloc(video_enc->rc_override,
3064
                           sizeof(RcOverride)*(i+1));
3065
            video_enc->rc_override[i].start_frame= start;
3066
            video_enc->rc_override[i].end_frame  = end;
3067
            if(q>0){
3068
                video_enc->rc_override[i].qscale= q;
3069
                video_enc->rc_override[i].quality_factor= 1.0;
3070
            }
3071
            else{
3072
                video_enc->rc_override[i].qscale= 0;
3073
                video_enc->rc_override[i].quality_factor= -q/100.0;
3074
            }
3075
            p= strchr(p, '/');
3076
            if(p) p++;
3077
        }
3078
        video_enc->rc_override_count=i;
3079
        if (!video_enc->rc_initial_buffer_occupancy)
3080
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3081
        video_enc->me_threshold= me_threshold;
3082
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3083

    
3084
        if (do_psnr)
3085
            video_enc->flags|= CODEC_FLAG_PSNR;
3086

    
3087
        /* two pass mode */
3088
        if (do_pass) {
3089
            if (do_pass == 1) {
3090
                video_enc->flags |= CODEC_FLAG_PASS1;
3091
            } else {
3092
                video_enc->flags |= CODEC_FLAG_PASS2;
3093
            }
3094
        }
3095
    }
3096
    nb_ocodecs++;
3097

    
3098
    /* reset some key parameters */
3099
    video_disable = 0;
3100
    av_freep(&video_codec_name);
3101
    video_stream_copy = 0;
3102
}
3103

    
3104
static void new_audio_stream(AVFormatContext *oc)
3105
{
3106
    AVStream *st;
3107
    AVCodecContext *audio_enc;
3108
    int codec_id;
3109

    
3110
    st = av_new_stream(oc, oc->nb_streams);
3111
    if (!st) {
3112
        fprintf(stderr, "Could not alloc stream\n");
3113
        av_exit(1);
3114
    }
3115
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3116

    
3117
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3118
    audio_bitstream_filters= NULL;
3119

    
3120
    if(thread_count>1)
3121
        avcodec_thread_init(st->codec, thread_count);
3122

    
3123
    audio_enc = st->codec;
3124
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3125

    
3126
    if(audio_codec_tag)
3127
        audio_enc->codec_tag= audio_codec_tag;
3128

    
3129
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3130
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3131
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3132
    }
3133
    if (audio_stream_copy) {
3134
        st->stream_copy = 1;
3135
        audio_enc->channels = audio_channels;
3136
    } else {
3137
        AVCodec *codec;
3138

    
3139
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3140

    
3141
        if (audio_codec_name) {
3142
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3143
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3144
            output_codecs[nb_ocodecs] = codec;
3145
        } else {
3146
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3147
            codec = avcodec_find_encoder(codec_id);
3148
        }
3149
        audio_enc->codec_id = codec_id;
3150

    
3151
        if (audio_qscale > QSCALE_NONE) {
3152
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3153
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3154
        }
3155
        audio_enc->thread_count = thread_count;
3156
        audio_enc->channels = audio_channels;
3157
        audio_enc->sample_fmt = audio_sample_fmt;
3158
        audio_enc->channel_layout = channel_layout;
3159

    
3160
        if(codec && codec->sample_fmts){
3161
            const enum SampleFormat *p= codec->sample_fmts;
3162
            for(; *p!=-1; p++){
3163
                if(*p == audio_enc->sample_fmt)
3164
                    break;
3165
            }
3166
            if(*p == -1)
3167
                audio_enc->sample_fmt = codec->sample_fmts[0];
3168
        }
3169
    }
3170
    nb_ocodecs++;
3171
    audio_enc->sample_rate = audio_sample_rate;
3172
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3173
    if (audio_language) {
3174
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3175
        av_free(audio_language);
3176
        audio_language = NULL;
3177
    }
3178

    
3179
    /* reset some key parameters */
3180
    audio_disable = 0;
3181
    av_freep(&audio_codec_name);
3182
    audio_stream_copy = 0;
3183
}
3184

    
3185
static void new_subtitle_stream(AVFormatContext *oc)
3186
{
3187
    AVStream *st;
3188
    AVCodecContext *subtitle_enc;
3189

    
3190
    st = av_new_stream(oc, oc->nb_streams);
3191
    if (!st) {
3192
        fprintf(stderr, "Could not alloc stream\n");
3193
        av_exit(1);
3194
    }
3195
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3196

    
3197
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3198
    subtitle_bitstream_filters= NULL;
3199

    
3200
    subtitle_enc = st->codec;
3201
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3202
    if (subtitle_stream_copy) {
3203
        st->stream_copy = 1;
3204
    } else {
3205
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3206
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3207
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3208
    }
3209
    nb_ocodecs++;
3210

    
3211
    if (subtitle_language) {
3212
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3213
        av_free(subtitle_language);
3214
        subtitle_language = NULL;
3215
    }
3216

    
3217
    subtitle_disable = 0;
3218
    av_freep(&subtitle_codec_name);
3219
    subtitle_stream_copy = 0;
3220
}
3221

    
3222
static void opt_new_audio_stream(void)
3223
{
3224
    AVFormatContext *oc;
3225
    if (nb_output_files <= 0) {
3226
        fprintf(stderr, "At least one output file must be specified\n");
3227
        av_exit(1);
3228
    }
3229
    oc = output_files[nb_output_files - 1];
3230
    new_audio_stream(oc);
3231
}
3232

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

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

    
3255
static void opt_output_file(const char *filename)
3256
{
3257
    AVFormatContext *oc;
3258
    int use_video, use_audio, use_subtitle;
3259
    int input_has_video, input_has_audio, input_has_subtitle;
3260
    AVFormatParameters params, *ap = &params;
3261

    
3262
    if (!strcmp(filename, "-"))
3263
        filename = "pipe:";
3264

    
3265
    oc = av_alloc_format_context();
3266

    
3267
    if (!file_oformat) {
3268
        file_oformat = guess_format(NULL, filename, NULL);
3269
        if (!file_oformat) {
3270
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3271
                    filename);
3272
            av_exit(1);
3273
        }
3274
    }
3275

    
3276
    oc->oformat = file_oformat;
3277
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3278

    
3279
    if (!strcmp(file_oformat->name, "ffm") &&
3280
        av_strstart(filename, "http:", NULL)) {
3281
        /* special case for files sent to ffserver: we get the stream
3282
           parameters from ffserver */
3283
        int err = read_ffserver_streams(oc, filename);
3284
        if (err < 0) {
3285
            print_error(filename, err);
3286
            av_exit(1);
3287
        }
3288
    } else {
3289
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3290
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3291
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3292

    
3293
        /* disable if no corresponding type found and at least one
3294
           input file */
3295
        if (nb_input_files > 0) {
3296
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3297
                                         &input_has_subtitle);
3298
            if (!input_has_video)
3299
                use_video = 0;
3300
            if (!input_has_audio)
3301
                use_audio = 0;
3302
            if (!input_has_subtitle)
3303
                use_subtitle = 0;
3304
        }
3305

    
3306
        /* manual disable */
3307
        if (audio_disable) {
3308
            use_audio = 0;
3309
        }
3310
        if (video_disable) {
3311
            use_video = 0;
3312
        }
3313
        if (subtitle_disable) {
3314
            use_subtitle = 0;
3315
        }
3316

    
3317
        if (use_video) {
3318
            new_video_stream(oc);
3319
        }
3320

    
3321
        if (use_audio) {
3322
            new_audio_stream(oc);
3323
        }
3324

    
3325
        if (use_subtitle) {
3326
            new_subtitle_stream(oc);
3327
        }
3328

    
3329
        oc->timestamp = rec_timestamp;
3330

    
3331
        if (str_title)
3332
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3333
        if (str_author)
3334
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3335
        if (str_copyright)
3336
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3337
        if (str_comment)
3338
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3339
        if (str_album)
3340
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3341
        if (str_genre)
3342
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3343
    }
3344

    
3345
    output_files[nb_output_files++] = oc;
3346

    
3347
    /* check filename in case of an image number is expected */
3348
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3349
        if (!av_filename_number_test(oc->filename)) {
3350
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3351
            av_exit(1);
3352
        }
3353
    }
3354

    
3355
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3356
        /* test if it already exists to avoid loosing precious files */
3357
        if (!file_overwrite &&
3358
            (strchr(filename, ':') == NULL ||
3359
             filename[1] == ':' ||
3360
             av_strstart(filename, "file:", NULL))) {
3361
            if (url_exist(filename)) {
3362
                int c;
3363

    
3364
                if (!using_stdin) {
3365
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3366
                    fflush(stderr);
3367
                    c = getchar();
3368
                    if (toupper(c) != 'Y') {
3369
                        fprintf(stderr, "Not overwriting - exiting\n");
3370
                        av_exit(1);
3371
                    }
3372
                }
3373
                else {
3374
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3375
                    av_exit(1);
3376
                }
3377
            }
3378
        }
3379

    
3380
        /* open the file */
3381
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3382
            fprintf(stderr, "Could not open '%s'\n", filename);
3383
            av_exit(1);
3384
        }
3385
    }
3386

    
3387
    memset(ap, 0, sizeof(*ap));
3388
    if (av_set_parameters(oc, ap) < 0) {
3389
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3390
                oc->filename);
3391
        av_exit(1);
3392
    }
3393

    
3394
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3395
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3396
    oc->loop_output = loop_output;
3397

    
3398
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3399

    
3400
    /* reset some options */
3401
    file_oformat = NULL;
3402
    file_iformat = NULL;
3403
}
3404

    
3405
/* same option as mencoder */
3406
static void opt_pass(const char *pass_str)
3407
{
3408
    int pass;
3409
    pass = atoi(pass_str);
3410
    if (pass != 1 && pass != 2) {
3411
        fprintf(stderr, "pass number can be only 1 or 2\n");
3412
        av_exit(1);
3413
    }
3414
    do_pass = pass;
3415
}
3416

    
3417
static int64_t getutime(void)
3418
{
3419
#ifdef HAVE_GETRUSAGE
3420
    struct rusage rusage;
3421

    
3422
    getrusage(RUSAGE_SELF, &rusage);
3423
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3424
#elif defined(HAVE_GETPROCESSTIMES)
3425
    HANDLE proc;
3426
    FILETIME c, e, k, u;
3427
    proc = GetCurrentProcess();
3428
    GetProcessTimes(proc, &c, &e, &k, &u);
3429
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3430
#else
3431
    return av_gettime();
3432
#endif
3433
}
3434

    
3435
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3436
{
3437
    int i;
3438
    const char *p = str;
3439
    for(i = 0;; i++) {
3440
        dest[i] = atoi(p);
3441
        if(i == 63)
3442
            break;
3443
        p = strchr(p, ',');
3444
        if(!p) {
3445
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3446
            av_exit(1);
3447
        }
3448
        p++;
3449
    }
3450
}
3451

    
3452
static void opt_inter_matrix(const char *arg)
3453
{
3454
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3455
    parse_matrix_coeffs(inter_matrix, arg);
3456
}
3457

    
3458
static void opt_intra_matrix(const char *arg)
3459
{
3460
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3461
    parse_matrix_coeffs(intra_matrix, arg);
3462
}
3463

    
3464
/**
3465
 * Trivial log callback.
3466
 * Only suitable for show_help and similar since it lacks prefix handling.
3467
 */
3468
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3469
{
3470
    vfprintf(stdout, fmt, vl);
3471
}
3472

    
3473
static void show_help(void)
3474
{
3475
    av_log_set_callback(log_callback_help);
3476
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3477
           "Hyper fast Audio and Video encoder\n");
3478
    printf("\n");
3479
    show_help_options(options, "Main options:\n",
3480
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3481
    show_help_options(options, "\nAdvanced options:\n",
3482
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3483
                      OPT_EXPERT);
3484
    show_help_options(options, "\nVideo options:\n",
3485
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3486
                      OPT_VIDEO);
3487
    show_help_options(options, "\nAdvanced Video options:\n",
3488
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3489
                      OPT_VIDEO | OPT_EXPERT);
3490
    show_help_options(options, "\nAudio options:\n",
3491
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3492
                      OPT_AUDIO);
3493
    show_help_options(options, "\nAdvanced Audio options:\n",
3494
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3495
                      OPT_AUDIO | OPT_EXPERT);
3496
    show_help_options(options, "\nSubtitle options:\n",
3497
                      OPT_SUBTITLE | OPT_GRAB,
3498
                      OPT_SUBTITLE);
3499
    show_help_options(options, "\nAudio/Video grab options:\n",
3500
                      OPT_GRAB,
3501
                      OPT_GRAB);
3502
    printf("\n");
3503
    av_opt_show(avctx_opts[0], NULL);
3504
    printf("\n");
3505
    av_opt_show(avformat_opts, NULL);
3506
    printf("\n");
3507
    av_opt_show(sws_opts, NULL);
3508
}
3509

    
3510
static void opt_target(const char *arg)
3511
{
3512
    int norm = -1;
3513
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3514

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

    
3559
    if(norm < 0) {
3560
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3561
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3562
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3563
        av_exit(1);
3564
    }
3565

    
3566
    if(!strcmp(arg, "vcd")) {
3567

    
3568
        opt_video_codec("mpeg1video");
3569
        opt_audio_codec("mp2");
3570
        opt_format("vcd");
3571

    
3572
        opt_frame_size(norm ? "352x240" : "352x288");
3573
        opt_frame_rate(NULL, frame_rates[norm]);
3574
        opt_default("gop", norm ? "18" : "15");
3575

    
3576
        opt_default("b", "1150000");
3577
        opt_default("maxrate", "1150000");
3578
        opt_default("minrate", "1150000");
3579
        opt_default("bufsize", "327680"); // 40*1024*8;
3580

    
3581
        opt_default("ab", "224000");
3582
        audio_sample_rate = 44100;
3583
        audio_channels = 2;
3584

    
3585
        opt_default("packetsize", "2324");
3586
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3587

    
3588
        /* We have to offset the PTS, so that it is consistent with the SCR.
3589
           SCR starts at 36000, but the first two packs contain only padding
3590
           and the first pack from the other stream, respectively, may also have
3591
           been written before.
3592
           So the real data starts at SCR 36000+3*1200. */
3593
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3594
    } else if(!strcmp(arg, "svcd")) {
3595

    
3596
        opt_video_codec("mpeg2video");
3597
        opt_audio_codec("mp2");
3598
        opt_format("svcd");
3599

    
3600
        opt_frame_size(norm ? "480x480" : "480x576");
3601
        opt_frame_rate(NULL, frame_rates[norm]);
3602
        opt_default("gop", norm ? "18" : "15");
3603

    
3604
        opt_default("b", "2040000");
3605
        opt_default("maxrate", "2516000");
3606
        opt_default("minrate", "0"); //1145000;
3607
        opt_default("bufsize", "1835008"); //224*1024*8;
3608
        opt_default("flags", "+scan_offset");
3609

    
3610

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

    
3614
        opt_default("packetsize", "2324");
3615

    
3616
    } else if(!strcmp(arg, "dvd")) {
3617

    
3618
        opt_video_codec("mpeg2video");
3619
        opt_audio_codec("ac3");
3620
        opt_format("dvd");
3621

    
3622
        opt_frame_size(norm ? "720x480" : "720x576");
3623
        opt_frame_rate(NULL, frame_rates[norm]);
3624
        opt_default("gop", norm ? "18" : "15");
3625

    
3626
        opt_default("b", "6000000");
3627
        opt_default("maxrate", "9000000");
3628
        opt_default("minrate", "0"); //1500000;
3629
        opt_default("bufsize", "1835008"); //224*1024*8;
3630

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

    
3634
        opt_default("ab", "448000");
3635
        audio_sample_rate = 48000;
3636

    
3637
    } else if(!strncmp(arg, "dv", 2)) {
3638

    
3639
        opt_format("dv");
3640

    
3641
        opt_frame_size(norm ? "720x480" : "720x576");
3642
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3643
                                             (norm ? "yuv411p" : "yuv420p"));
3644
        opt_frame_rate(NULL, frame_rates[norm]);
3645

    
3646
        audio_sample_rate = 48000;
3647
        audio_channels = 2;
3648

    
3649
    } else {
3650
        fprintf(stderr, "Unknown target: %s\n", arg);
3651
        av_exit(1);
3652
    }
3653
}
3654

    
3655
static void opt_vstats_file (const char *arg)
3656
{
3657
    av_free (vstats_filename);
3658
    vstats_filename=av_strdup (arg);
3659
}
3660

    
3661
static void opt_vstats (void)
3662
{
3663
    char filename[40];
3664
    time_t today2 = time(NULL);
3665
    struct tm *today = localtime(&today2);
3666

    
3667
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3668
             today->tm_sec);
3669
    opt_vstats_file(filename);
3670
}
3671

    
3672
static int opt_bsf(const char *opt, const char *arg)
3673
{
3674
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3675
    AVBitStreamFilterContext **bsfp;
3676

    
3677
    if(!bsfc){
3678
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3679
        av_exit(1);
3680
    }
3681

    
3682
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3683
          *opt == 'a' ? &audio_bitstream_filters :
3684
                        &subtitle_bitstream_filters;
3685
    while(*bsfp)
3686
        bsfp= &(*bsfp)->next;
3687

    
3688
    *bsfp= bsfc;
3689

    
3690
    return 0;
3691
}
3692

    
3693
static int opt_preset(const char *opt, const char *arg)
3694
{
3695
    FILE *f=NULL;
3696
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3697
    int i;
3698
    const char *base[3]= { getenv("HOME"),
3699
                           "/usr/local/share",
3700
                           "/usr/share",
3701
                         };
3702

    
3703
    for(i=!base[0]; i<3 && !f; i++){
3704
        snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3705
        f= fopen(filename, "r");
3706
        if(!f){
3707
            char *codec_name= *opt == 'v' ? video_codec_name :
3708
                              *opt == 'a' ? audio_codec_name :
3709
                                            subtitle_codec_name;
3710
            snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3711
            f= fopen(filename, "r");
3712
        }
3713
    }
3714
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3715
              is_dos_path(arg))){
3716
        snprintf(filename, sizeof(filename), arg);
3717
        f= fopen(filename, "r");
3718
    }
3719

    
3720
    if(!f){
3721
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3722
        av_exit(1);
3723
    }
3724

    
3725
    while(!feof(f)){
3726
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3727
        if(line[0] == '#' && !e)
3728
            continue;
3729
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3730
        if(e){
3731
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3732
            av_exit(1);
3733
        }
3734
        if(!strcmp(tmp, "acodec")){
3735
            opt_audio_codec(tmp2);
3736
        }else if(!strcmp(tmp, "vcodec")){
3737
            opt_video_codec(tmp2);
3738
        }else if(!strcmp(tmp, "scodec")){
3739
            opt_subtitle_codec(tmp2);
3740
        }else if(opt_default(tmp, tmp2) < 0){
3741
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3742
            av_exit(1);
3743
        }
3744
    }
3745

    
3746
    fclose(f);
3747

    
3748
    return 0;
3749
}
3750

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

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

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

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

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

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

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

    
3876
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3877
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3878
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3879

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

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

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

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

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

    
3902
    show_banner();
3903

    
3904
    /* parse options */
3905
    parse_options(argc, argv, options, opt_output_file);
3906

    
3907
    /* file converter / grab */
3908
    if (nb_output_files <= 0) {
3909
        fprintf(stderr, "At least one output file must be specified\n");
3910
        av_exit(1);
3911
    }
3912

    
3913
    if (nb_input_files == 0) {
3914
        fprintf(stderr, "At least one input file must be specified\n");
3915
        av_exit(1);
3916
    }
3917

    
3918
    ti = getutime();
3919
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3920
              stream_maps, nb_stream_maps);
3921
    ti = getutime() - ti;
3922
    if (do_benchmark) {
3923
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3924
    }
3925

    
3926
    return av_exit(0);
3927
}