Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ede0e475

History | View | Annotate | Download (140 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "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
    exit(ret); /* not all OS-es handle main() return value */
438
    return ret;
439
}
440

    
441
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
442
{
443
    int i, err;
444
    AVFormatContext *ic;
445
    int nopts = 0;
446

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

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

    
462
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
463
            st->stream_copy = 1;
464
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
465
            st->stream_copy = 1;
466

    
467
        if(!st->codec->thread_count)
468
            st->codec->thread_count = 1;
469
        if(st->codec->thread_count>1)
470
            avcodec_thread_init(st->codec, st->codec->thread_count);
471

    
472
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
473
            nopts = 1;
474
    }
475

    
476
    if (!nopts)
477
        s->timestamp = av_gettime();
478

    
479
    av_close_input_file(ic);
480
    return 0;
481
}
482

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

    
490
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
491
    int ret;
492

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

    
512
        bsfc= bsfc->next;
513
    }
514

    
515
    ret= av_interleaved_write_frame(s, pkt);
516
    if(ret < 0){
517
        print_error("av_interleaved_write_frame()", ret);
518
        av_exit(1);
519
    }
520
}
521

    
522
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
523

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

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

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

    
549
    if (enc->channels != dec->channels)
550
        ost->audio_resample = 1;
551

    
552
    if (ost->audio_resample && !ost->resample) {
553
        if (dec->sample_fmt != SAMPLE_FMT_S16)
554
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
555
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
556
                                               enc->sample_rate, dec->sample_rate,
557
                                               enc->sample_fmt,  dec->sample_fmt,
558
                                               16, 10, 0, 0.8);
559
        if (!ost->resample) {
560
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
561
                    dec->channels, dec->sample_rate,
562
                    enc->channels, enc->sample_rate);
563
            av_exit(1);
564
        }
565
    }
566

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

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

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

    
609
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
610
                        ist->is_start=0;
611
                    else
612
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
613

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

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

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

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

    
670
        frame_bytes = enc->frame_size * osize * enc->channels;
671

    
672
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
673
            AVPacket pkt;
674
            av_init_packet(&pkt);
675

    
676
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
677

    
678
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
679

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

    
695
            ost->sync_opts += enc->frame_size;
696
        }
697
    } else {
698
        AVPacket pkt;
699
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
700
        av_init_packet(&pkt);
701

    
702
        ost->sync_opts += size_out / (osize * enc->channels);
703

    
704
        /* output a pcm frame */
705
        /* determine the size of the coded buffer */
706
        size_out /= osize;
707
        if (coded_bps)
708
            size_out *= coded_bps;
709

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

    
728
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
729
{
730
    AVCodecContext *dec;
731
    AVPicture *picture2;
732
    AVPicture picture_tmp;
733
    uint8_t *buf = 0;
734

    
735
    dec = ist->st->codec;
736

    
737
    /* deinterlace : must be done before any resize */
738
    if (do_deinterlace) {
739
        int size;
740

    
741
        /* create temporary picture */
742
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
743
        buf = av_malloc(size);
744
        if (!buf)
745
            return;
746

    
747
        picture2 = &picture_tmp;
748
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
749

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

    
766
    if (picture != picture2)
767
        *picture = *picture2;
768
    *bufp = buf;
769
}
770

    
771
/* we begin to correct av delay at this threshold */
772
#define AV_DELAY_MAX 0.100
773

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

    
786
    if (pts == AV_NOPTS_VALUE) {
787
        fprintf(stderr, "Subtitle packets must have a pts\n");
788
        if (exit_on_error)
789
            av_exit(1);
790
        return;
791
    }
792

    
793
    enc = ost->st->codec;
794

    
795
    if (!subtitle_out) {
796
        subtitle_out = av_malloc(subtitle_out_max_size);
797
    }
798

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

    
807
    for(i = 0; i < nb; i++) {
808
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
809
                                                    subtitle_out_max_size, sub);
810

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

    
828
static int bit_buffer_size= 1024*256;
829
static uint8_t *bit_buffer= NULL;
830

    
831
static void do_video_out(AVFormatContext *s,
832
                         AVOutputStream *ost,
833
                         AVInputStream *ist,
834
                         AVFrame *in_picture,
835
                         int *frame_size)
836
{
837
    int nb_frames, i, ret;
838
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
839
    AVFrame picture_crop_temp, picture_pad_temp;
840
    AVCodecContext *enc, *dec;
841

    
842
    avcodec_get_frame_defaults(&picture_crop_temp);
843
    avcodec_get_frame_defaults(&picture_pad_temp);
844

    
845
    enc = ost->st->codec;
846
    dec = ist->st->codec;
847

    
848
    /* by default, we output a single frame */
849
    nb_frames = 1;
850

    
851
    *frame_size = 0;
852

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

    
879
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
880
    if (nb_frames <= 0)
881
        return;
882

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

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

    
911
    if (ost->video_resample) {
912
        padding_src = NULL;
913
        final_picture = &ost->pict_tmp;
914
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
915
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
916
    }
917

    
918
    if (ost->video_pad) {
919
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
920
                enc->height, enc->width, enc->pix_fmt,
921
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
922
    }
923

    
924
    /* duplicates frame if needed */
925
    for(i=0;i<nb_frames;i++) {
926
        AVPacket pkt;
927
        av_init_packet(&pkt);
928
        pkt.stream_index= ost->index;
929

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

    
941
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
942
            enc->coded_frame = old_frame;
943
        } else {
944
            AVFrame big_picture;
945

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

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

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

    
1005
static double psnr(double d){
1006
    return -10.0*log(d)/log(10.0);
1007
}
1008

    
1009
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1010
                           int frame_size)
1011
{
1012
    AVCodecContext *enc;
1013
    int frame_number;
1014
    double ti1, bitrate, avg_bitrate;
1015

    
1016
    /* this is executed just the first time do_video_stats is called */
1017
    if (!vstats_file) {
1018
        vstats_file = fopen(vstats_filename, "w");
1019
        if (!vstats_file) {
1020
            perror("fopen");
1021
            av_exit(1);
1022
        }
1023
    }
1024

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

    
1032
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1033
        /* compute pts value */
1034
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1035
        if (ti1 < 0.01)
1036
            ti1 = 0.01;
1037

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

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

    
1060
    if (!is_last_report) {
1061
        int64_t cur_time;
1062
        /* display the report every 0.5 seconds */
1063
        cur_time = av_gettime();
1064
        if (last_time == -1) {
1065
            last_time = cur_time;
1066
            return;
1067
        }
1068
        if ((cur_time - last_time) < 500000)
1069
            return;
1070
        last_time = cur_time;
1071
    }
1072

    
1073

    
1074
    oc = output_files[0];
1075

    
1076
    total_size = url_fsize(oc->pb);
1077
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1078
        total_size= url_ftell(oc->pb);
1079

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

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

    
1141
    if (verbose || is_last_report) {
1142
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1143

    
1144
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1145
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1146
            (double)total_size / 1024, ti1, bitrate);
1147

    
1148
        if (verbose > 1)
1149
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1150
                  nb_frames_dup, nb_frames_drop);
1151

    
1152
        if (verbose >= 0)
1153
            fprintf(stderr, "%s    \r", buf);
1154

    
1155
        fflush(stderr);
1156
    }
1157

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

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

    
1188
    av_init_packet(&avpkt);
1189

    
1190
    if(ist->next_pts == AV_NOPTS_VALUE)
1191
        ist->next_pts= ist->pts;
1192

    
1193
    if (pkt == NULL) {
1194
        /* EOF handling */
1195
        avpkt.data = NULL;
1196
        avpkt.size = 0;
1197
        goto handle_eof;
1198
    }
1199

    
1200
    if(pkt->dts != AV_NOPTS_VALUE)
1201
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1202

    
1203
    avpkt.size = pkt->size;
1204
    avpkt.data = pkt->data;
1205

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

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

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

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

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

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

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

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

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

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

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

    
1371
                        av_init_packet(&opkt);
1372

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1542
    return -1;
1543
}
1544

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1732
        codec = ost->st->codec;
1733
        icodec = ist->st->codec;
1734

    
1735
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1736
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1737
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1738

    
1739
        ost->st->disposition = ist->st->disposition;
1740

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

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

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

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

    
1907
    if (!bit_buffer)
1908
        bit_buffer = av_malloc(bit_buffer_size);
1909
    if (!bit_buffer) {
1910
        ret = AVERROR(ENOMEM);
1911
        goto fail;
1912
    }
1913

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

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

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

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

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

    
1991
        out_file = output_files[out_file_index];
1992
        in_file = input_files[in_file_index];
1993

    
1994

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

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

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

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

    
2040
    if (ret) {
2041
        fprintf(stderr, "%s\n", error);
2042
        goto fail;
2043
    }
2044

    
2045
    if (want_sdp) {
2046
        print_sdp(output_files, nb_output_files);
2047
    }
2048

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

    
2055
    key = -1;
2056
    timer_start = av_gettime();
2057

    
2058
    for(; received_sigterm == 0;) {
2059
        int file_index, ist_index;
2060
        AVPacket pkt;
2061
        double ipts_min;
2062
        double opts_min;
2063

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

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

    
2118
        /* finish if recording time exhausted */
2119
        if (opts_min >= (recording_time / 1000000.0))
2120
            break;
2121

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

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

    
2142
        no_packet_count=0;
2143
        memset(no_packet, 0, sizeof(no_packet));
2144

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

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

    
2162
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2163
            if(pkt.pts != AV_NOPTS_VALUE)
2164
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2165
            if(pkt.dts != AV_NOPTS_VALUE)
2166
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2167
        }
2168

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

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

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

    
2196
    discard_packet:
2197
        av_free_packet(&pkt);
2198

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

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

    
2211
    term_exit();
2212

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

    
2219
    /* dump report by using the first video and audio streams */
2220
    print_report(output_files, ost_table, nb_ostreams, 1);
2221

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

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

    
2239
    /* finished ! */
2240
    ret = 0;
2241

    
2242
 fail:
2243
    av_freep(&bit_buffer);
2244
    av_free(file_table);
2245

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

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

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

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

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

    
2318
static void opt_video_rc_override_string(const char *arg)
2319
{
2320
    video_rc_override_string = arg;
2321
}
2322

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

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

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

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

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

    
2354
    opt_default(opt, arg);
2355

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

    
2359
    return 0;
2360
}
2361

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

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

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

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

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

    
2446

    
2447
#define SCALEBITS 10
2448
#define ONE_HALF  (1 << (SCALEBITS - 1))
2449
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2450

    
2451
#define RGB_TO_Y(r, g, b) \
2452
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2453
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2454

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

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

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

    
2469
    r = (rgb >> 16);
2470
    g = ((rgb >> 8) & 255);
2471
    b = (rgb & 255);
2472

    
2473
    padcolor[0] = RGB_TO_Y(r,g,b);
2474
    padcolor[1] = RGB_TO_U(r,g,b,0);
2475
    padcolor[2] = RGB_TO_V(r,g,b,0);
2476
}
2477

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

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

    
2504

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

    
2518

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

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

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

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

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

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

    
2580
static int opt_metadata(const char *opt, const char *arg)
2581
{
2582
    char *mid= strchr(arg, '=');
2583

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

    
2590
    metadata_count++;
2591
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2592
    metadata[metadata_count-1].key  = av_strdup(arg);
2593
    metadata[metadata_count-1].value= av_strdup(mid);
2594

    
2595
    return 0;
2596
}
2597

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

    
2608
static void opt_top_field_first(const char *arg)
2609
{
2610
    top_field_first= atoi(arg);
2611
}
2612

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

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

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

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

    
2645
static void opt_video_channel(const char *arg)
2646
{
2647
    video_channel = strtol(arg, NULL, 0);
2648
}
2649

    
2650
static void opt_video_standard(const char *arg)
2651
{
2652
    video_standard = av_strdup(arg);
2653
}
2654

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

    
2666
static void opt_audio_codec(const char *arg)
2667
{
2668
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2669
}
2670

    
2671
static void opt_audio_tag(const char *arg)
2672
{
2673
    char *tail;
2674
    audio_codec_tag= strtol(arg, &tail, 0);
2675

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

    
2680
static void opt_video_tag(const char *arg)
2681
{
2682
    char *tail;
2683
    video_codec_tag= strtol(arg, &tail, 0);
2684

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

    
2689
static void opt_video_codec(const char *arg)
2690
{
2691
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2692
}
2693

    
2694
static void opt_subtitle_codec(const char *arg)
2695
{
2696
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2697
}
2698

    
2699
static void opt_subtitle_tag(const char *arg)
2700
{
2701
    char *tail;
2702
    subtitle_codec_tag= strtol(arg, &tail, 0);
2703

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

    
2708
static void opt_map(const char *arg)
2709
{
2710
    AVStreamMap *m;
2711
    char *p;
2712

    
2713
    m = &stream_maps[nb_stream_maps++];
2714

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

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

    
2732
static void opt_map_meta_data(const char *arg)
2733
{
2734
    AVMetaDataMap *m;
2735
    char *p;
2736

    
2737
    m = &meta_data_maps[nb_meta_data_maps++];
2738

    
2739
    m->out_file = strtol(arg, &p, 0);
2740
    if (*p)
2741
        p++;
2742

    
2743
    m->in_file = strtol(p, &p, 0);
2744
}
2745

    
2746
static void opt_input_ts_scale(const char *arg)
2747
{
2748
    unsigned int stream;
2749
    double scale;
2750
    char *p;
2751

    
2752
    stream = strtol(arg, &p, 0);
2753
    if (*p)
2754
        p++;
2755
    scale= strtod(p, &p);
2756

    
2757
    if(stream >= MAX_STREAMS)
2758
        av_exit(1);
2759

    
2760
    input_files_ts_scale[nb_input_files][stream]= scale;
2761
}
2762

    
2763
static int opt_recording_time(const char *opt, const char *arg)
2764
{
2765
    recording_time = parse_time_or_die(opt, arg, 1);
2766
    return 0;
2767
}
2768

    
2769
static int opt_start_time(const char *opt, const char *arg)
2770
{
2771
    start_time = parse_time_or_die(opt, arg, 1);
2772
    return 0;
2773
}
2774

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

    
2781
static int opt_input_ts_offset(const char *opt, const char *arg)
2782
{
2783
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2784
    return 0;
2785
}
2786

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

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

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

    
2815
    if (!strcmp(filename, "-"))
2816
        filename = "pipe:";
2817

    
2818
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2819
                    !strcmp(filename, "/dev/stdin");
2820

    
2821
    /* get default parameters from command line */
2822
    ic = avformat_alloc_context();
2823

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

    
2841
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2842

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

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

    
2861
    ic->loop_input = loop_input;
2862

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

    
2871
    timestamp = start_time;
2872
    /* add the stream start time */
2873
    if (ic->start_time != AV_NOPTS_VALUE)
2874
        timestamp += ic->start_time;
2875

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

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

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

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

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

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

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

    
2961
    nb_input_files++;
2962
    file_iformat = NULL;
2963
    file_oformat = NULL;
2964

    
2965
    video_channel = 0;
2966

    
2967
    av_freep(&video_codec_name);
2968
    av_freep(&audio_codec_name);
2969
    av_freep(&subtitle_codec_name);
2970
}
2971

    
2972
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2973
                                         int *has_subtitle_ptr)
2974
{
2975
    int has_video, has_audio, has_subtitle, i, j;
2976
    AVFormatContext *ic;
2977

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

    
3009
static void new_video_stream(AVFormatContext *oc)
3010
{
3011
    AVStream *st;
3012
    AVCodecContext *video_enc;
3013
    int codec_id;
3014

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

    
3024
    if(thread_count>1)
3025
        avcodec_thread_init(st->codec, thread_count);
3026

    
3027
    video_enc = st->codec;
3028

    
3029
    if(video_codec_tag)
3030
        video_enc->codec_tag= video_codec_tag;
3031

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

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

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

    
3062
        video_enc->codec_id = codec_id;
3063

    
3064
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3065

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

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

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

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

    
3095
        if(intra_matrix)
3096
            video_enc->intra_matrix = intra_matrix;
3097
        if(inter_matrix)
3098
            video_enc->inter_matrix = inter_matrix;
3099

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

    
3131
        if (do_psnr)
3132
            video_enc->flags|= CODEC_FLAG_PSNR;
3133

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

    
3145
    /* reset some key parameters */
3146
    video_disable = 0;
3147
    av_freep(&video_codec_name);
3148
    video_stream_copy = 0;
3149
}
3150

    
3151
static void new_audio_stream(AVFormatContext *oc)
3152
{
3153
    AVStream *st;
3154
    AVCodecContext *audio_enc;
3155
    int codec_id;
3156

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

    
3164
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3165
    audio_bitstream_filters= NULL;
3166

    
3167
    if(thread_count>1)
3168
        avcodec_thread_init(st->codec, thread_count);
3169

    
3170
    audio_enc = st->codec;
3171
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3172

    
3173
    if(audio_codec_tag)
3174
        audio_enc->codec_tag= audio_codec_tag;
3175

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

    
3186
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3187

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

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

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

    
3226
    /* reset some key parameters */
3227
    audio_disable = 0;
3228
    av_freep(&audio_codec_name);
3229
    audio_stream_copy = 0;
3230
}
3231

    
3232
static void new_subtitle_stream(AVFormatContext *oc)
3233
{
3234
    AVStream *st;
3235
    AVCodecContext *subtitle_enc;
3236

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

    
3244
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3245
    subtitle_bitstream_filters= NULL;
3246

    
3247
    subtitle_enc = st->codec;
3248
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3249

    
3250
    if(subtitle_codec_tag)
3251
        subtitle_enc->codec_tag= subtitle_codec_tag;
3252

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

    
3262
    if (subtitle_language) {
3263
        av_metadata_set(&st->metadata, "language", subtitle_language);
3264
        av_free(subtitle_language);
3265
        subtitle_language = NULL;
3266
    }
3267

    
3268
    subtitle_disable = 0;
3269
    av_freep(&subtitle_codec_name);
3270
    subtitle_stream_copy = 0;
3271
}
3272

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

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

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

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

    
3313
    if (!strcmp(filename, "-"))
3314
        filename = "pipe:";
3315

    
3316
    oc = avformat_alloc_context();
3317

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

    
3327
    oc->oformat = file_oformat;
3328
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3329

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

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

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

    
3368
        if (use_video) {
3369
            new_video_stream(oc);
3370
        }
3371

    
3372
        if (use_audio) {
3373
            new_audio_stream(oc);
3374
        }
3375

    
3376
        if (use_subtitle) {
3377
            new_subtitle_stream(oc);
3378
        }
3379

    
3380
        oc->timestamp = rec_timestamp;
3381

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

    
3389
    output_files[nb_output_files++] = oc;
3390

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

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

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

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

    
3435
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3436
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3437
    oc->loop_output = loop_output;
3438
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3439

    
3440
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3441

    
3442
    /* reset some options */
3443
    file_oformat = NULL;
3444
    file_iformat = NULL;
3445
}
3446

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

    
3459
static int64_t getutime(void)
3460
{
3461
#if HAVE_GETRUSAGE
3462
    struct rusage rusage;
3463

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

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

    
3494
static void opt_inter_matrix(const char *arg)
3495
{
3496
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3497
    parse_matrix_coeffs(inter_matrix, arg);
3498
}
3499

    
3500
static void opt_intra_matrix(const char *arg)
3501
{
3502
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3503
    parse_matrix_coeffs(intra_matrix, arg);
3504
}
3505

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

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

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

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

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

    
3608
    if(!strcmp(arg, "vcd")) {
3609

    
3610
        opt_video_codec("mpeg1video");
3611
        opt_audio_codec("mp2");
3612
        opt_format("vcd");
3613

    
3614
        opt_frame_size(norm ? "352x240" : "352x288");
3615
        opt_frame_rate(NULL, frame_rates[norm]);
3616
        opt_default("gop", norm ? "18" : "15");
3617

    
3618
        opt_default("b", "1150000");
3619
        opt_default("maxrate", "1150000");
3620
        opt_default("minrate", "1150000");
3621
        opt_default("bufsize", "327680"); // 40*1024*8;
3622

    
3623
        opt_default("ab", "224000");
3624
        audio_sample_rate = 44100;
3625
        audio_channels = 2;
3626

    
3627
        opt_default("packetsize", "2324");
3628
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3629

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

    
3638
        opt_video_codec("mpeg2video");
3639
        opt_audio_codec("mp2");
3640
        opt_format("svcd");
3641

    
3642
        opt_frame_size(norm ? "480x480" : "480x576");
3643
        opt_frame_rate(NULL, frame_rates[norm]);
3644
        opt_default("gop", norm ? "18" : "15");
3645

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

    
3652

    
3653
        opt_default("ab", "224000");
3654
        audio_sample_rate = 44100;
3655

    
3656
        opt_default("packetsize", "2324");
3657

    
3658
    } else if(!strcmp(arg, "dvd")) {
3659

    
3660
        opt_video_codec("mpeg2video");
3661
        opt_audio_codec("ac3");
3662
        opt_format("dvd");
3663

    
3664
        opt_frame_size(norm ? "720x480" : "720x576");
3665
        opt_frame_rate(NULL, frame_rates[norm]);
3666
        opt_default("gop", norm ? "18" : "15");
3667

    
3668
        opt_default("b", "6000000");
3669
        opt_default("maxrate", "9000000");
3670
        opt_default("minrate", "0"); //1500000;
3671
        opt_default("bufsize", "1835008"); //224*1024*8;
3672

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

    
3676
        opt_default("ab", "448000");
3677
        audio_sample_rate = 48000;
3678

    
3679
    } else if(!strncmp(arg, "dv", 2)) {
3680

    
3681
        opt_format("dv");
3682

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

    
3688
        audio_sample_rate = 48000;
3689
        audio_channels = 2;
3690

    
3691
    } else {
3692
        fprintf(stderr, "Unknown target: %s\n", arg);
3693
        av_exit(1);
3694
    }
3695
}
3696

    
3697
static void opt_vstats_file (const char *arg)
3698
{
3699
    av_free (vstats_filename);
3700
    vstats_filename=av_strdup (arg);
3701
}
3702

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

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

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

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

    
3724
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3725
          *opt == 'a' ? &audio_bitstream_filters :
3726
                        &subtitle_bitstream_filters;
3727
    while(*bsfp)
3728
        bsfp= &(*bsfp)->next;
3729

    
3730
    *bsfp= bsfc;
3731

    
3732
    return 0;
3733
}
3734

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

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

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

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

    
3787
    fclose(f);
3788

    
3789
    return 0;
3790
}
3791

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

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

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

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

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

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

    
3907
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3908
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3909
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3910

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

    
3915
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3916
    { NULL, },
3917
};
3918

    
3919
int main(int argc, char **argv)
3920
{
3921
    int i;
3922
    int64_t ti;
3923

    
3924
    avcodec_register_all();
3925
    avdevice_register_all();
3926
    av_register_all();
3927

    
3928
    if(isatty(STDIN_FILENO))
3929
        url_set_interrupt_cb(decode_interrupt_cb);
3930

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

    
3937
    show_banner();
3938

    
3939
    /* parse options */
3940
    parse_options(argc, argv, options, opt_output_file);
3941

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

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

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

    
3962
    return av_exit(0);
3963
}