Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 3b801075

History | View | Annotate | Download (141 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 "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/fifo.h"
40
#include "libavutil/avstring.h"
41
#include "libavformat/os_support.h"
42

    
43
#if HAVE_SYS_RESOURCE_H
44
#include <sys/types.h>
45
#include <sys/resource.h>
46
#elif HAVE_GETPROCESSTIMES
47
#include <windows.h>
48
#endif
49

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

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

    
65
#include "cmdutils.h"
66

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

    
70
#undef exit
71

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

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

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

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

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

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

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

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

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

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

    
162
static int subtitle_disable = 0;
163
static char *subtitle_codec_name = NULL;
164
static char *subtitle_language = NULL;
165
static int subtitle_codec_tag = 0;
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 int metadata_count;
176
static AVMetadataTag *metadata;
177
static int do_benchmark = 0;
178
static int do_hex_dump = 0;
179
static int do_pkt_dump = 0;
180
static int do_psnr = 0;
181
static int do_pass = 0;
182
static char *pass_logfilename_prefix = NULL;
183
static int audio_stream_copy = 0;
184
static int video_stream_copy = 0;
185
static int subtitle_stream_copy = 0;
186
static int video_sync_method= -1;
187
static int audio_sync_method= 0;
188
static float audio_drift_threshold= 0.1;
189
static int copy_ts= 0;
190
static int opt_shortest = 0;
191
static int video_global_header = 0;
192
static char *vstats_filename;
193
static FILE *vstats_file;
194
static int opt_programid = 0;
195
static int copy_initial_nonkeyframes = 0;
196

    
197
static int rate_emu = 0;
198

    
199
static int  video_channel = 0;
200
static char *video_standard;
201

    
202
static int audio_volume = 256;
203

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

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

    
221
static unsigned int sws_flags = SWS_BICUBIC;
222

    
223
static int64_t timer_start;
224

    
225
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
226
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
227
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
228
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
229

    
230
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
231

    
232
struct AVInputStream;
233

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

    
252
    int video_crop;
253
    int topBand;             /* cropping area sizes */
254
    int leftBand;
255

    
256
    int video_pad;
257
    int padtop;              /* padding area sizes */
258
    int padbottom;
259
    int padleft;
260
    int padright;
261

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

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

    
279
    int64_t       start;     /* time when read started */
280
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
281
                                is not defined */
282
    int64_t       pts;       /* current pts */
283
    int is_start;            /* is 1 at the start and after a discontinuity */
284
} AVInputStream;
285

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

    
293
#if HAVE_TERMIOS_H
294

    
295
/* init terminal so that we can grab keys */
296
static struct termios oldtty;
297
#endif
298

    
299
static void term_exit(void)
300
{
301
#if HAVE_TERMIOS_H
302
    tcsetattr (0, TCSANOW, &oldtty);
303
#endif
304
}
305

    
306
static volatile sig_atomic_t received_sigterm = 0;
307

    
308
static void
309
sigterm_handler(int sig)
310
{
311
    received_sigterm = sig;
312
    term_exit();
313
}
314

    
315
static void term_init(void)
316
{
317
#if HAVE_TERMIOS_H
318
    struct termios tty;
319

    
320
    tcgetattr (0, &tty);
321
    oldtty = tty;
322

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

    
332
    tcsetattr (0, TCSANOW, &tty);
333
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
334
#endif
335

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

    
347
/* read a key without blocking */
348
static int read_key(void)
349
{
350
#if HAVE_TERMIOS_H
351
    int n = 1;
352
    unsigned char ch;
353
#if !CONFIG_BEOS_NETSERVER
354
    struct timeval tv;
355
    fd_set rfds;
356

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

    
368
        return n;
369
    }
370
#elif HAVE_CONIO_H
371
    if(kbhit())
372
        return(getch());
373
#endif
374
    return -1;
375
}
376

    
377
static int decode_interrupt_cb(void)
378
{
379
    return q_pressed || (q_pressed = read_key() == 'q');
380
}
381

    
382
static int av_exit(int ret)
383
{
384
    int i;
385

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

    
410
    av_free(intra_matrix);
411
    av_free(inter_matrix);
412

    
413
    if (vstats_file)
414
        fclose(vstats_file);
415
    av_free(vstats_filename);
416

    
417
    av_free(opt_names);
418

    
419
    av_free(video_codec_name);
420
    av_free(audio_codec_name);
421
    av_free(subtitle_codec_name);
422

    
423
    av_free(video_standard);
424

    
425
#if CONFIG_POWERPC_PERF
426
    void powerpc_display_perf_report(void);
427
    powerpc_display_perf_report();
428
#endif /* CONFIG_POWERPC_PERF */
429

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

    
437
    for (i=0;i<CODEC_TYPE_NB;i++)
438
        av_free(avcodec_opts[i]);
439
    av_free(avformat_opts);
440
    av_free(sws_opts);
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_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
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) {
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 (picture != picture2)
772
        *picture = *picture2;
773
    *bufp = buf;
774
}
775

    
776
/* we begin to correct av delay at this threshold */
777
#define AV_DELAY_MAX 0.100
778

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

    
791
    if (pts == AV_NOPTS_VALUE) {
792
        fprintf(stderr, "Subtitle packets must have a pts\n");
793
        if (exit_on_error)
794
            av_exit(1);
795
        return;
796
    }
797

    
798
    enc = ost->st->codec;
799

    
800
    if (!subtitle_out) {
801
        subtitle_out = av_malloc(subtitle_out_max_size);
802
    }
803

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

    
812
    for(i = 0; i < nb; i++) {
813
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
814
                                                    subtitle_out_max_size, sub);
815

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

    
833
static int bit_buffer_size= 1024*256;
834
static uint8_t *bit_buffer= NULL;
835

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

    
847
    avcodec_get_frame_defaults(&picture_crop_temp);
848
    avcodec_get_frame_defaults(&picture_pad_temp);
849

    
850
    enc = ost->st->codec;
851
    dec = ist->st->codec;
852

    
853
    /* by default, we output a single frame */
854
    nb_frames = 1;
855

    
856
    *frame_size = 0;
857

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1078

    
1079
    oc = output_files[0];
1080

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

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

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

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

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

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

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

    
1160
        fflush(stderr);
1161
    }
1162

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

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

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

    
1196
    if (pkt == NULL) {
1197
        /* EOF handling */
1198
        av_init_packet(&avpkt);
1199
        avpkt.data = NULL;
1200
        avpkt.size = 0;
1201
        goto handle_eof;
1202
    } else {
1203
        avpkt = *pkt;
1204
    }
1205

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

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

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

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

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

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

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

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

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

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

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

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

    
1374
                        av_init_packet(&opkt);
1375

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1508
    return 0;
1509
 fail_decode:
1510
    return -1;
1511
}
1512

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

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

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

    
1545
    return -1;
1546
}
1547

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

    
1569
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1570
    if (!file_table)
1571
        goto fail;
1572

    
1573
    /* input stream init */
1574
    j = 0;
1575
    for(i=0;i<nb_input_files;i++) {
1576
        is = input_files[i];
1577
        file_table[i].ist_index = j;
1578
        file_table[i].nb_streams = is->nb_streams;
1579
        j += is->nb_streams;
1580
    }
1581
    nb_istreams = j;
1582

    
1583
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1584
    if (!ist_table)
1585
        goto fail;
1586

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

    
1604
            if (rate_emu) {
1605
                ist->start = av_gettime();
1606
            }
1607
        }
1608
    }
1609

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

    
1626
    /* Sanity check the mapping args -- do the input files & streams exist? */
1627
    for(i=0;i<nb_stream_maps;i++) {
1628
        int fi = stream_maps[i].file_index;
1629
        int si = stream_maps[i].stream_index;
1630

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

    
1645
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1646
    if (!ost_table)
1647
        goto fail;
1648
    for(i=0;i<nb_ostreams;i++) {
1649
        ost = av_mallocz(sizeof(AVOutputStream));
1650
        if (!ost)
1651
            goto fail;
1652
        ost_table[i] = ost;
1653
    }
1654

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

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

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

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

    
1728
    /* for each output stream, we compute the right encoding parameters */
1729
    for(i=0;i<nb_ostreams;i++) {
1730
        AVMetadataTag *lang;
1731
        ost = ost_table[i];
1732
        os = output_files[ost->file_index];
1733
        ist = ist_table[ost->source_index];
1734

    
1735
        codec = ost->st->codec;
1736
        icodec = ist->st->codec;
1737

    
1738
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1739
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1740
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1741

    
1742
        ost->st->disposition = ist->st->disposition;
1743

    
1744
        if (ost->st->stream_copy) {
1745
            /* if stream_copy is selected, no need to decode or encode */
1746
            codec->codec_id = icodec->codec_id;
1747
            codec->codec_type = icodec->codec_type;
1748

    
1749
            if(!codec->codec_tag){
1750
                if(   !os->oformat->codec_tag
1751
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1752
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1753
                    codec->codec_tag = icodec->codec_tag;
1754
            }
1755

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

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

    
1910
    if (!bit_buffer)
1911
        bit_buffer = av_malloc(bit_buffer_size);
1912
    if (!bit_buffer) {
1913
        ret = AVERROR(ENOMEM);
1914
        goto fail;
1915
    }
1916

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

    
1940
    /* open each decoder */
1941
    for(i=0;i<nb_istreams;i++) {
1942
        ist = ist_table[i];
1943
        if (ist->decoding_needed) {
1944
            AVCodec *codec = input_codecs[i];
1945
            if (!codec)
1946
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1947
            if (!codec) {
1948
                snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1949
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1950
                ret = AVERROR(EINVAL);
1951
                goto dump_format;
1952
            }
1953
            if (avcodec_open(ist->st->codec, codec) < 0) {
1954
                snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1955
                        ist->file_index, ist->index);
1956
                ret = AVERROR(EINVAL);
1957
                goto dump_format;
1958
            }
1959
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1960
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1961
        }
1962
    }
1963

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

    
1973
    /* set meta data information from input file if required */
1974
    for (i=0;i<nb_meta_data_maps;i++) {
1975
        AVFormatContext *out_file;
1976
        AVFormatContext *in_file;
1977
        AVMetadataTag *mtag;
1978

    
1979
        int out_file_index = meta_data_maps[i].out_file;
1980
        int in_file_index = meta_data_maps[i].in_file;
1981
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1982
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1983
                     out_file_index, out_file_index, in_file_index);
1984
            ret = AVERROR(EINVAL);
1985
            goto dump_format;
1986
        }
1987
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1988
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1989
                     in_file_index, out_file_index, in_file_index);
1990
            ret = AVERROR(EINVAL);
1991
            goto dump_format;
1992
        }
1993

    
1994
        out_file = output_files[out_file_index];
1995
        in_file = input_files[in_file_index];
1996

    
1997

    
1998
        mtag=NULL;
1999
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2000
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2001
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2002
                                    in_file->iformat->metadata_conv);
2003
    }
2004

    
2005
    /* open files and write file headers */
2006
    for(i=0;i<nb_output_files;i++) {
2007
        os = output_files[i];
2008
        if (av_write_header(os) < 0) {
2009
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2010
            ret = AVERROR(EINVAL);
2011
            goto dump_format;
2012
        }
2013
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2014
            want_sdp = 0;
2015
        }
2016
    }
2017

    
2018
 dump_format:
2019
    /* dump the file output parameters - cannot be done before in case
2020
       of stream copy */
2021
    for(i=0;i<nb_output_files;i++) {
2022
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2023
    }
2024

    
2025
    /* dump the stream mapping */
2026
    if (verbose >= 0) {
2027
        fprintf(stderr, "Stream mapping:\n");
2028
        for(i=0;i<nb_ostreams;i++) {
2029
            ost = ost_table[i];
2030
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2031
                    ist_table[ost->source_index]->file_index,
2032
                    ist_table[ost->source_index]->index,
2033
                    ost->file_index,
2034
                    ost->index);
2035
            if (ost->sync_ist != ist_table[ost->source_index])
2036
                fprintf(stderr, " [sync #%d.%d]",
2037
                        ost->sync_ist->file_index,
2038
                        ost->sync_ist->index);
2039
            fprintf(stderr, "\n");
2040
        }
2041
    }
2042

    
2043
    if (ret) {
2044
        fprintf(stderr, "%s\n", error);
2045
        goto fail;
2046
    }
2047

    
2048
    if (want_sdp) {
2049
        print_sdp(output_files, nb_output_files);
2050
    }
2051

    
2052
    if (!using_stdin && verbose >= 0) {
2053
        fprintf(stderr, "Press [q] to stop encoding\n");
2054
        url_set_interrupt_cb(decode_interrupt_cb);
2055
    }
2056
    term_init();
2057

    
2058
    key = -1;
2059
    timer_start = av_gettime();
2060

    
2061
    for(; received_sigterm == 0;) {
2062
        int file_index, ist_index;
2063
        AVPacket pkt;
2064
        double ipts_min;
2065
        double opts_min;
2066

    
2067
    redo:
2068
        ipts_min= 1e100;
2069
        opts_min= 1e100;
2070
        /* if 'q' pressed, exits */
2071
        if (!using_stdin) {
2072
            if (q_pressed)
2073
                break;
2074
            /* read_key() returns 0 on EOF */
2075
            key = read_key();
2076
            if (key == 'q')
2077
                break;
2078
        }
2079

    
2080
        /* select the stream that we must read now by looking at the
2081
           smallest output pts */
2082
        file_index = -1;
2083
        for(i=0;i<nb_ostreams;i++) {
2084
            double ipts, opts;
2085
            ost = ost_table[i];
2086
            os = output_files[ost->file_index];
2087
            ist = ist_table[ost->source_index];
2088
            if(no_packet[ist->file_index])
2089
                continue;
2090
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2091
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2092
            else
2093
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2094
            ipts = (double)ist->pts;
2095
            if (!file_table[ist->file_index].eof_reached){
2096
                if(ipts < ipts_min) {
2097
                    ipts_min = ipts;
2098
                    if(input_sync ) file_index = ist->file_index;
2099
                }
2100
                if(opts < opts_min) {
2101
                    opts_min = opts;
2102
                    if(!input_sync) file_index = ist->file_index;
2103
                }
2104
            }
2105
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2106
                file_index= -1;
2107
                break;
2108
            }
2109
        }
2110
        /* if none, if is finished */
2111
        if (file_index < 0) {
2112
            if(no_packet_count){
2113
                no_packet_count=0;
2114
                memset(no_packet, 0, sizeof(no_packet));
2115
                usleep(10000);
2116
                continue;
2117
            }
2118
            break;
2119
        }
2120

    
2121
        /* finish if recording time exhausted */
2122
        if (opts_min >= (recording_time / 1000000.0))
2123
            break;
2124

    
2125
        /* finish if limit size exhausted */
2126
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2127
            break;
2128

    
2129
        /* read a frame from it and output it in the fifo */
2130
        is = input_files[file_index];
2131
        ret= av_read_frame(is, &pkt);
2132
        if(ret == AVERROR(EAGAIN)){
2133
            no_packet[file_index]=1;
2134
            no_packet_count++;
2135
            continue;
2136
        }
2137
        if (ret < 0) {
2138
            file_table[file_index].eof_reached = 1;
2139
            if (opt_shortest)
2140
                break;
2141
            else
2142
                continue;
2143
        }
2144

    
2145
        no_packet_count=0;
2146
        memset(no_packet, 0, sizeof(no_packet));
2147

    
2148
        if (do_pkt_dump) {
2149
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2150
        }
2151
        /* the following test is needed in case new streams appear
2152
           dynamically in stream : we ignore them */
2153
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2154
            goto discard_packet;
2155
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2156
        ist = ist_table[ist_index];
2157
        if (ist->discard)
2158
            goto discard_packet;
2159

    
2160
        if (pkt.dts != AV_NOPTS_VALUE)
2161
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2162
        if (pkt.pts != AV_NOPTS_VALUE)
2163
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2164

    
2165
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2166
            if(pkt.pts != AV_NOPTS_VALUE)
2167
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2168
            if(pkt.dts != AV_NOPTS_VALUE)
2169
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2170
        }
2171

    
2172
//        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);
2173
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2174
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2175
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2176
            int64_t delta= pkt_dts - ist->next_pts;
2177
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2178
                input_files_ts_offset[ist->file_index]-= delta;
2179
                if (verbose > 2)
2180
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2181
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2182
                if(pkt.pts != AV_NOPTS_VALUE)
2183
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2184
            }
2185
        }
2186

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

    
2190
            if (verbose >= 0)
2191
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2192
                        ist->file_index, ist->index);
2193
            if (exit_on_error)
2194
                av_exit(1);
2195
            av_free_packet(&pkt);
2196
            goto redo;
2197
        }
2198

    
2199
    discard_packet:
2200
        av_free_packet(&pkt);
2201

    
2202
        /* dump report by using the output first video and audio streams */
2203
        print_report(output_files, ost_table, nb_ostreams, 0);
2204
    }
2205

    
2206
    /* at the end of stream, we must flush the decoder buffers */
2207
    for(i=0;i<nb_istreams;i++) {
2208
        ist = ist_table[i];
2209
        if (ist->decoding_needed) {
2210
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2211
        }
2212
    }
2213

    
2214
    term_exit();
2215

    
2216
    /* write the trailer if needed and close file */
2217
    for(i=0;i<nb_output_files;i++) {
2218
        os = output_files[i];
2219
        av_write_trailer(os);
2220
    }
2221

    
2222
    /* dump report by using the first video and audio streams */
2223
    print_report(output_files, ost_table, nb_ostreams, 1);
2224

    
2225
    /* close each encoder */
2226
    for(i=0;i<nb_ostreams;i++) {
2227
        ost = ost_table[i];
2228
        if (ost->encoding_needed) {
2229
            av_freep(&ost->st->codec->stats_in);
2230
            avcodec_close(ost->st->codec);
2231
        }
2232
    }
2233

    
2234
    /* close each decoder */
2235
    for(i=0;i<nb_istreams;i++) {
2236
        ist = ist_table[i];
2237
        if (ist->decoding_needed) {
2238
            avcodec_close(ist->st->codec);
2239
        }
2240
    }
2241

    
2242
    /* finished ! */
2243
    ret = 0;
2244

    
2245
 fail:
2246
    av_freep(&bit_buffer);
2247
    av_free(file_table);
2248

    
2249
    if (ist_table) {
2250
        for(i=0;i<nb_istreams;i++) {
2251
            ist = ist_table[i];
2252
            av_free(ist);
2253
        }
2254
        av_free(ist_table);
2255
    }
2256
    if (ost_table) {
2257
        for(i=0;i<nb_ostreams;i++) {
2258
            ost = ost_table[i];
2259
            if (ost) {
2260
                if (ost->logfile) {
2261
                    fclose(ost->logfile);
2262
                    ost->logfile = NULL;
2263
                }
2264
                av_fifo_free(ost->fifo); /* works even if fifo is not
2265
                                             initialized but set to zero */
2266
                av_free(ost->pict_tmp.data[0]);
2267
                if (ost->video_resample)
2268
                    sws_freeContext(ost->img_resample_ctx);
2269
                if (ost->resample)
2270
                    audio_resample_close(ost->resample);
2271
                if (ost->reformat_ctx)
2272
                    av_audio_convert_free(ost->reformat_ctx);
2273
                av_free(ost);
2274
            }
2275
        }
2276
        av_free(ost_table);
2277
    }
2278
    return ret;
2279
}
2280

    
2281
#if 0
2282
int file_read(const char *filename)
2283
{
2284
    URLContext *h;
2285
    unsigned char buffer[1024];
2286
    int len, i;
2287

2288
    if (url_open(&h, filename, O_RDONLY) < 0) {
2289
        printf("could not open '%s'\n", filename);
2290
        return -1;
2291
    }
2292
    for(;;) {
2293
        len = url_read(h, buffer, sizeof(buffer));
2294
        if (len <= 0)
2295
            break;
2296
        for(i=0;i<len;i++) putchar(buffer[i]);
2297
    }
2298
    url_close(h);
2299
    return 0;
2300
}
2301
#endif
2302

    
2303
static void opt_format(const char *arg)
2304
{
2305
    /* compatibility stuff for pgmyuv */
2306
    if (!strcmp(arg, "pgmyuv")) {
2307
        pgmyuv_compatibility_hack=1;
2308
//        opt_image_format(arg);
2309
        arg = "image2";
2310
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2311
    }
2312

    
2313
    file_iformat = av_find_input_format(arg);
2314
    file_oformat = guess_format(arg, NULL, NULL);
2315
    if (!file_iformat && !file_oformat) {
2316
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2317
        av_exit(1);
2318
    }
2319
}
2320

    
2321
static void opt_video_rc_override_string(const char *arg)
2322
{
2323
    video_rc_override_string = arg;
2324
}
2325

    
2326
static int opt_me_threshold(const char *opt, const char *arg)
2327
{
2328
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2329
    return 0;
2330
}
2331

    
2332
static void opt_loglevel(const char *opt, const char *arg)
2333
{
2334
    int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2335
    av_log_set_level(level);
2336
}
2337

    
2338
static int opt_verbose(const char *opt, const char *arg)
2339
{
2340
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2341
    return 0;
2342
}
2343

    
2344
static int opt_frame_rate(const char *opt, const char *arg)
2345
{
2346
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2347
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2348
        av_exit(1);
2349
    }
2350
    return 0;
2351
}
2352

    
2353
static int opt_bitrate(const char *opt, const char *arg)
2354
{
2355
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2356

    
2357
    opt_default(opt, arg);
2358

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

    
2362
    return 0;
2363
}
2364

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

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

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

    
2419
static void opt_frame_crop_right(const char *arg)
2420
{
2421
    frame_rightBand = atoi(arg);
2422
    if (frame_rightBand < 0) {
2423
        fprintf(stderr, "Incorrect right crop size\n");
2424
        av_exit(1);
2425
    }
2426
    if ((frame_rightBand % 2) != 0) {
2427
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2428
        av_exit(1);
2429
    }
2430
    if ((frame_rightBand) >= frame_width){
2431
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2432
        av_exit(1);
2433
    }
2434
    frame_width -= frame_rightBand;
2435
}
2436

    
2437
static void opt_frame_size(const char *arg)
2438
{
2439
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2440
        fprintf(stderr, "Incorrect frame size\n");
2441
        av_exit(1);
2442
    }
2443
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2444
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2445
        av_exit(1);
2446
    }
2447
}
2448

    
2449

    
2450
#define SCALEBITS 10
2451
#define ONE_HALF  (1 << (SCALEBITS - 1))
2452
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2453

    
2454
#define RGB_TO_Y(r, g, b) \
2455
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2456
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2457

    
2458
#define RGB_TO_U(r1, g1, b1, shift)\
2459
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2460
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2461

    
2462
#define RGB_TO_V(r1, g1, b1, shift)\
2463
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2464
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2465

    
2466
static void opt_pad_color(const char *arg) {
2467
    /* Input is expected to be six hex digits similar to
2468
       how colors are expressed in html tags (but without the #) */
2469
    int rgb = strtol(arg, NULL, 16);
2470
    int r,g,b;
2471

    
2472
    r = (rgb >> 16);
2473
    g = ((rgb >> 8) & 255);
2474
    b = (rgb & 255);
2475

    
2476
    padcolor[0] = RGB_TO_Y(r,g,b);
2477
    padcolor[1] = RGB_TO_U(r,g,b,0);
2478
    padcolor[2] = RGB_TO_V(r,g,b,0);
2479
}
2480

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

    
2494
static void opt_frame_pad_bottom(const char *arg)
2495
{
2496
    frame_padbottom = atoi(arg);
2497
    if (frame_padbottom < 0) {
2498
        fprintf(stderr, "Incorrect bottom pad size\n");
2499
        av_exit(1);
2500
    }
2501
    if ((frame_padbottom % 2) != 0) {
2502
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2503
        av_exit(1);
2504
    }
2505
}
2506

    
2507

    
2508
static void opt_frame_pad_left(const char *arg)
2509
{
2510
    frame_padleft = atoi(arg);
2511
    if (frame_padleft < 0) {
2512
        fprintf(stderr, "Incorrect left pad size\n");
2513
        av_exit(1);
2514
    }
2515
    if ((frame_padleft % 2) != 0) {
2516
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2517
        av_exit(1);
2518
    }
2519
}
2520

    
2521

    
2522
static void opt_frame_pad_right(const char *arg)
2523
{
2524
    frame_padright = atoi(arg);
2525
    if (frame_padright < 0) {
2526
        fprintf(stderr, "Incorrect right pad size\n");
2527
        av_exit(1);
2528
    }
2529
    if ((frame_padright % 2) != 0) {
2530
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2531
        av_exit(1);
2532
    }
2533
}
2534

    
2535
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2536
{
2537
    int i;
2538
    char fmt_str[128];
2539
    for (i=-1; i < nb_fmts; i++) {
2540
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2541
        fprintf(stdout, "%s\n", fmt_str);
2542
    }
2543
}
2544

    
2545
static void opt_frame_pix_fmt(const char *arg)
2546
{
2547
    if (strcmp(arg, "list")) {
2548
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2549
        if (frame_pix_fmt == PIX_FMT_NONE) {
2550
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2551
            av_exit(1);
2552
        }
2553
    } else {
2554
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2555
        av_exit(0);
2556
    }
2557
}
2558

    
2559
static void opt_frame_aspect_ratio(const char *arg)
2560
{
2561
    int x = 0, y = 0;
2562
    double ar = 0;
2563
    const char *p;
2564
    char *end;
2565

    
2566
    p = strchr(arg, ':');
2567
    if (p) {
2568
        x = strtol(arg, &end, 10);
2569
        if (end == p)
2570
            y = strtol(end+1, &end, 10);
2571
        if (x > 0 && y > 0)
2572
            ar = (double)x / (double)y;
2573
    } else
2574
        ar = strtod(arg, NULL);
2575

    
2576
    if (!ar) {
2577
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2578
        av_exit(1);
2579
    }
2580
    frame_aspect_ratio = ar;
2581
}
2582

    
2583
static int opt_metadata(const char *opt, const char *arg)
2584
{
2585
    char *mid= strchr(arg, '=');
2586

    
2587
    if(!mid){
2588
        fprintf(stderr, "Missing =\n");
2589
        av_exit(1);
2590
    }
2591
    *mid++= 0;
2592

    
2593
    metadata_count++;
2594
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2595
    metadata[metadata_count-1].key  = av_strdup(arg);
2596
    metadata[metadata_count-1].value= av_strdup(mid);
2597

    
2598
    return 0;
2599
}
2600

    
2601
static void opt_qscale(const char *arg)
2602
{
2603
    video_qscale = atof(arg);
2604
    if (video_qscale <= 0 ||
2605
        video_qscale > 255) {
2606
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2607
        av_exit(1);
2608
    }
2609
}
2610

    
2611
static void opt_top_field_first(const char *arg)
2612
{
2613
    top_field_first= atoi(arg);
2614
}
2615

    
2616
static int opt_thread_count(const char *opt, const char *arg)
2617
{
2618
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2619
#if !HAVE_THREADS
2620
    if (verbose >= 0)
2621
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2622
#endif
2623
    return 0;
2624
}
2625

    
2626
static void opt_audio_sample_fmt(const char *arg)
2627
{
2628
    if (strcmp(arg, "list"))
2629
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2630
    else {
2631
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2632
        av_exit(0);
2633
    }
2634
}
2635

    
2636
static int opt_audio_rate(const char *opt, const char *arg)
2637
{
2638
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2639
    return 0;
2640
}
2641

    
2642
static int opt_audio_channels(const char *opt, const char *arg)
2643
{
2644
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2645
    return 0;
2646
}
2647

    
2648
static void opt_video_channel(const char *arg)
2649
{
2650
    video_channel = strtol(arg, NULL, 0);
2651
}
2652

    
2653
static void opt_video_standard(const char *arg)
2654
{
2655
    video_standard = av_strdup(arg);
2656
}
2657

    
2658
static void opt_codec(int *pstream_copy, char **pcodec_name,
2659
                      int codec_type, const char *arg)
2660
{
2661
    av_freep(pcodec_name);
2662
    if (!strcmp(arg, "copy")) {
2663
        *pstream_copy = 1;
2664
    } else {
2665
        *pcodec_name = av_strdup(arg);
2666
    }
2667
}
2668

    
2669
static void opt_audio_codec(const char *arg)
2670
{
2671
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2672
}
2673

    
2674
static void opt_audio_tag(const char *arg)
2675
{
2676
    char *tail;
2677
    audio_codec_tag= strtol(arg, &tail, 0);
2678

    
2679
    if(!tail || *tail)
2680
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2681
}
2682

    
2683
static void opt_video_tag(const char *arg)
2684
{
2685
    char *tail;
2686
    video_codec_tag= strtol(arg, &tail, 0);
2687

    
2688
    if(!tail || *tail)
2689
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2690
}
2691

    
2692
static void opt_video_codec(const char *arg)
2693
{
2694
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2695
}
2696

    
2697
static void opt_subtitle_codec(const char *arg)
2698
{
2699
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2700
}
2701

    
2702
static void opt_subtitle_tag(const char *arg)
2703
{
2704
    char *tail;
2705
    subtitle_codec_tag= strtol(arg, &tail, 0);
2706

    
2707
    if(!tail || *tail)
2708
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2709
}
2710

    
2711
static void opt_map(const char *arg)
2712
{
2713
    AVStreamMap *m;
2714
    char *p;
2715

    
2716
    m = &stream_maps[nb_stream_maps++];
2717

    
2718
    m->file_index = strtol(arg, &p, 0);
2719
    if (*p)
2720
        p++;
2721

    
2722
    m->stream_index = strtol(p, &p, 0);
2723
    if (*p) {
2724
        p++;
2725
        m->sync_file_index = strtol(p, &p, 0);
2726
        if (*p)
2727
            p++;
2728
        m->sync_stream_index = strtol(p, &p, 0);
2729
    } else {
2730
        m->sync_file_index = m->file_index;
2731
        m->sync_stream_index = m->stream_index;
2732
    }
2733
}
2734

    
2735
static void opt_map_meta_data(const char *arg)
2736
{
2737
    AVMetaDataMap *m;
2738
    char *p;
2739

    
2740
    m = &meta_data_maps[nb_meta_data_maps++];
2741

    
2742
    m->out_file = strtol(arg, &p, 0);
2743
    if (*p)
2744
        p++;
2745

    
2746
    m->in_file = strtol(p, &p, 0);
2747
}
2748

    
2749
static void opt_input_ts_scale(const char *arg)
2750
{
2751
    unsigned int stream;
2752
    double scale;
2753
    char *p;
2754

    
2755
    stream = strtol(arg, &p, 0);
2756
    if (*p)
2757
        p++;
2758
    scale= strtod(p, &p);
2759

    
2760
    if(stream >= MAX_STREAMS)
2761
        av_exit(1);
2762

    
2763
    input_files_ts_scale[nb_input_files][stream]= scale;
2764
}
2765

    
2766
static int opt_recording_time(const char *opt, const char *arg)
2767
{
2768
    recording_time = parse_time_or_die(opt, arg, 1);
2769
    return 0;
2770
}
2771

    
2772
static int opt_start_time(const char *opt, const char *arg)
2773
{
2774
    start_time = parse_time_or_die(opt, arg, 1);
2775
    return 0;
2776
}
2777

    
2778
static int opt_rec_timestamp(const char *opt, const char *arg)
2779
{
2780
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2781
    return 0;
2782
}
2783

    
2784
static int opt_input_ts_offset(const char *opt, const char *arg)
2785
{
2786
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2787
    return 0;
2788
}
2789

    
2790
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2791
{
2792
    const char *codec_string = encoder ? "encoder" : "decoder";
2793
    AVCodec *codec;
2794

    
2795
    if(!name)
2796
        return CODEC_ID_NONE;
2797
    codec = encoder ?
2798
        avcodec_find_encoder_by_name(name) :
2799
        avcodec_find_decoder_by_name(name);
2800
    if(!codec) {
2801
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2802
        av_exit(1);
2803
    }
2804
    if(codec->type != type) {
2805
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2806
        av_exit(1);
2807
    }
2808
    return codec->id;
2809
}
2810

    
2811
static void opt_input_file(const char *filename)
2812
{
2813
    AVFormatContext *ic;
2814
    AVFormatParameters params, *ap = &params;
2815
    int err, i, ret, rfps, rfps_base;
2816
    int64_t timestamp;
2817

    
2818
    if (!strcmp(filename, "-"))
2819
        filename = "pipe:";
2820

    
2821
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2822
                    !strcmp(filename, "/dev/stdin");
2823

    
2824
    /* get default parameters from command line */
2825
    ic = avformat_alloc_context();
2826

    
2827
    memset(ap, 0, sizeof(*ap));
2828
    ap->prealloced_context = 1;
2829
    ap->sample_rate = audio_sample_rate;
2830
    ap->channels = audio_channels;
2831
    ap->time_base.den = frame_rate.num;
2832
    ap->time_base.num = frame_rate.den;
2833
    ap->width = frame_width + frame_padleft + frame_padright;
2834
    ap->height = frame_height + frame_padtop + frame_padbottom;
2835
    ap->pix_fmt = frame_pix_fmt;
2836
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2837
    ap->channel = video_channel;
2838
    ap->standard = video_standard;
2839
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2840
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2841
    if(pgmyuv_compatibility_hack)
2842
        ap->video_codec_id= CODEC_ID_PGMYUV;
2843

    
2844
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2845

    
2846
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2847
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2848
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2849
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2850

    
2851
    /* open the input file with generic libav function */
2852
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2853
    if (err < 0) {
2854
        print_error(filename, err);
2855
        av_exit(1);
2856
    }
2857
    if(opt_programid) {
2858
        int i;
2859
        for(i=0; i<ic->nb_programs; i++)
2860
            if(ic->programs[i]->id != opt_programid)
2861
                ic->programs[i]->discard = AVDISCARD_ALL;
2862
    }
2863

    
2864
    ic->loop_input = loop_input;
2865

    
2866
    /* If not enough info to get the stream parameters, we decode the
2867
       first frames to get it. (used in mpeg case for example) */
2868
    ret = av_find_stream_info(ic);
2869
    if (ret < 0 && verbose >= 0) {
2870
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2871
        av_exit(1);
2872
    }
2873

    
2874
    timestamp = start_time;
2875
    /* add the stream start time */
2876
    if (ic->start_time != AV_NOPTS_VALUE)
2877
        timestamp += ic->start_time;
2878

    
2879
    /* if seeking requested, we execute it */
2880
    if (start_time != 0) {
2881
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2882
        if (ret < 0) {
2883
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2884
                    filename, (double)timestamp / AV_TIME_BASE);
2885
        }
2886
        /* reset seek info */
2887
        start_time = 0;
2888
    }
2889

    
2890
    /* update the current parameters so that they match the one of the input stream */
2891
    for(i=0;i<ic->nb_streams;i++) {
2892
        AVCodecContext *enc = ic->streams[i]->codec;
2893
        if(thread_count>1)
2894
            avcodec_thread_init(enc, thread_count);
2895
        enc->thread_count= thread_count;
2896
        switch(enc->codec_type) {
2897
        case CODEC_TYPE_AUDIO:
2898
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2899
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2900
            channel_layout = enc->channel_layout;
2901
            audio_channels = enc->channels;
2902
            audio_sample_rate = enc->sample_rate;
2903
            audio_sample_fmt = enc->sample_fmt;
2904
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2905
            if(audio_disable)
2906
                ic->streams[i]->discard= AVDISCARD_ALL;
2907
            break;
2908
        case CODEC_TYPE_VIDEO:
2909
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2910
            frame_height = enc->height;
2911
            frame_width = enc->width;
2912
            if(ic->streams[i]->sample_aspect_ratio.num)
2913
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2914
            else
2915
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2916
            frame_aspect_ratio *= (float) enc->width / enc->height;
2917
            frame_pix_fmt = enc->pix_fmt;
2918
            rfps      = ic->streams[i]->r_frame_rate.num;
2919
            rfps_base = ic->streams[i]->r_frame_rate.den;
2920
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2921
            if(me_threshold)
2922
                enc->debug |= FF_DEBUG_MV;
2923

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

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

    
2930
                    (float)rfps / rfps_base, rfps, rfps_base);
2931
            }
2932
            /* update the current frame rate to match the stream frame rate */
2933
            frame_rate.num = rfps;
2934
            frame_rate.den = rfps_base;
2935

    
2936
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2937
            if(video_disable)
2938
                ic->streams[i]->discard= AVDISCARD_ALL;
2939
            else if(video_discard)
2940
                ic->streams[i]->discard= video_discard;
2941
            break;
2942
        case CODEC_TYPE_DATA:
2943
            break;
2944
        case CODEC_TYPE_SUBTITLE:
2945
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2946
            if(subtitle_disable)
2947
                ic->streams[i]->discard = AVDISCARD_ALL;
2948
            break;
2949
        case CODEC_TYPE_ATTACHMENT:
2950
        case CODEC_TYPE_UNKNOWN:
2951
            nb_icodecs++;
2952
            break;
2953
        default:
2954
            abort();
2955
        }
2956
    }
2957

    
2958
    input_files[nb_input_files] = ic;
2959
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2960
    /* dump the file content */
2961
    if (verbose >= 0)
2962
        dump_format(ic, nb_input_files, filename, 0);
2963

    
2964
    nb_input_files++;
2965
    file_iformat = NULL;
2966
    file_oformat = NULL;
2967

    
2968
    video_channel = 0;
2969

    
2970
    av_freep(&video_codec_name);
2971
    av_freep(&audio_codec_name);
2972
    av_freep(&subtitle_codec_name);
2973
}
2974

    
2975
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2976
                                         int *has_subtitle_ptr)
2977
{
2978
    int has_video, has_audio, has_subtitle, i, j;
2979
    AVFormatContext *ic;
2980

    
2981
    has_video = 0;
2982
    has_audio = 0;
2983
    has_subtitle = 0;
2984
    for(j=0;j<nb_input_files;j++) {
2985
        ic = input_files[j];
2986
        for(i=0;i<ic->nb_streams;i++) {
2987
            AVCodecContext *enc = ic->streams[i]->codec;
2988
            switch(enc->codec_type) {
2989
            case CODEC_TYPE_AUDIO:
2990
                has_audio = 1;
2991
                break;
2992
            case CODEC_TYPE_VIDEO:
2993
                has_video = 1;
2994
                break;
2995
            case CODEC_TYPE_SUBTITLE:
2996
                has_subtitle = 1;
2997
                break;
2998
            case CODEC_TYPE_DATA:
2999
            case CODEC_TYPE_ATTACHMENT:
3000
            case CODEC_TYPE_UNKNOWN:
3001
                break;
3002
            default:
3003
                abort();
3004
            }
3005
        }
3006
    }
3007
    *has_video_ptr = has_video;
3008
    *has_audio_ptr = has_audio;
3009
    *has_subtitle_ptr = has_subtitle;
3010
}
3011

    
3012
static void new_video_stream(AVFormatContext *oc)
3013
{
3014
    AVStream *st;
3015
    AVCodecContext *video_enc;
3016
    int codec_id;
3017

    
3018
    st = av_new_stream(oc, oc->nb_streams);
3019
    if (!st) {
3020
        fprintf(stderr, "Could not alloc stream\n");
3021
        av_exit(1);
3022
    }
3023
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3024
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3025
    video_bitstream_filters= NULL;
3026

    
3027
    if(thread_count>1)
3028
        avcodec_thread_init(st->codec, thread_count);
3029

    
3030
    video_enc = st->codec;
3031

    
3032
    if(video_codec_tag)
3033
        video_enc->codec_tag= video_codec_tag;
3034

    
3035
    if(   (video_global_header&1)
3036
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3037
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3038
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3039
    }
3040
    if(video_global_header&2){
3041
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3042
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3043
    }
3044

    
3045
    if (video_stream_copy) {
3046
        st->stream_copy = 1;
3047
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3048
        video_enc->sample_aspect_ratio =
3049
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3050
    } else {
3051
        const char *p;
3052
        int i;
3053
        AVCodec *codec;
3054
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3055

    
3056
        if (video_codec_name) {
3057
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3058
            codec = avcodec_find_encoder_by_name(video_codec_name);
3059
            output_codecs[nb_ocodecs] = codec;
3060
        } else {
3061
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3062
            codec = avcodec_find_encoder(codec_id);
3063
        }
3064

    
3065
        video_enc->codec_id = codec_id;
3066

    
3067
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3068

    
3069
        if (codec && codec->supported_framerates && !force_fps)
3070
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3071
        video_enc->time_base.den = fps.num;
3072
        video_enc->time_base.num = fps.den;
3073

    
3074
        video_enc->width = frame_width + frame_padright + frame_padleft;
3075
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3076
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3077
        video_enc->pix_fmt = frame_pix_fmt;
3078
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3079

    
3080
        if(codec && codec->pix_fmts){
3081
            const enum PixelFormat *p= codec->pix_fmts;
3082
            for(; *p!=-1; p++){
3083
                if(*p == video_enc->pix_fmt)
3084
                    break;
3085
            }
3086
            if(*p == -1)
3087
                video_enc->pix_fmt = codec->pix_fmts[0];
3088
        }
3089

    
3090
        if (intra_only)
3091
            video_enc->gop_size = 0;
3092
        if (video_qscale || same_quality) {
3093
            video_enc->flags |= CODEC_FLAG_QSCALE;
3094
            video_enc->global_quality=
3095
                st->quality = FF_QP2LAMBDA * video_qscale;
3096
        }
3097

    
3098
        if(intra_matrix)
3099
            video_enc->intra_matrix = intra_matrix;
3100
        if(inter_matrix)
3101
            video_enc->inter_matrix = inter_matrix;
3102

    
3103
        video_enc->thread_count = thread_count;
3104
        p= video_rc_override_string;
3105
        for(i=0; p; i++){
3106
            int start, end, q;
3107
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3108
            if(e!=3){
3109
                fprintf(stderr, "error parsing rc_override\n");
3110
                av_exit(1);
3111
            }
3112
            video_enc->rc_override=
3113
                av_realloc(video_enc->rc_override,
3114
                           sizeof(RcOverride)*(i+1));
3115
            video_enc->rc_override[i].start_frame= start;
3116
            video_enc->rc_override[i].end_frame  = end;
3117
            if(q>0){
3118
                video_enc->rc_override[i].qscale= q;
3119
                video_enc->rc_override[i].quality_factor= 1.0;
3120
            }
3121
            else{
3122
                video_enc->rc_override[i].qscale= 0;
3123
                video_enc->rc_override[i].quality_factor= -q/100.0;
3124
            }
3125
            p= strchr(p, '/');
3126
            if(p) p++;
3127
        }
3128
        video_enc->rc_override_count=i;
3129
        if (!video_enc->rc_initial_buffer_occupancy)
3130
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3131
        video_enc->me_threshold= me_threshold;
3132
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3133

    
3134
        if (do_psnr)
3135
            video_enc->flags|= CODEC_FLAG_PSNR;
3136

    
3137
        /* two pass mode */
3138
        if (do_pass) {
3139
            if (do_pass == 1) {
3140
                video_enc->flags |= CODEC_FLAG_PASS1;
3141
            } else {
3142
                video_enc->flags |= CODEC_FLAG_PASS2;
3143
            }
3144
        }
3145
    }
3146
    nb_ocodecs++;
3147

    
3148
    /* reset some key parameters */
3149
    video_disable = 0;
3150
    av_freep(&video_codec_name);
3151
    video_stream_copy = 0;
3152
}
3153

    
3154
static void new_audio_stream(AVFormatContext *oc)
3155
{
3156
    AVStream *st;
3157
    AVCodecContext *audio_enc;
3158
    int codec_id;
3159

    
3160
    st = av_new_stream(oc, oc->nb_streams);
3161
    if (!st) {
3162
        fprintf(stderr, "Could not alloc stream\n");
3163
        av_exit(1);
3164
    }
3165
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3166

    
3167
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3168
    audio_bitstream_filters= NULL;
3169

    
3170
    if(thread_count>1)
3171
        avcodec_thread_init(st->codec, thread_count);
3172

    
3173
    audio_enc = st->codec;
3174
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3175

    
3176
    if(audio_codec_tag)
3177
        audio_enc->codec_tag= audio_codec_tag;
3178

    
3179
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3180
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3181
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3182
    }
3183
    if (audio_stream_copy) {
3184
        st->stream_copy = 1;
3185
        audio_enc->channels = audio_channels;
3186
    } else {
3187
        AVCodec *codec;
3188

    
3189
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3190

    
3191
        if (audio_codec_name) {
3192
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3193
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3194
            output_codecs[nb_ocodecs] = codec;
3195
        } else {
3196
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3197
            codec = avcodec_find_encoder(codec_id);
3198
        }
3199
        audio_enc->codec_id = codec_id;
3200

    
3201
        if (audio_qscale > QSCALE_NONE) {
3202
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3203
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3204
        }
3205
        audio_enc->thread_count = thread_count;
3206
        audio_enc->channels = audio_channels;
3207
        audio_enc->sample_fmt = audio_sample_fmt;
3208
        audio_enc->channel_layout = channel_layout;
3209

    
3210
        if(codec && codec->sample_fmts){
3211
            const enum SampleFormat *p= codec->sample_fmts;
3212
            for(; *p!=-1; p++){
3213
                if(*p == audio_enc->sample_fmt)
3214
                    break;
3215
            }
3216
            if(*p == -1)
3217
                audio_enc->sample_fmt = codec->sample_fmts[0];
3218
        }
3219
    }
3220
    nb_ocodecs++;
3221
    audio_enc->sample_rate = audio_sample_rate;
3222
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3223
    if (audio_language) {
3224
        av_metadata_set(&st->metadata, "language", audio_language);
3225
        av_free(audio_language);
3226
        audio_language = NULL;
3227
    }
3228

    
3229
    /* reset some key parameters */
3230
    audio_disable = 0;
3231
    av_freep(&audio_codec_name);
3232
    audio_stream_copy = 0;
3233
}
3234

    
3235
static void new_subtitle_stream(AVFormatContext *oc)
3236
{
3237
    AVStream *st;
3238
    AVCodecContext *subtitle_enc;
3239

    
3240
    st = av_new_stream(oc, oc->nb_streams);
3241
    if (!st) {
3242
        fprintf(stderr, "Could not alloc stream\n");
3243
        av_exit(1);
3244
    }
3245
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3246

    
3247
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3248
    subtitle_bitstream_filters= NULL;
3249

    
3250
    subtitle_enc = st->codec;
3251
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3252

    
3253
    if(subtitle_codec_tag)
3254
        subtitle_enc->codec_tag= subtitle_codec_tag;
3255

    
3256
    if (subtitle_stream_copy) {
3257
        st->stream_copy = 1;
3258
    } else {
3259
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3260
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3261
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3262
    }
3263
    nb_ocodecs++;
3264

    
3265
    if (subtitle_language) {
3266
        av_metadata_set(&st->metadata, "language", subtitle_language);
3267
        av_free(subtitle_language);
3268
        subtitle_language = NULL;
3269
    }
3270

    
3271
    subtitle_disable = 0;
3272
    av_freep(&subtitle_codec_name);
3273
    subtitle_stream_copy = 0;
3274
}
3275

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

    
3287
static void opt_new_video_stream(void)
3288
{
3289
    AVFormatContext *oc;
3290
    if (nb_output_files <= 0) {
3291
        fprintf(stderr, "At least one output file must be specified\n");
3292
        av_exit(1);
3293
    }
3294
    oc = output_files[nb_output_files - 1];
3295
    new_video_stream(oc);
3296
}
3297

    
3298
static void opt_new_subtitle_stream(void)
3299
{
3300
    AVFormatContext *oc;
3301
    if (nb_output_files <= 0) {
3302
        fprintf(stderr, "At least one output file must be specified\n");
3303
        av_exit(1);
3304
    }
3305
    oc = output_files[nb_output_files - 1];
3306
    new_subtitle_stream(oc);
3307
}
3308

    
3309
static void opt_output_file(const char *filename)
3310
{
3311
    AVFormatContext *oc;
3312
    int use_video, use_audio, use_subtitle;
3313
    int input_has_video, input_has_audio, input_has_subtitle;
3314
    AVFormatParameters params, *ap = &params;
3315

    
3316
    if (!strcmp(filename, "-"))
3317
        filename = "pipe:";
3318

    
3319
    oc = avformat_alloc_context();
3320

    
3321
    if (!file_oformat) {
3322
        file_oformat = guess_format(NULL, filename, NULL);
3323
        if (!file_oformat) {
3324
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3325
                    filename);
3326
            av_exit(1);
3327
        }
3328
    }
3329

    
3330
    oc->oformat = file_oformat;
3331
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3332

    
3333
    if (!strcmp(file_oformat->name, "ffm") &&
3334
        av_strstart(filename, "http:", NULL)) {
3335
        /* special case for files sent to ffserver: we get the stream
3336
           parameters from ffserver */
3337
        int err = read_ffserver_streams(oc, filename);
3338
        if (err < 0) {
3339
            print_error(filename, err);
3340
            av_exit(1);
3341
        }
3342
    } else {
3343
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3344
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3345
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3346

    
3347
        /* disable if no corresponding type found and at least one
3348
           input file */
3349
        if (nb_input_files > 0) {
3350
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3351
                                         &input_has_subtitle);
3352
            if (!input_has_video)
3353
                use_video = 0;
3354
            if (!input_has_audio)
3355
                use_audio = 0;
3356
            if (!input_has_subtitle)
3357
                use_subtitle = 0;
3358
        }
3359

    
3360
        /* manual disable */
3361
        if (audio_disable) {
3362
            use_audio = 0;
3363
        }
3364
        if (video_disable) {
3365
            use_video = 0;
3366
        }
3367
        if (subtitle_disable) {
3368
            use_subtitle = 0;
3369
        }
3370

    
3371
        if (use_video) {
3372
            new_video_stream(oc);
3373
        }
3374

    
3375
        if (use_audio) {
3376
            new_audio_stream(oc);
3377
        }
3378

    
3379
        if (use_subtitle) {
3380
            new_subtitle_stream(oc);
3381
        }
3382

    
3383
        oc->timestamp = rec_timestamp;
3384

    
3385
        for(; metadata_count>0; metadata_count--){
3386
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3387
                                           metadata[metadata_count-1].value);
3388
        }
3389
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3390
    }
3391

    
3392
    output_files[nb_output_files++] = oc;
3393

    
3394
    /* check filename in case of an image number is expected */
3395
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3396
        if (!av_filename_number_test(oc->filename)) {
3397
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3398
            av_exit(1);
3399
        }
3400
    }
3401

    
3402
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3403
        /* test if it already exists to avoid loosing precious files */
3404
        if (!file_overwrite &&
3405
            (strchr(filename, ':') == NULL ||
3406
             filename[1] == ':' ||
3407
             av_strstart(filename, "file:", NULL))) {
3408
            if (url_exist(filename)) {
3409
                if (!using_stdin) {
3410
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3411
                    fflush(stderr);
3412
                    if (!read_yesno()) {
3413
                        fprintf(stderr, "Not overwriting - exiting\n");
3414
                        av_exit(1);
3415
                    }
3416
                }
3417
                else {
3418
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3419
                    av_exit(1);
3420
                }
3421
            }
3422
        }
3423

    
3424
        /* open the file */
3425
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3426
            fprintf(stderr, "Could not open '%s'\n", filename);
3427
            av_exit(1);
3428
        }
3429
    }
3430

    
3431
    memset(ap, 0, sizeof(*ap));
3432
    if (av_set_parameters(oc, ap) < 0) {
3433
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3434
                oc->filename);
3435
        av_exit(1);
3436
    }
3437

    
3438
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3439
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3440
    oc->loop_output = loop_output;
3441
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3442

    
3443
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3444

    
3445
    /* reset some options */
3446
    file_oformat = NULL;
3447
    file_iformat = NULL;
3448
}
3449

    
3450
/* same option as mencoder */
3451
static void opt_pass(const char *pass_str)
3452
{
3453
    int pass;
3454
    pass = atoi(pass_str);
3455
    if (pass != 1 && pass != 2) {
3456
        fprintf(stderr, "pass number can be only 1 or 2\n");
3457
        av_exit(1);
3458
    }
3459
    do_pass = pass;
3460
}
3461

    
3462
static int64_t getutime(void)
3463
{
3464
#if HAVE_GETRUSAGE
3465
    struct rusage rusage;
3466

    
3467
    getrusage(RUSAGE_SELF, &rusage);
3468
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3469
#elif HAVE_GETPROCESSTIMES
3470
    HANDLE proc;
3471
    FILETIME c, e, k, u;
3472
    proc = GetCurrentProcess();
3473
    GetProcessTimes(proc, &c, &e, &k, &u);
3474
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3475
#else
3476
    return av_gettime();
3477
#endif
3478
}
3479

    
3480
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3481
{
3482
    int i;
3483
    const char *p = str;
3484
    for(i = 0;; i++) {
3485
        dest[i] = atoi(p);
3486
        if(i == 63)
3487
            break;
3488
        p = strchr(p, ',');
3489
        if(!p) {
3490
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3491
            av_exit(1);
3492
        }
3493
        p++;
3494
    }
3495
}
3496

    
3497
static void opt_inter_matrix(const char *arg)
3498
{
3499
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3500
    parse_matrix_coeffs(inter_matrix, arg);
3501
}
3502

    
3503
static void opt_intra_matrix(const char *arg)
3504
{
3505
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3506
    parse_matrix_coeffs(intra_matrix, arg);
3507
}
3508

    
3509
/**
3510
 * Trivial log callback.
3511
 * Only suitable for show_help and similar since it lacks prefix handling.
3512
 */
3513
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3514
{
3515
    vfprintf(stdout, fmt, vl);
3516
}
3517

    
3518
static void show_help(void)
3519
{
3520
    av_log_set_callback(log_callback_help);
3521
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3522
           "Hyper fast Audio and Video encoder\n");
3523
    printf("\n");
3524
    show_help_options(options, "Main options:\n",
3525
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3526
    show_help_options(options, "\nAdvanced options:\n",
3527
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3528
                      OPT_EXPERT);
3529
    show_help_options(options, "\nVideo options:\n",
3530
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3531
                      OPT_VIDEO);
3532
    show_help_options(options, "\nAdvanced Video options:\n",
3533
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3534
                      OPT_VIDEO | OPT_EXPERT);
3535
    show_help_options(options, "\nAudio options:\n",
3536
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3537
                      OPT_AUDIO);
3538
    show_help_options(options, "\nAdvanced Audio options:\n",
3539
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3540
                      OPT_AUDIO | OPT_EXPERT);
3541
    show_help_options(options, "\nSubtitle options:\n",
3542
                      OPT_SUBTITLE | OPT_GRAB,
3543
                      OPT_SUBTITLE);
3544
    show_help_options(options, "\nAudio/Video grab options:\n",
3545
                      OPT_GRAB,
3546
                      OPT_GRAB);
3547
    printf("\n");
3548
    av_opt_show(avcodec_opts[0], NULL);
3549
    printf("\n");
3550
    av_opt_show(avformat_opts, NULL);
3551
    printf("\n");
3552
    av_opt_show(sws_opts, NULL);
3553
}
3554

    
3555
static void opt_target(const char *arg)
3556
{
3557
    int norm = -1;
3558
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3559

    
3560
    if(!strncmp(arg, "pal-", 4)) {
3561
        norm = 0;
3562
        arg += 4;
3563
    } else if(!strncmp(arg, "ntsc-", 5)) {
3564
        norm = 1;
3565
        arg += 5;
3566
    } else if(!strncmp(arg, "film-", 5)) {
3567
        norm = 2;
3568
        arg += 5;
3569
    } else {
3570
        int fr;
3571
        /* Calculate FR via float to avoid int overflow */
3572
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3573
        if(fr == 25000) {
3574
            norm = 0;
3575
        } else if((fr == 29970) || (fr == 23976)) {
3576
            norm = 1;
3577
        } else {
3578
            /* Try to determine PAL/NTSC by peeking in the input files */
3579
            if(nb_input_files) {
3580
                int i, j;
3581
                for(j = 0; j < nb_input_files; j++) {
3582
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3583
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3584
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3585
                            continue;
3586
                        fr = c->time_base.den * 1000 / c->time_base.num;
3587
                        if(fr == 25000) {
3588
                            norm = 0;
3589
                            break;
3590
                        } else if((fr == 29970) || (fr == 23976)) {
3591
                            norm = 1;
3592
                            break;
3593
                        }
3594
                    }
3595
                    if(norm >= 0)
3596
                        break;
3597
                }
3598
            }
3599
        }
3600
        if(verbose && norm >= 0)
3601
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3602
    }
3603

    
3604
    if(norm < 0) {
3605
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3606
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3607
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3608
        av_exit(1);
3609
    }
3610

    
3611
    if(!strcmp(arg, "vcd")) {
3612

    
3613
        opt_video_codec("mpeg1video");
3614
        opt_audio_codec("mp2");
3615
        opt_format("vcd");
3616

    
3617
        opt_frame_size(norm ? "352x240" : "352x288");
3618
        opt_frame_rate(NULL, frame_rates[norm]);
3619
        opt_default("gop", norm ? "18" : "15");
3620

    
3621
        opt_default("b", "1150000");
3622
        opt_default("maxrate", "1150000");
3623
        opt_default("minrate", "1150000");
3624
        opt_default("bufsize", "327680"); // 40*1024*8;
3625

    
3626
        opt_default("ab", "224000");
3627
        audio_sample_rate = 44100;
3628
        audio_channels = 2;
3629

    
3630
        opt_default("packetsize", "2324");
3631
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3632

    
3633
        /* We have to offset the PTS, so that it is consistent with the SCR.
3634
           SCR starts at 36000, but the first two packs contain only padding
3635
           and the first pack from the other stream, respectively, may also have
3636
           been written before.
3637
           So the real data starts at SCR 36000+3*1200. */
3638
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3639
    } else if(!strcmp(arg, "svcd")) {
3640

    
3641
        opt_video_codec("mpeg2video");
3642
        opt_audio_codec("mp2");
3643
        opt_format("svcd");
3644

    
3645
        opt_frame_size(norm ? "480x480" : "480x576");
3646
        opt_frame_rate(NULL, frame_rates[norm]);
3647
        opt_default("gop", norm ? "18" : "15");
3648

    
3649
        opt_default("b", "2040000");
3650
        opt_default("maxrate", "2516000");
3651
        opt_default("minrate", "0"); //1145000;
3652
        opt_default("bufsize", "1835008"); //224*1024*8;
3653
        opt_default("flags", "+scan_offset");
3654

    
3655

    
3656
        opt_default("ab", "224000");
3657
        audio_sample_rate = 44100;
3658

    
3659
        opt_default("packetsize", "2324");
3660

    
3661
    } else if(!strcmp(arg, "dvd")) {
3662

    
3663
        opt_video_codec("mpeg2video");
3664
        opt_audio_codec("ac3");
3665
        opt_format("dvd");
3666

    
3667
        opt_frame_size(norm ? "720x480" : "720x576");
3668
        opt_frame_rate(NULL, frame_rates[norm]);
3669
        opt_default("gop", norm ? "18" : "15");
3670

    
3671
        opt_default("b", "6000000");
3672
        opt_default("maxrate", "9000000");
3673
        opt_default("minrate", "0"); //1500000;
3674
        opt_default("bufsize", "1835008"); //224*1024*8;
3675

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

    
3679
        opt_default("ab", "448000");
3680
        audio_sample_rate = 48000;
3681

    
3682
    } else if(!strncmp(arg, "dv", 2)) {
3683

    
3684
        opt_format("dv");
3685

    
3686
        opt_frame_size(norm ? "720x480" : "720x576");
3687
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3688
                                             (norm ? "yuv411p" : "yuv420p"));
3689
        opt_frame_rate(NULL, frame_rates[norm]);
3690

    
3691
        audio_sample_rate = 48000;
3692
        audio_channels = 2;
3693

    
3694
    } else {
3695
        fprintf(stderr, "Unknown target: %s\n", arg);
3696
        av_exit(1);
3697
    }
3698
}
3699

    
3700
static void opt_vstats_file (const char *arg)
3701
{
3702
    av_free (vstats_filename);
3703
    vstats_filename=av_strdup (arg);
3704
}
3705

    
3706
static void opt_vstats (void)
3707
{
3708
    char filename[40];
3709
    time_t today2 = time(NULL);
3710
    struct tm *today = localtime(&today2);
3711

    
3712
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3713
             today->tm_sec);
3714
    opt_vstats_file(filename);
3715
}
3716

    
3717
static int opt_bsf(const char *opt, const char *arg)
3718
{
3719
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3720
    AVBitStreamFilterContext **bsfp;
3721

    
3722
    if(!bsfc){
3723
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3724
        av_exit(1);
3725
    }
3726

    
3727
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3728
          *opt == 'a' ? &audio_bitstream_filters :
3729
                        &subtitle_bitstream_filters;
3730
    while(*bsfp)
3731
        bsfp= &(*bsfp)->next;
3732

    
3733
    *bsfp= bsfc;
3734

    
3735
    return 0;
3736
}
3737

    
3738
static int opt_preset(const char *opt, const char *arg)
3739
{
3740
    FILE *f=NULL;
3741
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3742
    int i;
3743
    const char *base[2]= { getenv("HOME"),
3744
                           FFMPEG_DATADIR,
3745
                         };
3746

    
3747
    for(i=!base[0]; i<2 && !f; i++){
3748
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3749
        f= fopen(filename, "r");
3750
        if(!f){
3751
            char *codec_name= *opt == 'v' ? video_codec_name :
3752
                              *opt == 'a' ? audio_codec_name :
3753
                                            subtitle_codec_name;
3754
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3755
            f= fopen(filename, "r");
3756
        }
3757
    }
3758
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3759
              is_dos_path(arg))){
3760
        av_strlcpy(filename, arg, sizeof(filename));
3761
        f= fopen(filename, "r");
3762
    }
3763

    
3764
    if(!f){
3765
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3766
        av_exit(1);
3767
    }
3768

    
3769
    while(!feof(f)){
3770
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3771
        if(line[0] == '#' && !e)
3772
            continue;
3773
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3774
        if(e){
3775
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3776
            av_exit(1);
3777
        }
3778
        if(!strcmp(tmp, "acodec")){
3779
            opt_audio_codec(tmp2);
3780
        }else if(!strcmp(tmp, "vcodec")){
3781
            opt_video_codec(tmp2);
3782
        }else if(!strcmp(tmp, "scodec")){
3783
            opt_subtitle_codec(tmp2);
3784
        }else if(opt_default(tmp, tmp2) < 0){
3785
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3786
            av_exit(1);
3787
        }
3788
    }
3789

    
3790
    fclose(f);
3791

    
3792
    return 0;
3793
}
3794

    
3795
static const OptionDef options[] = {
3796
    /* main options */
3797
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3798
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3799
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3800
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3801
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3802
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3803
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3804
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3805
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3806
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3807
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3808
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3809
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3810
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3811
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3812
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3813
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3814
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3815
      "add timings for benchmarking" },
3816
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3817
      "dump each input packet" },
3818
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3819
      "when dumping packets, also dump the payload" },
3820
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3821
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3822
    { "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)", "" },
3823
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3824
    { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3825
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3826
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3827
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3828
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3829
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3830
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3831
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3832
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3833
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3834
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3835
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3836
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3837

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

    
3880
    /* audio options */
3881
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3882
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3883
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3884
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3885
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3886
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3887
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3888
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3889
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3890
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3891
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3892
    { "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" },
3893

    
3894
    /* subtitle options */
3895
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3896
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3897
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3898
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3899
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3900

    
3901
    /* grab options */
3902
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3903
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3904
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3905

    
3906
    /* muxer options */
3907
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3908
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3909

    
3910
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3911
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3912
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3913

    
3914
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3915
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3916
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3917

    
3918
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3919
    { NULL, },
3920
};
3921

    
3922
int main(int argc, char **argv)
3923
{
3924
    int i;
3925
    int64_t ti;
3926

    
3927
    avcodec_register_all();
3928
    avdevice_register_all();
3929
    av_register_all();
3930

    
3931
    if(isatty(STDIN_FILENO))
3932
        url_set_interrupt_cb(decode_interrupt_cb);
3933

    
3934
    for(i=0; i<CODEC_TYPE_NB; i++){
3935
        avcodec_opts[i]= avcodec_alloc_context2(i);
3936
    }
3937
    avformat_opts = avformat_alloc_context();
3938
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3939

    
3940
    show_banner();
3941

    
3942
    /* parse options */
3943
    parse_options(argc, argv, options, opt_output_file);
3944

    
3945
    /* file converter / grab */
3946
    if (nb_output_files <= 0) {
3947
        fprintf(stderr, "At least one output file must be specified\n");
3948
        av_exit(1);
3949
    }
3950

    
3951
    if (nb_input_files == 0) {
3952
        fprintf(stderr, "At least one input file must be specified\n");
3953
        av_exit(1);
3954
    }
3955

    
3956
    ti = getutime();
3957
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3958
                  stream_maps, nb_stream_maps) < 0)
3959
        av_exit(1);
3960
    ti = getutime() - ti;
3961
    if (do_benchmark) {
3962
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3963
    }
3964

    
3965
    return av_exit(0);
3966
}