Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 34583e1b

History | View | Annotate | Download (140 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
#if HAVE_SYS_RESOURCE_H
45
#include <sys/types.h>
46
#include <sys/resource.h>
47
#elif HAVE_GETPROCESSTIMES
48
#include <windows.h>
49
#endif
50

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

    
55
#if HAVE_TERMIOS_H
56
#include <fcntl.h>
57
#include <sys/ioctl.h>
58
#include <sys/time.h>
59
#include <termios.h>
60
#elif 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
#if 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
#if 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
#if 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
#if 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 HAVE_TERMIOS_H
356
    int n = 1;
357
    unsigned char ch;
358
#if !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 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
#if 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, "Warning, using s16 intermediate sample format for resampling\n");
560
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
561
                                               enc->sample_rate, dec->sample_rate,
562
                                               enc->sample_fmt,  dec->sample_fmt,
563
                                               16, 10, 0, 0.8);
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 (!ost->audio_resample && 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 (!ost->audio_resample && 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 (CONFIG_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 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS)))
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
            fprintf(stderr, "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
                fprintf(stderr, "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
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : 1;
1265
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1266
                                          ist->st->codec->time_base.num * ticks) /
1267
                            ist->st->codec->time_base.den;
1268
                    }
1269
                    len = 0;
1270
                    break;
1271
            case CODEC_TYPE_SUBTITLE:
1272
                ret = avcodec_decode_subtitle(ist->st->codec,
1273
                                              &subtitle, &got_subtitle, ptr, len);
1274
                if (ret < 0)
1275
                    goto fail_decode;
1276
                if (!got_subtitle) {
1277
                    goto discard_packet;
1278
                }
1279
                subtitle_to_free = &subtitle;
1280
                len = 0;
1281
                break;
1282
            default:
1283
                goto fail_decode;
1284
            }
1285
        } else {
1286
            switch(ist->st->codec->codec_type) {
1287
            case CODEC_TYPE_AUDIO:
1288
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1289
                    ist->st->codec->sample_rate;
1290
                break;
1291
            case CODEC_TYPE_VIDEO:
1292
                if (ist->st->codec->time_base.num != 0) {
1293
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : 1;
1294
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1295
                                      ist->st->codec->time_base.num * ticks) /
1296
                        ist->st->codec->time_base.den;
1297
                }
1298
                break;
1299
            }
1300
            data_buf = ptr;
1301
            data_size = len;
1302
            ret = len;
1303
            len = 0;
1304
        }
1305

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

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

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

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

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

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

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

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

    
1378
                        /* no reencoding needed : output the packet directly */
1379
                        /* force the input stream PTS */
1380

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

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

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

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

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

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

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

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

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

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

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

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

    
1506
    return 0;
1507
 fail_decode:
1508
    return -1;
1509
}
1510

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

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

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

    
1543
    return -1;
1544
}
1545

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1729
        codec = ost->st->codec;
1730
        icodec = ist->st->codec;
1731

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

    
1736
        ost->st->disposition = ist->st->disposition;
1737

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

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

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

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

    
1906
    if (!bit_buffer)
1907
        bit_buffer = av_malloc(bit_buffer_size);
1908
    if (!bit_buffer)
1909
        goto fail;
1910

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

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

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

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

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

    
1987
    /* set meta data information from input file if required */
1988
    for (i=0;i<nb_meta_data_maps;i++) {
1989
        AVFormatContext *out_file;
1990
        AVFormatContext *in_file;
1991

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

    
2005
        out_file = output_files[out_file_index];
2006
        in_file = input_files[in_file_index];
2007

    
2008
        strcpy(out_file->title, in_file->title);
2009
        strcpy(out_file->author, in_file->author);
2010
        strcpy(out_file->copyright, in_file->copyright);
2011
        strcpy(out_file->comment, in_file->comment);
2012
        strcpy(out_file->album, in_file->album);
2013
        out_file->year = in_file->year;
2014
        out_file->track = in_file->track;
2015
        strcpy(out_file->genre, in_file->genre);
2016
    }
2017

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

    
2034
    if (!using_stdin && verbose >= 0) {
2035
        fprintf(stderr, "Press [q] to stop encoding\n");
2036
        url_set_interrupt_cb(decode_interrupt_cb);
2037
    }
2038
    term_init();
2039

    
2040
    key = -1;
2041
    timer_start = av_gettime();
2042

    
2043
    for(; received_sigterm == 0;) {
2044
        int file_index, ist_index;
2045
        AVPacket pkt;
2046
        double ipts_min;
2047
        double opts_min;
2048

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

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

    
2095
        /* finish if recording time exhausted */
2096
        if (opts_min >= (recording_time / 1000000.0))
2097
            break;
2098

    
2099
        /* finish if limit size exhausted */
2100
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2101
            break;
2102

    
2103
        /* read a frame from it and output it in the fifo */
2104
        is = input_files[file_index];
2105
        ret= av_read_frame(is, &pkt);
2106
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm"))
2107
            continue;
2108
        if (ret < 0) {
2109
            file_table[file_index].eof_reached = 1;
2110
            if (opt_shortest)
2111
                break;
2112
            else
2113
                continue;
2114
        }
2115

    
2116
        if (do_pkt_dump) {
2117
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2118
        }
2119
        /* the following test is needed in case new streams appear
2120
           dynamically in stream : we ignore them */
2121
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2122
            goto discard_packet;
2123
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2124
        ist = ist_table[ist_index];
2125
        if (ist->discard)
2126
            goto discard_packet;
2127

    
2128
        if (pkt.dts != AV_NOPTS_VALUE)
2129
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2130
        if (pkt.pts != AV_NOPTS_VALUE)
2131
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2132

    
2133
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2134
            if(pkt.pts != AV_NOPTS_VALUE)
2135
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2136
            if(pkt.dts != AV_NOPTS_VALUE)
2137
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2138
        }
2139

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

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

    
2158
            if (verbose >= 0)
2159
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2160
                        ist->file_index, ist->index);
2161
            if (exit_on_error)
2162
                av_exit(1);
2163
            av_free_packet(&pkt);
2164
            goto redo;
2165
        }
2166

    
2167
    discard_packet:
2168
        av_free_packet(&pkt);
2169

    
2170
        /* dump report by using the output first video and audio streams */
2171
        print_report(output_files, ost_table, nb_ostreams, 0);
2172
    }
2173

    
2174
    /* at the end of stream, we must flush the decoder buffers */
2175
    for(i=0;i<nb_istreams;i++) {
2176
        ist = ist_table[i];
2177
        if (ist->decoding_needed) {
2178
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2179
        }
2180
    }
2181

    
2182
    term_exit();
2183

    
2184
    /* write the trailer if needed and close file */
2185
    for(i=0;i<nb_output_files;i++) {
2186
        os = output_files[i];
2187
        av_write_trailer(os);
2188
    }
2189

    
2190
    /* dump report by using the first video and audio streams */
2191
    print_report(output_files, ost_table, nb_ostreams, 1);
2192

    
2193
    /* close each encoder */
2194
    for(i=0;i<nb_ostreams;i++) {
2195
        ost = ost_table[i];
2196
        if (ost->encoding_needed) {
2197
            av_freep(&ost->st->codec->stats_in);
2198
            avcodec_close(ost->st->codec);
2199
        }
2200
    }
2201

    
2202
    /* close each decoder */
2203
    for(i=0;i<nb_istreams;i++) {
2204
        ist = ist_table[i];
2205
        if (ist->decoding_needed) {
2206
            avcodec_close(ist->st->codec);
2207
        }
2208
    }
2209

    
2210
    /* finished ! */
2211

    
2212
    ret = 0;
2213
 fail1:
2214
    av_freep(&bit_buffer);
2215
    av_free(file_table);
2216

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

    
2252
#if 0
2253
int file_read(const char *filename)
2254
{
2255
    URLContext *h;
2256
    unsigned char buffer[1024];
2257
    int len, i;
2258

2259
    if (url_open(&h, filename, O_RDONLY) < 0) {
2260
        printf("could not open '%s'\n", filename);
2261
        return -1;
2262
    }
2263
    for(;;) {
2264
        len = url_read(h, buffer, sizeof(buffer));
2265
        if (len <= 0)
2266
            break;
2267
        for(i=0;i<len;i++) putchar(buffer[i]);
2268
    }
2269
    url_close(h);
2270
    return 0;
2271
}
2272
#endif
2273

    
2274
static void opt_format(const char *arg)
2275
{
2276
    /* compatibility stuff for pgmyuv */
2277
    if (!strcmp(arg, "pgmyuv")) {
2278
        pgmyuv_compatibility_hack=1;
2279
//        opt_image_format(arg);
2280
        arg = "image2";
2281
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2282
    }
2283

    
2284
    file_iformat = av_find_input_format(arg);
2285
    file_oformat = guess_format(arg, NULL, NULL);
2286
    if (!file_iformat && !file_oformat) {
2287
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2288
        av_exit(1);
2289
    }
2290
}
2291

    
2292
static void opt_video_rc_override_string(const char *arg)
2293
{
2294
    video_rc_override_string = arg;
2295
}
2296

    
2297
static int opt_me_threshold(const char *opt, const char *arg)
2298
{
2299
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2300
    return 0;
2301
}
2302

    
2303
static int opt_verbose(const char *opt, const char *arg)
2304
{
2305
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2306
    av_log_set_level(verbose);
2307
    return 0;
2308
}
2309

    
2310
static int opt_frame_rate(const char *opt, const char *arg)
2311
{
2312
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2313
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2314
        av_exit(1);
2315
    }
2316
    return 0;
2317
}
2318

    
2319
static int opt_bitrate(const char *opt, const char *arg)
2320
{
2321
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2322

    
2323
    opt_default(opt, arg);
2324

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

    
2328
    return 0;
2329
}
2330

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

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

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

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

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

    
2415

    
2416
#define SCALEBITS 10
2417
#define ONE_HALF  (1 << (SCALEBITS - 1))
2418
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2419

    
2420
#define RGB_TO_Y(r, g, b) \
2421
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2422
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2423

    
2424
#define RGB_TO_U(r1, g1, b1, shift)\
2425
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2426
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2427

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

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

    
2438
    r = (rgb >> 16);
2439
    g = ((rgb >> 8) & 255);
2440
    b = (rgb & 255);
2441

    
2442
    padcolor[0] = RGB_TO_Y(r,g,b);
2443
    padcolor[1] = RGB_TO_U(r,g,b,0);
2444
    padcolor[2] = RGB_TO_V(r,g,b,0);
2445
}
2446

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

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

    
2473

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

    
2487

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

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

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

    
2521
static void opt_frame_aspect_ratio(const char *arg)
2522
{
2523
    int x = 0, y = 0;
2524
    double ar = 0;
2525
    const char *p;
2526
    char *end;
2527

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

    
2538
    if (!ar) {
2539
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2540
        av_exit(1);
2541
    }
2542
    frame_aspect_ratio = ar;
2543
}
2544

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

    
2555
static void opt_top_field_first(const char *arg)
2556
{
2557
    top_field_first= atoi(arg);
2558
}
2559

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

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

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

    
2586
static int opt_audio_channels(const char *opt, const char *arg)
2587
{
2588
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2589
    return 0;
2590
}
2591

    
2592
static void opt_video_channel(const char *arg)
2593
{
2594
    video_channel = strtol(arg, NULL, 0);
2595
}
2596

    
2597
static void opt_video_standard(const char *arg)
2598
{
2599
    video_standard = av_strdup(arg);
2600
}
2601

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

    
2613
static void opt_audio_codec(const char *arg)
2614
{
2615
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2616
}
2617

    
2618
static void opt_audio_tag(const char *arg)
2619
{
2620
    char *tail;
2621
    audio_codec_tag= strtol(arg, &tail, 0);
2622

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

    
2627
static void opt_video_tag(const char *arg)
2628
{
2629
    char *tail;
2630
    video_codec_tag= strtol(arg, &tail, 0);
2631

    
2632
    if(!tail || *tail)
2633
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2634
}
2635

    
2636
#if CONFIG_VHOOK
2637
static void add_frame_hooker(const char *arg)
2638
{
2639
    int argc = 0;
2640
    char *argv[64];
2641
    int i;
2642
    char *args = av_strdup(arg);
2643

    
2644
    using_vhook = 1;
2645

    
2646
    argv[0] = strtok(args, " ");
2647
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2648
    }
2649

    
2650
    i = frame_hook_add(argc, argv);
2651

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

    
2659
static void opt_video_codec(const char *arg)
2660
{
2661
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2662
}
2663

    
2664
static void opt_subtitle_codec(const char *arg)
2665
{
2666
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2667
}
2668

    
2669
static void opt_map(const char *arg)
2670
{
2671
    AVStreamMap *m;
2672
    char *p;
2673

    
2674
    m = &stream_maps[nb_stream_maps++];
2675

    
2676
    m->file_index = strtol(arg, &p, 0);
2677
    if (*p)
2678
        p++;
2679

    
2680
    m->stream_index = strtol(p, &p, 0);
2681
    if (*p) {
2682
        p++;
2683
        m->sync_file_index = strtol(p, &p, 0);
2684
        if (*p)
2685
            p++;
2686
        m->sync_stream_index = strtol(p, &p, 0);
2687
    } else {
2688
        m->sync_file_index = m->file_index;
2689
        m->sync_stream_index = m->stream_index;
2690
    }
2691
}
2692

    
2693
static void opt_map_meta_data(const char *arg)
2694
{
2695
    AVMetaDataMap *m;
2696
    char *p;
2697

    
2698
    m = &meta_data_maps[nb_meta_data_maps++];
2699

    
2700
    m->out_file = strtol(arg, &p, 0);
2701
    if (*p)
2702
        p++;
2703

    
2704
    m->in_file = strtol(p, &p, 0);
2705
}
2706

    
2707
static void opt_input_ts_scale(const char *arg)
2708
{
2709
    unsigned int stream;
2710
    double scale;
2711
    char *p;
2712

    
2713
    stream = strtol(arg, &p, 0);
2714
    if (*p)
2715
        p++;
2716
    scale= strtod(p, &p);
2717

    
2718
    if(stream >= MAX_STREAMS)
2719
        av_exit(1);
2720

    
2721
    input_files_ts_scale[nb_input_files][stream]= scale;
2722
}
2723

    
2724
static int opt_recording_time(const char *opt, const char *arg)
2725
{
2726
    recording_time = parse_time_or_die(opt, arg, 1);
2727
    return 0;
2728
}
2729

    
2730
static int opt_start_time(const char *opt, const char *arg)
2731
{
2732
    start_time = parse_time_or_die(opt, arg, 1);
2733
    return 0;
2734
}
2735

    
2736
static int opt_rec_timestamp(const char *opt, const char *arg)
2737
{
2738
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2739
    return 0;
2740
}
2741

    
2742
static int opt_input_ts_offset(const char *opt, const char *arg)
2743
{
2744
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2745
    return 0;
2746
}
2747

    
2748
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2749
{
2750
    const char *codec_string = encoder ? "encoder" : "decoder";
2751
    AVCodec *codec;
2752

    
2753
    if(!name)
2754
        return CODEC_ID_NONE;
2755
    codec = encoder ?
2756
        avcodec_find_encoder_by_name(name) :
2757
        avcodec_find_decoder_by_name(name);
2758
    if(!codec) {
2759
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2760
        av_exit(1);
2761
    }
2762
    if(codec->type != type) {
2763
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2764
        av_exit(1);
2765
    }
2766
    return codec->id;
2767
}
2768

    
2769
static void opt_input_file(const char *filename)
2770
{
2771
    AVFormatContext *ic;
2772
    AVFormatParameters params, *ap = &params;
2773
    int err, i, ret, rfps, rfps_base;
2774
    int64_t timestamp;
2775

    
2776
    if (!strcmp(filename, "-"))
2777
        filename = "pipe:";
2778

    
2779
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2780
                    !strcmp(filename, "/dev/stdin");
2781

    
2782
    /* get default parameters from command line */
2783
    ic = avformat_alloc_context();
2784

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

    
2802
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2803

    
2804
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2805
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2806
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2807

    
2808
    /* open the input file with generic libav function */
2809
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2810
    if (err < 0) {
2811
        print_error(filename, err);
2812
        av_exit(1);
2813
    }
2814
    if(opt_programid) {
2815
        int i;
2816
        for(i=0; i<ic->nb_programs; i++)
2817
            if(ic->programs[i]->id != opt_programid)
2818
                ic->programs[i]->discard = AVDISCARD_ALL;
2819
    }
2820

    
2821
    ic->loop_input = loop_input;
2822

    
2823
    /* If not enough info to get the stream parameters, we decode the
2824
       first frames to get it. (used in mpeg case for example) */
2825
    ret = av_find_stream_info(ic);
2826
    if (ret < 0 && verbose >= 0) {
2827
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2828
        av_exit(1);
2829
    }
2830

    
2831
    timestamp = start_time;
2832
    /* add the stream start time */
2833
    if (ic->start_time != AV_NOPTS_VALUE)
2834
        timestamp += ic->start_time;
2835

    
2836
    /* if seeking requested, we execute it */
2837
    if (start_time != 0) {
2838
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2839
        if (ret < 0) {
2840
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2841
                    filename, (double)timestamp / AV_TIME_BASE);
2842
        }
2843
        /* reset seek info */
2844
        start_time = 0;
2845
    }
2846

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

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

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

    
2887
                    (float)rfps / rfps_base, rfps, rfps_base);
2888
            }
2889
            /* update the current frame rate to match the stream frame rate */
2890
            frame_rate.num = rfps;
2891
            frame_rate.den = rfps_base;
2892

    
2893
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2894
            if(video_disable)
2895
                ic->streams[i]->discard= AVDISCARD_ALL;
2896
            else if(video_discard)
2897
                ic->streams[i]->discard= video_discard;
2898
            break;
2899
        case CODEC_TYPE_DATA:
2900
            break;
2901
        case CODEC_TYPE_SUBTITLE:
2902
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2903
            if(subtitle_disable)
2904
                ic->streams[i]->discard = AVDISCARD_ALL;
2905
            break;
2906
        case CODEC_TYPE_ATTACHMENT:
2907
        case CODEC_TYPE_UNKNOWN:
2908
            nb_icodecs++;
2909
            break;
2910
        default:
2911
            abort();
2912
        }
2913
    }
2914

    
2915
    input_files[nb_input_files] = ic;
2916
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2917
    /* dump the file content */
2918
    if (verbose >= 0)
2919
        dump_format(ic, nb_input_files, filename, 0);
2920

    
2921
    nb_input_files++;
2922
    file_iformat = NULL;
2923
    file_oformat = NULL;
2924

    
2925
    video_channel = 0;
2926

    
2927
    av_freep(&video_codec_name);
2928
    av_freep(&audio_codec_name);
2929
    av_freep(&subtitle_codec_name);
2930
}
2931

    
2932
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2933
                                         int *has_subtitle_ptr)
2934
{
2935
    int has_video, has_audio, has_subtitle, i, j;
2936
    AVFormatContext *ic;
2937

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

    
2969
static void new_video_stream(AVFormatContext *oc)
2970
{
2971
    AVStream *st;
2972
    AVCodecContext *video_enc;
2973
    int codec_id;
2974

    
2975
    st = av_new_stream(oc, oc->nb_streams);
2976
    if (!st) {
2977
        fprintf(stderr, "Could not alloc stream\n");
2978
        av_exit(1);
2979
    }
2980
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2981
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2982
    video_bitstream_filters= NULL;
2983

    
2984
    if(thread_count>1)
2985
        avcodec_thread_init(st->codec, thread_count);
2986

    
2987
    video_enc = st->codec;
2988

    
2989
    if(video_codec_tag)
2990
        video_enc->codec_tag= video_codec_tag;
2991

    
2992
    if(   (video_global_header&1)
2993
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2994
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2995
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2996
    }
2997
    if(video_global_header&2){
2998
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2999
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3000
    }
3001

    
3002
    if (video_stream_copy) {
3003
        st->stream_copy = 1;
3004
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3005
        video_enc->sample_aspect_ratio =
3006
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3007
    } else {
3008
        const char *p;
3009
        int i;
3010
        AVCodec *codec;
3011
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3012

    
3013
        if (video_codec_name) {
3014
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3015
            codec = avcodec_find_encoder_by_name(video_codec_name);
3016
            output_codecs[nb_ocodecs] = codec;
3017
        } else {
3018
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3019
            codec = avcodec_find_encoder(codec_id);
3020
        }
3021

    
3022
        video_enc->codec_id = codec_id;
3023

    
3024
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3025

    
3026
        if (codec && codec->supported_framerates && !force_fps)
3027
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3028
        video_enc->time_base.den = fps.num;
3029
        video_enc->time_base.num = fps.den;
3030

    
3031
        video_enc->width = frame_width + frame_padright + frame_padleft;
3032
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3033
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3034
        video_enc->pix_fmt = frame_pix_fmt;
3035
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3036

    
3037
        if(codec && codec->pix_fmts){
3038
            const enum PixelFormat *p= codec->pix_fmts;
3039
            for(; *p!=-1; p++){
3040
                if(*p == video_enc->pix_fmt)
3041
                    break;
3042
            }
3043
            if(*p == -1)
3044
                video_enc->pix_fmt = codec->pix_fmts[0];
3045
        }
3046

    
3047
        if (intra_only)
3048
            video_enc->gop_size = 0;
3049
        if (video_qscale || same_quality) {
3050
            video_enc->flags |= CODEC_FLAG_QSCALE;
3051
            video_enc->global_quality=
3052
                st->quality = FF_QP2LAMBDA * video_qscale;
3053
        }
3054

    
3055
        if(intra_matrix)
3056
            video_enc->intra_matrix = intra_matrix;
3057
        if(inter_matrix)
3058
            video_enc->inter_matrix = inter_matrix;
3059

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

    
3091
        if (do_psnr)
3092
            video_enc->flags|= CODEC_FLAG_PSNR;
3093

    
3094
        /* two pass mode */
3095
        if (do_pass) {
3096
            if (do_pass == 1) {
3097
                video_enc->flags |= CODEC_FLAG_PASS1;
3098
            } else {
3099
                video_enc->flags |= CODEC_FLAG_PASS2;
3100
            }
3101
        }
3102
    }
3103
    nb_ocodecs++;
3104

    
3105
    /* reset some key parameters */
3106
    video_disable = 0;
3107
    av_freep(&video_codec_name);
3108
    video_stream_copy = 0;
3109
}
3110

    
3111
static void new_audio_stream(AVFormatContext *oc)
3112
{
3113
    AVStream *st;
3114
    AVCodecContext *audio_enc;
3115
    int codec_id;
3116

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

    
3124
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3125
    audio_bitstream_filters= NULL;
3126

    
3127
    if(thread_count>1)
3128
        avcodec_thread_init(st->codec, thread_count);
3129

    
3130
    audio_enc = st->codec;
3131
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3132

    
3133
    if(audio_codec_tag)
3134
        audio_enc->codec_tag= audio_codec_tag;
3135

    
3136
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3137
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3138
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3139
    }
3140
    if (audio_stream_copy) {
3141
        st->stream_copy = 1;
3142
        audio_enc->channels = audio_channels;
3143
    } else {
3144
        AVCodec *codec;
3145

    
3146
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3147

    
3148
        if (audio_codec_name) {
3149
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3150
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3151
            output_codecs[nb_ocodecs] = codec;
3152
        } else {
3153
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3154
            codec = avcodec_find_encoder(codec_id);
3155
        }
3156
        audio_enc->codec_id = codec_id;
3157

    
3158
        if (audio_qscale > QSCALE_NONE) {
3159
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3160
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3161
        }
3162
        audio_enc->thread_count = thread_count;
3163
        audio_enc->channels = audio_channels;
3164
        audio_enc->sample_fmt = audio_sample_fmt;
3165
        audio_enc->channel_layout = channel_layout;
3166

    
3167
        if(codec && codec->sample_fmts){
3168
            const enum SampleFormat *p= codec->sample_fmts;
3169
            for(; *p!=-1; p++){
3170
                if(*p == audio_enc->sample_fmt)
3171
                    break;
3172
            }
3173
            if(*p == -1)
3174
                audio_enc->sample_fmt = codec->sample_fmts[0];
3175
        }
3176
    }
3177
    nb_ocodecs++;
3178
    audio_enc->sample_rate = audio_sample_rate;
3179
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3180
    if (audio_language) {
3181
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3182
        av_free(audio_language);
3183
        audio_language = NULL;
3184
    }
3185

    
3186
    /* reset some key parameters */
3187
    audio_disable = 0;
3188
    av_freep(&audio_codec_name);
3189
    audio_stream_copy = 0;
3190
}
3191

    
3192
static void new_subtitle_stream(AVFormatContext *oc)
3193
{
3194
    AVStream *st;
3195
    AVCodecContext *subtitle_enc;
3196

    
3197
    st = av_new_stream(oc, oc->nb_streams);
3198
    if (!st) {
3199
        fprintf(stderr, "Could not alloc stream\n");
3200
        av_exit(1);
3201
    }
3202
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3203

    
3204
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3205
    subtitle_bitstream_filters= NULL;
3206

    
3207
    subtitle_enc = st->codec;
3208
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3209
    if (subtitle_stream_copy) {
3210
        st->stream_copy = 1;
3211
    } else {
3212
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3213
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3214
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3215
    }
3216
    nb_ocodecs++;
3217

    
3218
    if (subtitle_language) {
3219
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3220
        av_free(subtitle_language);
3221
        subtitle_language = NULL;
3222
    }
3223

    
3224
    subtitle_disable = 0;
3225
    av_freep(&subtitle_codec_name);
3226
    subtitle_stream_copy = 0;
3227
}
3228

    
3229
static void opt_new_audio_stream(void)
3230
{
3231
    AVFormatContext *oc;
3232
    if (nb_output_files <= 0) {
3233
        fprintf(stderr, "At least one output file must be specified\n");
3234
        av_exit(1);
3235
    }
3236
    oc = output_files[nb_output_files - 1];
3237
    new_audio_stream(oc);
3238
}
3239

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

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

    
3262
static void opt_output_file(const char *filename)
3263
{
3264
    AVFormatContext *oc;
3265
    int use_video, use_audio, use_subtitle;
3266
    int input_has_video, input_has_audio, input_has_subtitle;
3267
    AVFormatParameters params, *ap = &params;
3268

    
3269
    if (!strcmp(filename, "-"))
3270
        filename = "pipe:";
3271

    
3272
    oc = avformat_alloc_context();
3273

    
3274
    if (!file_oformat) {
3275
        file_oformat = guess_format(NULL, filename, NULL);
3276
        if (!file_oformat) {
3277
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3278
                    filename);
3279
            av_exit(1);
3280
        }
3281
    }
3282

    
3283
    oc->oformat = file_oformat;
3284
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3285

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

    
3300
        /* disable if no corresponding type found and at least one
3301
           input file */
3302
        if (nb_input_files > 0) {
3303
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3304
                                         &input_has_subtitle);
3305
            if (!input_has_video)
3306
                use_video = 0;
3307
            if (!input_has_audio)
3308
                use_audio = 0;
3309
            if (!input_has_subtitle)
3310
                use_subtitle = 0;
3311
        }
3312

    
3313
        /* manual disable */
3314
        if (audio_disable) {
3315
            use_audio = 0;
3316
        }
3317
        if (video_disable) {
3318
            use_video = 0;
3319
        }
3320
        if (subtitle_disable) {
3321
            use_subtitle = 0;
3322
        }
3323

    
3324
        if (use_video) {
3325
            new_video_stream(oc);
3326
        }
3327

    
3328
        if (use_audio) {
3329
            new_audio_stream(oc);
3330
        }
3331

    
3332
        if (use_subtitle) {
3333
            new_subtitle_stream(oc);
3334
        }
3335

    
3336
        oc->timestamp = rec_timestamp;
3337

    
3338
        if (str_title)
3339
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3340
        if (str_author)
3341
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3342
        if (str_copyright)
3343
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3344
        if (str_comment)
3345
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3346
        if (str_album)
3347
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3348
        if (str_genre)
3349
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3350
    }
3351

    
3352
    output_files[nb_output_files++] = oc;
3353

    
3354
    /* check filename in case of an image number is expected */
3355
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3356
        if (!av_filename_number_test(oc->filename)) {
3357
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3358
            av_exit(1);
3359
        }
3360
    }
3361

    
3362
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3363
        /* test if it already exists to avoid loosing precious files */
3364
        if (!file_overwrite &&
3365
            (strchr(filename, ':') == NULL ||
3366
             filename[1] == ':' ||
3367
             av_strstart(filename, "file:", NULL))) {
3368
            if (url_exist(filename)) {
3369
                int c;
3370

    
3371
                if (!using_stdin) {
3372
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3373
                    fflush(stderr);
3374
                    c = getchar();
3375
                    if (toupper(c) != 'Y') {
3376
                        fprintf(stderr, "Not overwriting - exiting\n");
3377
                        av_exit(1);
3378
                    }
3379
                }
3380
                else {
3381
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3382
                    av_exit(1);
3383
                }
3384
            }
3385
        }
3386

    
3387
        /* open the file */
3388
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3389
            fprintf(stderr, "Could not open '%s'\n", filename);
3390
            av_exit(1);
3391
        }
3392
    }
3393

    
3394
    memset(ap, 0, sizeof(*ap));
3395
    if (av_set_parameters(oc, ap) < 0) {
3396
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3397
                oc->filename);
3398
        av_exit(1);
3399
    }
3400

    
3401
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3402
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3403
    oc->loop_output = loop_output;
3404

    
3405
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3406

    
3407
    /* reset some options */
3408
    file_oformat = NULL;
3409
    file_iformat = NULL;
3410
}
3411

    
3412
/* same option as mencoder */
3413
static void opt_pass(const char *pass_str)
3414
{
3415
    int pass;
3416
    pass = atoi(pass_str);
3417
    if (pass != 1 && pass != 2) {
3418
        fprintf(stderr, "pass number can be only 1 or 2\n");
3419
        av_exit(1);
3420
    }
3421
    do_pass = pass;
3422
}
3423

    
3424
static int64_t getutime(void)
3425
{
3426
#if HAVE_GETRUSAGE
3427
    struct rusage rusage;
3428

    
3429
    getrusage(RUSAGE_SELF, &rusage);
3430
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3431
#elif HAVE_GETPROCESSTIMES
3432
    HANDLE proc;
3433
    FILETIME c, e, k, u;
3434
    proc = GetCurrentProcess();
3435
    GetProcessTimes(proc, &c, &e, &k, &u);
3436
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3437
#else
3438
    return av_gettime();
3439
#endif
3440
}
3441

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

    
3459
static void opt_inter_matrix(const char *arg)
3460
{
3461
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3462
    parse_matrix_coeffs(inter_matrix, arg);
3463
}
3464

    
3465
static void opt_intra_matrix(const char *arg)
3466
{
3467
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3468
    parse_matrix_coeffs(intra_matrix, arg);
3469
}
3470

    
3471
/**
3472
 * Trivial log callback.
3473
 * Only suitable for show_help and similar since it lacks prefix handling.
3474
 */
3475
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3476
{
3477
    vfprintf(stdout, fmt, vl);
3478
}
3479

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

    
3517
static void opt_target(const char *arg)
3518
{
3519
    int norm = -1;
3520
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3521

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

    
3566
    if(norm < 0) {
3567
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3568
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3569
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3570
        av_exit(1);
3571
    }
3572

    
3573
    if(!strcmp(arg, "vcd")) {
3574

    
3575
        opt_video_codec("mpeg1video");
3576
        opt_audio_codec("mp2");
3577
        opt_format("vcd");
3578

    
3579
        opt_frame_size(norm ? "352x240" : "352x288");
3580
        opt_frame_rate(NULL, frame_rates[norm]);
3581
        opt_default("gop", norm ? "18" : "15");
3582

    
3583
        opt_default("b", "1150000");
3584
        opt_default("maxrate", "1150000");
3585
        opt_default("minrate", "1150000");
3586
        opt_default("bufsize", "327680"); // 40*1024*8;
3587

    
3588
        opt_default("ab", "224000");
3589
        audio_sample_rate = 44100;
3590
        audio_channels = 2;
3591

    
3592
        opt_default("packetsize", "2324");
3593
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3594

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

    
3603
        opt_video_codec("mpeg2video");
3604
        opt_audio_codec("mp2");
3605
        opt_format("svcd");
3606

    
3607
        opt_frame_size(norm ? "480x480" : "480x576");
3608
        opt_frame_rate(NULL, frame_rates[norm]);
3609
        opt_default("gop", norm ? "18" : "15");
3610

    
3611
        opt_default("b", "2040000");
3612
        opt_default("maxrate", "2516000");
3613
        opt_default("minrate", "0"); //1145000;
3614
        opt_default("bufsize", "1835008"); //224*1024*8;
3615
        opt_default("flags", "+scan_offset");
3616

    
3617

    
3618
        opt_default("ab", "224000");
3619
        audio_sample_rate = 44100;
3620

    
3621
        opt_default("packetsize", "2324");
3622

    
3623
    } else if(!strcmp(arg, "dvd")) {
3624

    
3625
        opt_video_codec("mpeg2video");
3626
        opt_audio_codec("ac3");
3627
        opt_format("dvd");
3628

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

    
3633
        opt_default("b", "6000000");
3634
        opt_default("maxrate", "9000000");
3635
        opt_default("minrate", "0"); //1500000;
3636
        opt_default("bufsize", "1835008"); //224*1024*8;
3637

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

    
3641
        opt_default("ab", "448000");
3642
        audio_sample_rate = 48000;
3643

    
3644
    } else if(!strncmp(arg, "dv", 2)) {
3645

    
3646
        opt_format("dv");
3647

    
3648
        opt_frame_size(norm ? "720x480" : "720x576");
3649
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3650
                                             (norm ? "yuv411p" : "yuv420p"));
3651
        opt_frame_rate(NULL, frame_rates[norm]);
3652

    
3653
        audio_sample_rate = 48000;
3654
        audio_channels = 2;
3655

    
3656
    } else {
3657
        fprintf(stderr, "Unknown target: %s\n", arg);
3658
        av_exit(1);
3659
    }
3660
}
3661

    
3662
static void opt_vstats_file (const char *arg)
3663
{
3664
    av_free (vstats_filename);
3665
    vstats_filename=av_strdup (arg);
3666
}
3667

    
3668
static void opt_vstats (void)
3669
{
3670
    char filename[40];
3671
    time_t today2 = time(NULL);
3672
    struct tm *today = localtime(&today2);
3673

    
3674
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3675
             today->tm_sec);
3676
    opt_vstats_file(filename);
3677
}
3678

    
3679
static int opt_bsf(const char *opt, const char *arg)
3680
{
3681
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3682
    AVBitStreamFilterContext **bsfp;
3683

    
3684
    if(!bsfc){
3685
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3686
        av_exit(1);
3687
    }
3688

    
3689
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3690
          *opt == 'a' ? &audio_bitstream_filters :
3691
                        &subtitle_bitstream_filters;
3692
    while(*bsfp)
3693
        bsfp= &(*bsfp)->next;
3694

    
3695
    *bsfp= bsfc;
3696

    
3697
    return 0;
3698
}
3699

    
3700
static int opt_preset(const char *opt, const char *arg)
3701
{
3702
    FILE *f=NULL;
3703
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3704
    int i;
3705
    const char *base[2]= { getenv("HOME"),
3706
                           FFMPEG_DATADIR,
3707
                         };
3708

    
3709
    for(i=!base[0]; i<2 && !f; i++){
3710
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3711
        f= fopen(filename, "r");
3712
        if(!f){
3713
            char *codec_name= *opt == 'v' ? video_codec_name :
3714
                              *opt == 'a' ? audio_codec_name :
3715
                                            subtitle_codec_name;
3716
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3717
            f= fopen(filename, "r");
3718
        }
3719
    }
3720
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3721
              is_dos_path(arg))){
3722
        av_strlcpy(filename, arg, sizeof(filename));
3723
        f= fopen(filename, "r");
3724
    }
3725

    
3726
    if(!f){
3727
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3728
        av_exit(1);
3729
    }
3730

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

    
3752
    fclose(f);
3753

    
3754
    return 0;
3755
}
3756

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

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

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

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

    
3869
    /* grab options */
3870
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3871
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3872
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3873

    
3874
    /* muxer options */
3875
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3876
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3877

    
3878
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3879
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3880
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3881

    
3882
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3883
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3884
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3885

    
3886
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3887
    { NULL, },
3888
};
3889

    
3890
int main(int argc, char **argv)
3891
{
3892
    int i;
3893
    int64_t ti;
3894

    
3895
    avcodec_register_all();
3896
    avdevice_register_all();
3897
    av_register_all();
3898

    
3899
    if(isatty(STDIN_FILENO))
3900
        url_set_interrupt_cb(decode_interrupt_cb);
3901

    
3902
    for(i=0; i<CODEC_TYPE_NB; i++){
3903
        avctx_opts[i]= avcodec_alloc_context2(i);
3904
    }
3905
    avformat_opts = avformat_alloc_context();
3906
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3907

    
3908
    show_banner();
3909

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

    
3913
    /* file converter / grab */
3914
    if (nb_output_files <= 0) {
3915
        fprintf(stderr, "At least one output file must be specified\n");
3916
        av_exit(1);
3917
    }
3918

    
3919
    if (nb_input_files == 0) {
3920
        fprintf(stderr, "At least one input file must be specified\n");
3921
        av_exit(1);
3922
    }
3923

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

    
3933
    return av_exit(0);
3934
}