Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 8c8bf9ec

History | View | Annotate | Download (147 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 "libavcodec/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/pixdesc.h"
42
#include "libavutil/avstring.h"
43
#include "libavformat/os_support.h"
44

    
45
#if HAVE_SYS_RESOURCE_H
46
#include <sys/types.h>
47
#include <sys/time.h>
48
#include <sys/resource.h>
49
#elif HAVE_GETPROCESSTIMES
50
#include <windows.h>
51
#endif
52
#if HAVE_GETPROCESSMEMORYINFO
53
#include <windows.h>
54
#include <psapi.h>
55
#endif
56

    
57
#if HAVE_SYS_SELECT_H
58
#include <sys/select.h>
59
#endif
60

    
61
#if HAVE_TERMIOS_H
62
#include <fcntl.h>
63
#include <sys/ioctl.h>
64
#include <sys/time.h>
65
#include <termios.h>
66
#elif HAVE_CONIO_H
67
#include <conio.h>
68
#endif
69
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
70
#include <time.h>
71

    
72
#include "cmdutils.h"
73

    
74
#undef NDEBUG
75
#include <assert.h>
76

    
77
#undef exit
78

    
79
const char program_name[] = "FFmpeg";
80
const int program_birth_year = 2000;
81

    
82
/* select an input stream for an output stream */
83
typedef struct AVStreamMap {
84
    int file_index;
85
    int stream_index;
86
    int sync_file_index;
87
    int sync_stream_index;
88
} AVStreamMap;
89

    
90
/** select an input file for an output file */
91
typedef struct AVMetaDataMap {
92
    int out_file;
93
    int in_file;
94
} AVMetaDataMap;
95

    
96
static const OptionDef options[];
97

    
98
#define MAX_FILES 100
99

    
100
static const char *last_asked_format = NULL;
101
static AVFormatContext *input_files[MAX_FILES];
102
static int64_t input_files_ts_offset[MAX_FILES];
103
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
104
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
105
static int nb_input_files = 0;
106
static int nb_icodecs;
107

    
108
static AVFormatContext *output_files[MAX_FILES];
109
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
110
static int nb_output_files = 0;
111
static int nb_ocodecs;
112

    
113
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
114
static int nb_stream_maps;
115

    
116
static AVMetaDataMap meta_data_maps[MAX_FILES];
117
static int nb_meta_data_maps;
118

    
119
static int frame_width  = 0;
120
static int frame_height = 0;
121
static float frame_aspect_ratio = 0;
122
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
123
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
124
static int frame_padtop  = 0;
125
static int frame_padbottom = 0;
126
static int frame_padleft  = 0;
127
static int frame_padright = 0;
128
static int padcolor[3] = {16,128,128}; /* default to black */
129
static int frame_topBand  = 0;
130
static int frame_bottomBand = 0;
131
static int frame_leftBand  = 0;
132
static int frame_rightBand = 0;
133
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
134
static AVRational frame_rate;
135
static float video_qscale = 0;
136
static uint16_t *intra_matrix = NULL;
137
static uint16_t *inter_matrix = NULL;
138
static const char *video_rc_override_string=NULL;
139
static int video_disable = 0;
140
static int video_discard = 0;
141
static char *video_codec_name = NULL;
142
static int video_codec_tag = 0;
143
static char *video_language = NULL;
144
static int same_quality = 0;
145
static int do_deinterlace = 0;
146
static int top_field_first = -1;
147
static int me_threshold = 0;
148
static int intra_dc_precision = 8;
149
static int loop_input = 0;
150
static int loop_output = AVFMT_NOOUTPUTLOOP;
151
static int qp_hist = 0;
152

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

    
164
static int subtitle_disable = 0;
165
static char *subtitle_codec_name = NULL;
166
static char *subtitle_language = NULL;
167
static int subtitle_codec_tag = 0;
168

    
169
static float mux_preload= 0.5;
170
static float mux_max_delay= 0.7;
171

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

    
199
static int rate_emu = 0;
200

    
201
static int  video_channel = 0;
202
static char *video_standard;
203

    
204
static int audio_volume = 256;
205

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

    
220
static int pgmyuv_compatibility_hack=0;
221
static float dts_delta_threshold = 10;
222

    
223
static unsigned int sws_flags = SWS_BICUBIC;
224

    
225
static int64_t timer_start;
226

    
227
static uint8_t *audio_buf;
228
static uint8_t *audio_out;
229
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
230

    
231
static short *samples;
232

    
233
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
234
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
235
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
236
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
237

    
238
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
239

    
240
struct AVInputStream;
241

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

    
262
    /* full frame size of first frame */
263
    int original_height;
264
    int original_width;
265

    
266
    /* cropping area sizes */
267
    int video_crop;
268
    int topBand;
269
    int bottomBand;
270
    int leftBand;
271
    int rightBand;
272

    
273
    /* cropping area of first frame */
274
    int original_topBand;
275
    int original_bottomBand;
276
    int original_leftBand;
277
    int original_rightBand;
278

    
279
    /* padding area sizes */
280
    int video_pad;
281
    int padtop;
282
    int padbottom;
283
    int padleft;
284
    int padright;
285

    
286
    /* audio only */
287
    int audio_resample;
288
    ReSampleContext *resample; /* for audio resampling */
289
    int reformat_pair;
290
    AVAudioConvert *reformat_ctx;
291
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
292
    FILE *logfile;
293
} AVOutputStream;
294

    
295
typedef struct AVInputStream {
296
    int file_index;
297
    int index;
298
    AVStream *st;
299
    int discard;             /* true if stream data should be discarded */
300
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
301
    int64_t sample_index;      /* current sample */
302

    
303
    int64_t       start;     /* time when read started */
304
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
305
                                is not defined */
306
    int64_t       pts;       /* current pts */
307
    int is_start;            /* is 1 at the start and after a discontinuity */
308
    int showed_multi_packet_warning;
309
    int is_past_recording_time;
310
} AVInputStream;
311

    
312
typedef struct AVInputFile {
313
    int eof_reached;      /* true if eof reached */
314
    int ist_index;        /* index of first stream in ist_table */
315
    int buffer_size;      /* current total buffer size */
316
    int nb_streams;       /* nb streams we are aware of */
317
} AVInputFile;
318

    
319
#if HAVE_TERMIOS_H
320

    
321
/* init terminal so that we can grab keys */
322
static struct termios oldtty;
323
#endif
324

    
325
static void term_exit(void)
326
{
327
#if HAVE_TERMIOS_H
328
    tcsetattr (0, TCSANOW, &oldtty);
329
#endif
330
}
331

    
332
static volatile int received_sigterm = 0;
333

    
334
static void
335
sigterm_handler(int sig)
336
{
337
    received_sigterm = sig;
338
    term_exit();
339
}
340

    
341
static void term_init(void)
342
{
343
#if HAVE_TERMIOS_H
344
    struct termios tty;
345

    
346
    tcgetattr (0, &tty);
347
    oldtty = tty;
348

    
349
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
350
                          |INLCR|IGNCR|ICRNL|IXON);
351
    tty.c_oflag |= OPOST;
352
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
353
    tty.c_cflag &= ~(CSIZE|PARENB);
354
    tty.c_cflag |= CS8;
355
    tty.c_cc[VMIN] = 1;
356
    tty.c_cc[VTIME] = 0;
357

    
358
    tcsetattr (0, TCSANOW, &tty);
359
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
360
#endif
361

    
362
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
363
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
364
#ifdef SIGXCPU
365
    signal(SIGXCPU, sigterm_handler);
366
#endif
367

    
368
    /*
369
    register a function to be called at normal program termination
370
    */
371
    atexit(term_exit);
372
#if CONFIG_BEOS_NETSERVER
373
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
374
#endif
375
}
376

    
377
/* read a key without blocking */
378
static int read_key(void)
379
{
380
#if HAVE_TERMIOS_H
381
    int n = 1;
382
    unsigned char ch;
383
#if !CONFIG_BEOS_NETSERVER
384
    struct timeval tv;
385
    fd_set rfds;
386

    
387
    FD_ZERO(&rfds);
388
    FD_SET(0, &rfds);
389
    tv.tv_sec = 0;
390
    tv.tv_usec = 0;
391
    n = select(1, &rfds, NULL, NULL, &tv);
392
#endif
393
    if (n > 0) {
394
        n = read(0, &ch, 1);
395
        if (n == 1)
396
            return ch;
397

    
398
        return n;
399
    }
400
#elif HAVE_CONIO_H
401
    if(kbhit())
402
        return(getch());
403
#endif
404
    return -1;
405
}
406

    
407
static int decode_interrupt_cb(void)
408
{
409
    return q_pressed || (q_pressed = read_key() == 'q');
410
}
411

    
412
static int av_exit(int ret)
413
{
414
    int i;
415

    
416
    /* close files */
417
    for(i=0;i<nb_output_files;i++) {
418
        /* maybe av_close_output_file ??? */
419
        AVFormatContext *s = output_files[i];
420
        int j;
421
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
422
            url_fclose(s->pb);
423
        for(j=0;j<s->nb_streams;j++) {
424
            av_metadata_free(&s->streams[j]->metadata);
425
            av_free(s->streams[j]->codec);
426
            av_free(s->streams[j]);
427
        }
428
        for(j=0;j<s->nb_programs;j++) {
429
            av_metadata_free(&s->programs[j]->metadata);
430
        }
431
        for(j=0;j<s->nb_chapters;j++) {
432
            av_metadata_free(&s->chapters[j]->metadata);
433
        }
434
        av_metadata_free(&s->metadata);
435
        av_free(s);
436
    }
437
    for(i=0;i<nb_input_files;i++)
438
        av_close_input_file(input_files[i]);
439

    
440
    av_free(intra_matrix);
441
    av_free(inter_matrix);
442

    
443
    if (vstats_file)
444
        fclose(vstats_file);
445
    av_free(vstats_filename);
446

    
447
    av_free(opt_names);
448

    
449
    av_free(video_codec_name);
450
    av_free(audio_codec_name);
451
    av_free(subtitle_codec_name);
452

    
453
    av_free(video_standard);
454

    
455
#if CONFIG_POWERPC_PERF
456
    void powerpc_display_perf_report(void);
457
    powerpc_display_perf_report();
458
#endif /* CONFIG_POWERPC_PERF */
459

    
460
    for (i=0;i<CODEC_TYPE_NB;i++)
461
        av_free(avcodec_opts[i]);
462
    av_free(avformat_opts);
463
    av_free(sws_opts);
464
    av_free(audio_buf);
465
    av_free(audio_out);
466
    allocated_audio_buf_size= allocated_audio_out_size= 0;
467
    av_free(samples);
468

    
469
    if (received_sigterm) {
470
        fprintf(stderr,
471
            "Received signal %d: terminating.\n",
472
            (int) received_sigterm);
473
        exit (255);
474
    }
475

    
476
    exit(ret); /* not all OS-es handle main() return value */
477
    return ret;
478
}
479

    
480
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
481
{
482
    int i, err;
483
    AVFormatContext *ic;
484
    int nopts = 0;
485

    
486
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
487
    if (err < 0)
488
        return err;
489
    /* copy stream format */
490
    s->nb_streams = ic->nb_streams;
491
    for(i=0;i<ic->nb_streams;i++) {
492
        AVStream *st;
493

    
494
        // FIXME: a more elegant solution is needed
495
        st = av_mallocz(sizeof(AVStream));
496
        memcpy(st, ic->streams[i], sizeof(AVStream));
497
        st->codec = avcodec_alloc_context();
498
        if (!st->codec) {
499
            print_error(filename, AVERROR(ENOMEM));
500
            av_exit(1);
501
        }
502
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
503
        s->streams[i] = st;
504

    
505
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
506
            st->stream_copy = 1;
507
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
508
            st->stream_copy = 1;
509

    
510
        if(!st->codec->thread_count)
511
            st->codec->thread_count = 1;
512
        if(st->codec->thread_count>1)
513
            avcodec_thread_init(st->codec, st->codec->thread_count);
514

    
515
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
516
            nopts = 1;
517
    }
518

    
519
    if (!nopts)
520
        s->timestamp = av_gettime();
521

    
522
    av_close_input_file(ic);
523
    return 0;
524
}
525

    
526
static double
527
get_sync_ipts(const AVOutputStream *ost)
528
{
529
    const AVInputStream *ist = ost->sync_ist;
530
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
531
}
532

    
533
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
534
    int ret;
535

    
536
    while(bsfc){
537
        AVPacket new_pkt= *pkt;
538
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
539
                                          &new_pkt.data, &new_pkt.size,
540
                                          pkt->data, pkt->size,
541
                                          pkt->flags & PKT_FLAG_KEY);
542
        if(a>0){
543
            av_free_packet(pkt);
544
            new_pkt.destruct= av_destruct_packet;
545
        } else if(a<0){
546
            fprintf(stderr, "%s failed for stream %d, codec %s",
547
                    bsfc->filter->name, pkt->stream_index,
548
                    avctx->codec ? avctx->codec->name : "copy");
549
            print_error("", a);
550
            if (exit_on_error)
551
                av_exit(1);
552
        }
553
        *pkt= new_pkt;
554

    
555
        bsfc= bsfc->next;
556
    }
557

    
558
    ret= av_interleaved_write_frame(s, pkt);
559
    if(ret < 0){
560
        print_error("av_interleaved_write_frame()", ret);
561
        av_exit(1);
562
    }
563
}
564

    
565
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
566

    
567
static void do_audio_out(AVFormatContext *s,
568
                         AVOutputStream *ost,
569
                         AVInputStream *ist,
570
                         unsigned char *buf, int size)
571
{
572
    uint8_t *buftmp;
573
    int64_t audio_out_size, audio_buf_size;
574
    int64_t allocated_for_size= size;
575

    
576
    int size_out, frame_bytes, ret;
577
    AVCodecContext *enc= ost->st->codec;
578
    AVCodecContext *dec= ist->st->codec;
579
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
580
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
581
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
582

    
583
need_realloc:
584
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
585
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
586
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
587
    audio_buf_size*= osize*enc->channels;
588

    
589
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
590
    if(coded_bps > 8*osize)
591
        audio_out_size= audio_out_size * coded_bps / (8*osize);
592
    audio_out_size += FF_MIN_BUFFER_SIZE;
593

    
594
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
595
        fprintf(stderr, "Buffer sizes too large\n");
596
        av_exit(1);
597
    }
598

    
599
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
600
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
601
    if (!audio_buf || !audio_out){
602
        fprintf(stderr, "Out of memory in do_audio_out\n");
603
        av_exit(1);
604
    }
605

    
606
    if (enc->channels != dec->channels)
607
        ost->audio_resample = 1;
608

    
609
    if (ost->audio_resample && !ost->resample) {
610
        if (dec->sample_fmt != SAMPLE_FMT_S16)
611
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
612
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
613
                                               enc->sample_rate, dec->sample_rate,
614
                                               enc->sample_fmt,  dec->sample_fmt,
615
                                               16, 10, 0, 0.8);
616
        if (!ost->resample) {
617
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
618
                    dec->channels, dec->sample_rate,
619
                    enc->channels, enc->sample_rate);
620
            av_exit(1);
621
        }
622
    }
623

    
624
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
625
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
626
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
627
        if (ost->reformat_ctx)
628
            av_audio_convert_free(ost->reformat_ctx);
629
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
630
                                                   dec->sample_fmt, 1, NULL, 0);
631
        if (!ost->reformat_ctx) {
632
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
633
                avcodec_get_sample_fmt_name(dec->sample_fmt),
634
                avcodec_get_sample_fmt_name(enc->sample_fmt));
635
            av_exit(1);
636
        }
637
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
638
    }
639

    
640
    if(audio_sync_method){
641
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
642
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
643
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
644
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
645

    
646
        //FIXME resample delay
647
        if(fabs(delta) > 50){
648
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
649
                if(byte_delta < 0){
650
                    byte_delta= FFMAX(byte_delta, -size);
651
                    size += byte_delta;
652
                    buf  -= byte_delta;
653
                    if(verbose > 2)
654
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
655
                    if(!size)
656
                        return;
657
                    ist->is_start=0;
658
                }else{
659
                    static uint8_t *input_tmp= NULL;
660
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
661

    
662
                    if(byte_delta > allocated_for_size - size){
663
                        allocated_for_size= byte_delta + (int64_t)size;
664
                        goto need_realloc;
665
                    }
666
                    ist->is_start=0;
667

    
668
                    memset(input_tmp, 0, byte_delta);
669
                    memcpy(input_tmp + byte_delta, buf, size);
670
                    buf= input_tmp;
671
                    size += byte_delta;
672
                    if(verbose > 2)
673
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
674
                }
675
            }else if(audio_sync_method>1){
676
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
677
                assert(ost->audio_resample);
678
                if(verbose > 2)
679
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
680
//                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));
681
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
682
            }
683
        }
684
    }else
685
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
686
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
687

    
688
    if (ost->audio_resample) {
689
        buftmp = audio_buf;
690
        size_out = audio_resample(ost->resample,
691
                                  (short *)buftmp, (short *)buf,
692
                                  size / (ist->st->codec->channels * isize));
693
        size_out = size_out * enc->channels * osize;
694
    } else {
695
        buftmp = buf;
696
        size_out = size;
697
    }
698

    
699
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
700
        const void *ibuf[6]= {buftmp};
701
        void *obuf[6]= {audio_buf};
702
        int istride[6]= {isize};
703
        int ostride[6]= {osize};
704
        int len= size_out/istride[0];
705
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
706
            printf("av_audio_convert() failed\n");
707
            if (exit_on_error)
708
                av_exit(1);
709
            return;
710
        }
711
        buftmp = audio_buf;
712
        size_out = len*osize;
713
    }
714

    
715
    /* now encode as many frames as possible */
716
    if (enc->frame_size > 1) {
717
        /* output resampled raw samples */
718
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
719
            fprintf(stderr, "av_fifo_realloc2() failed\n");
720
            av_exit(1);
721
        }
722
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
723

    
724
        frame_bytes = enc->frame_size * osize * enc->channels;
725

    
726
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
727
            AVPacket pkt;
728
            av_init_packet(&pkt);
729

    
730
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
731

    
732
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
733

    
734
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
735
                                       (short *)audio_buf);
736
            if (ret < 0) {
737
                fprintf(stderr, "Audio encoding failed\n");
738
                av_exit(1);
739
            }
740
            audio_size += ret;
741
            pkt.stream_index= ost->index;
742
            pkt.data= audio_out;
743
            pkt.size= ret;
744
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
745
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
746
            pkt.flags |= PKT_FLAG_KEY;
747
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
748

    
749
            ost->sync_opts += enc->frame_size;
750
        }
751
    } else {
752
        AVPacket pkt;
753
        av_init_packet(&pkt);
754

    
755
        ost->sync_opts += size_out / (osize * enc->channels);
756

    
757
        /* output a pcm frame */
758
        /* determine the size of the coded buffer */
759
        size_out /= osize;
760
        if (coded_bps)
761
            size_out = size_out*coded_bps/8;
762

    
763
        if(size_out > audio_out_size){
764
            fprintf(stderr, "Internal error, buffer size too small\n");
765
            av_exit(1);
766
        }
767

    
768
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
769
        ret = avcodec_encode_audio(enc, audio_out, size_out,
770
                                   (short *)buftmp);
771
        if (ret < 0) {
772
            fprintf(stderr, "Audio encoding failed\n");
773
            av_exit(1);
774
        }
775
        audio_size += ret;
776
        pkt.stream_index= ost->index;
777
        pkt.data= audio_out;
778
        pkt.size= ret;
779
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
780
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
781
        pkt.flags |= PKT_FLAG_KEY;
782
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
783
    }
784
}
785

    
786
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
787
{
788
    AVCodecContext *dec;
789
    AVPicture *picture2;
790
    AVPicture picture_tmp;
791
    uint8_t *buf = 0;
792

    
793
    dec = ist->st->codec;
794

    
795
    /* deinterlace : must be done before any resize */
796
    if (do_deinterlace) {
797
        int size;
798

    
799
        /* create temporary picture */
800
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
801
        buf = av_malloc(size);
802
        if (!buf)
803
            return;
804

    
805
        picture2 = &picture_tmp;
806
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
807

    
808
        if(avpicture_deinterlace(picture2, picture,
809
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
810
            /* if error, do not deinterlace */
811
            fprintf(stderr, "Deinterlacing failed\n");
812
            av_free(buf);
813
            buf = NULL;
814
            picture2 = picture;
815
        }
816
    } else {
817
        picture2 = picture;
818
    }
819

    
820
    if (picture != picture2)
821
        *picture = *picture2;
822
    *bufp = buf;
823
}
824

    
825
/* we begin to correct av delay at this threshold */
826
#define AV_DELAY_MAX 0.100
827

    
828
static void do_subtitle_out(AVFormatContext *s,
829
                            AVOutputStream *ost,
830
                            AVInputStream *ist,
831
                            AVSubtitle *sub,
832
                            int64_t pts)
833
{
834
    static uint8_t *subtitle_out = NULL;
835
    int subtitle_out_max_size = 1024 * 1024;
836
    int subtitle_out_size, nb, i;
837
    AVCodecContext *enc;
838
    AVPacket pkt;
839

    
840
    if (pts == AV_NOPTS_VALUE) {
841
        fprintf(stderr, "Subtitle packets must have a pts\n");
842
        if (exit_on_error)
843
            av_exit(1);
844
        return;
845
    }
846

    
847
    enc = ost->st->codec;
848

    
849
    if (!subtitle_out) {
850
        subtitle_out = av_malloc(subtitle_out_max_size);
851
    }
852

    
853
    /* Note: DVB subtitle need one packet to draw them and one other
854
       packet to clear them */
855
    /* XXX: signal it in the codec context ? */
856
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
857
        nb = 2;
858
    else
859
        nb = 1;
860

    
861
    for(i = 0; i < nb; i++) {
862
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
863
        // start_display_time is required to be 0
864
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
865
        sub->end_display_time -= sub->start_display_time;
866
        sub->start_display_time = 0;
867
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
868
                                                    subtitle_out_max_size, sub);
869
        if (subtitle_out_size < 0) {
870
            fprintf(stderr, "Subtitle encoding failed\n");
871
            av_exit(1);
872
        }
873

    
874
        av_init_packet(&pkt);
875
        pkt.stream_index = ost->index;
876
        pkt.data = subtitle_out;
877
        pkt.size = subtitle_out_size;
878
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
879
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
880
            /* XXX: the pts correction is handled here. Maybe handling
881
               it in the codec would be better */
882
            if (i == 0)
883
                pkt.pts += 90 * sub->start_display_time;
884
            else
885
                pkt.pts += 90 * sub->end_display_time;
886
        }
887
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
888
    }
889
}
890

    
891
static int bit_buffer_size= 1024*256;
892
static uint8_t *bit_buffer= NULL;
893

    
894
static void do_video_out(AVFormatContext *s,
895
                         AVOutputStream *ost,
896
                         AVInputStream *ist,
897
                         AVFrame *in_picture,
898
                         int *frame_size)
899
{
900
    int nb_frames, i, ret;
901
    int64_t topBand, bottomBand, leftBand, rightBand;
902
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
903
    AVFrame picture_crop_temp, picture_pad_temp;
904
    AVCodecContext *enc, *dec;
905

    
906
    avcodec_get_frame_defaults(&picture_crop_temp);
907
    avcodec_get_frame_defaults(&picture_pad_temp);
908

    
909
    enc = ost->st->codec;
910
    dec = ist->st->codec;
911

    
912
    /* by default, we output a single frame */
913
    nb_frames = 1;
914

    
915
    *frame_size = 0;
916

    
917
    if(video_sync_method){
918
        double vdelta;
919
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
920
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
921
        if (vdelta < -1.1)
922
            nb_frames = 0;
923
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
924
            if(vdelta<=-0.6){
925
                nb_frames=0;
926
            }else if(vdelta>0.6)
927
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
928
        }else if (vdelta > 1.1)
929
            nb_frames = lrintf(vdelta);
930
//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);
931
        if (nb_frames == 0){
932
            ++nb_frames_drop;
933
            if (verbose>2)
934
                fprintf(stderr, "*** drop!\n");
935
        }else if (nb_frames > 1) {
936
            nb_frames_dup += nb_frames - 1;
937
            if (verbose>2)
938
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
939
        }
940
    }else
941
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
942

    
943
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
944
    if (nb_frames <= 0)
945
        return;
946

    
947
    if (ost->video_crop) {
948
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
949
            fprintf(stderr, "error cropping picture\n");
950
            if (exit_on_error)
951
                av_exit(1);
952
            return;
953
        }
954
        formatted_picture = &picture_crop_temp;
955
    } else {
956
        formatted_picture = in_picture;
957
    }
958

    
959
    final_picture = formatted_picture;
960
    padding_src = formatted_picture;
961
    resampling_dst = &ost->pict_tmp;
962
    if (ost->video_pad) {
963
        final_picture = &ost->pict_tmp;
964
        if (ost->video_resample) {
965
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
966
                fprintf(stderr, "error padding picture\n");
967
                if (exit_on_error)
968
                    av_exit(1);
969
                return;
970
            }
971
            resampling_dst = &picture_pad_temp;
972
        }
973
    }
974

    
975
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
976
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
977
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
978

    
979
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
980
        if(!ost->video_resample)
981
            av_exit(1);
982
    }
983

    
984
    if (ost->video_resample) {
985
        padding_src = NULL;
986
        final_picture = &ost->pict_tmp;
987
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
988
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
989
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
990

    
991
            /* keep bands proportional to the frame size */
992
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
993
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
994
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
995
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
996

    
997
            /* sanity check to ensure no bad band sizes sneak in */
998
            assert(topBand    <= INT_MAX && topBand    >= 0);
999
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
1000
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
1001
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
1002

    
1003
            ost->topBand    = topBand;
1004
            ost->bottomBand = bottomBand;
1005
            ost->leftBand   = leftBand;
1006
            ost->rightBand  = rightBand;
1007

    
1008
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1009
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1010
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1011

    
1012
            /* initialize a new scaler context */
1013
            sws_freeContext(ost->img_resample_ctx);
1014
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1015
            ost->img_resample_ctx = sws_getContext(
1016
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1017
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1018
                ist->st->codec->pix_fmt,
1019
                ost->st->codec->width  - (ost->padleft  + ost->padright),
1020
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
1021
                ost->st->codec->pix_fmt,
1022
                sws_flags, NULL, NULL, NULL);
1023
            if (ost->img_resample_ctx == NULL) {
1024
                fprintf(stderr, "Cannot get resampling context\n");
1025
                av_exit(1);
1026
            }
1027
        }
1028
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1029
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1030
    }
1031

    
1032
    if (ost->video_pad) {
1033
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1034
                enc->height, enc->width, enc->pix_fmt,
1035
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1036
    }
1037

    
1038
    /* duplicates frame if needed */
1039
    for(i=0;i<nb_frames;i++) {
1040
        AVPacket pkt;
1041
        av_init_packet(&pkt);
1042
        pkt.stream_index= ost->index;
1043

    
1044
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1045
            /* raw pictures are written as AVPicture structure to
1046
               avoid any copies. We support temorarily the older
1047
               method. */
1048
            AVFrame* old_frame = enc->coded_frame;
1049
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1050
            pkt.data= (uint8_t *)final_picture;
1051
            pkt.size=  sizeof(AVPicture);
1052
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1053
            pkt.flags |= PKT_FLAG_KEY;
1054

    
1055
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1056
            enc->coded_frame = old_frame;
1057
        } else {
1058
            AVFrame big_picture;
1059

    
1060
            big_picture= *final_picture;
1061
            /* better than nothing: use input picture interlaced
1062
               settings */
1063
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1064
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1065
                if(top_field_first == -1)
1066
                    big_picture.top_field_first = in_picture->top_field_first;
1067
                else
1068
                    big_picture.top_field_first = top_field_first;
1069
            }
1070

    
1071
            /* handles sameq here. This is not correct because it may
1072
               not be a global option */
1073
            if (same_quality) {
1074
                big_picture.quality = ist->st->quality;
1075
            }else
1076
                big_picture.quality = ost->st->quality;
1077
            if(!me_threshold)
1078
                big_picture.pict_type = 0;
1079
//            big_picture.pts = AV_NOPTS_VALUE;
1080
            big_picture.pts= ost->sync_opts;
1081
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1082
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1083
            ret = avcodec_encode_video(enc,
1084
                                       bit_buffer, bit_buffer_size,
1085
                                       &big_picture);
1086
            if (ret < 0) {
1087
                fprintf(stderr, "Video encoding failed\n");
1088
                av_exit(1);
1089
            }
1090

    
1091
            if(ret>0){
1092
                pkt.data= bit_buffer;
1093
                pkt.size= ret;
1094
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1095
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1096
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1097
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1098
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1099

    
1100
                if(enc->coded_frame->key_frame)
1101
                    pkt.flags |= PKT_FLAG_KEY;
1102
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1103
                *frame_size = ret;
1104
                video_size += ret;
1105
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1106
                //        enc->frame_number-1, ret, enc->pict_type);
1107
                /* if two pass, output log */
1108
                if (ost->logfile && enc->stats_out) {
1109
                    fprintf(ost->logfile, "%s", enc->stats_out);
1110
                }
1111
            }
1112
        }
1113
        ost->sync_opts++;
1114
        ost->frame_number++;
1115
    }
1116
}
1117

    
1118
static double psnr(double d){
1119
    return -10.0*log(d)/log(10.0);
1120
}
1121

    
1122
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1123
                           int frame_size)
1124
{
1125
    AVCodecContext *enc;
1126
    int frame_number;
1127
    double ti1, bitrate, avg_bitrate;
1128

    
1129
    /* this is executed just the first time do_video_stats is called */
1130
    if (!vstats_file) {
1131
        vstats_file = fopen(vstats_filename, "w");
1132
        if (!vstats_file) {
1133
            perror("fopen");
1134
            av_exit(1);
1135
        }
1136
    }
1137

    
1138
    enc = ost->st->codec;
1139
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1140
        frame_number = ost->frame_number;
1141
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1142
        if (enc->flags&CODEC_FLAG_PSNR)
1143
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1144

    
1145
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1146
        /* compute pts value */
1147
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1148
        if (ti1 < 0.01)
1149
            ti1 = 0.01;
1150

    
1151
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1152
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1153
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1154
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1155
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1156
    }
1157
}
1158

    
1159
static void print_report(AVFormatContext **output_files,
1160
                         AVOutputStream **ost_table, int nb_ostreams,
1161
                         int is_last_report)
1162
{
1163
    char buf[1024];
1164
    AVOutputStream *ost;
1165
    AVFormatContext *oc;
1166
    int64_t total_size;
1167
    AVCodecContext *enc;
1168
    int frame_number, vid, i;
1169
    double bitrate, ti1, pts;
1170
    static int64_t last_time = -1;
1171
    static int qp_histogram[52];
1172

    
1173
    if (!is_last_report) {
1174
        int64_t cur_time;
1175
        /* display the report every 0.5 seconds */
1176
        cur_time = av_gettime();
1177
        if (last_time == -1) {
1178
            last_time = cur_time;
1179
            return;
1180
        }
1181
        if ((cur_time - last_time) < 500000)
1182
            return;
1183
        last_time = cur_time;
1184
    }
1185

    
1186

    
1187
    oc = output_files[0];
1188

    
1189
    total_size = url_fsize(oc->pb);
1190
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1191
        total_size= url_ftell(oc->pb);
1192

    
1193
    buf[0] = '\0';
1194
    ti1 = 1e10;
1195
    vid = 0;
1196
    for(i=0;i<nb_ostreams;i++) {
1197
        ost = ost_table[i];
1198
        enc = ost->st->codec;
1199
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1200
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1201
                     !ost->st->stream_copy ?
1202
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1203
        }
1204
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1205
            float t = (av_gettime()-timer_start) / 1000000.0;
1206

    
1207
            frame_number = ost->frame_number;
1208
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1209
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1210
                     !ost->st->stream_copy ?
1211
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1212
            if(is_last_report)
1213
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1214
            if(qp_hist){
1215
                int j;
1216
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1217
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1218
                    qp_histogram[qp]++;
1219
                for(j=0; j<32; j++)
1220
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1221
            }
1222
            if (enc->flags&CODEC_FLAG_PSNR){
1223
                int j;
1224
                double error, error_sum=0;
1225
                double scale, scale_sum=0;
1226
                char type[3]= {'Y','U','V'};
1227
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1228
                for(j=0; j<3; j++){
1229
                    if(is_last_report){
1230
                        error= enc->error[j];
1231
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1232
                    }else{
1233
                        error= enc->coded_frame->error[j];
1234
                        scale= enc->width*enc->height*255.0*255.0;
1235
                    }
1236
                    if(j) scale/=4;
1237
                    error_sum += error;
1238
                    scale_sum += scale;
1239
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1240
                }
1241
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1242
            }
1243
            vid = 1;
1244
        }
1245
        /* compute min output value */
1246
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1247
        if ((pts < ti1) && (pts > 0))
1248
            ti1 = pts;
1249
    }
1250
    if (ti1 < 0.01)
1251
        ti1 = 0.01;
1252

    
1253
    if (verbose || is_last_report) {
1254
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1255

    
1256
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1257
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1258
            (double)total_size / 1024, ti1, bitrate);
1259

    
1260
        if (nb_frames_dup || nb_frames_drop)
1261
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1262
                  nb_frames_dup, nb_frames_drop);
1263

    
1264
        if (verbose >= 0)
1265
            fprintf(stderr, "%s    \r", buf);
1266

    
1267
        fflush(stderr);
1268
    }
1269

    
1270
    if (is_last_report && verbose >= 0){
1271
        int64_t raw= audio_size + video_size + extra_size;
1272
        fprintf(stderr, "\n");
1273
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1274
                video_size/1024.0,
1275
                audio_size/1024.0,
1276
                extra_size/1024.0,
1277
                100.0*(total_size - raw)/raw
1278
        );
1279
    }
1280
}
1281

    
1282
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1283
static int output_packet(AVInputStream *ist, int ist_index,
1284
                         AVOutputStream **ost_table, int nb_ostreams,
1285
                         const AVPacket *pkt)
1286
{
1287
    AVFormatContext *os;
1288
    AVOutputStream *ost;
1289
    int ret, i;
1290
    int got_picture;
1291
    AVFrame picture;
1292
    void *buffer_to_free;
1293
    static unsigned int samples_size= 0;
1294
    AVSubtitle subtitle, *subtitle_to_free;
1295
    int got_subtitle;
1296
    AVPacket avpkt;
1297
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1298

    
1299
    if(ist->next_pts == AV_NOPTS_VALUE)
1300
        ist->next_pts= ist->pts;
1301

    
1302
    if (pkt == NULL) {
1303
        /* EOF handling */
1304
        av_init_packet(&avpkt);
1305
        avpkt.data = NULL;
1306
        avpkt.size = 0;
1307
        goto handle_eof;
1308
    } else {
1309
        avpkt = *pkt;
1310
    }
1311

    
1312
    if(pkt->dts != AV_NOPTS_VALUE)
1313
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1314

    
1315
    //while we have more to decode or while the decoder did output something on EOF
1316
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1317
        uint8_t *data_buf, *decoded_data_buf;
1318
        int data_size, decoded_data_size;
1319
    handle_eof:
1320
        ist->pts= ist->next_pts;
1321

    
1322
        if(avpkt.size && avpkt.size != pkt->size &&
1323
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1324
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1325
            ist->showed_multi_packet_warning=1;
1326
        }
1327

    
1328
        /* decode the packet if needed */
1329
        decoded_data_buf = NULL; /* fail safe */
1330
        decoded_data_size= 0;
1331
        data_buf  = avpkt.data;
1332
        data_size = avpkt.size;
1333
        subtitle_to_free = NULL;
1334
        if (ist->decoding_needed) {
1335
            switch(ist->st->codec->codec_type) {
1336
            case CODEC_TYPE_AUDIO:{
1337
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1338
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1339
                    av_free(samples);
1340
                    samples= av_malloc(samples_size);
1341
                }
1342
                decoded_data_size= samples_size;
1343
                    /* XXX: could avoid copy if PCM 16 bits with same
1344
                       endianness as CPU */
1345
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1346
                                            &avpkt);
1347
                if (ret < 0)
1348
                    goto fail_decode;
1349
                avpkt.data += ret;
1350
                avpkt.size -= ret;
1351
                data_size   = ret;
1352
                /* Some bug in mpeg audio decoder gives */
1353
                /* decoded_data_size < 0, it seems they are overflows */
1354
                if (decoded_data_size <= 0) {
1355
                    /* no audio frame */
1356
                    continue;
1357
                }
1358
                decoded_data_buf = (uint8_t *)samples;
1359
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1360
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1361
                break;}
1362
            case CODEC_TYPE_VIDEO:
1363
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1364
                    /* XXX: allocate picture correctly */
1365
                    avcodec_get_frame_defaults(&picture);
1366

    
1367
                    ret = avcodec_decode_video2(ist->st->codec,
1368
                                                &picture, &got_picture, &avpkt);
1369
                    ist->st->quality= picture.quality;
1370
                    if (ret < 0)
1371
                        goto fail_decode;
1372
                    if (!got_picture) {
1373
                        /* no picture yet */
1374
                        goto discard_packet;
1375
                    }
1376
                    if (ist->st->codec->time_base.num != 0) {
1377
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1378
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1379
                                          ist->st->codec->time_base.num * ticks) /
1380
                            ist->st->codec->time_base.den;
1381
                    }
1382
                    avpkt.size = 0;
1383
                    break;
1384
            case CODEC_TYPE_SUBTITLE:
1385
                ret = avcodec_decode_subtitle2(ist->st->codec,
1386
                                               &subtitle, &got_subtitle, &avpkt);
1387
                if (ret < 0)
1388
                    goto fail_decode;
1389
                if (!got_subtitle) {
1390
                    goto discard_packet;
1391
                }
1392
                subtitle_to_free = &subtitle;
1393
                avpkt.size = 0;
1394
                break;
1395
            default:
1396
                goto fail_decode;
1397
            }
1398
        } else {
1399
            switch(ist->st->codec->codec_type) {
1400
            case CODEC_TYPE_AUDIO:
1401
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1402
                    ist->st->codec->sample_rate;
1403
                break;
1404
            case CODEC_TYPE_VIDEO:
1405
                if (ist->st->codec->time_base.num != 0) {
1406
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1407
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1408
                                      ist->st->codec->time_base.num * ticks) /
1409
                        ist->st->codec->time_base.den;
1410
                }
1411
                break;
1412
            }
1413
            ret = avpkt.size;
1414
            avpkt.size = 0;
1415
        }
1416

    
1417
        buffer_to_free = NULL;
1418
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1419
            pre_process_video_frame(ist, (AVPicture *)&picture,
1420
                                    &buffer_to_free);
1421
        }
1422

    
1423
        // preprocess audio (volume)
1424
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1425
            if (audio_volume != 256) {
1426
                short *volp;
1427
                volp = samples;
1428
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1429
                    int v = ((*volp) * audio_volume + 128) >> 8;
1430
                    if (v < -32768) v = -32768;
1431
                    if (v >  32767) v = 32767;
1432
                    *volp++ = v;
1433
                }
1434
            }
1435
        }
1436

    
1437
        /* frame rate emulation */
1438
        if (rate_emu) {
1439
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1440
            int64_t now = av_gettime() - ist->start;
1441
            if (pts > now)
1442
                usleep(pts - now);
1443
        }
1444

    
1445
        /* if output time reached then transcode raw format,
1446
           encode packets and output them */
1447
        if (start_time == 0 || ist->pts >= start_time)
1448
            for(i=0;i<nb_ostreams;i++) {
1449
                int frame_size;
1450

    
1451
                ost = ost_table[i];
1452
                if (ost->source_index == ist_index) {
1453
                    os = output_files[ost->file_index];
1454

    
1455
                    /* set the input output pts pairs */
1456
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1457

    
1458
                    if (ost->encoding_needed) {
1459
                        assert(ist->decoding_needed);
1460
                        switch(ost->st->codec->codec_type) {
1461
                        case CODEC_TYPE_AUDIO:
1462
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1463
                            break;
1464
                        case CODEC_TYPE_VIDEO:
1465
                            do_video_out(os, ost, ist, &picture, &frame_size);
1466
                            if (vstats_filename && frame_size)
1467
                                do_video_stats(os, ost, frame_size);
1468
                            break;
1469
                        case CODEC_TYPE_SUBTITLE:
1470
                            do_subtitle_out(os, ost, ist, &subtitle,
1471
                                            pkt->pts);
1472
                            break;
1473
                        default:
1474
                            abort();
1475
                        }
1476
                    } else {
1477
                        AVFrame avframe; //FIXME/XXX remove this
1478
                        AVPacket opkt;
1479
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1480

    
1481
                        av_init_packet(&opkt);
1482

    
1483
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1484
                            continue;
1485

    
1486
                        /* no reencoding needed : output the packet directly */
1487
                        /* force the input stream PTS */
1488

    
1489
                        avcodec_get_frame_defaults(&avframe);
1490
                        ost->st->codec->coded_frame= &avframe;
1491
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1492

    
1493
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1494
                            audio_size += data_size;
1495
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1496
                            video_size += data_size;
1497
                            ost->sync_opts++;
1498
                        }
1499

    
1500
                        opkt.stream_index= ost->index;
1501
                        if(pkt->pts != AV_NOPTS_VALUE)
1502
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1503
                        else
1504
                            opkt.pts= AV_NOPTS_VALUE;
1505

    
1506
                        if (pkt->dts == AV_NOPTS_VALUE)
1507
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1508
                        else
1509
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1510
                        opkt.dts -= ost_tb_start_time;
1511

    
1512
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1513
                        opkt.flags= pkt->flags;
1514

    
1515
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1516
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1517
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1518
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1519
                           ) {
1520
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1521
                                opkt.destruct= av_destruct_packet;
1522
                        } else {
1523
                            opkt.data = data_buf;
1524
                            opkt.size = data_size;
1525
                        }
1526

    
1527
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1528
                        ost->st->codec->frame_number++;
1529
                        ost->frame_number++;
1530
                        av_free_packet(&opkt);
1531
                    }
1532
                }
1533
            }
1534
        av_free(buffer_to_free);
1535
        /* XXX: allocate the subtitles in the codec ? */
1536
        if (subtitle_to_free) {
1537
            if (subtitle_to_free->rects != NULL) {
1538
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1539
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1540
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1541
                    av_freep(&subtitle_to_free->rects[i]);
1542
                }
1543
                av_freep(&subtitle_to_free->rects);
1544
            }
1545
            subtitle_to_free->num_rects = 0;
1546
            subtitle_to_free = NULL;
1547
        }
1548
    }
1549
 discard_packet:
1550
    if (pkt == NULL) {
1551
        /* EOF handling */
1552

    
1553
        for(i=0;i<nb_ostreams;i++) {
1554
            ost = ost_table[i];
1555
            if (ost->source_index == ist_index) {
1556
                AVCodecContext *enc= ost->st->codec;
1557
                os = output_files[ost->file_index];
1558

    
1559
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1560
                    continue;
1561
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1562
                    continue;
1563

    
1564
                if (ost->encoding_needed) {
1565
                    for(;;) {
1566
                        AVPacket pkt;
1567
                        int fifo_bytes;
1568
                        av_init_packet(&pkt);
1569
                        pkt.stream_index= ost->index;
1570

    
1571
                        switch(ost->st->codec->codec_type) {
1572
                        case CODEC_TYPE_AUDIO:
1573
                            fifo_bytes = av_fifo_size(ost->fifo);
1574
                            ret = 0;
1575
                            /* encode any samples remaining in fifo */
1576
                            if (fifo_bytes > 0) {
1577
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1578
                                int fs_tmp = enc->frame_size;
1579

    
1580
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1581
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1582
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1583
                                } else { /* pad */
1584
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1585
                                    if (samples_size < frame_bytes)
1586
                                        av_exit(1);
1587
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1588
                                }
1589

    
1590
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1591
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1592
                                                          ost->st->time_base.num, enc->sample_rate);
1593
                                enc->frame_size = fs_tmp;
1594
                            }
1595
                            if(ret <= 0) {
1596
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1597
                            }
1598
                            if (ret < 0) {
1599
                                fprintf(stderr, "Audio encoding failed\n");
1600
                                av_exit(1);
1601
                            }
1602
                            audio_size += ret;
1603
                            pkt.flags |= PKT_FLAG_KEY;
1604
                            break;
1605
                        case CODEC_TYPE_VIDEO:
1606
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1607
                            if (ret < 0) {
1608
                                fprintf(stderr, "Video encoding failed\n");
1609
                                av_exit(1);
1610
                            }
1611
                            video_size += ret;
1612
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1613
                                pkt.flags |= PKT_FLAG_KEY;
1614
                            if (ost->logfile && enc->stats_out) {
1615
                                fprintf(ost->logfile, "%s", enc->stats_out);
1616
                            }
1617
                            break;
1618
                        default:
1619
                            ret=-1;
1620
                        }
1621

    
1622
                        if(ret<=0)
1623
                            break;
1624
                        pkt.data= bit_buffer;
1625
                        pkt.size= ret;
1626
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1627
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1628
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1629
                    }
1630
                }
1631
            }
1632
        }
1633
    }
1634

    
1635
    return 0;
1636
 fail_decode:
1637
    return -1;
1638
}
1639

    
1640
static void print_sdp(AVFormatContext **avc, int n)
1641
{
1642
    char sdp[2048];
1643

    
1644
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1645
    printf("SDP:\n%s\n", sdp);
1646
    fflush(stdout);
1647
}
1648

    
1649
/*
1650
 * The following code is the main loop of the file converter
1651
 */
1652
static int av_encode(AVFormatContext **output_files,
1653
                     int nb_output_files,
1654
                     AVFormatContext **input_files,
1655
                     int nb_input_files,
1656
                     AVStreamMap *stream_maps, int nb_stream_maps)
1657
{
1658
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1659
    AVFormatContext *is, *os;
1660
    AVCodecContext *codec, *icodec;
1661
    AVOutputStream *ost, **ost_table = NULL;
1662
    AVInputStream *ist, **ist_table = NULL;
1663
    AVInputFile *file_table;
1664
    char error[1024];
1665
    int key;
1666
    int want_sdp = 1;
1667
    uint8_t no_packet[MAX_FILES]={0};
1668
    int no_packet_count=0;
1669

    
1670
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1671
    if (!file_table)
1672
        goto fail;
1673

    
1674
    /* input stream init */
1675
    j = 0;
1676
    for(i=0;i<nb_input_files;i++) {
1677
        is = input_files[i];
1678
        file_table[i].ist_index = j;
1679
        file_table[i].nb_streams = is->nb_streams;
1680
        j += is->nb_streams;
1681
    }
1682
    nb_istreams = j;
1683

    
1684
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1685
    if (!ist_table)
1686
        goto fail;
1687

    
1688
    for(i=0;i<nb_istreams;i++) {
1689
        ist = av_mallocz(sizeof(AVInputStream));
1690
        if (!ist)
1691
            goto fail;
1692
        ist_table[i] = ist;
1693
    }
1694
    j = 0;
1695
    for(i=0;i<nb_input_files;i++) {
1696
        is = input_files[i];
1697
        for(k=0;k<is->nb_streams;k++) {
1698
            ist = ist_table[j++];
1699
            ist->st = is->streams[k];
1700
            ist->file_index = i;
1701
            ist->index = k;
1702
            ist->discard = 1; /* the stream is discarded by default
1703
                                 (changed later) */
1704

    
1705
            if (rate_emu) {
1706
                ist->start = av_gettime();
1707
            }
1708
        }
1709
    }
1710

    
1711
    /* output stream init */
1712
    nb_ostreams = 0;
1713
    for(i=0;i<nb_output_files;i++) {
1714
        os = output_files[i];
1715
        if (!os->nb_streams) {
1716
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1717
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1718
            av_exit(1);
1719
        }
1720
        nb_ostreams += os->nb_streams;
1721
    }
1722
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1723
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1724
        av_exit(1);
1725
    }
1726

    
1727
    /* Sanity check the mapping args -- do the input files & streams exist? */
1728
    for(i=0;i<nb_stream_maps;i++) {
1729
        int fi = stream_maps[i].file_index;
1730
        int si = stream_maps[i].stream_index;
1731

    
1732
        if (fi < 0 || fi > nb_input_files - 1 ||
1733
            si < 0 || si > file_table[fi].nb_streams - 1) {
1734
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1735
            av_exit(1);
1736
        }
1737
        fi = stream_maps[i].sync_file_index;
1738
        si = stream_maps[i].sync_stream_index;
1739
        if (fi < 0 || fi > nb_input_files - 1 ||
1740
            si < 0 || si > file_table[fi].nb_streams - 1) {
1741
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1742
            av_exit(1);
1743
        }
1744
    }
1745

    
1746
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1747
    if (!ost_table)
1748
        goto fail;
1749
    for(i=0;i<nb_ostreams;i++) {
1750
        ost = av_mallocz(sizeof(AVOutputStream));
1751
        if (!ost)
1752
            goto fail;
1753
        ost_table[i] = ost;
1754
    }
1755

    
1756
    n = 0;
1757
    for(k=0;k<nb_output_files;k++) {
1758
        os = output_files[k];
1759
        for(i=0;i<os->nb_streams;i++,n++) {
1760
            int found;
1761
            ost = ost_table[n];
1762
            ost->file_index = k;
1763
            ost->index = i;
1764
            ost->st = os->streams[i];
1765
            if (nb_stream_maps > 0) {
1766
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1767
                    stream_maps[n].stream_index;
1768

    
1769
                /* Sanity check that the stream types match */
1770
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1771
                    int i= ost->file_index;
1772
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1773
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1774
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1775
                        ost->file_index, ost->index);
1776
                    av_exit(1);
1777
                }
1778

    
1779
            } else {
1780
                int best_nb_frames=-1;
1781
                    /* get corresponding input stream index : we select the first one with the right type */
1782
                    found = 0;
1783
                    for(j=0;j<nb_istreams;j++) {
1784
                        int skip=0;
1785
                        ist = ist_table[j];
1786
                        if(opt_programid){
1787
                            int pi,si;
1788
                            AVFormatContext *f= input_files[ ist->file_index ];
1789
                            skip=1;
1790
                            for(pi=0; pi<f->nb_programs; pi++){
1791
                                AVProgram *p= f->programs[pi];
1792
                                if(p->id == opt_programid)
1793
                                    for(si=0; si<p->nb_stream_indexes; si++){
1794
                                        if(f->streams[ p->stream_index[si] ] == ist->st)
1795
                                            skip=0;
1796
                                    }
1797
                            }
1798
                        }
1799
                        if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
1800
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1801
                            if(best_nb_frames < ist->st->codec_info_nb_frames){
1802
                                best_nb_frames= ist->st->codec_info_nb_frames;
1803
                                ost->source_index = j;
1804
                                found = 1;
1805
                            }
1806
                        }
1807
                    }
1808

    
1809
                if (!found) {
1810
                    if(! opt_programid) {
1811
                        /* try again and reuse existing stream */
1812
                        for(j=0;j<nb_istreams;j++) {
1813
                            ist = ist_table[j];
1814
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
1815
                                && ist->st->discard != AVDISCARD_ALL) {
1816
                                ost->source_index = j;
1817
                                found = 1;
1818
                            }
1819
                        }
1820
                    }
1821
                    if (!found) {
1822
                        int i= ost->file_index;
1823
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1824
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1825
                                ost->file_index, ost->index);
1826
                        av_exit(1);
1827
                    }
1828
                }
1829
            }
1830
            ist = ist_table[ost->source_index];
1831
            ist->discard = 0;
1832
            ost->sync_ist = (nb_stream_maps > 0) ?
1833
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1834
                         stream_maps[n].sync_stream_index] : ist;
1835
        }
1836
    }
1837

    
1838
    /* for each output stream, we compute the right encoding parameters */
1839
    for(i=0;i<nb_ostreams;i++) {
1840
        AVMetadataTag *t = NULL, *lang = NULL;
1841
        ost = ost_table[i];
1842
        os = output_files[ost->file_index];
1843
        ist = ist_table[ost->source_index];
1844

    
1845
        codec = ost->st->codec;
1846
        icodec = ist->st->codec;
1847

    
1848
        if (av_metadata_get(ist->st->metadata, "language", NULL, 0))
1849
            lang = av_metadata_get(ost->st->metadata, "language", NULL, 0);
1850
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
1851
            if (lang && !strcmp(t->key, "language"))
1852
                continue;
1853
            av_metadata_set2(&ost->st->metadata, t->key, t->value, NULL);
1854
        }
1855

    
1856
        ost->st->disposition = ist->st->disposition;
1857
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1858
        codec->chroma_sample_location = icodec->chroma_sample_location;
1859

    
1860
        if (ost->st->stream_copy) {
1861
            /* if stream_copy is selected, no need to decode or encode */
1862
            codec->codec_id = icodec->codec_id;
1863
            codec->codec_type = icodec->codec_type;
1864

    
1865
            if(!codec->codec_tag){
1866
                if(   !os->oformat->codec_tag
1867
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1868
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1869
                    codec->codec_tag = icodec->codec_tag;
1870
            }
1871

    
1872
            codec->bit_rate = icodec->bit_rate;
1873
            codec->extradata= icodec->extradata;
1874
            codec->extradata_size= icodec->extradata_size;
1875
            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){
1876
                codec->time_base = icodec->time_base;
1877
                codec->time_base.num *= icodec->ticks_per_frame;
1878
            }else
1879
                codec->time_base = ist->st->time_base;
1880
            switch(codec->codec_type) {
1881
            case CODEC_TYPE_AUDIO:
1882
                if(audio_volume != 256) {
1883
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1884
                    av_exit(1);
1885
                }
1886
                codec->channel_layout = icodec->channel_layout;
1887
                codec->sample_rate = icodec->sample_rate;
1888
                codec->channels = icodec->channels;
1889
                codec->frame_size = icodec->frame_size;
1890
                codec->block_align= icodec->block_align;
1891
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1892
                    codec->block_align= 0;
1893
                if(codec->codec_id == CODEC_ID_AC3)
1894
                    codec->block_align= 0;
1895
                break;
1896
            case CODEC_TYPE_VIDEO:
1897
                codec->pix_fmt = icodec->pix_fmt;
1898
                codec->width = icodec->width;
1899
                codec->height = icodec->height;
1900
                codec->has_b_frames = icodec->has_b_frames;
1901
                break;
1902
            case CODEC_TYPE_SUBTITLE:
1903
                codec->width = icodec->width;
1904
                codec->height = icodec->height;
1905
                break;
1906
            default:
1907
                abort();
1908
            }
1909
        } else {
1910
            switch(codec->codec_type) {
1911
            case CODEC_TYPE_AUDIO:
1912
                ost->fifo= av_fifo_alloc(1024);
1913
                if(!ost->fifo)
1914
                    goto fail;
1915
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1916
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1917
                icodec->request_channels = codec->channels;
1918
                ist->decoding_needed = 1;
1919
                ost->encoding_needed = 1;
1920
                break;
1921
            case CODEC_TYPE_VIDEO:
1922
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1923
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1924
                    av_exit(1);
1925
                }
1926
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1927
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1928
                ost->video_resample = ((codec->width != icodec->width -
1929
                                (frame_leftBand + frame_rightBand) +
1930
                                (frame_padleft + frame_padright)) ||
1931
                        (codec->height != icodec->height -
1932
                                (frame_topBand  + frame_bottomBand) +
1933
                                (frame_padtop + frame_padbottom)) ||
1934
                        (codec->pix_fmt != icodec->pix_fmt));
1935
                if (ost->video_crop) {
1936
                    ost->topBand    = ost->original_topBand    = frame_topBand;
1937
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1938
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
1939
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
1940
                }
1941
                if (ost->video_pad) {
1942
                    ost->padtop = frame_padtop;
1943
                    ost->padleft = frame_padleft;
1944
                    ost->padbottom = frame_padbottom;
1945
                    ost->padright = frame_padright;
1946
                    if (!ost->video_resample) {
1947
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1948
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1949
                                         codec->width, codec->height))
1950
                            goto fail;
1951
                    }
1952
                }
1953
                if (ost->video_resample) {
1954
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1955
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1956
                                         codec->width, codec->height)) {
1957
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1958
                        av_exit(1);
1959
                    }
1960
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1961
                    ost->img_resample_ctx = sws_getContext(
1962
                            icodec->width - (frame_leftBand + frame_rightBand),
1963
                            icodec->height - (frame_topBand + frame_bottomBand),
1964
                            icodec->pix_fmt,
1965
                            codec->width - (frame_padleft + frame_padright),
1966
                            codec->height - (frame_padtop + frame_padbottom),
1967
                            codec->pix_fmt,
1968
                            sws_flags, NULL, NULL, NULL);
1969
                    if (ost->img_resample_ctx == NULL) {
1970
                        fprintf(stderr, "Cannot get resampling context\n");
1971
                        av_exit(1);
1972
                    }
1973

    
1974
                    ost->original_height = icodec->height;
1975
                    ost->original_width  = icodec->width;
1976

    
1977
                    codec->bits_per_raw_sample= 0;
1978
                }
1979
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1980
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1981
                ost->resample_pix_fmt= icodec->pix_fmt;
1982
                ost->encoding_needed = 1;
1983
                ist->decoding_needed = 1;
1984
                break;
1985
            case CODEC_TYPE_SUBTITLE:
1986
                ost->encoding_needed = 1;
1987
                ist->decoding_needed = 1;
1988
                break;
1989
            default:
1990
                abort();
1991
                break;
1992
            }
1993
            /* two pass mode */
1994
            if (ost->encoding_needed &&
1995
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1996
                char logfilename[1024];
1997
                FILE *f;
1998
                int size;
1999
                char *logbuffer;
2000

    
2001
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2002
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2003
                         i);
2004
                if (codec->flags & CODEC_FLAG_PASS1) {
2005
                    f = fopen(logfilename, "w");
2006
                    if (!f) {
2007
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2008
                        av_exit(1);
2009
                    }
2010
                    ost->logfile = f;
2011
                } else {
2012
                    /* read the log file */
2013
                    f = fopen(logfilename, "r");
2014
                    if (!f) {
2015
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2016
                        av_exit(1);
2017
                    }
2018
                    fseek(f, 0, SEEK_END);
2019
                    size = ftell(f);
2020
                    fseek(f, 0, SEEK_SET);
2021
                    logbuffer = av_malloc(size + 1);
2022
                    if (!logbuffer) {
2023
                        fprintf(stderr, "Could not allocate log buffer\n");
2024
                        av_exit(1);
2025
                    }
2026
                    size = fread(logbuffer, 1, size, f);
2027
                    fclose(f);
2028
                    logbuffer[size] = '\0';
2029
                    codec->stats_in = logbuffer;
2030
                }
2031
            }
2032
        }
2033
        if(codec->codec_type == CODEC_TYPE_VIDEO){
2034
            int size= codec->width * codec->height;
2035
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2036
        }
2037
    }
2038

    
2039
    if (!bit_buffer)
2040
        bit_buffer = av_malloc(bit_buffer_size);
2041
    if (!bit_buffer) {
2042
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2043
                bit_buffer_size);
2044
        ret = AVERROR(ENOMEM);
2045
        goto fail;
2046
    }
2047

    
2048
    /* open each encoder */
2049
    for(i=0;i<nb_ostreams;i++) {
2050
        ost = ost_table[i];
2051
        if (ost->encoding_needed) {
2052
            AVCodec *codec = output_codecs[i];
2053
            if (!codec)
2054
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2055
            if (!codec) {
2056
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2057
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2058
                ret = AVERROR(EINVAL);
2059
                goto dump_format;
2060
            }
2061
            if (avcodec_open(ost->st->codec, codec) < 0) {
2062
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2063
                        ost->file_index, ost->index);
2064
                ret = AVERROR(EINVAL);
2065
                goto dump_format;
2066
            }
2067
            extra_size += ost->st->codec->extradata_size;
2068
        }
2069
    }
2070

    
2071
    /* open each decoder */
2072
    for(i=0;i<nb_istreams;i++) {
2073
        ist = ist_table[i];
2074
        if (ist->decoding_needed) {
2075
            AVCodec *codec = input_codecs[i];
2076
            if (!codec)
2077
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2078
            if (!codec) {
2079
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2080
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2081
                ret = AVERROR(EINVAL);
2082
                goto dump_format;
2083
            }
2084
            if (avcodec_open(ist->st->codec, codec) < 0) {
2085
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2086
                        ist->file_index, ist->index);
2087
                ret = AVERROR(EINVAL);
2088
                goto dump_format;
2089
            }
2090
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2091
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2092
        }
2093
    }
2094

    
2095
    /* init pts */
2096
    for(i=0;i<nb_istreams;i++) {
2097
        AVStream *st;
2098
        ist = ist_table[i];
2099
        st= ist->st;
2100
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2101
        ist->next_pts = AV_NOPTS_VALUE;
2102
        ist->is_start = 1;
2103
    }
2104

    
2105
    /* set meta data information from input file if required */
2106
    for (i=0;i<nb_meta_data_maps;i++) {
2107
        AVFormatContext *out_file;
2108
        AVFormatContext *in_file;
2109
        AVMetadataTag *mtag;
2110

    
2111
        int out_file_index = meta_data_maps[i].out_file;
2112
        int in_file_index = meta_data_maps[i].in_file;
2113
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2114
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2115
                     out_file_index, out_file_index, in_file_index);
2116
            ret = AVERROR(EINVAL);
2117
            goto dump_format;
2118
        }
2119
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2120
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2121
                     in_file_index, out_file_index, in_file_index);
2122
            ret = AVERROR(EINVAL);
2123
            goto dump_format;
2124
        }
2125

    
2126
        out_file = output_files[out_file_index];
2127
        in_file = input_files[in_file_index];
2128

    
2129

    
2130
        mtag=NULL;
2131
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2132
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2133
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2134
                                    in_file->iformat->metadata_conv);
2135
    }
2136

    
2137
    /* open files and write file headers */
2138
    for(i=0;i<nb_output_files;i++) {
2139
        os = output_files[i];
2140
        if (av_write_header(os) < 0) {
2141
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2142
            ret = AVERROR(EINVAL);
2143
            goto dump_format;
2144
        }
2145
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2146
            want_sdp = 0;
2147
        }
2148
    }
2149

    
2150
 dump_format:
2151
    /* dump the file output parameters - cannot be done before in case
2152
       of stream copy */
2153
    for(i=0;i<nb_output_files;i++) {
2154
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2155
    }
2156

    
2157
    /* dump the stream mapping */
2158
    if (verbose >= 0) {
2159
        fprintf(stderr, "Stream mapping:\n");
2160
        for(i=0;i<nb_ostreams;i++) {
2161
            ost = ost_table[i];
2162
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2163
                    ist_table[ost->source_index]->file_index,
2164
                    ist_table[ost->source_index]->index,
2165
                    ost->file_index,
2166
                    ost->index);
2167
            if (ost->sync_ist != ist_table[ost->source_index])
2168
                fprintf(stderr, " [sync #%d.%d]",
2169
                        ost->sync_ist->file_index,
2170
                        ost->sync_ist->index);
2171
            fprintf(stderr, "\n");
2172
        }
2173
    }
2174

    
2175
    if (ret) {
2176
        fprintf(stderr, "%s\n", error);
2177
        goto fail;
2178
    }
2179

    
2180
    if (want_sdp) {
2181
        print_sdp(output_files, nb_output_files);
2182
    }
2183

    
2184
    if (!using_stdin && verbose >= 0) {
2185
        fprintf(stderr, "Press [q] to stop encoding\n");
2186
        url_set_interrupt_cb(decode_interrupt_cb);
2187
    }
2188
    term_init();
2189

    
2190
    timer_start = av_gettime();
2191

    
2192
    for(; received_sigterm == 0;) {
2193
        int file_index, ist_index;
2194
        AVPacket pkt;
2195
        double ipts_min;
2196
        double opts_min;
2197

    
2198
    redo:
2199
        ipts_min= 1e100;
2200
        opts_min= 1e100;
2201
        /* if 'q' pressed, exits */
2202
        if (!using_stdin) {
2203
            if (q_pressed)
2204
                break;
2205
            /* read_key() returns 0 on EOF */
2206
            key = read_key();
2207
            if (key == 'q')
2208
                break;
2209
        }
2210

    
2211
        /* select the stream that we must read now by looking at the
2212
           smallest output pts */
2213
        file_index = -1;
2214
        for(i=0;i<nb_ostreams;i++) {
2215
            double ipts, opts;
2216
            ost = ost_table[i];
2217
            os = output_files[ost->file_index];
2218
            ist = ist_table[ost->source_index];
2219
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2220
                continue;
2221
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2222
            ipts = (double)ist->pts;
2223
            if (!file_table[ist->file_index].eof_reached){
2224
                if(ipts < ipts_min) {
2225
                    ipts_min = ipts;
2226
                    if(input_sync ) file_index = ist->file_index;
2227
                }
2228
                if(opts < opts_min) {
2229
                    opts_min = opts;
2230
                    if(!input_sync) file_index = ist->file_index;
2231
                }
2232
            }
2233
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2234
                file_index= -1;
2235
                break;
2236
            }
2237
        }
2238
        /* if none, if is finished */
2239
        if (file_index < 0) {
2240
            if(no_packet_count){
2241
                no_packet_count=0;
2242
                memset(no_packet, 0, sizeof(no_packet));
2243
                usleep(10000);
2244
                continue;
2245
            }
2246
            break;
2247
        }
2248

    
2249
        /* finish if limit size exhausted */
2250
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2251
            break;
2252

    
2253
        /* read a frame from it and output it in the fifo */
2254
        is = input_files[file_index];
2255
        ret= av_read_frame(is, &pkt);
2256
        if(ret == AVERROR(EAGAIN)){
2257
            no_packet[file_index]=1;
2258
            no_packet_count++;
2259
            continue;
2260
        }
2261
        if (ret < 0) {
2262
            file_table[file_index].eof_reached = 1;
2263
            if (opt_shortest)
2264
                break;
2265
            else
2266
                continue;
2267
        }
2268

    
2269
        no_packet_count=0;
2270
        memset(no_packet, 0, sizeof(no_packet));
2271

    
2272
        if (do_pkt_dump) {
2273
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2274
        }
2275
        /* the following test is needed in case new streams appear
2276
           dynamically in stream : we ignore them */
2277
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2278
            goto discard_packet;
2279
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2280
        ist = ist_table[ist_index];
2281
        if (ist->discard)
2282
            goto discard_packet;
2283

    
2284
        if (pkt.dts != AV_NOPTS_VALUE)
2285
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2286
        if (pkt.pts != AV_NOPTS_VALUE)
2287
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2288

    
2289
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2290
            if(pkt.pts != AV_NOPTS_VALUE)
2291
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2292
            if(pkt.dts != AV_NOPTS_VALUE)
2293
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2294
        }
2295

    
2296
//        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);
2297
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2298
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2299
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2300
            int64_t delta= pkt_dts - ist->next_pts;
2301
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2302
                input_files_ts_offset[ist->file_index]-= delta;
2303
                if (verbose > 2)
2304
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2305
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2306
                if(pkt.pts != AV_NOPTS_VALUE)
2307
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2308
            }
2309
        }
2310

    
2311
        /* finish if recording time exhausted */
2312
        if (recording_time != INT64_MAX &&
2313
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2314
            ist->is_past_recording_time = 1;
2315
            goto discard_packet;
2316
        }
2317

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

    
2321
            if (verbose >= 0)
2322
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2323
                        ist->file_index, ist->index);
2324
            if (exit_on_error)
2325
                av_exit(1);
2326
            av_free_packet(&pkt);
2327
            goto redo;
2328
        }
2329

    
2330
    discard_packet:
2331
        av_free_packet(&pkt);
2332

    
2333
        /* dump report by using the output first video and audio streams */
2334
        print_report(output_files, ost_table, nb_ostreams, 0);
2335
    }
2336

    
2337
    /* at the end of stream, we must flush the decoder buffers */
2338
    for(i=0;i<nb_istreams;i++) {
2339
        ist = ist_table[i];
2340
        if (ist->decoding_needed) {
2341
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2342
        }
2343
    }
2344

    
2345
    term_exit();
2346

    
2347
    /* write the trailer if needed and close file */
2348
    for(i=0;i<nb_output_files;i++) {
2349
        os = output_files[i];
2350
        av_write_trailer(os);
2351
    }
2352

    
2353
    /* dump report by using the first video and audio streams */
2354
    print_report(output_files, ost_table, nb_ostreams, 1);
2355

    
2356
    /* close each encoder */
2357
    for(i=0;i<nb_ostreams;i++) {
2358
        ost = ost_table[i];
2359
        if (ost->encoding_needed) {
2360
            av_freep(&ost->st->codec->stats_in);
2361
            avcodec_close(ost->st->codec);
2362
        }
2363
    }
2364

    
2365
    /* close each decoder */
2366
    for(i=0;i<nb_istreams;i++) {
2367
        ist = ist_table[i];
2368
        if (ist->decoding_needed) {
2369
            avcodec_close(ist->st->codec);
2370
        }
2371
    }
2372

    
2373
    /* finished ! */
2374
    ret = 0;
2375

    
2376
 fail:
2377
    av_freep(&bit_buffer);
2378
    av_free(file_table);
2379

    
2380
    if (ist_table) {
2381
        for(i=0;i<nb_istreams;i++) {
2382
            ist = ist_table[i];
2383
            av_free(ist);
2384
        }
2385
        av_free(ist_table);
2386
    }
2387
    if (ost_table) {
2388
        for(i=0;i<nb_ostreams;i++) {
2389
            ost = ost_table[i];
2390
            if (ost) {
2391
                if (ost->logfile) {
2392
                    fclose(ost->logfile);
2393
                    ost->logfile = NULL;
2394
                }
2395
                av_fifo_free(ost->fifo); /* works even if fifo is not
2396
                                             initialized but set to zero */
2397
                av_free(ost->pict_tmp.data[0]);
2398
                if (ost->video_resample)
2399
                    sws_freeContext(ost->img_resample_ctx);
2400
                if (ost->resample)
2401
                    audio_resample_close(ost->resample);
2402
                if (ost->reformat_ctx)
2403
                    av_audio_convert_free(ost->reformat_ctx);
2404
                av_free(ost);
2405
            }
2406
        }
2407
        av_free(ost_table);
2408
    }
2409
    return ret;
2410
}
2411

    
2412
static void opt_format(const char *arg)
2413
{
2414
    /* compatibility stuff for pgmyuv */
2415
    if (!strcmp(arg, "pgmyuv")) {
2416
        pgmyuv_compatibility_hack=1;
2417
//        opt_image_format(arg);
2418
        arg = "image2";
2419
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2420
    }
2421

    
2422
    last_asked_format = arg;
2423
}
2424

    
2425
static void opt_video_rc_override_string(const char *arg)
2426
{
2427
    video_rc_override_string = arg;
2428
}
2429

    
2430
static int opt_me_threshold(const char *opt, const char *arg)
2431
{
2432
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2433
    return 0;
2434
}
2435

    
2436
static int opt_verbose(const char *opt, const char *arg)
2437
{
2438
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2439
    return 0;
2440
}
2441

    
2442
static int opt_frame_rate(const char *opt, const char *arg)
2443
{
2444
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2445
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2446
        av_exit(1);
2447
    }
2448
    return 0;
2449
}
2450

    
2451
static int opt_bitrate(const char *opt, const char *arg)
2452
{
2453
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2454

    
2455
    opt_default(opt, arg);
2456

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

    
2460
    return 0;
2461
}
2462

    
2463
static void opt_frame_crop_top(const char *arg)
2464
{
2465
    frame_topBand = atoi(arg);
2466
    if (frame_topBand < 0) {
2467
        fprintf(stderr, "Incorrect top crop size\n");
2468
        av_exit(1);
2469
    }
2470
    if ((frame_topBand) >= frame_height){
2471
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2472
        av_exit(1);
2473
    }
2474
    frame_height -= frame_topBand;
2475
}
2476

    
2477
static void opt_frame_crop_bottom(const char *arg)
2478
{
2479
    frame_bottomBand = atoi(arg);
2480
    if (frame_bottomBand < 0) {
2481
        fprintf(stderr, "Incorrect bottom crop size\n");
2482
        av_exit(1);
2483
    }
2484
    if ((frame_bottomBand) >= frame_height){
2485
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2486
        av_exit(1);
2487
    }
2488
    frame_height -= frame_bottomBand;
2489
}
2490

    
2491
static void opt_frame_crop_left(const char *arg)
2492
{
2493
    frame_leftBand = atoi(arg);
2494
    if (frame_leftBand < 0) {
2495
        fprintf(stderr, "Incorrect left crop size\n");
2496
        av_exit(1);
2497
    }
2498
    if ((frame_leftBand) >= frame_width){
2499
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2500
        av_exit(1);
2501
    }
2502
    frame_width -= frame_leftBand;
2503
}
2504

    
2505
static void opt_frame_crop_right(const char *arg)
2506
{
2507
    frame_rightBand = atoi(arg);
2508
    if (frame_rightBand < 0) {
2509
        fprintf(stderr, "Incorrect right crop size\n");
2510
        av_exit(1);
2511
    }
2512
    if ((frame_rightBand) >= frame_width){
2513
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2514
        av_exit(1);
2515
    }
2516
    frame_width -= frame_rightBand;
2517
}
2518

    
2519
static void opt_frame_size(const char *arg)
2520
{
2521
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2522
        fprintf(stderr, "Incorrect frame size\n");
2523
        av_exit(1);
2524
    }
2525
}
2526

    
2527
static void opt_pad_color(const char *arg) {
2528
    /* Input is expected to be six hex digits similar to
2529
       how colors are expressed in html tags (but without the #) */
2530
    int rgb = strtol(arg, NULL, 16);
2531
    int r,g,b;
2532

    
2533
    r = (rgb >> 16);
2534
    g = ((rgb >> 8) & 255);
2535
    b = (rgb & 255);
2536

    
2537
    padcolor[0] = RGB_TO_Y(r,g,b);
2538
    padcolor[1] = RGB_TO_U(r,g,b,0);
2539
    padcolor[2] = RGB_TO_V(r,g,b,0);
2540
}
2541

    
2542
static void opt_frame_pad_top(const char *arg)
2543
{
2544
    frame_padtop = atoi(arg);
2545
    if (frame_padtop < 0) {
2546
        fprintf(stderr, "Incorrect top pad size\n");
2547
        av_exit(1);
2548
    }
2549
}
2550

    
2551
static void opt_frame_pad_bottom(const char *arg)
2552
{
2553
    frame_padbottom = atoi(arg);
2554
    if (frame_padbottom < 0) {
2555
        fprintf(stderr, "Incorrect bottom pad size\n");
2556
        av_exit(1);
2557
    }
2558
}
2559

    
2560

    
2561
static void opt_frame_pad_left(const char *arg)
2562
{
2563
    frame_padleft = atoi(arg);
2564
    if (frame_padleft < 0) {
2565
        fprintf(stderr, "Incorrect left pad size\n");
2566
        av_exit(1);
2567
    }
2568
}
2569

    
2570

    
2571
static void opt_frame_pad_right(const char *arg)
2572
{
2573
    frame_padright = atoi(arg);
2574
    if (frame_padright < 0) {
2575
        fprintf(stderr, "Incorrect right pad size\n");
2576
        av_exit(1);
2577
    }
2578
}
2579

    
2580
static void opt_frame_pix_fmt(const char *arg)
2581
{
2582
    if (strcmp(arg, "list")) {
2583
        frame_pix_fmt = av_get_pix_fmt(arg);
2584
        if (frame_pix_fmt == PIX_FMT_NONE) {
2585
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2586
            av_exit(1);
2587
        }
2588
    } else {
2589
        show_pix_fmts();
2590
        av_exit(0);
2591
    }
2592
}
2593

    
2594
static void opt_frame_aspect_ratio(const char *arg)
2595
{
2596
    int x = 0, y = 0;
2597
    double ar = 0;
2598
    const char *p;
2599
    char *end;
2600

    
2601
    p = strchr(arg, ':');
2602
    if (p) {
2603
        x = strtol(arg, &end, 10);
2604
        if (end == p)
2605
            y = strtol(end+1, &end, 10);
2606
        if (x > 0 && y > 0)
2607
            ar = (double)x / (double)y;
2608
    } else
2609
        ar = strtod(arg, NULL);
2610

    
2611
    if (!ar) {
2612
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2613
        av_exit(1);
2614
    }
2615
    frame_aspect_ratio = ar;
2616
}
2617

    
2618
static int opt_metadata(const char *opt, const char *arg)
2619
{
2620
    char *mid= strchr(arg, '=');
2621

    
2622
    if(!mid){
2623
        fprintf(stderr, "Missing =\n");
2624
        av_exit(1);
2625
    }
2626
    *mid++= 0;
2627

    
2628
    metadata_count++;
2629
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2630
    metadata[metadata_count-1].key  = av_strdup(arg);
2631
    metadata[metadata_count-1].value= av_strdup(mid);
2632

    
2633
    return 0;
2634
}
2635

    
2636
static void opt_qscale(const char *arg)
2637
{
2638
    video_qscale = atof(arg);
2639
    if (video_qscale <= 0 ||
2640
        video_qscale > 255) {
2641
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2642
        av_exit(1);
2643
    }
2644
}
2645

    
2646
static void opt_top_field_first(const char *arg)
2647
{
2648
    top_field_first= atoi(arg);
2649
}
2650

    
2651
static int opt_thread_count(const char *opt, const char *arg)
2652
{
2653
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2654
#if !HAVE_THREADS
2655
    if (verbose >= 0)
2656
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2657
#endif
2658
    return 0;
2659
}
2660

    
2661
static void opt_audio_sample_fmt(const char *arg)
2662
{
2663
    if (strcmp(arg, "list"))
2664
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2665
    else {
2666
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2667
        av_exit(0);
2668
    }
2669
}
2670

    
2671
static int opt_audio_rate(const char *opt, const char *arg)
2672
{
2673
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2674
    return 0;
2675
}
2676

    
2677
static int opt_audio_channels(const char *opt, const char *arg)
2678
{
2679
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2680
    return 0;
2681
}
2682

    
2683
static void opt_video_channel(const char *arg)
2684
{
2685
    video_channel = strtol(arg, NULL, 0);
2686
}
2687

    
2688
static void opt_video_standard(const char *arg)
2689
{
2690
    video_standard = av_strdup(arg);
2691
}
2692

    
2693
static void opt_codec(int *pstream_copy, char **pcodec_name,
2694
                      int codec_type, const char *arg)
2695
{
2696
    av_freep(pcodec_name);
2697
    if (!strcmp(arg, "copy")) {
2698
        *pstream_copy = 1;
2699
    } else {
2700
        *pcodec_name = av_strdup(arg);
2701
    }
2702
}
2703

    
2704
static void opt_audio_codec(const char *arg)
2705
{
2706
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2707
}
2708

    
2709
static void opt_audio_tag(const char *arg)
2710
{
2711
    char *tail;
2712
    audio_codec_tag= strtol(arg, &tail, 0);
2713

    
2714
    if(!tail || *tail)
2715
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2716
}
2717

    
2718
static void opt_video_tag(const char *arg)
2719
{
2720
    char *tail;
2721
    video_codec_tag= strtol(arg, &tail, 0);
2722

    
2723
    if(!tail || *tail)
2724
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2725
}
2726

    
2727
static void opt_video_codec(const char *arg)
2728
{
2729
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2730
}
2731

    
2732
static void opt_subtitle_codec(const char *arg)
2733
{
2734
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2735
}
2736

    
2737
static void opt_subtitle_tag(const char *arg)
2738
{
2739
    char *tail;
2740
    subtitle_codec_tag= strtol(arg, &tail, 0);
2741

    
2742
    if(!tail || *tail)
2743
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2744
}
2745

    
2746
static void opt_map(const char *arg)
2747
{
2748
    AVStreamMap *m;
2749
    char *p;
2750

    
2751
    m = &stream_maps[nb_stream_maps++];
2752

    
2753
    m->file_index = strtol(arg, &p, 0);
2754
    if (*p)
2755
        p++;
2756

    
2757
    m->stream_index = strtol(p, &p, 0);
2758
    if (*p) {
2759
        p++;
2760
        m->sync_file_index = strtol(p, &p, 0);
2761
        if (*p)
2762
            p++;
2763
        m->sync_stream_index = strtol(p, &p, 0);
2764
    } else {
2765
        m->sync_file_index = m->file_index;
2766
        m->sync_stream_index = m->stream_index;
2767
    }
2768
}
2769

    
2770
static void opt_map_meta_data(const char *arg)
2771
{
2772
    AVMetaDataMap *m;
2773
    char *p;
2774

    
2775
    m = &meta_data_maps[nb_meta_data_maps++];
2776

    
2777
    m->out_file = strtol(arg, &p, 0);
2778
    if (*p)
2779
        p++;
2780

    
2781
    m->in_file = strtol(p, &p, 0);
2782
}
2783

    
2784
static void opt_input_ts_scale(const char *arg)
2785
{
2786
    unsigned int stream;
2787
    double scale;
2788
    char *p;
2789

    
2790
    stream = strtol(arg, &p, 0);
2791
    if (*p)
2792
        p++;
2793
    scale= strtod(p, &p);
2794

    
2795
    if(stream >= MAX_STREAMS)
2796
        av_exit(1);
2797

    
2798
    input_files_ts_scale[nb_input_files][stream]= scale;
2799
}
2800

    
2801
static int opt_recording_time(const char *opt, const char *arg)
2802
{
2803
    recording_time = parse_time_or_die(opt, arg, 1);
2804
    return 0;
2805
}
2806

    
2807
static int opt_start_time(const char *opt, const char *arg)
2808
{
2809
    start_time = parse_time_or_die(opt, arg, 1);
2810
    return 0;
2811
}
2812

    
2813
static int opt_rec_timestamp(const char *opt, const char *arg)
2814
{
2815
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2816
    return 0;
2817
}
2818

    
2819
static int opt_input_ts_offset(const char *opt, const char *arg)
2820
{
2821
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2822
    return 0;
2823
}
2824

    
2825
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2826
{
2827
    const char *codec_string = encoder ? "encoder" : "decoder";
2828
    AVCodec *codec;
2829

    
2830
    if(!name)
2831
        return CODEC_ID_NONE;
2832
    codec = encoder ?
2833
        avcodec_find_encoder_by_name(name) :
2834
        avcodec_find_decoder_by_name(name);
2835
    if(!codec) {
2836
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2837
        av_exit(1);
2838
    }
2839
    if(codec->type != type) {
2840
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2841
        av_exit(1);
2842
    }
2843
    return codec->id;
2844
}
2845

    
2846
static void opt_input_file(const char *filename)
2847
{
2848
    AVFormatContext *ic;
2849
    AVFormatParameters params, *ap = &params;
2850
    AVInputFormat *file_iformat = NULL;
2851
    int err, i, ret, rfps, rfps_base;
2852
    int64_t timestamp;
2853

    
2854
    if (last_asked_format) {
2855
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
2856
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2857
            av_exit(1);
2858
        }
2859
        last_asked_format = NULL;
2860
    }
2861

    
2862
    if (!strcmp(filename, "-"))
2863
        filename = "pipe:";
2864

    
2865
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2866
                    !strcmp(filename, "/dev/stdin");
2867

    
2868
    /* get default parameters from command line */
2869
    ic = avformat_alloc_context();
2870
    if (!ic) {
2871
        print_error(filename, AVERROR(ENOMEM));
2872
        av_exit(1);
2873
    }
2874

    
2875
    memset(ap, 0, sizeof(*ap));
2876
    ap->prealloced_context = 1;
2877
    ap->sample_rate = audio_sample_rate;
2878
    ap->channels = audio_channels;
2879
    ap->time_base.den = frame_rate.num;
2880
    ap->time_base.num = frame_rate.den;
2881
    ap->width = frame_width + frame_padleft + frame_padright;
2882
    ap->height = frame_height + frame_padtop + frame_padbottom;
2883
    ap->pix_fmt = frame_pix_fmt;
2884
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2885
    ap->channel = video_channel;
2886
    ap->standard = video_standard;
2887

    
2888
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2889

    
2890
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2891
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2892
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2893
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2894

    
2895
    if(pgmyuv_compatibility_hack)
2896
        ic->video_codec_id= CODEC_ID_PGMYUV;
2897

    
2898
    /* open the input file with generic libav function */
2899
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2900
    if (err < 0) {
2901
        print_error(filename, err);
2902
        av_exit(1);
2903
    }
2904
    if(opt_programid) {
2905
        int i, j;
2906
        int found=0;
2907
        for(i=0; i<ic->nb_streams; i++){
2908
            ic->streams[i]->discard= AVDISCARD_ALL;
2909
        }
2910
        for(i=0; i<ic->nb_programs; i++){
2911
            AVProgram *p= ic->programs[i];
2912
            if(p->id != opt_programid){
2913
                p->discard = AVDISCARD_ALL;
2914
            }else{
2915
                found=1;
2916
                for(j=0; j<p->nb_stream_indexes; j++){
2917
                    ic->streams[p->stream_index[j]]->discard= 0;
2918
                }
2919
            }
2920
        }
2921
        if(!found){
2922
            fprintf(stderr, "Specified program id not found\n");
2923
            av_exit(1);
2924
        }
2925
        opt_programid=0;
2926
    }
2927

    
2928
    ic->loop_input = loop_input;
2929

    
2930
    /* If not enough info to get the stream parameters, we decode the
2931
       first frames to get it. (used in mpeg case for example) */
2932
    ret = av_find_stream_info(ic);
2933
    if (ret < 0 && verbose >= 0) {
2934
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2935
        av_exit(1);
2936
    }
2937

    
2938
    timestamp = start_time;
2939
    /* add the stream start time */
2940
    if (ic->start_time != AV_NOPTS_VALUE)
2941
        timestamp += ic->start_time;
2942

    
2943
    /* if seeking requested, we execute it */
2944
    if (start_time != 0) {
2945
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2946
        if (ret < 0) {
2947
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2948
                    filename, (double)timestamp / AV_TIME_BASE);
2949
        }
2950
        /* reset seek info */
2951
        start_time = 0;
2952
    }
2953

    
2954
    /* update the current parameters so that they match the one of the input stream */
2955
    for(i=0;i<ic->nb_streams;i++) {
2956
        AVStream *st = ic->streams[i];
2957
        AVCodecContext *enc = st->codec;
2958
        avcodec_thread_init(enc, thread_count);
2959
        switch(enc->codec_type) {
2960
        case CODEC_TYPE_AUDIO:
2961
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2962
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2963
            channel_layout = enc->channel_layout;
2964
            audio_channels = enc->channels;
2965
            audio_sample_rate = enc->sample_rate;
2966
            audio_sample_fmt = enc->sample_fmt;
2967
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2968
            if(audio_disable)
2969
                st->discard= AVDISCARD_ALL;
2970
            break;
2971
        case CODEC_TYPE_VIDEO:
2972
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2973
            frame_height = enc->height;
2974
            frame_width = enc->width;
2975
            if(ic->streams[i]->sample_aspect_ratio.num)
2976
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2977
            else
2978
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2979
            frame_aspect_ratio *= (float) enc->width / enc->height;
2980
            frame_pix_fmt = enc->pix_fmt;
2981
            rfps      = ic->streams[i]->r_frame_rate.num;
2982
            rfps_base = ic->streams[i]->r_frame_rate.den;
2983
            if(enc->lowres) {
2984
                enc->flags |= CODEC_FLAG_EMU_EDGE;
2985
                frame_height >>= enc->lowres;
2986
                frame_width  >>= enc->lowres;
2987
            }
2988
            if(me_threshold)
2989
                enc->debug |= FF_DEBUG_MV;
2990

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

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

    
2997
                    (float)rfps / rfps_base, rfps, rfps_base);
2998
            }
2999
            /* update the current frame rate to match the stream frame rate */
3000
            frame_rate.num = rfps;
3001
            frame_rate.den = rfps_base;
3002

    
3003
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3004
            if(video_disable)
3005
                st->discard= AVDISCARD_ALL;
3006
            else if(video_discard)
3007
                st->discard= video_discard;
3008
            break;
3009
        case CODEC_TYPE_DATA:
3010
            break;
3011
        case CODEC_TYPE_SUBTITLE:
3012
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3013
            if(subtitle_disable)
3014
                st->discard = AVDISCARD_ALL;
3015
            break;
3016
        case CODEC_TYPE_ATTACHMENT:
3017
        case CODEC_TYPE_UNKNOWN:
3018
            nb_icodecs++;
3019
            break;
3020
        default:
3021
            abort();
3022
        }
3023
    }
3024

    
3025
    input_files[nb_input_files] = ic;
3026
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3027
    /* dump the file content */
3028
    if (verbose >= 0)
3029
        dump_format(ic, nb_input_files, filename, 0);
3030

    
3031
    nb_input_files++;
3032

    
3033
    video_channel = 0;
3034

    
3035
    av_freep(&video_codec_name);
3036
    av_freep(&audio_codec_name);
3037
    av_freep(&subtitle_codec_name);
3038
}
3039

    
3040
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3041
                                         int *has_subtitle_ptr)
3042
{
3043
    int has_video, has_audio, has_subtitle, i, j;
3044
    AVFormatContext *ic;
3045

    
3046
    has_video = 0;
3047
    has_audio = 0;
3048
    has_subtitle = 0;
3049
    for(j=0;j<nb_input_files;j++) {
3050
        ic = input_files[j];
3051
        for(i=0;i<ic->nb_streams;i++) {
3052
            AVCodecContext *enc = ic->streams[i]->codec;
3053
            switch(enc->codec_type) {
3054
            case CODEC_TYPE_AUDIO:
3055
                has_audio = 1;
3056
                break;
3057
            case CODEC_TYPE_VIDEO:
3058
                has_video = 1;
3059
                break;
3060
            case CODEC_TYPE_SUBTITLE:
3061
                has_subtitle = 1;
3062
                break;
3063
            case CODEC_TYPE_DATA:
3064
            case CODEC_TYPE_ATTACHMENT:
3065
            case CODEC_TYPE_UNKNOWN:
3066
                break;
3067
            default:
3068
                abort();
3069
            }
3070
        }
3071
    }
3072
    *has_video_ptr = has_video;
3073
    *has_audio_ptr = has_audio;
3074
    *has_subtitle_ptr = has_subtitle;
3075
}
3076

    
3077
static void new_video_stream(AVFormatContext *oc)
3078
{
3079
    AVStream *st;
3080
    AVCodecContext *video_enc;
3081
    enum CodecID codec_id;
3082

    
3083
    st = av_new_stream(oc, oc->nb_streams);
3084
    if (!st) {
3085
        fprintf(stderr, "Could not alloc stream\n");
3086
        av_exit(1);
3087
    }
3088
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3089
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3090
    video_bitstream_filters= NULL;
3091

    
3092
    avcodec_thread_init(st->codec, thread_count);
3093

    
3094
    video_enc = st->codec;
3095

    
3096
    if(video_codec_tag)
3097
        video_enc->codec_tag= video_codec_tag;
3098

    
3099
    if(   (video_global_header&1)
3100
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3101
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3102
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3103
    }
3104
    if(video_global_header&2){
3105
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3106
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3107
    }
3108

    
3109
    if (video_stream_copy) {
3110
        st->stream_copy = 1;
3111
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3112
        video_enc->sample_aspect_ratio =
3113
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3114
    } else {
3115
        const char *p;
3116
        int i;
3117
        AVCodec *codec;
3118
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3119

    
3120
        if (video_codec_name) {
3121
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3122
            codec = avcodec_find_encoder_by_name(video_codec_name);
3123
            output_codecs[nb_ocodecs] = codec;
3124
        } else {
3125
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3126
            codec = avcodec_find_encoder(codec_id);
3127
        }
3128

    
3129
        video_enc->codec_id = codec_id;
3130

    
3131
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3132

    
3133
        if (codec && codec->supported_framerates && !force_fps)
3134
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3135
        video_enc->time_base.den = fps.num;
3136
        video_enc->time_base.num = fps.den;
3137

    
3138
        video_enc->width = frame_width + frame_padright + frame_padleft;
3139
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3140
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3141
        video_enc->pix_fmt = frame_pix_fmt;
3142
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3143

    
3144
        if(codec && codec->pix_fmts){
3145
            const enum PixelFormat *p= codec->pix_fmts;
3146
            for(; *p!=-1; p++){
3147
                if(*p == video_enc->pix_fmt)
3148
                    break;
3149
            }
3150
            if(*p == -1)
3151
                video_enc->pix_fmt = codec->pix_fmts[0];
3152
        }
3153

    
3154
        if (intra_only)
3155
            video_enc->gop_size = 0;
3156
        if (video_qscale || same_quality) {
3157
            video_enc->flags |= CODEC_FLAG_QSCALE;
3158
            video_enc->global_quality=
3159
                st->quality = FF_QP2LAMBDA * video_qscale;
3160
        }
3161

    
3162
        if(intra_matrix)
3163
            video_enc->intra_matrix = intra_matrix;
3164
        if(inter_matrix)
3165
            video_enc->inter_matrix = inter_matrix;
3166

    
3167
        p= video_rc_override_string;
3168
        for(i=0; p; i++){
3169
            int start, end, q;
3170
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3171
            if(e!=3){
3172
                fprintf(stderr, "error parsing rc_override\n");
3173
                av_exit(1);
3174
            }
3175
            video_enc->rc_override=
3176
                av_realloc(video_enc->rc_override,
3177
                           sizeof(RcOverride)*(i+1));
3178
            video_enc->rc_override[i].start_frame= start;
3179
            video_enc->rc_override[i].end_frame  = end;
3180
            if(q>0){
3181
                video_enc->rc_override[i].qscale= q;
3182
                video_enc->rc_override[i].quality_factor= 1.0;
3183
            }
3184
            else{
3185
                video_enc->rc_override[i].qscale= 0;
3186
                video_enc->rc_override[i].quality_factor= -q/100.0;
3187
            }
3188
            p= strchr(p, '/');
3189
            if(p) p++;
3190
        }
3191
        video_enc->rc_override_count=i;
3192
        if (!video_enc->rc_initial_buffer_occupancy)
3193
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3194
        video_enc->me_threshold= me_threshold;
3195
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3196

    
3197
        if (do_psnr)
3198
            video_enc->flags|= CODEC_FLAG_PSNR;
3199

    
3200
        /* two pass mode */
3201
        if (do_pass) {
3202
            if (do_pass == 1) {
3203
                video_enc->flags |= CODEC_FLAG_PASS1;
3204
            } else {
3205
                video_enc->flags |= CODEC_FLAG_PASS2;
3206
            }
3207
        }
3208
    }
3209
    nb_ocodecs++;
3210
    if (video_language) {
3211
        av_metadata_set(&st->metadata, "language", video_language);
3212
        av_freep(&video_language);
3213
    }
3214

    
3215
    /* reset some key parameters */
3216
    video_disable = 0;
3217
    av_freep(&video_codec_name);
3218
    video_stream_copy = 0;
3219
    frame_pix_fmt = PIX_FMT_NONE;
3220
}
3221

    
3222
static void new_audio_stream(AVFormatContext *oc)
3223
{
3224
    AVStream *st;
3225
    AVCodecContext *audio_enc;
3226
    enum CodecID codec_id;
3227

    
3228
    st = av_new_stream(oc, oc->nb_streams);
3229
    if (!st) {
3230
        fprintf(stderr, "Could not alloc stream\n");
3231
        av_exit(1);
3232
    }
3233
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3234

    
3235
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3236
    audio_bitstream_filters= NULL;
3237

    
3238
    avcodec_thread_init(st->codec, thread_count);
3239

    
3240
    audio_enc = st->codec;
3241
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3242

    
3243
    if(audio_codec_tag)
3244
        audio_enc->codec_tag= audio_codec_tag;
3245

    
3246
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3247
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3248
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3249
    }
3250
    if (audio_stream_copy) {
3251
        st->stream_copy = 1;
3252
        audio_enc->channels = audio_channels;
3253
    } else {
3254
        AVCodec *codec;
3255

    
3256
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3257

    
3258
        if (audio_codec_name) {
3259
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3260
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3261
            output_codecs[nb_ocodecs] = codec;
3262
        } else {
3263
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3264
            codec = avcodec_find_encoder(codec_id);
3265
        }
3266
        audio_enc->codec_id = codec_id;
3267

    
3268
        if (audio_qscale > QSCALE_NONE) {
3269
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3270
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3271
        }
3272
        audio_enc->channels = audio_channels;
3273
        audio_enc->sample_fmt = audio_sample_fmt;
3274
        audio_enc->channel_layout = channel_layout;
3275
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3276
            audio_enc->channel_layout = 0;
3277

    
3278
        if(codec && codec->sample_fmts){
3279
            const enum SampleFormat *p= codec->sample_fmts;
3280
            for(; *p!=-1; p++){
3281
                if(*p == audio_enc->sample_fmt)
3282
                    break;
3283
            }
3284
            if(*p == -1)
3285
                audio_enc->sample_fmt = codec->sample_fmts[0];
3286
        }
3287
    }
3288
    nb_ocodecs++;
3289
    audio_enc->sample_rate = audio_sample_rate;
3290
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3291
    if (audio_language) {
3292
        av_metadata_set(&st->metadata, "language", audio_language);
3293
        av_freep(&audio_language);
3294
    }
3295

    
3296
    /* reset some key parameters */
3297
    audio_disable = 0;
3298
    av_freep(&audio_codec_name);
3299
    audio_stream_copy = 0;
3300
}
3301

    
3302
static void new_subtitle_stream(AVFormatContext *oc)
3303
{
3304
    AVStream *st;
3305
    AVCodecContext *subtitle_enc;
3306

    
3307
    st = av_new_stream(oc, oc->nb_streams);
3308
    if (!st) {
3309
        fprintf(stderr, "Could not alloc stream\n");
3310
        av_exit(1);
3311
    }
3312
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3313

    
3314
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3315
    subtitle_bitstream_filters= NULL;
3316

    
3317
    subtitle_enc = st->codec;
3318
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3319

    
3320
    if(subtitle_codec_tag)
3321
        subtitle_enc->codec_tag= subtitle_codec_tag;
3322

    
3323
    if (subtitle_stream_copy) {
3324
        st->stream_copy = 1;
3325
    } else {
3326
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3327
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3328
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3329
    }
3330
    nb_ocodecs++;
3331

    
3332
    if (subtitle_language) {
3333
        av_metadata_set(&st->metadata, "language", subtitle_language);
3334
        av_freep(&subtitle_language);
3335
    }
3336

    
3337
    subtitle_disable = 0;
3338
    av_freep(&subtitle_codec_name);
3339
    subtitle_stream_copy = 0;
3340
}
3341

    
3342
static void opt_new_audio_stream(void)
3343
{
3344
    AVFormatContext *oc;
3345
    if (nb_output_files <= 0) {
3346
        fprintf(stderr, "At least one output file must be specified\n");
3347
        av_exit(1);
3348
    }
3349
    oc = output_files[nb_output_files - 1];
3350
    new_audio_stream(oc);
3351
}
3352

    
3353
static void opt_new_video_stream(void)
3354
{
3355
    AVFormatContext *oc;
3356
    if (nb_output_files <= 0) {
3357
        fprintf(stderr, "At least one output file must be specified\n");
3358
        av_exit(1);
3359
    }
3360
    oc = output_files[nb_output_files - 1];
3361
    new_video_stream(oc);
3362
}
3363

    
3364
static void opt_new_subtitle_stream(void)
3365
{
3366
    AVFormatContext *oc;
3367
    if (nb_output_files <= 0) {
3368
        fprintf(stderr, "At least one output file must be specified\n");
3369
        av_exit(1);
3370
    }
3371
    oc = output_files[nb_output_files - 1];
3372
    new_subtitle_stream(oc);
3373
}
3374

    
3375
static void opt_output_file(const char *filename)
3376
{
3377
    AVFormatContext *oc;
3378
    int use_video, use_audio, use_subtitle;
3379
    int input_has_video, input_has_audio, input_has_subtitle;
3380
    AVFormatParameters params, *ap = &params;
3381
    AVOutputFormat *file_oformat;
3382

    
3383
    if (!strcmp(filename, "-"))
3384
        filename = "pipe:";
3385

    
3386
    oc = avformat_alloc_context();
3387
    if (!oc) {
3388
        print_error(filename, AVERROR(ENOMEM));
3389
        av_exit(1);
3390
    }
3391

    
3392
    if (last_asked_format) {
3393
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3394
        if (!file_oformat) {
3395
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3396
            av_exit(1);
3397
        }
3398
        last_asked_format = NULL;
3399
    } else {
3400
        file_oformat = av_guess_format(NULL, filename, NULL);
3401
        if (!file_oformat) {
3402
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3403
                    filename);
3404
            av_exit(1);
3405
        }
3406
    }
3407

    
3408
    oc->oformat = file_oformat;
3409
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3410

    
3411
    if (!strcmp(file_oformat->name, "ffm") &&
3412
        av_strstart(filename, "http:", NULL)) {
3413
        /* special case for files sent to ffserver: we get the stream
3414
           parameters from ffserver */
3415
        int err = read_ffserver_streams(oc, filename);
3416
        if (err < 0) {
3417
            print_error(filename, err);
3418
            av_exit(1);
3419
        }
3420
    } else {
3421
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3422
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3423
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3424

    
3425
        /* disable if no corresponding type found and at least one
3426
           input file */
3427
        if (nb_input_files > 0) {
3428
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3429
                                         &input_has_subtitle);
3430
            if (!input_has_video)
3431
                use_video = 0;
3432
            if (!input_has_audio)
3433
                use_audio = 0;
3434
            if (!input_has_subtitle)
3435
                use_subtitle = 0;
3436
        }
3437

    
3438
        /* manual disable */
3439
        if (audio_disable) {
3440
            use_audio = 0;
3441
        }
3442
        if (video_disable) {
3443
            use_video = 0;
3444
        }
3445
        if (subtitle_disable) {
3446
            use_subtitle = 0;
3447
        }
3448

    
3449
        if (use_video) {
3450
            new_video_stream(oc);
3451
        }
3452

    
3453
        if (use_audio) {
3454
            new_audio_stream(oc);
3455
        }
3456

    
3457
        if (use_subtitle) {
3458
            new_subtitle_stream(oc);
3459
        }
3460

    
3461
        oc->timestamp = rec_timestamp;
3462

    
3463
        for(; metadata_count>0; metadata_count--){
3464
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3465
                                           metadata[metadata_count-1].value);
3466
        }
3467
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3468
    }
3469

    
3470
    output_files[nb_output_files++] = oc;
3471

    
3472
    /* check filename in case of an image number is expected */
3473
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3474
        if (!av_filename_number_test(oc->filename)) {
3475
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3476
            av_exit(1);
3477
        }
3478
    }
3479

    
3480
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3481
        /* test if it already exists to avoid loosing precious files */
3482
        if (!file_overwrite &&
3483
            (strchr(filename, ':') == NULL ||
3484
             filename[1] == ':' ||
3485
             av_strstart(filename, "file:", NULL))) {
3486
            if (url_exist(filename)) {
3487
                if (!using_stdin) {
3488
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3489
                    fflush(stderr);
3490
                    if (!read_yesno()) {
3491
                        fprintf(stderr, "Not overwriting - exiting\n");
3492
                        av_exit(1);
3493
                    }
3494
                }
3495
                else {
3496
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3497
                    av_exit(1);
3498
                }
3499
            }
3500
        }
3501

    
3502
        /* open the file */
3503
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3504
            fprintf(stderr, "Could not open '%s'\n", filename);
3505
            av_exit(1);
3506
        }
3507
    }
3508

    
3509
    memset(ap, 0, sizeof(*ap));
3510
    if (av_set_parameters(oc, ap) < 0) {
3511
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3512
                oc->filename);
3513
        av_exit(1);
3514
    }
3515

    
3516
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3517
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3518
    oc->loop_output = loop_output;
3519
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3520

    
3521
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3522
}
3523

    
3524
/* same option as mencoder */
3525
static void opt_pass(const char *pass_str)
3526
{
3527
    int pass;
3528
    pass = atoi(pass_str);
3529
    if (pass != 1 && pass != 2) {
3530
        fprintf(stderr, "pass number can be only 1 or 2\n");
3531
        av_exit(1);
3532
    }
3533
    do_pass = pass;
3534
}
3535

    
3536
static int64_t getutime(void)
3537
{
3538
#if HAVE_GETRUSAGE
3539
    struct rusage rusage;
3540

    
3541
    getrusage(RUSAGE_SELF, &rusage);
3542
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3543
#elif HAVE_GETPROCESSTIMES
3544
    HANDLE proc;
3545
    FILETIME c, e, k, u;
3546
    proc = GetCurrentProcess();
3547
    GetProcessTimes(proc, &c, &e, &k, &u);
3548
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3549
#else
3550
    return av_gettime();
3551
#endif
3552
}
3553

    
3554
static int64_t getmaxrss(void)
3555
{
3556
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3557
    struct rusage rusage;
3558
    getrusage(RUSAGE_SELF, &rusage);
3559
    return (int64_t)rusage.ru_maxrss * 1024;
3560
#elif HAVE_GETPROCESSMEMORYINFO
3561
    HANDLE proc;
3562
    PROCESS_MEMORY_COUNTERS memcounters;
3563
    proc = GetCurrentProcess();
3564
    memcounters.cb = sizeof(memcounters);
3565
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3566
    return memcounters.PeakPagefileUsage;
3567
#else
3568
    return 0;
3569
#endif
3570
}
3571

    
3572
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3573
{
3574
    int i;
3575
    const char *p = str;
3576
    for(i = 0;; i++) {
3577
        dest[i] = atoi(p);
3578
        if(i == 63)
3579
            break;
3580
        p = strchr(p, ',');
3581
        if(!p) {
3582
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3583
            av_exit(1);
3584
        }
3585
        p++;
3586
    }
3587
}
3588

    
3589
static void opt_inter_matrix(const char *arg)
3590
{
3591
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3592
    parse_matrix_coeffs(inter_matrix, arg);
3593
}
3594

    
3595
static void opt_intra_matrix(const char *arg)
3596
{
3597
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3598
    parse_matrix_coeffs(intra_matrix, arg);
3599
}
3600

    
3601
/**
3602
 * Trivial log callback.
3603
 * Only suitable for show_help and similar since it lacks prefix handling.
3604
 */
3605
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3606
{
3607
    vfprintf(stdout, fmt, vl);
3608
}
3609

    
3610
static void show_usage(void)
3611
{
3612
    printf("Hyper fast Audio and Video encoder\n");
3613
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3614
    printf("\n");
3615
}
3616

    
3617
static void show_help(void)
3618
{
3619
    av_log_set_callback(log_callback_help);
3620
    show_usage();
3621
    show_help_options(options, "Main options:\n",
3622
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3623
    show_help_options(options, "\nAdvanced options:\n",
3624
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3625
                      OPT_EXPERT);
3626
    show_help_options(options, "\nVideo options:\n",
3627
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3628
                      OPT_VIDEO);
3629
    show_help_options(options, "\nAdvanced Video options:\n",
3630
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3631
                      OPT_VIDEO | OPT_EXPERT);
3632
    show_help_options(options, "\nAudio options:\n",
3633
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3634
                      OPT_AUDIO);
3635
    show_help_options(options, "\nAdvanced Audio options:\n",
3636
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3637
                      OPT_AUDIO | OPT_EXPERT);
3638
    show_help_options(options, "\nSubtitle options:\n",
3639
                      OPT_SUBTITLE | OPT_GRAB,
3640
                      OPT_SUBTITLE);
3641
    show_help_options(options, "\nAudio/Video grab options:\n",
3642
                      OPT_GRAB,
3643
                      OPT_GRAB);
3644
    printf("\n");
3645
    av_opt_show(avcodec_opts[0], NULL);
3646
    printf("\n");
3647
    av_opt_show(avformat_opts, NULL);
3648
    printf("\n");
3649
    av_opt_show(sws_opts, NULL);
3650
}
3651

    
3652
static void opt_target(const char *arg)
3653
{
3654
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3655
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3656

    
3657
    if(!strncmp(arg, "pal-", 4)) {
3658
        norm = PAL;
3659
        arg += 4;
3660
    } else if(!strncmp(arg, "ntsc-", 5)) {
3661
        norm = NTSC;
3662
        arg += 5;
3663
    } else if(!strncmp(arg, "film-", 5)) {
3664
        norm = FILM;
3665
        arg += 5;
3666
    } else {
3667
        int fr;
3668
        /* Calculate FR via float to avoid int overflow */
3669
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3670
        if(fr == 25000) {
3671
            norm = PAL;
3672
        } else if((fr == 29970) || (fr == 23976)) {
3673
            norm = NTSC;
3674
        } else {
3675
            /* Try to determine PAL/NTSC by peeking in the input files */
3676
            if(nb_input_files) {
3677
                int i, j;
3678
                for(j = 0; j < nb_input_files; j++) {
3679
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3680
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3681
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3682
                            continue;
3683
                        fr = c->time_base.den * 1000 / c->time_base.num;
3684
                        if(fr == 25000) {
3685
                            norm = PAL;
3686
                            break;
3687
                        } else if((fr == 29970) || (fr == 23976)) {
3688
                            norm = NTSC;
3689
                            break;
3690
                        }
3691
                    }
3692
                    if(norm != UNKNOWN)
3693
                        break;
3694
                }
3695
            }
3696
        }
3697
        if(verbose && norm != UNKNOWN)
3698
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3699
    }
3700

    
3701
    if(norm == UNKNOWN) {
3702
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3703
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3704
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3705
        av_exit(1);
3706
    }
3707

    
3708
    if(!strcmp(arg, "vcd")) {
3709

    
3710
        opt_video_codec("mpeg1video");
3711
        opt_audio_codec("mp2");
3712
        opt_format("vcd");
3713

    
3714
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3715
        opt_frame_rate(NULL, frame_rates[norm]);
3716
        opt_default("g", norm == PAL ? "15" : "18");
3717

    
3718
        opt_default("b", "1150000");
3719
        opt_default("maxrate", "1150000");
3720
        opt_default("minrate", "1150000");
3721
        opt_default("bufsize", "327680"); // 40*1024*8;
3722

    
3723
        opt_default("ab", "224000");
3724
        audio_sample_rate = 44100;
3725
        audio_channels = 2;
3726

    
3727
        opt_default("packetsize", "2324");
3728
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3729

    
3730
        /* We have to offset the PTS, so that it is consistent with the SCR.
3731
           SCR starts at 36000, but the first two packs contain only padding
3732
           and the first pack from the other stream, respectively, may also have
3733
           been written before.
3734
           So the real data starts at SCR 36000+3*1200. */
3735
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3736
    } else if(!strcmp(arg, "svcd")) {
3737

    
3738
        opt_video_codec("mpeg2video");
3739
        opt_audio_codec("mp2");
3740
        opt_format("svcd");
3741

    
3742
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3743
        opt_frame_rate(NULL, frame_rates[norm]);
3744
        opt_default("g", norm == PAL ? "15" : "18");
3745

    
3746
        opt_default("b", "2040000");
3747
        opt_default("maxrate", "2516000");
3748
        opt_default("minrate", "0"); //1145000;
3749
        opt_default("bufsize", "1835008"); //224*1024*8;
3750
        opt_default("flags", "+scan_offset");
3751

    
3752

    
3753
        opt_default("ab", "224000");
3754
        audio_sample_rate = 44100;
3755

    
3756
        opt_default("packetsize", "2324");
3757

    
3758
    } else if(!strcmp(arg, "dvd")) {
3759

    
3760
        opt_video_codec("mpeg2video");
3761
        opt_audio_codec("ac3");
3762
        opt_format("dvd");
3763

    
3764
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3765
        opt_frame_rate(NULL, frame_rates[norm]);
3766
        opt_default("g", norm == PAL ? "15" : "18");
3767

    
3768
        opt_default("b", "6000000");
3769
        opt_default("maxrate", "9000000");
3770
        opt_default("minrate", "0"); //1500000;
3771
        opt_default("bufsize", "1835008"); //224*1024*8;
3772

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

    
3776
        opt_default("ab", "448000");
3777
        audio_sample_rate = 48000;
3778

    
3779
    } else if(!strncmp(arg, "dv", 2)) {
3780

    
3781
        opt_format("dv");
3782

    
3783
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3784
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3785
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3786
        opt_frame_rate(NULL, frame_rates[norm]);
3787

    
3788
        audio_sample_rate = 48000;
3789
        audio_channels = 2;
3790

    
3791
    } else {
3792
        fprintf(stderr, "Unknown target: %s\n", arg);
3793
        av_exit(1);
3794
    }
3795
}
3796

    
3797
static void opt_vstats_file (const char *arg)
3798
{
3799
    av_free (vstats_filename);
3800
    vstats_filename=av_strdup (arg);
3801
}
3802

    
3803
static void opt_vstats (void)
3804
{
3805
    char filename[40];
3806
    time_t today2 = time(NULL);
3807
    struct tm *today = localtime(&today2);
3808

    
3809
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3810
             today->tm_sec);
3811
    opt_vstats_file(filename);
3812
}
3813

    
3814
static int opt_bsf(const char *opt, const char *arg)
3815
{
3816
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3817
    AVBitStreamFilterContext **bsfp;
3818

    
3819
    if(!bsfc){
3820
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3821
        av_exit(1);
3822
    }
3823

    
3824
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3825
          *opt == 'a' ? &audio_bitstream_filters :
3826
                        &subtitle_bitstream_filters;
3827
    while(*bsfp)
3828
        bsfp= &(*bsfp)->next;
3829

    
3830
    *bsfp= bsfc;
3831

    
3832
    return 0;
3833
}
3834

    
3835
static int opt_preset(const char *opt, const char *arg)
3836
{
3837
    FILE *f=NULL;
3838
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3839
    int i;
3840
    const char *base[2]= { getenv("HOME"),
3841
                           FFMPEG_DATADIR,
3842
                         };
3843

    
3844
    if (*opt != 'f') {
3845
        for(i=!base[0]; i<2 && !f; i++){
3846
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3847
            f= fopen(filename, "r");
3848
            if(!f){
3849
                char *codec_name= *opt == 'v' ? video_codec_name :
3850
                                  *opt == 'a' ? audio_codec_name :
3851
                                                subtitle_codec_name;
3852
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3853
                f= fopen(filename, "r");
3854
            }
3855
        }
3856
    } else {
3857
        av_strlcpy(filename, arg, sizeof(filename));
3858
        f= fopen(filename, "r");
3859
    }
3860

    
3861
    if(!f){
3862
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3863
        av_exit(1);
3864
    }
3865

    
3866
    while(!feof(f)){
3867
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3868
        if(line[0] == '#' && !e)
3869
            continue;
3870
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3871
        if(e){
3872
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3873
            av_exit(1);
3874
        }
3875
        if(!strcmp(tmp, "acodec")){
3876
            opt_audio_codec(tmp2);
3877
        }else if(!strcmp(tmp, "vcodec")){
3878
            opt_video_codec(tmp2);
3879
        }else if(!strcmp(tmp, "scodec")){
3880
            opt_subtitle_codec(tmp2);
3881
        }else if(opt_default(tmp, tmp2) < 0){
3882
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3883
            av_exit(1);
3884
        }
3885
    }
3886

    
3887
    fclose(f);
3888

    
3889
    return 0;
3890
}
3891

    
3892
static const OptionDef options[] = {
3893
    /* main options */
3894
#include "cmdutils_common_opts.h"
3895
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3896
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3897
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3898
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3899
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3900
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3901
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3902
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3903
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3904
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3905
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3906
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3907
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3908
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3909
      "add timings for benchmarking" },
3910
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3911
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3912
      "dump each input packet" },
3913
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3914
      "when dumping packets, also dump the payload" },
3915
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3916
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3917
    { "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)", "" },
3918
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3919
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3920
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3921
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3922
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3923
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3924
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3925
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3926
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3927
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3928
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3929
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3930
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3931

    
3932
    /* video options */
3933
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3934
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3935
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3936
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3937
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3938
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3939
    { "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" },
3940
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3941
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3942
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3943
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3944
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3945
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3946
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3947
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3948
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3949
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3950
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3951
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3952
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3953
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3954
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3955
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3956
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3957
      "use same video quality as source (implies VBR)" },
3958
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3959
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3960
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3961
      "deinterlace pictures" },
3962
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3963
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3964
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3965
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3966
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3967
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3968
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3969
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3970
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3971
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
3972
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3973
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3974

    
3975
    /* audio options */
3976
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3977
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3978
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3979
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3980
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3981
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3982
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3983
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3984
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3985
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3986
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3987
    { "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" },
3988

    
3989
    /* subtitle options */
3990
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3991
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3992
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3993
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3994
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3995

    
3996
    /* grab options */
3997
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3998
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3999
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4000

    
4001
    /* muxer options */
4002
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4003
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4004

    
4005
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4006
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4007
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4008

    
4009
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4010
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4011
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4012
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4013

    
4014
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4015
    { NULL, },
4016
};
4017

    
4018
int main(int argc, char **argv)
4019
{
4020
    int i;
4021
    int64_t ti;
4022

    
4023
    avcodec_register_all();
4024
    avdevice_register_all();
4025
    av_register_all();
4026

    
4027
#if HAVE_ISATTY
4028
    if(isatty(STDIN_FILENO))
4029
        url_set_interrupt_cb(decode_interrupt_cb);
4030
#endif
4031

    
4032
    for(i=0; i<CODEC_TYPE_NB; i++){
4033
        avcodec_opts[i]= avcodec_alloc_context2(i);
4034
    }
4035
    avformat_opts = avformat_alloc_context();
4036
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4037

    
4038
    show_banner();
4039

    
4040
    /* parse options */
4041
    parse_options(argc, argv, options, opt_output_file);
4042

    
4043
    if(nb_output_files <= 0 && nb_input_files == 0) {
4044
        show_usage();
4045
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4046
        av_exit(1);
4047
    }
4048

    
4049
    /* file converter / grab */
4050
    if (nb_output_files <= 0) {
4051
        fprintf(stderr, "At least one output file must be specified\n");
4052
        av_exit(1);
4053
    }
4054

    
4055
    if (nb_input_files == 0) {
4056
        fprintf(stderr, "At least one input file must be specified\n");
4057
        av_exit(1);
4058
    }
4059

    
4060
    ti = getutime();
4061
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4062
                  stream_maps, nb_stream_maps) < 0)
4063
        av_exit(1);
4064
    ti = getutime() - ti;
4065
    if (do_benchmark) {
4066
        int maxrss = getmaxrss() / 1024;
4067
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4068
    }
4069

    
4070
    return av_exit(0);
4071
}