Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 386c88de

History | View | Annotate | Download (137 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
#define HAVE_AV_CONFIG_H
22
#include <signal.h>
23
#include <limits.h>
24
#include "avformat.h"
25
#include "swscale.h"
26
#include "framehook.h"
27
#include "dsputil.h"
28
#include "opt.h"
29
#include "fifo.h"
30

    
31
#ifdef __MINGW32__
32
#include <conio.h>
33
#else
34
#include <unistd.h>
35
#include <fcntl.h>
36
#include <sys/ioctl.h>
37
#include <sys/time.h>
38
#include <termios.h>
39
#include <sys/resource.h>
40
#endif
41
#ifdef CONFIG_OS2
42
#include <sys/types.h>
43
#include <sys/select.h>
44
#include <stdlib.h>
45
#endif
46
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
47
#include <time.h>
48

    
49
#include "version.h"
50
#include "cmdutils.h"
51

    
52
#undef NDEBUG
53
#include <assert.h>
54

    
55
#if !defined(INFINITY) && defined(HUGE_VAL)
56
#define INFINITY HUGE_VAL
57
#endif
58

    
59
/* select an input stream for an output stream */
60
typedef struct AVStreamMap {
61
    int file_index;
62
    int stream_index;
63
    int sync_file_index;
64
    int sync_stream_index;
65
} AVStreamMap;
66

    
67
/** select an input file for an output file */
68
typedef struct AVMetaDataMap {
69
    int out_file;
70
    int in_file;
71
} AVMetaDataMap;
72

    
73
extern const OptionDef options[];
74

    
75
static void show_help(void);
76
static void show_license(void);
77
static int opt_default(const char *opt, const char *arg);
78

    
79
#define MAX_FILES 20
80

    
81
static AVFormatContext *input_files[MAX_FILES];
82
static int64_t input_files_ts_offset[MAX_FILES];
83
static int nb_input_files = 0;
84

    
85
static AVFormatContext *output_files[MAX_FILES];
86
static int nb_output_files = 0;
87

    
88
static AVStreamMap stream_maps[MAX_FILES];
89
static int nb_stream_maps;
90

    
91
static AVMetaDataMap meta_data_maps[MAX_FILES];
92
static int nb_meta_data_maps;
93

    
94
static AVInputFormat *file_iformat;
95
static AVOutputFormat *file_oformat;
96
static int frame_width  = 0;
97
static int frame_height = 0;
98
static float frame_aspect_ratio = 0;
99
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
100
static int frame_padtop  = 0;
101
static int frame_padbottom = 0;
102
static int frame_padleft  = 0;
103
static int frame_padright = 0;
104
static int padcolor[3] = {16,128,128}; /* default to black */
105
static int frame_topBand  = 0;
106
static int frame_bottomBand = 0;
107
static int frame_leftBand  = 0;
108
static int frame_rightBand = 0;
109
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
110
static int frame_rate = 25;
111
static int frame_rate_base = 1;
112
static float video_qscale = 0;
113
static int video_qdiff = 3;
114
static uint16_t *intra_matrix = NULL;
115
static uint16_t *inter_matrix = NULL;
116
#if 0 //experimental, (can be removed)
117
static float video_rc_qsquish=1.0;
118
static float video_rc_qmod_amp=0;
119
static int video_rc_qmod_freq=0;
120
#endif
121
static char *video_rc_override_string=NULL;
122
static char *video_rc_eq="tex^qComp";
123
static int me_method = ME_EPZS;
124
static int video_disable = 0;
125
static int video_discard = 0;
126
static int video_codec_id = CODEC_ID_NONE;
127
static int video_codec_tag = 0;
128
static int same_quality = 0;
129
static int do_deinterlace = 0;
130
static int packet_size = 0;
131
static int strict = 0;
132
static int top_field_first = -1;
133
static int me_threshold = 0;
134
static int intra_dc_precision = 8;
135
static int loop_input = 0;
136
static int loop_output = AVFMT_NOOUTPUTLOOP;
137
static int qp_hist = 0;
138

    
139
static int intra_only = 0;
140
static int audio_sample_rate = 44100;
141
static int audio_bit_rate = 64000;
142
#define QSCALE_NONE -99999
143
static float audio_qscale = QSCALE_NONE;
144
static int audio_disable = 0;
145
static int audio_channels = 1;
146
static int audio_codec_id = CODEC_ID_NONE;
147
static int audio_codec_tag = 0;
148
static char *audio_language = NULL;
149

    
150
static int subtitle_codec_id = CODEC_ID_NONE;
151
static char *subtitle_language = NULL;
152

    
153
static float mux_preload= 0.5;
154
static float mux_max_delay= 0.7;
155

    
156
static int64_t recording_time = 0;
157
static int64_t start_time = 0;
158
static int64_t rec_timestamp = 0;
159
static int64_t input_ts_offset = 0;
160
static int file_overwrite = 0;
161
static char *str_title = NULL;
162
static char *str_author = NULL;
163
static char *str_copyright = NULL;
164
static char *str_comment = NULL;
165
static char *str_album = NULL;
166
static int do_benchmark = 0;
167
static int do_hex_dump = 0;
168
static int do_pkt_dump = 0;
169
static int do_psnr = 0;
170
static int do_vstats = 0;
171
static int do_pass = 0;
172
static char *pass_logfilename = NULL;
173
static int audio_stream_copy = 0;
174
static int video_stream_copy = 0;
175
static int subtitle_stream_copy = 0;
176
static int video_sync_method= 1;
177
static int audio_sync_method= 0;
178
static int copy_ts= 0;
179
static int opt_shortest = 0; //
180
static int video_global_header = 0;
181

    
182
static int rate_emu = 0;
183

    
184
#ifdef CONFIG_BKTR
185
static const char *video_grab_format = "bktr";
186
#else
187
#ifdef CONFIG_VIDEO4LINUX2
188
static const char *video_grab_format = "video4linux2";
189
#else
190
static const char *video_grab_format = "video4linux";
191
#endif
192
#endif
193
static char *video_device = NULL;
194
static char *grab_device = NULL;
195
static int  video_channel = 0;
196
static char *video_standard = "ntsc";
197

    
198
static const char *audio_grab_format = "audio_device";
199
static char *audio_device = NULL;
200
static int audio_volume = 256;
201

    
202
static int using_stdin = 0;
203
static int using_vhook = 0;
204
static int verbose = 1;
205
static int thread_count= 1;
206
static int q_pressed = 0;
207
static int64_t video_size = 0;
208
static int64_t audio_size = 0;
209
static int64_t extra_size = 0;
210
static int nb_frames_dup = 0;
211
static int nb_frames_drop = 0;
212
static int input_sync;
213
static int limit_filesize = 0; //
214

    
215
static int pgmyuv_compatibility_hack=0;
216
static int dts_delta_threshold = 10;
217

    
218
static int sws_flags = SWS_BICUBIC;
219

    
220
const char **opt_names=NULL;
221
int opt_name_count=0;
222
AVCodecContext *avctx_opts;
223
AVFormatContext *avformat_opts;
224

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

    
229
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
230

    
231
struct AVInputStream;
232

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

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

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

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

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

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

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

    
293
#ifndef __MINGW32__
294

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

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

    
306
static volatile sig_atomic_t received_sigterm = 0;
307

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

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

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

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

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

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

    
347
/* read a key without blocking */
348
static int read_key(void)
349
{
350
#ifdef __MINGW32__
351
    if(kbhit())
352
        return(getch());
353
#else
354
    int n = 1;
355
    unsigned char ch;
356
#ifndef CONFIG_BEOS_NETSERVER
357
    struct timeval tv;
358
    fd_set rfds;
359

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

    
371
        return n;
372
    }
373
#endif
374
    return -1;
375
}
376

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

    
382
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
383
{
384
    int i, err;
385
    AVFormatContext *ic;
386

    
387
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
388
    if (err < 0)
389
        return err;
390
    /* copy stream format */
391
    s->nb_streams = ic->nb_streams;
392
    for(i=0;i<ic->nb_streams;i++) {
393
        AVStream *st;
394

    
395
        // FIXME: a more elegant solution is needed
396
        st = av_mallocz(sizeof(AVStream));
397
        memcpy(st, ic->streams[i], sizeof(AVStream));
398
        st->codec = avcodec_alloc_context();
399
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
400
        s->streams[i] = st;
401
    }
402

    
403
    av_close_input_file(ic);
404
    return 0;
405
}
406

    
407
static double
408
get_sync_ipts(const AVOutputStream *ost)
409
{
410
    const AVInputStream *ist = ost->sync_ist;
411
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
412
}
413

    
414
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
415
    while(bsfc){
416
        AVPacket new_pkt= *pkt;
417
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
418
                                          &new_pkt.data, &new_pkt.size,
419
                                          pkt->data, pkt->size,
420
                                          pkt->flags & PKT_FLAG_KEY);
421
        if(a){
422
            av_free_packet(pkt);
423
            new_pkt.destruct= av_destruct_packet;
424
        }
425
        *pkt= new_pkt;
426

    
427
        bsfc= bsfc->next;
428
    }
429

    
430
    av_interleaved_write_frame(s, pkt);
431
}
432

    
433
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
434

    
435
static void do_audio_out(AVFormatContext *s,
436
                         AVOutputStream *ost,
437
                         AVInputStream *ist,
438
                         unsigned char *buf, int size)
439
{
440
    uint8_t *buftmp;
441
    static uint8_t *audio_buf = NULL;
442
    static uint8_t *audio_out = NULL;
443
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
444

    
445
    int size_out, frame_bytes, ret;
446
    AVCodecContext *enc= ost->st->codec;
447

    
448
    /* SC: dynamic allocation of buffers */
449
    if (!audio_buf)
450
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
451
    if (!audio_out)
452
        audio_out = av_malloc(audio_out_size);
453
    if (!audio_buf || !audio_out)
454
        return;               /* Should signal an error ! */
455

    
456
    if(audio_sync_method){
457
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
458
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
459
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
460
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
461

    
462
        //FIXME resample delay
463
        if(fabs(delta) > 50){
464
            if(ist->is_start){
465
                if(byte_delta < 0){
466
                    byte_delta= FFMAX(byte_delta, -size);
467
                    size += byte_delta;
468
                    buf  -= byte_delta;
469
                    if(verbose > 2)
470
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
471
                    if(!size)
472
                        return;
473
                    ist->is_start=0;
474
                }else{
475
                    static uint8_t *input_tmp= NULL;
476
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
477

    
478
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
479
                        ist->is_start=0;
480
                    else
481
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
482

    
483
                    memset(input_tmp, 0, byte_delta);
484
                    memcpy(input_tmp + byte_delta, buf, size);
485
                    buf= input_tmp;
486
                    size += byte_delta;
487
                    if(verbose > 2)
488
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
489
                }
490
            }else if(audio_sync_method>1){
491
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
492
                assert(ost->audio_resample);
493
                if(verbose > 2)
494
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
495
//                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));
496
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
497
            }
498
        }
499
    }else
500
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
501
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
502

    
503
    if (ost->audio_resample) {
504
        buftmp = audio_buf;
505
        size_out = audio_resample(ost->resample,
506
                                  (short *)buftmp, (short *)buf,
507
                                  size / (ist->st->codec->channels * 2));
508
        size_out = size_out * enc->channels * 2;
509
    } else {
510
        buftmp = buf;
511
        size_out = size;
512
    }
513

    
514
    /* now encode as many frames as possible */
515
    if (enc->frame_size > 1) {
516
        /* output resampled raw samples */
517
        av_fifo_write(&ost->fifo, buftmp, size_out);
518

    
519
        frame_bytes = enc->frame_size * 2 * enc->channels;
520

    
521
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
522
            AVPacket pkt;
523
            av_init_packet(&pkt);
524

    
525
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
526
                                       (short *)audio_buf);
527
            audio_size += ret;
528
            pkt.stream_index= ost->index;
529
            pkt.data= audio_out;
530
            pkt.size= ret;
531
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
532
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
533
            pkt.flags |= PKT_FLAG_KEY;
534
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
535

    
536
            ost->sync_opts += enc->frame_size;
537
        }
538
    } else {
539
        AVPacket pkt;
540
        av_init_packet(&pkt);
541

    
542
        ost->sync_opts += size_out / (2 * enc->channels);
543

    
544
        /* output a pcm frame */
545
        /* XXX: change encoding codec API to avoid this ? */
546
        switch(enc->codec->id) {
547
        case CODEC_ID_PCM_S32LE:
548
        case CODEC_ID_PCM_S32BE:
549
        case CODEC_ID_PCM_U32LE:
550
        case CODEC_ID_PCM_U32BE:
551
            size_out = size_out << 1;
552
            break;
553
        case CODEC_ID_PCM_S24LE:
554
        case CODEC_ID_PCM_S24BE:
555
        case CODEC_ID_PCM_U24LE:
556
        case CODEC_ID_PCM_U24BE:
557
        case CODEC_ID_PCM_S24DAUD:
558
            size_out = size_out / 2 * 3;
559
            break;
560
        case CODEC_ID_PCM_S16LE:
561
        case CODEC_ID_PCM_S16BE:
562
        case CODEC_ID_PCM_U16LE:
563
        case CODEC_ID_PCM_U16BE:
564
            break;
565
        default:
566
            size_out = size_out >> 1;
567
            break;
568
        }
569
        ret = avcodec_encode_audio(enc, audio_out, size_out,
570
                                   (short *)buftmp);
571
        audio_size += ret;
572
        pkt.stream_index= ost->index;
573
        pkt.data= audio_out;
574
        pkt.size= ret;
575
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
576
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
577
        pkt.flags |= PKT_FLAG_KEY;
578
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
579
    }
580
}
581

    
582
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
583
{
584
    AVCodecContext *dec;
585
    AVPicture *picture2;
586
    AVPicture picture_tmp;
587
    uint8_t *buf = 0;
588

    
589
    dec = ist->st->codec;
590

    
591
    /* deinterlace : must be done before any resize */
592
    if (do_deinterlace || using_vhook) {
593
        int size;
594

    
595
        /* create temporary picture */
596
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
597
        buf = av_malloc(size);
598
        if (!buf)
599
            return;
600

    
601
        picture2 = &picture_tmp;
602
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
603

    
604
        if (do_deinterlace){
605
            if(avpicture_deinterlace(picture2, picture,
606
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
607
                /* if error, do not deinterlace */
608
                av_free(buf);
609
                buf = NULL;
610
                picture2 = picture;
611
            }
612
        } else {
613
            img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
614
        }
615
    } else {
616
        picture2 = picture;
617
    }
618

    
619
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
620

    
621
    if (picture != picture2)
622
        *picture = *picture2;
623
    *bufp = buf;
624
}
625

    
626
/* we begin to correct av delay at this threshold */
627
#define AV_DELAY_MAX 0.100
628

    
629
static void do_subtitle_out(AVFormatContext *s,
630
                            AVOutputStream *ost,
631
                            AVInputStream *ist,
632
                            AVSubtitle *sub,
633
                            int64_t pts)
634
{
635
    static uint8_t *subtitle_out = NULL;
636
    int subtitle_out_max_size = 65536;
637
    int subtitle_out_size, nb, i;
638
    AVCodecContext *enc;
639
    AVPacket pkt;
640

    
641
    if (pts == AV_NOPTS_VALUE) {
642
        fprintf(stderr, "Subtitle packets must have a pts\n");
643
        return;
644
    }
645

    
646
    enc = ost->st->codec;
647

    
648
    if (!subtitle_out) {
649
        subtitle_out = av_malloc(subtitle_out_max_size);
650
    }
651

    
652
    /* Note: DVB subtitle need one packet to draw them and one other
653
       packet to clear them */
654
    /* XXX: signal it in the codec context ? */
655
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
656
        nb = 2;
657
    else
658
        nb = 1;
659

    
660
    for(i = 0; i < nb; i++) {
661
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
662
                                                    subtitle_out_max_size, sub);
663

    
664
        av_init_packet(&pkt);
665
        pkt.stream_index = ost->index;
666
        pkt.data = subtitle_out;
667
        pkt.size = subtitle_out_size;
668
        pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
669
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
670
            /* XXX: the pts correction is handled here. Maybe handling
671
               it in the codec would be better */
672
            if (i == 0)
673
                pkt.pts += 90 * sub->start_display_time;
674
            else
675
                pkt.pts += 90 * sub->end_display_time;
676
        }
677
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
678
    }
679
}
680

    
681
static int bit_buffer_size= 1024*256;
682
static uint8_t *bit_buffer= NULL;
683

    
684
static void do_video_out(AVFormatContext *s,
685
                         AVOutputStream *ost,
686
                         AVInputStream *ist,
687
                         AVFrame *in_picture,
688
                         int *frame_size)
689
{
690
    int nb_frames, i, ret;
691
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
692
    AVFrame picture_crop_temp, picture_pad_temp;
693
    uint8_t *buf = NULL, *buf1 = NULL;
694
    AVCodecContext *enc, *dec;
695

    
696
    avcodec_get_frame_defaults(&picture_crop_temp);
697
    avcodec_get_frame_defaults(&picture_pad_temp);
698

    
699
    enc = ost->st->codec;
700
    dec = ist->st->codec;
701

    
702
    /* by default, we output a single frame */
703
    nb_frames = 1;
704

    
705
    *frame_size = 0;
706

    
707
    if(video_sync_method){
708
        double vdelta;
709
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
710
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
711
        if (vdelta < -1.1)
712
            nb_frames = 0;
713
        else if (vdelta > 1.1)
714
            nb_frames = lrintf(vdelta);
715
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
716
        if (nb_frames == 0){
717
            ++nb_frames_drop;
718
            if (verbose>2)
719
                fprintf(stderr, "*** drop!\n");
720
        }else if (nb_frames > 1) {
721
            nb_frames_dup += nb_frames;
722
            if (verbose>2)
723
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
724
        }
725
    }else
726
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
727

    
728
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
729
    if (nb_frames <= 0)
730
        return;
731

    
732
    if (ost->video_crop) {
733
        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
734
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
735
            goto the_end;
736
        }
737
        formatted_picture = &picture_crop_temp;
738
    } else {
739
        formatted_picture = in_picture;
740
    }
741

    
742
    final_picture = formatted_picture;
743
    padding_src = formatted_picture;
744
    resampling_dst = &ost->pict_tmp;
745
    if (ost->video_pad) {
746
        final_picture = &ost->pict_tmp;
747
        if (ost->video_resample) {
748
            if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
749
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
750
                goto the_end;
751
            }
752
            resampling_dst = &picture_pad_temp;
753
        }
754
    }
755

    
756
    if (ost->video_resample) {
757
        padding_src = NULL;
758
        final_picture = &ost->pict_tmp;
759
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
760
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
761
    }
762

    
763
    if (ost->video_pad) {
764
        img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
765
                enc->height, enc->width, enc->pix_fmt,
766
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
767
    }
768

    
769
    /* duplicates frame if needed */
770
    for(i=0;i<nb_frames;i++) {
771
        AVPacket pkt;
772
        av_init_packet(&pkt);
773
        pkt.stream_index= ost->index;
774

    
775
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
776
            /* raw pictures are written as AVPicture structure to
777
               avoid any copies. We support temorarily the older
778
               method. */
779
            AVFrame* old_frame = enc->coded_frame;
780
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
781
            pkt.data= (uint8_t *)final_picture;
782
            pkt.size=  sizeof(AVPicture);
783
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
784
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
785
            if(dec->coded_frame && dec->coded_frame->key_frame)
786
                pkt.flags |= PKT_FLAG_KEY;
787

    
788
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
789
            enc->coded_frame = old_frame;
790
        } else {
791
            AVFrame big_picture;
792

    
793
            big_picture= *final_picture;
794
            /* better than nothing: use input picture interlaced
795
               settings */
796
            big_picture.interlaced_frame = in_picture->interlaced_frame;
797
            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
798
                if(top_field_first == -1)
799
                    big_picture.top_field_first = in_picture->top_field_first;
800
                else
801
                    big_picture.top_field_first = top_field_first;
802
            }
803

    
804
            /* handles sameq here. This is not correct because it may
805
               not be a global option */
806
            if (same_quality) {
807
                big_picture.quality = ist->st->quality;
808
            }else
809
                big_picture.quality = ost->st->quality;
810
            if(!me_threshold)
811
                big_picture.pict_type = 0;
812
//            big_picture.pts = AV_NOPTS_VALUE;
813
            big_picture.pts= ost->sync_opts;
814
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
815
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
816
            ret = avcodec_encode_video(enc,
817
                                       bit_buffer, bit_buffer_size,
818
                                       &big_picture);
819
            if (ret == -1) {
820
                fprintf(stderr, "Video encoding failed\n");
821
                exit(1);
822
            }
823
            //enc->frame_number = enc->real_pict_num;
824
            if(ret>0){
825
                pkt.data= bit_buffer;
826
                pkt.size= ret;
827
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
828
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
829
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
830
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
831
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
832

    
833
                if(enc->coded_frame && enc->coded_frame->key_frame)
834
                    pkt.flags |= PKT_FLAG_KEY;
835
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
836
                *frame_size = ret;
837
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
838
                //        enc->frame_number-1, enc->real_pict_num, ret,
839
                //        enc->pict_type);
840
                /* if two pass, output log */
841
                if (ost->logfile && enc->stats_out) {
842
                    fprintf(ost->logfile, "%s", enc->stats_out);
843
                }
844
            }
845
        }
846
        ost->sync_opts++;
847
        ost->frame_number++;
848
    }
849
 the_end:
850
    av_free(buf);
851
    av_free(buf1);
852
}
853

    
854
static double psnr(double d){
855
    if(d==0) return INFINITY;
856
    return -10.0*log(d)/log(10.0);
857
}
858

    
859
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
860
                           int frame_size)
861
{
862
    static FILE *fvstats=NULL;
863
    char filename[40];
864
    time_t today2;
865
    struct tm *today;
866
    AVCodecContext *enc;
867
    int frame_number;
868
    int64_t ti;
869
    double ti1, bitrate, avg_bitrate;
870

    
871
    if (!fvstats) {
872
        today2 = time(NULL);
873
        today = localtime(&today2);
874
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
875
                                               today->tm_min,
876
                                               today->tm_sec);
877
        fvstats = fopen(filename,"w");
878
        if (!fvstats) {
879
            perror("fopen");
880
            exit(1);
881
        }
882
    }
883

    
884
    ti = INT64_MAX;
885
    enc = ost->st->codec;
886
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
887
        frame_number = ost->frame_number;
888
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
889
        if (enc->flags&CODEC_FLAG_PSNR)
890
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
891

    
892
        fprintf(fvstats,"f_size= %6d ", frame_size);
893
        /* compute pts value */
894
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
895
        if (ti1 < 0.01)
896
            ti1 = 0.01;
897

    
898
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
899
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
900
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
901
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
902
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
903
    }
904
}
905

    
906
static void print_report(AVFormatContext **output_files,
907
                         AVOutputStream **ost_table, int nb_ostreams,
908
                         int is_last_report)
909
{
910
    char buf[1024];
911
    AVOutputStream *ost;
912
    AVFormatContext *oc, *os;
913
    int64_t total_size;
914
    AVCodecContext *enc;
915
    int frame_number, vid, i;
916
    double bitrate, ti1, pts;
917
    static int64_t last_time = -1;
918
    static int qp_histogram[52];
919

    
920
    if (!is_last_report) {
921
        int64_t cur_time;
922
        /* display the report every 0.5 seconds */
923
        cur_time = av_gettime();
924
        if (last_time == -1) {
925
            last_time = cur_time;
926
            return;
927
        }
928
        if ((cur_time - last_time) < 500000)
929
            return;
930
        last_time = cur_time;
931
    }
932

    
933

    
934
    oc = output_files[0];
935

    
936
    total_size = url_ftell(&oc->pb);
937

    
938
    buf[0] = '\0';
939
    ti1 = 1e10;
940
    vid = 0;
941
    for(i=0;i<nb_ostreams;i++) {
942
        ost = ost_table[i];
943
        os = output_files[ost->file_index];
944
        enc = ost->st->codec;
945
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
946
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
947
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
948
        }
949
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
950
            frame_number = ost->frame_number;
951
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
952
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
953
            if(is_last_report)
954
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
955
            if(qp_hist && enc->coded_frame){
956
                int j;
957
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
958
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
959
                    qp_histogram[qp]++;
960
                for(j=0; j<32; j++)
961
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
962
            }
963
            if (enc->flags&CODEC_FLAG_PSNR){
964
                int j;
965
                double error, error_sum=0;
966
                double scale, scale_sum=0;
967
                char type[3]= {'Y','U','V'};
968
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
969
                for(j=0; j<3; j++){
970
                    if(is_last_report){
971
                        error= enc->error[j];
972
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
973
                    }else{
974
                        error= enc->coded_frame->error[j];
975
                        scale= enc->width*enc->height*255.0*255.0;
976
                    }
977
                    if(j) scale/=4;
978
                    error_sum += error;
979
                    scale_sum += scale;
980
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
981
                }
982
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
983
            }
984
            vid = 1;
985
        }
986
        /* compute min output value */
987
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
988
        if ((pts < ti1) && (pts > 0))
989
            ti1 = pts;
990
    }
991
    if (ti1 < 0.01)
992
        ti1 = 0.01;
993

    
994
    if (verbose || is_last_report) {
995
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
996

    
997
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
998
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
999
            (double)total_size / 1024, ti1, bitrate);
1000

    
1001
        if (verbose > 1)
1002
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1003
                  nb_frames_dup, nb_frames_drop);
1004

    
1005
        if (verbose >= 0)
1006
            fprintf(stderr, "%s    \r", buf);
1007

    
1008
        fflush(stderr);
1009
    }
1010

    
1011
    if (is_last_report && verbose >= 0){
1012
        int64_t raw= audio_size + video_size + extra_size;
1013
        fprintf(stderr, "\n");
1014
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1015
                video_size/1024.0,
1016
                audio_size/1024.0,
1017
                extra_size/1024.0,
1018
                100.0*(total_size - raw)/raw
1019
        );
1020
    }
1021
}
1022

    
1023
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1024
static int output_packet(AVInputStream *ist, int ist_index,
1025
                         AVOutputStream **ost_table, int nb_ostreams,
1026
                         const AVPacket *pkt)
1027
{
1028
    AVFormatContext *os;
1029
    AVOutputStream *ost;
1030
    uint8_t *ptr;
1031
    int len, ret, i;
1032
    uint8_t *data_buf;
1033
    int data_size, got_picture;
1034
    AVFrame picture;
1035
    void *buffer_to_free;
1036
    static unsigned int samples_size= 0;
1037
    static short *samples= NULL;
1038
    AVSubtitle subtitle, *subtitle_to_free;
1039
    int got_subtitle;
1040

    
1041
    if(!pkt){
1042
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1043
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1044
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1045
    } else {
1046
//        assert(ist->pts == ist->next_pts);
1047
    }
1048

    
1049
    if (pkt == NULL) {
1050
        /* EOF handling */
1051
        ptr = NULL;
1052
        len = 0;
1053
        goto handle_eof;
1054
    }
1055

    
1056
    len = pkt->size;
1057
    ptr = pkt->data;
1058
    while (len > 0) {
1059
    handle_eof:
1060
        /* decode the packet if needed */
1061
        data_buf = NULL; /* fail safe */
1062
        data_size = 0;
1063
        subtitle_to_free = NULL;
1064
        if (ist->decoding_needed) {
1065
            switch(ist->st->codec->codec_type) {
1066
            case CODEC_TYPE_AUDIO:{
1067
                if(pkt)
1068
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1069
                    /* XXX: could avoid copy if PCM 16 bits with same
1070
                       endianness as CPU */
1071
                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1072
                                           ptr, len);
1073
                if (ret < 0)
1074
                    goto fail_decode;
1075
                ptr += ret;
1076
                len -= ret;
1077
                /* Some bug in mpeg audio decoder gives */
1078
                /* data_size < 0, it seems they are overflows */
1079
                if (data_size <= 0) {
1080
                    /* no audio frame */
1081
                    continue;
1082
                }
1083
                data_buf = (uint8_t *)samples;
1084
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1085
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1086
                break;}
1087
            case CODEC_TYPE_VIDEO:
1088
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1089
                    /* XXX: allocate picture correctly */
1090
                    avcodec_get_frame_defaults(&picture);
1091

    
1092
                    ret = avcodec_decode_video(ist->st->codec,
1093
                                               &picture, &got_picture, ptr, len);
1094
                    ist->st->quality= picture.quality;
1095
                    if (ret < 0)
1096
                        goto fail_decode;
1097
                    if (!got_picture) {
1098
                        /* no picture yet */
1099
                        goto discard_packet;
1100
                    }
1101
                    if (ist->st->codec->time_base.num != 0) {
1102
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1103
                                          ist->st->codec->time_base.num) /
1104
                            ist->st->codec->time_base.den;
1105
                    }
1106
                    len = 0;
1107
                    break;
1108
            case CODEC_TYPE_SUBTITLE:
1109
                ret = avcodec_decode_subtitle(ist->st->codec,
1110
                                              &subtitle, &got_subtitle, ptr, len);
1111
                if (ret < 0)
1112
                    goto fail_decode;
1113
                if (!got_subtitle) {
1114
                    goto discard_packet;
1115
                }
1116
                subtitle_to_free = &subtitle;
1117
                len = 0;
1118
                break;
1119
            default:
1120
                goto fail_decode;
1121
            }
1122
        } else {
1123
                switch(ist->st->codec->codec_type) {
1124
                case CODEC_TYPE_AUDIO:
1125
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1126
                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1127
                    break;
1128
                case CODEC_TYPE_VIDEO:
1129
                    if (ist->st->codec->time_base.num != 0) {
1130
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1131
                                          ist->st->codec->time_base.num) /
1132
                            ist->st->codec->time_base.den;
1133
                    }
1134
                    break;
1135
                }
1136
                data_buf = ptr;
1137
                data_size = len;
1138
                ret = len;
1139
                len = 0;
1140
            }
1141

    
1142
            buffer_to_free = NULL;
1143
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1144
                pre_process_video_frame(ist, (AVPicture *)&picture,
1145
                                        &buffer_to_free);
1146
            }
1147

    
1148
            // preprocess audio (volume)
1149
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1150
                if (audio_volume != 256) {
1151
                    short *volp;
1152
                    volp = samples;
1153
                    for(i=0;i<(data_size / sizeof(short));i++) {
1154
                        int v = ((*volp) * audio_volume + 128) >> 8;
1155
                        if (v < -32768) v = -32768;
1156
                        if (v >  32767) v = 32767;
1157
                        *volp++ = v;
1158
                    }
1159
                }
1160
            }
1161

    
1162
            /* frame rate emulation */
1163
            if (ist->st->codec->rate_emu) {
1164
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1165
                int64_t now = av_gettime() - ist->start;
1166
                if (pts > now)
1167
                    usleep(pts - now);
1168

    
1169
                ist->frame++;
1170
            }
1171

    
1172
#if 0
1173
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1174
               is the one of the next displayed one */
1175
            /* XXX: add mpeg4 too ? */
1176
            if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1177
                if (ist->st->codec->pict_type != B_TYPE) {
1178
                    int64_t tmp;
1179
                    tmp = ist->last_ip_pts;
1180
                    ist->last_ip_pts  = ist->frac_pts.val;
1181
                    ist->frac_pts.val = tmp;
1182
                }
1183
            }
1184
#endif
1185
            /* if output time reached then transcode raw format,
1186
               encode packets and output them */
1187
            if (start_time == 0 || ist->pts >= start_time)
1188
                for(i=0;i<nb_ostreams;i++) {
1189
                    int frame_size;
1190

    
1191
                    ost = ost_table[i];
1192
                    if (ost->source_index == ist_index) {
1193
                        os = output_files[ost->file_index];
1194

    
1195
#if 0
1196
                        printf("%d: got pts=%0.3f %0.3f\n", i,
1197
                               (double)pkt->pts / AV_TIME_BASE,
1198
                               ((double)ist->pts / AV_TIME_BASE) -
1199
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1200
#endif
1201
                        /* set the input output pts pairs */
1202
                        //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1203

    
1204
                        if (ost->encoding_needed) {
1205
                            switch(ost->st->codec->codec_type) {
1206
                            case CODEC_TYPE_AUDIO:
1207
                                do_audio_out(os, ost, ist, data_buf, data_size);
1208
                                break;
1209
                            case CODEC_TYPE_VIDEO:
1210
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1211
                                    video_size += frame_size;
1212
                                    if (do_vstats && frame_size)
1213
                                        do_video_stats(os, ost, frame_size);
1214
                                break;
1215
                            case CODEC_TYPE_SUBTITLE:
1216
                                do_subtitle_out(os, ost, ist, &subtitle,
1217
                                                pkt->pts);
1218
                                break;
1219
                            default:
1220
                                av_abort();
1221
                            }
1222
                        } else {
1223
                            AVFrame avframe; //FIXME/XXX remove this
1224
                            AVPacket opkt;
1225
                            av_init_packet(&opkt);
1226

    
1227
                            /* no reencoding needed : output the packet directly */
1228
                            /* force the input stream PTS */
1229

    
1230
                            avcodec_get_frame_defaults(&avframe);
1231
                            ost->st->codec->coded_frame= &avframe;
1232
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1233

    
1234
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1235
                                audio_size += data_size;
1236
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1237
                                video_size += data_size;
1238
                                ost->sync_opts++;
1239
                            }
1240

    
1241
                            opkt.stream_index= ost->index;
1242
                            if(pkt->pts != AV_NOPTS_VALUE)
1243
                                opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1244
                            else
1245
                                opkt.pts= AV_NOPTS_VALUE;
1246

    
1247
                            {
1248
                                int64_t dts;
1249
                                if (pkt->dts == AV_NOPTS_VALUE)
1250
                                    dts = ist->next_pts;
1251
                                else
1252
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1253
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1254
                            }
1255
                            opkt.flags= pkt->flags;
1256

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

    
1261
                            write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1262
                            ost->st->codec->frame_number++;
1263
                            ost->frame_number++;
1264
                            av_free_packet(&opkt);
1265
                        }
1266
                    }
1267
                }
1268
            av_free(buffer_to_free);
1269
            /* XXX: allocate the subtitles in the codec ? */
1270
            if (subtitle_to_free) {
1271
                if (subtitle_to_free->rects != NULL) {
1272
                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
1273
                        av_free(subtitle_to_free->rects[i].bitmap);
1274
                        av_free(subtitle_to_free->rects[i].rgba_palette);
1275
                    }
1276
                    av_freep(&subtitle_to_free->rects);
1277
                }
1278
                subtitle_to_free->num_rects = 0;
1279
                subtitle_to_free = NULL;
1280
            }
1281
        }
1282
 discard_packet:
1283
    if (pkt == NULL) {
1284
        /* EOF handling */
1285

    
1286
        for(i=0;i<nb_ostreams;i++) {
1287
            ost = ost_table[i];
1288
            if (ost->source_index == ist_index) {
1289
                AVCodecContext *enc= ost->st->codec;
1290
                os = output_files[ost->file_index];
1291

    
1292
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1293
                    continue;
1294
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1295
                    continue;
1296

    
1297
                if (ost->encoding_needed) {
1298
                    for(;;) {
1299
                        AVPacket pkt;
1300
                        int fifo_bytes;
1301
                        av_init_packet(&pkt);
1302
                        pkt.stream_index= ost->index;
1303

    
1304
                        switch(ost->st->codec->codec_type) {
1305
                        case CODEC_TYPE_AUDIO:
1306
                            fifo_bytes = av_fifo_size(&ost->fifo);
1307
                            ret = 0;
1308
                            /* encode any samples remaining in fifo */
1309
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1310
                                int fs_tmp = enc->frame_size;
1311
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1312
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1313
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1314
                                }
1315
                                enc->frame_size = fs_tmp;
1316
                            }
1317
                            if(ret <= 0) {
1318
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1319
                            }
1320
                            audio_size += ret;
1321
                            pkt.flags |= PKT_FLAG_KEY;
1322
                            break;
1323
                        case CODEC_TYPE_VIDEO:
1324
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1325
                            video_size += ret;
1326
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1327
                                pkt.flags |= PKT_FLAG_KEY;
1328
                            if (ost->logfile && enc->stats_out) {
1329
                                fprintf(ost->logfile, "%s", enc->stats_out);
1330
                            }
1331
                            break;
1332
                        default:
1333
                            ret=-1;
1334
                        }
1335

    
1336
                        if(ret<=0)
1337
                            break;
1338
                        pkt.data= bit_buffer;
1339
                        pkt.size= ret;
1340
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1341
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1342
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1343
                    }
1344
                }
1345
            }
1346
        }
1347
    }
1348

    
1349
    return 0;
1350
 fail_decode:
1351
    return -1;
1352
}
1353

    
1354

    
1355
/*
1356
 * The following code is the main loop of the file converter
1357
 */
1358
static int av_encode(AVFormatContext **output_files,
1359
                     int nb_output_files,
1360
                     AVFormatContext **input_files,
1361
                     int nb_input_files,
1362
                     AVStreamMap *stream_maps, int nb_stream_maps)
1363
{
1364
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1365
    AVFormatContext *is, *os;
1366
    AVCodecContext *codec, *icodec;
1367
    AVOutputStream *ost, **ost_table = NULL;
1368
    AVInputStream *ist, **ist_table = NULL;
1369
    AVInputFile *file_table;
1370
    AVFormatContext *stream_no_data;
1371
    int key;
1372

    
1373
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1374
    if (!file_table)
1375
        goto fail;
1376

    
1377
    /* input stream init */
1378
    j = 0;
1379
    for(i=0;i<nb_input_files;i++) {
1380
        is = input_files[i];
1381
        file_table[i].ist_index = j;
1382
        file_table[i].nb_streams = is->nb_streams;
1383
        j += is->nb_streams;
1384
    }
1385
    nb_istreams = j;
1386

    
1387
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1388
    if (!ist_table)
1389
        goto fail;
1390

    
1391
    for(i=0;i<nb_istreams;i++) {
1392
        ist = av_mallocz(sizeof(AVInputStream));
1393
        if (!ist)
1394
            goto fail;
1395
        ist_table[i] = ist;
1396
    }
1397
    j = 0;
1398
    for(i=0;i<nb_input_files;i++) {
1399
        is = input_files[i];
1400
        for(k=0;k<is->nb_streams;k++) {
1401
            ist = ist_table[j++];
1402
            ist->st = is->streams[k];
1403
            ist->file_index = i;
1404
            ist->index = k;
1405
            ist->discard = 1; /* the stream is discarded by default
1406
                                 (changed later) */
1407

    
1408
            if (ist->st->codec->rate_emu) {
1409
                ist->start = av_gettime();
1410
                ist->frame = 0;
1411
            }
1412
        }
1413
    }
1414

    
1415
    /* output stream init */
1416
    nb_ostreams = 0;
1417
    for(i=0;i<nb_output_files;i++) {
1418
        os = output_files[i];
1419
        if (!os->nb_streams) {
1420
            fprintf(stderr, "Output file does not contain any stream\n");
1421
            exit(1);
1422
        }
1423
        nb_ostreams += os->nb_streams;
1424
    }
1425
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1426
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1427
        exit(1);
1428
    }
1429

    
1430
    /* Sanity check the mapping args -- do the input files & streams exist? */
1431
    for(i=0;i<nb_stream_maps;i++) {
1432
        int fi = stream_maps[i].file_index;
1433
        int si = stream_maps[i].stream_index;
1434

    
1435
        if (fi < 0 || fi > nb_input_files - 1 ||
1436
            si < 0 || si > file_table[fi].nb_streams - 1) {
1437
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1438
            exit(1);
1439
        }
1440
        fi = stream_maps[i].sync_file_index;
1441
        si = stream_maps[i].sync_stream_index;
1442
        if (fi < 0 || fi > nb_input_files - 1 ||
1443
            si < 0 || si > file_table[fi].nb_streams - 1) {
1444
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1445
            exit(1);
1446
        }
1447
    }
1448

    
1449
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1450
    if (!ost_table)
1451
        goto fail;
1452
    for(i=0;i<nb_ostreams;i++) {
1453
        ost = av_mallocz(sizeof(AVOutputStream));
1454
        if (!ost)
1455
            goto fail;
1456
        ost_table[i] = ost;
1457
    }
1458

    
1459
    n = 0;
1460
    for(k=0;k<nb_output_files;k++) {
1461
        os = output_files[k];
1462
        for(i=0;i<os->nb_streams;i++) {
1463
            int found;
1464
            ost = ost_table[n++];
1465
            ost->file_index = k;
1466
            ost->index = i;
1467
            ost->st = os->streams[i];
1468
            if (nb_stream_maps > 0) {
1469
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1470
                    stream_maps[n-1].stream_index;
1471

    
1472
                /* Sanity check that the stream types match */
1473
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1474
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1475
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1476
                        ost->file_index, ost->index);
1477
                    exit(1);
1478
                }
1479

    
1480
            } else {
1481
                /* get corresponding input stream index : we select the first one with the right type */
1482
                found = 0;
1483
                for(j=0;j<nb_istreams;j++) {
1484
                    ist = ist_table[j];
1485
                    if (ist->discard &&
1486
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1487
                        ost->source_index = j;
1488
                        found = 1;
1489
                        break;
1490
                    }
1491
                }
1492

    
1493
                if (!found) {
1494
                    /* try again and reuse existing stream */
1495
                    for(j=0;j<nb_istreams;j++) {
1496
                        ist = ist_table[j];
1497
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1498
                            ost->source_index = j;
1499
                            found = 1;
1500
                        }
1501
                    }
1502
                    if (!found) {
1503
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1504
                                ost->file_index, ost->index);
1505
                        exit(1);
1506
                    }
1507
                }
1508
            }
1509
            ist = ist_table[ost->source_index];
1510
            ist->discard = 0;
1511
            ost->sync_ist = (nb_stream_maps > 0) ?
1512
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1513
                         stream_maps[n-1].sync_stream_index] : ist;
1514
        }
1515
    }
1516

    
1517
    /* for each output stream, we compute the right encoding parameters */
1518
    for(i=0;i<nb_ostreams;i++) {
1519
        ost = ost_table[i];
1520
        ist = ist_table[ost->source_index];
1521

    
1522
        codec = ost->st->codec;
1523
        icodec = ist->st->codec;
1524

    
1525
        if (ost->st->stream_copy) {
1526
            /* if stream_copy is selected, no need to decode or encode */
1527
            codec->codec_id = icodec->codec_id;
1528
            codec->codec_type = icodec->codec_type;
1529
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1530
            codec->bit_rate = icodec->bit_rate;
1531
            codec->extradata= icodec->extradata;
1532
            codec->extradata_size= icodec->extradata_size;
1533
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1534
                codec->time_base = icodec->time_base;
1535
            else
1536
                codec->time_base = ist->st->time_base;
1537
            switch(codec->codec_type) {
1538
            case CODEC_TYPE_AUDIO:
1539
                codec->sample_rate = icodec->sample_rate;
1540
                codec->channels = icodec->channels;
1541
                codec->frame_size = icodec->frame_size;
1542
                codec->block_align= icodec->block_align;
1543
                break;
1544
            case CODEC_TYPE_VIDEO:
1545
                codec->pix_fmt = icodec->pix_fmt;
1546
                codec->width = icodec->width;
1547
                codec->height = icodec->height;
1548
                codec->has_b_frames = icodec->has_b_frames;
1549
                break;
1550
            case CODEC_TYPE_SUBTITLE:
1551
                break;
1552
            default:
1553
                av_abort();
1554
            }
1555
        } else {
1556
            switch(codec->codec_type) {
1557
            case CODEC_TYPE_AUDIO:
1558
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1559
                    goto fail;
1560

    
1561
                if (codec->channels == icodec->channels &&
1562
                    codec->sample_rate == icodec->sample_rate) {
1563
                    ost->audio_resample = 0;
1564
                } else {
1565
                    if (codec->channels != icodec->channels &&
1566
                        (icodec->codec_id == CODEC_ID_AC3 ||
1567
                         icodec->codec_id == CODEC_ID_DTS)) {
1568
                        /* Special case for 5:1 AC3 and DTS input */
1569
                        /* and mono or stereo output      */
1570
                        /* Request specific number of channels */
1571
                        icodec->channels = codec->channels;
1572
                        if (codec->sample_rate == icodec->sample_rate)
1573
                            ost->audio_resample = 0;
1574
                        else {
1575
                            ost->audio_resample = 1;
1576
                        }
1577
                    } else {
1578
                        ost->audio_resample = 1;
1579
                    }
1580
                }
1581
                if(audio_sync_method>1)
1582
                    ost->audio_resample = 1;
1583

    
1584
                if(ost->audio_resample){
1585
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1586
                                                    codec->sample_rate, icodec->sample_rate);
1587
                    if(!ost->resample){
1588
                        printf("Can't resample.  Aborting.\n");
1589
                        av_abort();
1590
                    }
1591
                }
1592
                ist->decoding_needed = 1;
1593
                ost->encoding_needed = 1;
1594
                break;
1595
            case CODEC_TYPE_VIDEO:
1596
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1597
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1598
                ost->video_resample = ((codec->width != icodec->width -
1599
                                (frame_leftBand + frame_rightBand) +
1600
                                (frame_padleft + frame_padright)) ||
1601
                        (codec->height != icodec->height -
1602
                                (frame_topBand  + frame_bottomBand) +
1603
                                (frame_padtop + frame_padbottom)) ||
1604
                        (codec->pix_fmt != icodec->pix_fmt));
1605
                if (ost->video_crop) {
1606
                    ost->topBand = frame_topBand;
1607
                    ost->leftBand = frame_leftBand;
1608
                }
1609
                if (ost->video_pad) {
1610
                    ost->padtop = frame_padtop;
1611
                    ost->padleft = frame_padleft;
1612
                    ost->padbottom = frame_padbottom;
1613
                    ost->padright = frame_padright;
1614
                    if (!ost->video_resample) {
1615
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1616
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1617
                                         codec->width, codec->height ) )
1618
                            goto fail;
1619
                    }
1620
                }
1621
                if (ost->video_resample) {
1622
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1623
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1624
                                         codec->width, codec->height ) )
1625
                        goto fail;
1626

    
1627
                    ost->img_resample_ctx = sws_getContext(
1628
                            icodec->width - (frame_leftBand + frame_rightBand),
1629
                            icodec->height - (frame_topBand + frame_bottomBand),
1630
                            icodec->pix_fmt,
1631
                            codec->width - (frame_padleft + frame_padright),
1632
                            codec->height - (frame_padtop + frame_padbottom),
1633
                            codec->pix_fmt,
1634
                            sws_flags, NULL, NULL, NULL);
1635
                    if (ost->img_resample_ctx == NULL) {
1636
                        fprintf(stderr, "Cannot get resampling context\n");
1637
                        exit(1);
1638
                    }
1639
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1640
                }
1641
                ost->encoding_needed = 1;
1642
                ist->decoding_needed = 1;
1643
                break;
1644
            case CODEC_TYPE_SUBTITLE:
1645
                ost->encoding_needed = 1;
1646
                ist->decoding_needed = 1;
1647
                break;
1648
            default:
1649
                av_abort();
1650
                break;
1651
            }
1652
            /* two pass mode */
1653
            if (ost->encoding_needed &&
1654
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1655
                char logfilename[1024];
1656
                FILE *f;
1657
                int size;
1658
                char *logbuffer;
1659

    
1660
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1661
                         pass_logfilename ?
1662
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1663
                if (codec->flags & CODEC_FLAG_PASS1) {
1664
                    f = fopen(logfilename, "w");
1665
                    if (!f) {
1666
                        perror(logfilename);
1667
                        exit(1);
1668
                    }
1669
                    ost->logfile = f;
1670
                } else {
1671
                    /* read the log file */
1672
                    f = fopen(logfilename, "r");
1673
                    if (!f) {
1674
                        perror(logfilename);
1675
                        exit(1);
1676
                    }
1677
                    fseek(f, 0, SEEK_END);
1678
                    size = ftell(f);
1679
                    fseek(f, 0, SEEK_SET);
1680
                    logbuffer = av_malloc(size + 1);
1681
                    if (!logbuffer) {
1682
                        fprintf(stderr, "Could not allocate log buffer\n");
1683
                        exit(1);
1684
                    }
1685
                    size = fread(logbuffer, 1, size, f);
1686
                    fclose(f);
1687
                    logbuffer[size] = '\0';
1688
                    codec->stats_in = logbuffer;
1689
                }
1690
            }
1691
        }
1692
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1693
            int size= codec->width * codec->height;
1694
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1695
        }
1696
    }
1697

    
1698
    if (!bit_buffer)
1699
        bit_buffer = av_malloc(bit_buffer_size);
1700
    if (!bit_buffer)
1701
        goto fail;
1702

    
1703
    /* dump the file output parameters - cannot be done before in case
1704
       of stream copy */
1705
    for(i=0;i<nb_output_files;i++) {
1706
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1707
    }
1708

    
1709
    /* dump the stream mapping */
1710
    if (verbose >= 0) {
1711
        fprintf(stderr, "Stream mapping:\n");
1712
        for(i=0;i<nb_ostreams;i++) {
1713
            ost = ost_table[i];
1714
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1715
                    ist_table[ost->source_index]->file_index,
1716
                    ist_table[ost->source_index]->index,
1717
                    ost->file_index,
1718
                    ost->index);
1719
            if (ost->sync_ist != ist_table[ost->source_index])
1720
                fprintf(stderr, " [sync #%d.%d]",
1721
                        ost->sync_ist->file_index,
1722
                        ost->sync_ist->index);
1723
            fprintf(stderr, "\n");
1724
        }
1725
    }
1726

    
1727
    /* open each encoder */
1728
    for(i=0;i<nb_ostreams;i++) {
1729
        ost = ost_table[i];
1730
        if (ost->encoding_needed) {
1731
            AVCodec *codec;
1732
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1733
            if (!codec) {
1734
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1735
                        ost->file_index, ost->index);
1736
                exit(1);
1737
            }
1738
            if (avcodec_open(ost->st->codec, codec) < 0) {
1739
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1740
                        ost->file_index, ost->index);
1741
                exit(1);
1742
            }
1743
            extra_size += ost->st->codec->extradata_size;
1744
        }
1745
    }
1746

    
1747
    /* open each decoder */
1748
    for(i=0;i<nb_istreams;i++) {
1749
        ist = ist_table[i];
1750
        if (ist->decoding_needed) {
1751
            AVCodec *codec;
1752
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1753
            if (!codec) {
1754
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1755
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1756
                exit(1);
1757
            }
1758
            if (avcodec_open(ist->st->codec, codec) < 0) {
1759
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1760
                        ist->file_index, ist->index);
1761
                exit(1);
1762
            }
1763
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1764
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1765
        }
1766
    }
1767

    
1768
    /* init pts */
1769
    for(i=0;i<nb_istreams;i++) {
1770
        ist = ist_table[i];
1771
        is = input_files[ist->file_index];
1772
        ist->pts = 0;
1773
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1774
        if(ist->st->start_time == AV_NOPTS_VALUE)
1775
            ist->next_pts=0;
1776
        if(input_files_ts_offset[ist->file_index])
1777
            ist->next_pts= AV_NOPTS_VALUE;
1778
        ist->is_start = 1;
1779
    }
1780

    
1781
    /* compute buffer size max (should use a complete heuristic) */
1782
    for(i=0;i<nb_input_files;i++) {
1783
        file_table[i].buffer_size_max = 2048;
1784
    }
1785

    
1786
    /* set meta data information from input file if required */
1787
    for (i=0;i<nb_meta_data_maps;i++) {
1788
        AVFormatContext *out_file;
1789
        AVFormatContext *in_file;
1790

    
1791
        int out_file_index = meta_data_maps[i].out_file;
1792
        int in_file_index = meta_data_maps[i].in_file;
1793
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1794
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1795
            ret = -EINVAL;
1796
            goto fail;
1797
        }
1798
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1799
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1800
            ret = -EINVAL;
1801
            goto fail;
1802
        }
1803

    
1804
        out_file = output_files[out_file_index];
1805
        in_file = input_files[in_file_index];
1806

    
1807
        strcpy(out_file->title, in_file->title);
1808
        strcpy(out_file->author, in_file->author);
1809
        strcpy(out_file->copyright, in_file->copyright);
1810
        strcpy(out_file->comment, in_file->comment);
1811
        strcpy(out_file->album, in_file->album);
1812
        out_file->year = in_file->year;
1813
        out_file->track = in_file->track;
1814
        strcpy(out_file->genre, in_file->genre);
1815
    }
1816

    
1817
    /* open files and write file headers */
1818
    for(i=0;i<nb_output_files;i++) {
1819
        os = output_files[i];
1820
        if (av_write_header(os) < 0) {
1821
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1822
            ret = -EINVAL;
1823
            goto fail;
1824
        }
1825
    }
1826

    
1827
    if ( !using_stdin && verbose >= 0) {
1828
        fprintf(stderr, "Press [q] to stop encoding\n");
1829
        url_set_interrupt_cb(decode_interrupt_cb);
1830
    }
1831
    term_init();
1832

    
1833
    stream_no_data = 0;
1834
    key = -1;
1835

    
1836
    for(; received_sigterm == 0;) {
1837
        int file_index, ist_index;
1838
        AVPacket pkt;
1839
        double ipts_min;
1840
        double opts_min;
1841

    
1842
    redo:
1843
        ipts_min= 1e100;
1844
        opts_min= 1e100;
1845
        /* if 'q' pressed, exits */
1846
        if (!using_stdin) {
1847
            if (q_pressed)
1848
                break;
1849
            /* read_key() returns 0 on EOF */
1850
            key = read_key();
1851
            if (key == 'q')
1852
                break;
1853
        }
1854

    
1855
        /* select the stream that we must read now by looking at the
1856
           smallest output pts */
1857
        file_index = -1;
1858
        for(i=0;i<nb_ostreams;i++) {
1859
            double ipts, opts;
1860
            ost = ost_table[i];
1861
            os = output_files[ost->file_index];
1862
            ist = ist_table[ost->source_index];
1863
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1864
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1865
            else
1866
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1867
            ipts = (double)ist->pts;
1868
            if (!file_table[ist->file_index].eof_reached){
1869
                if(ipts < ipts_min) {
1870
                    ipts_min = ipts;
1871
                    if(input_sync ) file_index = ist->file_index;
1872
                }
1873
                if(opts < opts_min) {
1874
                    opts_min = opts;
1875
                    if(!input_sync) file_index = ist->file_index;
1876
                }
1877
            }
1878
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1879
                file_index= -1;
1880
                break;
1881
            }
1882
        }
1883
        /* if none, if is finished */
1884
        if (file_index < 0) {
1885
            break;
1886
        }
1887

    
1888
        /* finish if recording time exhausted */
1889
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1890
            break;
1891

    
1892
        /* finish if limit size exhausted */
1893
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1894
            break;
1895

    
1896
        /* read a frame from it and output it in the fifo */
1897
        is = input_files[file_index];
1898
        if (av_read_frame(is, &pkt) < 0) {
1899
            file_table[file_index].eof_reached = 1;
1900
            if (opt_shortest) break; else continue; //
1901
        }
1902

    
1903
        if (!pkt.size) {
1904
            stream_no_data = is;
1905
        } else {
1906
            stream_no_data = 0;
1907
        }
1908
        if (do_pkt_dump) {
1909
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1910
        }
1911
        /* the following test is needed in case new streams appear
1912
           dynamically in stream : we ignore them */
1913
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1914
            goto discard_packet;
1915
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1916
        ist = ist_table[ist_index];
1917
        if (ist->discard)
1918
            goto discard_packet;
1919

    
1920
//        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);
1921
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1922
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1923
            if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1924
                input_files_ts_offset[ist->file_index]-= delta;
1925
                if (verbose > 2)
1926
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1927
                for(i=0; i<file_table[file_index].nb_streams; i++){
1928
                    int index= file_table[file_index].ist_index + i;
1929
                    ist_table[index]->next_pts += delta;
1930
                    ist_table[index]->is_start=1;
1931
                }
1932
            }
1933
        }
1934

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

    
1938
            if (verbose >= 0)
1939
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1940
                        ist->file_index, ist->index);
1941

    
1942
            av_free_packet(&pkt);
1943
            goto redo;
1944
        }
1945

    
1946
    discard_packet:
1947
        av_free_packet(&pkt);
1948

    
1949
        /* dump report by using the output first video and audio streams */
1950
        print_report(output_files, ost_table, nb_ostreams, 0);
1951
    }
1952

    
1953
    /* at the end of stream, we must flush the decoder buffers */
1954
    for(i=0;i<nb_istreams;i++) {
1955
        ist = ist_table[i];
1956
        if (ist->decoding_needed) {
1957
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1958
        }
1959
    }
1960

    
1961
    term_exit();
1962

    
1963
    /* write the trailer if needed and close file */
1964
    for(i=0;i<nb_output_files;i++) {
1965
        os = output_files[i];
1966
        av_write_trailer(os);
1967
    }
1968

    
1969
    /* dump report by using the first video and audio streams */
1970
    print_report(output_files, ost_table, nb_ostreams, 1);
1971

    
1972
    /* close each encoder */
1973
    for(i=0;i<nb_ostreams;i++) {
1974
        ost = ost_table[i];
1975
        if (ost->encoding_needed) {
1976
            av_freep(&ost->st->codec->stats_in);
1977
            avcodec_close(ost->st->codec);
1978
        }
1979
    }
1980

    
1981
    /* close each decoder */
1982
    for(i=0;i<nb_istreams;i++) {
1983
        ist = ist_table[i];
1984
        if (ist->decoding_needed) {
1985
            avcodec_close(ist->st->codec);
1986
        }
1987
    }
1988

    
1989
    /* finished ! */
1990

    
1991
    ret = 0;
1992
 fail1:
1993
    av_freep(&bit_buffer);
1994
    av_free(file_table);
1995

    
1996
    if (ist_table) {
1997
        for(i=0;i<nb_istreams;i++) {
1998
            ist = ist_table[i];
1999
            av_free(ist);
2000
        }
2001
        av_free(ist_table);
2002
    }
2003
    if (ost_table) {
2004
        for(i=0;i<nb_ostreams;i++) {
2005
            ost = ost_table[i];
2006
            if (ost) {
2007
                if (ost->logfile) {
2008
                    fclose(ost->logfile);
2009
                    ost->logfile = NULL;
2010
                }
2011
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2012
                                             initialized but set to zero */
2013
                av_free(ost->pict_tmp.data[0]);
2014
                if (ost->video_resample)
2015
                    sws_freeContext(ost->img_resample_ctx);
2016
                if (ost->audio_resample)
2017
                    audio_resample_close(ost->resample);
2018
                av_free(ost);
2019
            }
2020
        }
2021
        av_free(ost_table);
2022
    }
2023
    return ret;
2024
 fail:
2025
    ret = -ENOMEM;
2026
    goto fail1;
2027
}
2028

    
2029
#if 0
2030
int file_read(const char *filename)
2031
{
2032
    URLContext *h;
2033
    unsigned char buffer[1024];
2034
    int len, i;
2035

2036
    if (url_open(&h, filename, O_RDONLY) < 0) {
2037
        printf("could not open '%s'\n", filename);
2038
        return -1;
2039
    }
2040
    for(;;) {
2041
        len = url_read(h, buffer, sizeof(buffer));
2042
        if (len <= 0)
2043
            break;
2044
        for(i=0;i<len;i++) putchar(buffer[i]);
2045
    }
2046
    url_close(h);
2047
    return 0;
2048
}
2049
#endif
2050

    
2051
static void opt_format(const char *arg)
2052
{
2053
    /* compatibility stuff for pgmyuv */
2054
    if (!strcmp(arg, "pgmyuv")) {
2055
        pgmyuv_compatibility_hack=1;
2056
//        opt_image_format(arg);
2057
        arg = "image2";
2058
    }
2059

    
2060
    file_iformat = av_find_input_format(arg);
2061
    file_oformat = guess_format(arg, NULL, NULL);
2062
    if (!file_iformat && !file_oformat) {
2063
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2064
        exit(1);
2065
    }
2066
}
2067

    
2068
static void opt_video_rc_eq(char *arg)
2069
{
2070
    video_rc_eq = arg;
2071
}
2072

    
2073
static void opt_video_rc_override_string(char *arg)
2074
{
2075
    video_rc_override_string = arg;
2076
}
2077

    
2078
static void opt_me_threshold(const char *arg)
2079
{
2080
    me_threshold = atoi(arg);
2081
}
2082

    
2083
static void opt_verbose(const char *arg)
2084
{
2085
    verbose = atoi(arg);
2086
    av_log_set_level(atoi(arg));
2087
}
2088

    
2089
static void opt_frame_rate(const char *arg)
2090
{
2091
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2092
        fprintf(stderr, "Incorrect frame rate\n");
2093
        exit(1);
2094
    }
2095
}
2096

    
2097
static void opt_frame_crop_top(const char *arg)
2098
{
2099
    frame_topBand = atoi(arg);
2100
    if (frame_topBand < 0) {
2101
        fprintf(stderr, "Incorrect top crop size\n");
2102
        exit(1);
2103
    }
2104
    if ((frame_topBand % 2) != 0) {
2105
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2106
        exit(1);
2107
    }
2108
    if ((frame_topBand) >= frame_height){
2109
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2110
        exit(1);
2111
    }
2112
    frame_height -= frame_topBand;
2113
}
2114

    
2115
static void opt_frame_crop_bottom(const char *arg)
2116
{
2117
    frame_bottomBand = atoi(arg);
2118
    if (frame_bottomBand < 0) {
2119
        fprintf(stderr, "Incorrect bottom crop size\n");
2120
        exit(1);
2121
    }
2122
    if ((frame_bottomBand % 2) != 0) {
2123
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2124
        exit(1);
2125
    }
2126
    if ((frame_bottomBand) >= frame_height){
2127
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2128
        exit(1);
2129
    }
2130
    frame_height -= frame_bottomBand;
2131
}
2132

    
2133
static void opt_frame_crop_left(const char *arg)
2134
{
2135
    frame_leftBand = atoi(arg);
2136
    if (frame_leftBand < 0) {
2137
        fprintf(stderr, "Incorrect left crop size\n");
2138
        exit(1);
2139
    }
2140
    if ((frame_leftBand % 2) != 0) {
2141
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2142
        exit(1);
2143
    }
2144
    if ((frame_leftBand) >= frame_width){
2145
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2146
        exit(1);
2147
    }
2148
    frame_width -= frame_leftBand;
2149
}
2150

    
2151
static void opt_frame_crop_right(const char *arg)
2152
{
2153
    frame_rightBand = atoi(arg);
2154
    if (frame_rightBand < 0) {
2155
        fprintf(stderr, "Incorrect right crop size\n");
2156
        exit(1);
2157
    }
2158
    if ((frame_rightBand % 2) != 0) {
2159
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2160
        exit(1);
2161
    }
2162
    if ((frame_rightBand) >= frame_width){
2163
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2164
        exit(1);
2165
    }
2166
    frame_width -= frame_rightBand;
2167
}
2168

    
2169
static void opt_frame_size(const char *arg)
2170
{
2171
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2172
        fprintf(stderr, "Incorrect frame size\n");
2173
        exit(1);
2174
    }
2175
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2176
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2177
        exit(1);
2178
    }
2179
}
2180

    
2181

    
2182
#define SCALEBITS 10
2183
#define ONE_HALF  (1 << (SCALEBITS - 1))
2184
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2185

    
2186
#define RGB_TO_Y(r, g, b) \
2187
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2188
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2189

    
2190
#define RGB_TO_U(r1, g1, b1, shift)\
2191
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2192
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2193

    
2194
#define RGB_TO_V(r1, g1, b1, shift)\
2195
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2196
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2197

    
2198
static void opt_pad_color(const char *arg) {
2199
    /* Input is expected to be six hex digits similar to
2200
       how colors are expressed in html tags (but without the #) */
2201
    int rgb = strtol(arg, NULL, 16);
2202
    int r,g,b;
2203

    
2204
    r = (rgb >> 16);
2205
    g = ((rgb >> 8) & 255);
2206
    b = (rgb & 255);
2207

    
2208
    padcolor[0] = RGB_TO_Y(r,g,b);
2209
    padcolor[1] = RGB_TO_U(r,g,b,0);
2210
    padcolor[2] = RGB_TO_V(r,g,b,0);
2211
}
2212

    
2213
static void opt_frame_pad_top(const char *arg)
2214
{
2215
    frame_padtop = atoi(arg);
2216
    if (frame_padtop < 0) {
2217
        fprintf(stderr, "Incorrect top pad size\n");
2218
        exit(1);
2219
    }
2220
    if ((frame_padtop % 2) != 0) {
2221
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2222
        exit(1);
2223
    }
2224
}
2225

    
2226
static void opt_frame_pad_bottom(const char *arg)
2227
{
2228
    frame_padbottom = atoi(arg);
2229
    if (frame_padbottom < 0) {
2230
        fprintf(stderr, "Incorrect bottom pad size\n");
2231
        exit(1);
2232
    }
2233
    if ((frame_padbottom % 2) != 0) {
2234
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2235
        exit(1);
2236
    }
2237
}
2238

    
2239

    
2240
static void opt_frame_pad_left(const char *arg)
2241
{
2242
    frame_padleft = atoi(arg);
2243
    if (frame_padleft < 0) {
2244
        fprintf(stderr, "Incorrect left pad size\n");
2245
        exit(1);
2246
    }
2247
    if ((frame_padleft % 2) != 0) {
2248
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2249
        exit(1);
2250
    }
2251
}
2252

    
2253

    
2254
static void opt_frame_pad_right(const char *arg)
2255
{
2256
    frame_padright = atoi(arg);
2257
    if (frame_padright < 0) {
2258
        fprintf(stderr, "Incorrect right pad size\n");
2259
        exit(1);
2260
    }
2261
    if ((frame_padright % 2) != 0) {
2262
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2263
        exit(1);
2264
    }
2265
}
2266

    
2267

    
2268
static void opt_frame_pix_fmt(const char *arg)
2269
{
2270
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2271
}
2272

    
2273
static void opt_frame_aspect_ratio(const char *arg)
2274
{
2275
    int x = 0, y = 0;
2276
    double ar = 0;
2277
    const char *p;
2278

    
2279
    p = strchr(arg, ':');
2280
    if (p) {
2281
        x = strtol(arg, (char **)&arg, 10);
2282
        if (arg == p)
2283
            y = strtol(arg+1, (char **)&arg, 10);
2284
        if (x > 0 && y > 0)
2285
            ar = (double)x / (double)y;
2286
    } else
2287
        ar = strtod(arg, (char **)&arg);
2288

    
2289
    if (!ar) {
2290
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2291
        exit(1);
2292
    }
2293
    frame_aspect_ratio = ar;
2294
}
2295

    
2296
static void opt_qscale(const char *arg)
2297
{
2298
    video_qscale = atof(arg);
2299
    if (video_qscale <= 0 ||
2300
        video_qscale > 255) {
2301
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2302
        exit(1);
2303
    }
2304
}
2305

    
2306
static void opt_qdiff(const char *arg)
2307
{
2308
    video_qdiff = atoi(arg);
2309
    if (video_qdiff < 0 ||
2310
        video_qdiff > 31) {
2311
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2312
        exit(1);
2313
    }
2314
}
2315

    
2316
static void opt_packet_size(const char *arg)
2317
{
2318
    packet_size= atoi(arg);
2319
}
2320

    
2321
static void opt_strict(const char *arg)
2322
{
2323
    strict= atoi(arg);
2324
}
2325

    
2326
static void opt_top_field_first(const char *arg)
2327
{
2328
    top_field_first= atoi(arg);
2329
}
2330

    
2331
static void opt_thread_count(const char *arg)
2332
{
2333
    thread_count= atoi(arg);
2334
#if !defined(HAVE_THREADS)
2335
    if (verbose >= 0)
2336
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2337
#endif
2338
}
2339

    
2340
static void opt_audio_bitrate(const char *arg)
2341
{
2342
    audio_bit_rate = atoi(arg) * 1000;
2343
}
2344

    
2345
static void opt_audio_rate(const char *arg)
2346
{
2347
    audio_sample_rate = atoi(arg);
2348
}
2349

    
2350
static void opt_audio_channels(const char *arg)
2351
{
2352
    audio_channels = atoi(arg);
2353
}
2354

    
2355
static void opt_video_device(const char *arg)
2356
{
2357
    video_device = av_strdup(arg);
2358
}
2359

    
2360
static void opt_grab_device(const char *arg)
2361
{
2362
    grab_device = av_strdup(arg);
2363
}
2364

    
2365
static void opt_video_channel(const char *arg)
2366
{
2367
    video_channel = strtol(arg, NULL, 0);
2368
}
2369

    
2370
static void opt_video_standard(const char *arg)
2371
{
2372
    video_standard = av_strdup(arg);
2373
}
2374

    
2375
static void opt_audio_device(const char *arg)
2376
{
2377
    audio_device = av_strdup(arg);
2378
}
2379

    
2380
static void opt_codec(int *pstream_copy, int *pcodec_id,
2381
                      int codec_type, const char *arg)
2382
{
2383
    AVCodec *p;
2384

    
2385
    if (!strcmp(arg, "copy")) {
2386
        *pstream_copy = 1;
2387
    } else {
2388
        p = first_avcodec;
2389
        while (p) {
2390
            if (!strcmp(p->name, arg) && p->type == codec_type)
2391
                break;
2392
            p = p->next;
2393
        }
2394
        if (p == NULL) {
2395
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2396
            exit(1);
2397
        } else {
2398
            *pcodec_id = p->id;
2399
        }
2400
    }
2401
}
2402

    
2403
static void opt_audio_codec(const char *arg)
2404
{
2405
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2406
}
2407

    
2408
static void opt_audio_tag(const char *arg)
2409
{
2410
    char *tail;
2411
    audio_codec_tag= strtol(arg, &tail, 0);
2412

    
2413
    if(!tail || *tail)
2414
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2415
}
2416

    
2417
static void opt_video_tag(const char *arg)
2418
{
2419
    char *tail;
2420
    video_codec_tag= strtol(arg, &tail, 0);
2421

    
2422
    if(!tail || *tail)
2423
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2424
}
2425

    
2426
static void add_frame_hooker(const char *arg)
2427
{
2428
    int argc = 0;
2429
    char *argv[64];
2430
    int i;
2431
    char *args = av_strdup(arg);
2432

    
2433
    using_vhook = 1;
2434

    
2435
    argv[0] = strtok(args, " ");
2436
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2437
    }
2438

    
2439
    i = frame_hook_add(argc, argv);
2440

    
2441
    if (i != 0) {
2442
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2443
        exit(1);
2444
    }
2445
}
2446

    
2447
const char *motion_str[] = {
2448
    "zero",
2449
    "full",
2450
    "log",
2451
    "phods",
2452
    "epzs",
2453
    "x1",
2454
    "hex",
2455
    "umh",
2456
    "iter",
2457
    NULL,
2458
};
2459

    
2460
static void opt_motion_estimation(const char *arg)
2461
{
2462
    const char **p;
2463
    p = motion_str;
2464
    for(;;) {
2465
        if (!*p) {
2466
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2467
            exit(1);
2468
        }
2469
        if (!strcmp(*p, arg))
2470
            break;
2471
        p++;
2472
    }
2473
    me_method = (p - motion_str) + 1;
2474
}
2475

    
2476
static void opt_video_codec(const char *arg)
2477
{
2478
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2479
}
2480

    
2481
static void opt_subtitle_codec(const char *arg)
2482
{
2483
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2484
}
2485

    
2486
static void opt_map(const char *arg)
2487
{
2488
    AVStreamMap *m;
2489
    const char *p;
2490

    
2491
    p = arg;
2492
    m = &stream_maps[nb_stream_maps++];
2493

    
2494
    m->file_index = strtol(arg, (char **)&p, 0);
2495
    if (*p)
2496
        p++;
2497

    
2498
    m->stream_index = strtol(p, (char **)&p, 0);
2499
    if (*p) {
2500
        p++;
2501
        m->sync_file_index = strtol(p, (char **)&p, 0);
2502
        if (*p)
2503
            p++;
2504
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2505
    } else {
2506
        m->sync_file_index = m->file_index;
2507
        m->sync_stream_index = m->stream_index;
2508
    }
2509
}
2510

    
2511
static void opt_map_meta_data(const char *arg)
2512
{
2513
    AVMetaDataMap *m;
2514
    const char *p;
2515

    
2516
    p = arg;
2517
    m = &meta_data_maps[nb_meta_data_maps++];
2518

    
2519
    m->out_file = strtol(arg, (char **)&p, 0);
2520
    if (*p)
2521
        p++;
2522

    
2523
    m->in_file = strtol(p, (char **)&p, 0);
2524
}
2525

    
2526
static void opt_recording_time(const char *arg)
2527
{
2528
    recording_time = parse_date(arg, 1);
2529
}
2530

    
2531
static void opt_start_time(const char *arg)
2532
{
2533
    start_time = parse_date(arg, 1);
2534
}
2535

    
2536
static void opt_rec_timestamp(const char *arg)
2537
{
2538
    rec_timestamp = parse_date(arg, 0) / 1000000;
2539
}
2540

    
2541
static void opt_input_ts_offset(const char *arg)
2542
{
2543
    input_ts_offset = parse_date(arg, 1);
2544
}
2545

    
2546
static void opt_input_file(const char *filename)
2547
{
2548
    AVFormatContext *ic;
2549
    AVFormatParameters params, *ap = &params;
2550
    int err, i, ret, rfps, rfps_base;
2551
    int64_t timestamp;
2552

    
2553
    if (!strcmp(filename, "-"))
2554
        filename = "pipe:";
2555

    
2556
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2557
                   !strcmp( filename, "/dev/stdin" );
2558

    
2559
    /* get default parameters from command line */
2560
    ic = av_alloc_format_context();
2561

    
2562
    memset(ap, 0, sizeof(*ap));
2563
    ap->prealloced_context = 1;
2564
    ap->sample_rate = audio_sample_rate;
2565
    ap->channels = audio_channels;
2566
    ap->time_base.den = frame_rate;
2567
    ap->time_base.num = frame_rate_base;
2568
    ap->width = frame_width + frame_padleft + frame_padright;
2569
    ap->height = frame_height + frame_padtop + frame_padbottom;
2570
    ap->pix_fmt = frame_pix_fmt;
2571
    ap->device  = grab_device;
2572
    ap->channel = video_channel;
2573
    ap->standard = video_standard;
2574
    ap->video_codec_id = video_codec_id;
2575
    ap->audio_codec_id = audio_codec_id;
2576
    if(pgmyuv_compatibility_hack)
2577
        ap->video_codec_id= CODEC_ID_PGMYUV;
2578

    
2579
    for(i=0; i<opt_name_count; i++){
2580
        AVOption *opt;
2581
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2582
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2583
            av_set_double(ic, opt_names[i], d);
2584
    }
2585
    /* open the input file with generic libav function */
2586
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2587
    if (err < 0) {
2588
        print_error(filename, err);
2589
        exit(1);
2590
    }
2591

    
2592
    ic->loop_input = loop_input;
2593

    
2594
    /* If not enough info to get the stream parameters, we decode the
2595
       first frames to get it. (used in mpeg case for example) */
2596
    ret = av_find_stream_info(ic);
2597
    if (ret < 0 && verbose >= 0) {
2598
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2599
        exit(1);
2600
    }
2601

    
2602
    timestamp = start_time;
2603
    /* add the stream start time */
2604
    if (ic->start_time != AV_NOPTS_VALUE)
2605
        timestamp += ic->start_time;
2606

    
2607
    /* if seeking requested, we execute it */
2608
    if (start_time != 0) {
2609
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2610
        if (ret < 0) {
2611
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2612
                    filename, (double)timestamp / AV_TIME_BASE);
2613
        }
2614
        /* reset seek info */
2615
        start_time = 0;
2616
    }
2617

    
2618
    /* update the current parameters so that they match the one of the input stream */
2619
    for(i=0;i<ic->nb_streams;i++) {
2620
        int j;
2621
        AVCodecContext *enc = ic->streams[i]->codec;
2622
#if defined(HAVE_THREADS)
2623
        if(thread_count>1)
2624
            avcodec_thread_init(enc, thread_count);
2625
#endif
2626
        enc->thread_count= thread_count;
2627
        switch(enc->codec_type) {
2628
        case CODEC_TYPE_AUDIO:
2629
            for(j=0; j<opt_name_count; j++){
2630
                AVOption *opt;
2631
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2632
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2633
                    av_set_double(enc, opt_names[j], d);
2634
            }
2635
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2636
            audio_channels = enc->channels;
2637
            audio_sample_rate = enc->sample_rate;
2638
            if(audio_disable)
2639
                ic->streams[i]->discard= AVDISCARD_ALL;
2640
            break;
2641
        case CODEC_TYPE_VIDEO:
2642
            for(j=0; j<opt_name_count; j++){
2643
                AVOption *opt;
2644
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2645
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2646
                    av_set_double(enc, opt_names[j], d);
2647
            }
2648
            frame_height = enc->height;
2649
            frame_width = enc->width;
2650
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2651
            frame_pix_fmt = enc->pix_fmt;
2652
            rfps      = ic->streams[i]->r_frame_rate.num;
2653
            rfps_base = ic->streams[i]->r_frame_rate.den;
2654
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2655
            if(me_threshold)
2656
                enc->debug |= FF_DEBUG_MV;
2657

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

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

    
2664
                    (float)rfps / rfps_base, rfps, rfps_base);
2665
            }
2666
            /* update the current frame rate to match the stream frame rate */
2667
            frame_rate      = rfps;
2668
            frame_rate_base = rfps_base;
2669

    
2670
            enc->rate_emu = rate_emu;
2671
            if(video_disable)
2672
                ic->streams[i]->discard= AVDISCARD_ALL;
2673
            else if(video_discard)
2674
                ic->streams[i]->discard= video_discard;
2675
            break;
2676
        case CODEC_TYPE_DATA:
2677
            break;
2678
        case CODEC_TYPE_SUBTITLE:
2679
            break;
2680
        case CODEC_TYPE_UNKNOWN:
2681
            break;
2682
        default:
2683
            av_abort();
2684
        }
2685
    }
2686

    
2687
    input_files[nb_input_files] = ic;
2688
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2689
    /* dump the file content */
2690
    if (verbose >= 0)
2691
        dump_format(ic, nb_input_files, filename, 0);
2692

    
2693
    nb_input_files++;
2694
    file_iformat = NULL;
2695
    file_oformat = NULL;
2696

    
2697
    grab_device = NULL;
2698
    video_channel = 0;
2699

    
2700
    rate_emu = 0;
2701
}
2702

    
2703
static void opt_grab(const char *arg)
2704
{
2705
    file_iformat = av_find_input_format(arg);
2706
    opt_input_file("");
2707
}
2708

    
2709
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2710
{
2711
    int has_video, has_audio, i, j;
2712
    AVFormatContext *ic;
2713

    
2714
    has_video = 0;
2715
    has_audio = 0;
2716
    for(j=0;j<nb_input_files;j++) {
2717
        ic = input_files[j];
2718
        for(i=0;i<ic->nb_streams;i++) {
2719
            AVCodecContext *enc = ic->streams[i]->codec;
2720
            switch(enc->codec_type) {
2721
            case CODEC_TYPE_AUDIO:
2722
                has_audio = 1;
2723
                break;
2724
            case CODEC_TYPE_VIDEO:
2725
                has_video = 1;
2726
                break;
2727
            case CODEC_TYPE_DATA:
2728
            case CODEC_TYPE_UNKNOWN:
2729
            case CODEC_TYPE_SUBTITLE:
2730
                break;
2731
            default:
2732
                av_abort();
2733
            }
2734
        }
2735
    }
2736
    *has_video_ptr = has_video;
2737
    *has_audio_ptr = has_audio;
2738
}
2739

    
2740
static void new_video_stream(AVFormatContext *oc)
2741
{
2742
    AVStream *st;
2743
    AVCodecContext *video_enc;
2744
    int codec_id;
2745

    
2746
    st = av_new_stream(oc, oc->nb_streams);
2747
    if (!st) {
2748
        fprintf(stderr, "Could not alloc stream\n");
2749
        exit(1);
2750
    }
2751
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2752
    video_bitstream_filters= NULL;
2753

    
2754
#if defined(HAVE_THREADS)
2755
    if(thread_count>1)
2756
        avcodec_thread_init(st->codec, thread_count);
2757
#endif
2758

    
2759
    video_enc = st->codec;
2760

    
2761
    if(video_codec_tag)
2762
        video_enc->codec_tag= video_codec_tag;
2763

    
2764
    if(   (video_global_header&1)
2765
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2766
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2767
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2768
    }
2769
    if(video_global_header&2){
2770
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2771
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2772
    }
2773

    
2774
    if (video_stream_copy) {
2775
        st->stream_copy = 1;
2776
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2777
    } else {
2778
        char *p;
2779
        int i;
2780
        AVCodec *codec;
2781

    
2782
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2783
        if (video_codec_id != CODEC_ID_NONE)
2784
            codec_id = video_codec_id;
2785

    
2786
        video_enc->codec_id = codec_id;
2787
        codec = avcodec_find_encoder(codec_id);
2788

    
2789
        for(i=0; i<opt_name_count; i++){
2790
             AVOption *opt;
2791
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2792
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2793
                 av_set_double(video_enc, opt_names[i], d);
2794
        }
2795

    
2796
        video_enc->time_base.den = frame_rate;
2797
        video_enc->time_base.num = frame_rate_base;
2798
        if(codec && codec->supported_framerates){
2799
            const AVRational *p= codec->supported_framerates;
2800
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2801
            const AVRational *best=NULL;
2802
            AVRational best_error= (AVRational){INT_MAX, 1};
2803
            for(; p->den!=0; p++){
2804
                AVRational error= av_sub_q(req, *p);
2805
                if(error.num <0) error.num *= -1;
2806
                if(av_cmp_q(error, best_error) < 0){
2807
                    best_error= error;
2808
                    best= p;
2809
                }
2810
            }
2811
            video_enc->time_base.den= best->num;
2812
            video_enc->time_base.num= best->den;
2813
        }
2814

    
2815
        video_enc->width = frame_width + frame_padright + frame_padleft;
2816
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2817
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2818
        video_enc->pix_fmt = frame_pix_fmt;
2819

    
2820
        if(codec && codec->pix_fmts){
2821
            const enum PixelFormat *p= codec->pix_fmts;
2822
            for(; *p!=-1; p++){
2823
                if(*p == video_enc->pix_fmt)
2824
                    break;
2825
            }
2826
            if(*p == -1)
2827
                video_enc->pix_fmt = codec->pix_fmts[0];
2828
        }
2829

    
2830
        if (intra_only)
2831
            video_enc->gop_size = 0;
2832
        if (video_qscale || same_quality) {
2833
            video_enc->flags |= CODEC_FLAG_QSCALE;
2834
            video_enc->global_quality=
2835
                st->quality = FF_QP2LAMBDA * video_qscale;
2836
        }
2837

    
2838
        if(intra_matrix)
2839
            video_enc->intra_matrix = intra_matrix;
2840
        if(inter_matrix)
2841
            video_enc->inter_matrix = inter_matrix;
2842

    
2843
        video_enc->max_qdiff = video_qdiff;
2844
        video_enc->rc_eq = video_rc_eq;
2845
        video_enc->thread_count = thread_count;
2846
        p= video_rc_override_string;
2847
        for(i=0; p; i++){
2848
            int start, end, q;
2849
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2850
            if(e!=3){
2851
                fprintf(stderr, "error parsing rc_override\n");
2852
                exit(1);
2853
            }
2854
            video_enc->rc_override=
2855
                av_realloc(video_enc->rc_override,
2856
                           sizeof(RcOverride)*(i+1));
2857
            video_enc->rc_override[i].start_frame= start;
2858
            video_enc->rc_override[i].end_frame  = end;
2859
            if(q>0){
2860
                video_enc->rc_override[i].qscale= q;
2861
                video_enc->rc_override[i].quality_factor= 1.0;
2862
            }
2863
            else{
2864
                video_enc->rc_override[i].qscale= 0;
2865
                video_enc->rc_override[i].quality_factor= -q/100.0;
2866
            }
2867
            p= strchr(p, '/');
2868
            if(p) p++;
2869
        }
2870
        video_enc->rc_override_count=i;
2871
        video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2872
        video_enc->me_threshold= me_threshold;
2873
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2874
        video_enc->strict_std_compliance = strict;
2875

    
2876
        if(packet_size){
2877
            video_enc->rtp_mode= 1;
2878
            video_enc->rtp_payload_size= packet_size;
2879
        }
2880

    
2881
        if (do_psnr)
2882
            video_enc->flags|= CODEC_FLAG_PSNR;
2883

    
2884
        video_enc->me_method = me_method;
2885

    
2886
        /* two pass mode */
2887
        if (do_pass) {
2888
            if (do_pass == 1) {
2889
                video_enc->flags |= CODEC_FLAG_PASS1;
2890
            } else {
2891
                video_enc->flags |= CODEC_FLAG_PASS2;
2892
            }
2893
        }
2894
    }
2895

    
2896
    /* reset some key parameters */
2897
    video_disable = 0;
2898
    video_codec_id = CODEC_ID_NONE;
2899
    video_stream_copy = 0;
2900
}
2901

    
2902
static void new_audio_stream(AVFormatContext *oc)
2903
{
2904
    AVStream *st;
2905
    AVCodecContext *audio_enc;
2906
    int codec_id, i;
2907

    
2908
    st = av_new_stream(oc, oc->nb_streams);
2909
    if (!st) {
2910
        fprintf(stderr, "Could not alloc stream\n");
2911
        exit(1);
2912
    }
2913

    
2914
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2915
    audio_bitstream_filters= NULL;
2916

    
2917
#if defined(HAVE_THREADS)
2918
    if(thread_count>1)
2919
        avcodec_thread_init(st->codec, thread_count);
2920
#endif
2921

    
2922
    audio_enc = st->codec;
2923
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2924
    audio_enc->strict_std_compliance = strict;
2925

    
2926
    if(audio_codec_tag)
2927
        audio_enc->codec_tag= audio_codec_tag;
2928

    
2929
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2930
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2931
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2932
    }
2933
    if (audio_stream_copy) {
2934
        st->stream_copy = 1;
2935
        audio_enc->channels = audio_channels;
2936
    } else {
2937
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2938

    
2939
        for(i=0; i<opt_name_count; i++){
2940
            AVOption *opt;
2941
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
2942
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2943
                av_set_double(audio_enc, opt_names[i], d);
2944
        }
2945

    
2946
        if (audio_codec_id != CODEC_ID_NONE)
2947
            codec_id = audio_codec_id;
2948
        audio_enc->codec_id = codec_id;
2949

    
2950
        audio_enc->bit_rate = audio_bit_rate;
2951
        if (audio_qscale > QSCALE_NONE) {
2952
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2953
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2954
        }
2955
        audio_enc->thread_count = thread_count;
2956
        /* For audio codecs other than AC3 or DTS we limit */
2957
        /* the number of coded channels to stereo   */
2958
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2959
            && codec_id != CODEC_ID_DTS) {
2960
            audio_enc->channels = 2;
2961
        } else
2962
            audio_enc->channels = audio_channels;
2963
    }
2964
    audio_enc->sample_rate = audio_sample_rate;
2965
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2966
    if (audio_language) {
2967
        pstrcpy(st->language, sizeof(st->language), audio_language);
2968
        av_free(audio_language);
2969
        audio_language = NULL;
2970
    }
2971

    
2972
    /* reset some key parameters */
2973
    audio_disable = 0;
2974
    audio_codec_id = CODEC_ID_NONE;
2975
    audio_stream_copy = 0;
2976
}
2977

    
2978
static void opt_new_subtitle_stream(void)
2979
{
2980
    AVFormatContext *oc;
2981
    AVStream *st;
2982
    AVCodecContext *subtitle_enc;
2983
    int i;
2984

    
2985
    if (nb_output_files <= 0) {
2986
        fprintf(stderr, "At least one output file must be specified\n");
2987
        exit(1);
2988
    }
2989
    oc = output_files[nb_output_files - 1];
2990

    
2991
    st = av_new_stream(oc, oc->nb_streams);
2992
    if (!st) {
2993
        fprintf(stderr, "Could not alloc stream\n");
2994
        exit(1);
2995
    }
2996

    
2997
    subtitle_enc = st->codec;
2998
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2999
    if (subtitle_stream_copy) {
3000
        st->stream_copy = 1;
3001
    } else {
3002
        for(i=0; i<opt_name_count; i++){
3003
             AVOption *opt;
3004
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3005
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3006
                 av_set_double(subtitle_enc, opt_names[i], d);
3007
        }
3008
        subtitle_enc->codec_id = subtitle_codec_id;
3009
    }
3010

    
3011
    if (subtitle_language) {
3012
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3013
        av_free(subtitle_language);
3014
        subtitle_language = NULL;
3015
    }
3016

    
3017
    subtitle_codec_id = CODEC_ID_NONE;
3018
    subtitle_stream_copy = 0;
3019
}
3020

    
3021
static void opt_new_audio_stream(void)
3022
{
3023
    AVFormatContext *oc;
3024
    if (nb_output_files <= 0) {
3025
        fprintf(stderr, "At least one output file must be specified\n");
3026
        exit(1);
3027
    }
3028
    oc = output_files[nb_output_files - 1];
3029
    new_audio_stream(oc);
3030
}
3031

    
3032
static void opt_new_video_stream(void)
3033
{
3034
    AVFormatContext *oc;
3035
    if (nb_output_files <= 0) {
3036
        fprintf(stderr, "At least one output file must be specified\n");
3037
        exit(1);
3038
    }
3039
    oc = output_files[nb_output_files - 1];
3040
    new_video_stream(oc);
3041
}
3042

    
3043
static void opt_output_file(const char *filename)
3044
{
3045
    AVFormatContext *oc;
3046
    int use_video, use_audio, input_has_video, input_has_audio, i;
3047
    AVFormatParameters params, *ap = &params;
3048

    
3049
    if (!strcmp(filename, "-"))
3050
        filename = "pipe:";
3051

    
3052
    oc = av_alloc_format_context();
3053

    
3054
    if (!file_oformat) {
3055
        file_oformat = guess_format(NULL, filename, NULL);
3056
        if (!file_oformat) {
3057
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3058
                    filename);
3059
            exit(1);
3060
        }
3061
    }
3062

    
3063
    oc->oformat = file_oformat;
3064
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3065

    
3066
    if (!strcmp(file_oformat->name, "ffm") &&
3067
        strstart(filename, "http:", NULL)) {
3068
        /* special case for files sent to ffserver: we get the stream
3069
           parameters from ffserver */
3070
        if (read_ffserver_streams(oc, filename) < 0) {
3071
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3072
            exit(1);
3073
        }
3074
    } else {
3075
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3076
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3077

    
3078
        /* disable if no corresponding type found and at least one
3079
           input file */
3080
        if (nb_input_files > 0) {
3081
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3082
            if (!input_has_video)
3083
                use_video = 0;
3084
            if (!input_has_audio)
3085
                use_audio = 0;
3086
        }
3087

    
3088
        /* manual disable */
3089
        if (audio_disable) {
3090
            use_audio = 0;
3091
        }
3092
        if (video_disable) {
3093
            use_video = 0;
3094
        }
3095

    
3096
        if (use_video) {
3097
            new_video_stream(oc);
3098
        }
3099

    
3100
        if (use_audio) {
3101
            new_audio_stream(oc);
3102
        }
3103

    
3104
        oc->timestamp = rec_timestamp;
3105

    
3106
        if (str_title)
3107
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3108
        if (str_author)
3109
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3110
        if (str_copyright)
3111
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3112
        if (str_comment)
3113
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3114
        if (str_album)
3115
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3116
    }
3117

    
3118
    output_files[nb_output_files++] = oc;
3119

    
3120
    /* check filename in case of an image number is expected */
3121
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3122
        if (!av_filename_number_test(oc->filename)) {
3123
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3124
            exit(1);
3125
        }
3126
    }
3127

    
3128
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3129
        /* test if it already exists to avoid loosing precious files */
3130
        if (!file_overwrite &&
3131
            (strchr(filename, ':') == NULL ||
3132
             strstart(filename, "file:", NULL))) {
3133
            if (url_exist(filename)) {
3134
                int c;
3135

    
3136
                if ( !using_stdin ) {
3137
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3138
                    fflush(stderr);
3139
                    c = getchar();
3140
                    if (toupper(c) != 'Y') {
3141
                        fprintf(stderr, "Not overwriting - exiting\n");
3142
                        exit(1);
3143
                    }
3144
                                }
3145
                                else {
3146
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3147
                    exit(1);
3148
                                }
3149
            }
3150
        }
3151

    
3152
        /* open the file */
3153
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3154
            fprintf(stderr, "Could not open '%s'\n", filename);
3155
            exit(1);
3156
        }
3157
    }
3158

    
3159
    memset(ap, 0, sizeof(*ap));
3160
    if (av_set_parameters(oc, ap) < 0) {
3161
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3162
                oc->filename);
3163
        exit(1);
3164
    }
3165

    
3166
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3167
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3168
    oc->loop_output = loop_output;
3169

    
3170
    for(i=0; i<opt_name_count; i++){
3171
        AVOption *opt;
3172
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3173
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3174
            av_set_double(oc, opt_names[i], d);
3175
    }
3176

    
3177
    /* reset some options */
3178
    file_oformat = NULL;
3179
    file_iformat = NULL;
3180
}
3181

    
3182
/* prepare dummy protocols for grab */
3183
static void prepare_grab(void)
3184
{
3185
    int has_video, has_audio, i, j;
3186
    AVFormatContext *oc;
3187
    AVFormatContext *ic;
3188
    AVFormatParameters vp1, *vp = &vp1;
3189
    AVFormatParameters ap1, *ap = &ap1;
3190

    
3191
    /* see if audio/video inputs are needed */
3192
    has_video = 0;
3193
    has_audio = 0;
3194
    memset(ap, 0, sizeof(*ap));
3195
    memset(vp, 0, sizeof(*vp));
3196
    vp->time_base.num= 1;
3197
    for(j=0;j<nb_output_files;j++) {
3198
        oc = output_files[j];
3199
        for(i=0;i<oc->nb_streams;i++) {
3200
            AVCodecContext *enc = oc->streams[i]->codec;
3201
            switch(enc->codec_type) {
3202
            case CODEC_TYPE_AUDIO:
3203
                if (enc->sample_rate > ap->sample_rate)
3204
                    ap->sample_rate = enc->sample_rate;
3205
                if (enc->channels > ap->channels)
3206
                    ap->channels = enc->channels;
3207
                has_audio = 1;
3208
                break;
3209
            case CODEC_TYPE_VIDEO:
3210
                if (enc->width > vp->width)
3211
                    vp->width = enc->width;
3212
                if (enc->height > vp->height)
3213
                    vp->height = enc->height;
3214

    
3215
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3216
                    vp->time_base = enc->time_base;
3217
                    vp->width += frame_leftBand + frame_rightBand;
3218
                    vp->width -= (frame_padleft + frame_padright);
3219
                    vp->height += frame_topBand + frame_bottomBand;
3220
                    vp->height -= (frame_padtop + frame_padbottom);
3221
                }
3222
                has_video = 1;
3223
                break;
3224
            default:
3225
                av_abort();
3226
            }
3227
        }
3228
    }
3229

    
3230
    if (has_video == 0 && has_audio == 0) {
3231
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3232
        exit(1);
3233
    }
3234

    
3235
    if (has_video) {
3236
        AVInputFormat *fmt1;
3237
        fmt1 = av_find_input_format(video_grab_format);
3238
        vp->device  = video_device;
3239
        vp->channel = video_channel;
3240
        vp->standard = video_standard;
3241
        vp->pix_fmt = frame_pix_fmt;
3242
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3243
            fprintf(stderr, "Could not find video grab device\n");
3244
            exit(1);
3245
        }
3246
        /* If not enough info to get the stream parameters, we decode the
3247
           first frames to get it. */
3248
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3249
            fprintf(stderr, "Could not find video grab parameters\n");
3250
            exit(1);
3251
        }
3252
        /* by now video grab has one stream */
3253
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3254
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3255
        input_files[nb_input_files] = ic;
3256

    
3257
        if (verbose >= 0)
3258
            dump_format(ic, nb_input_files, "", 0);
3259

    
3260
        nb_input_files++;
3261
    }
3262
    if (has_audio && audio_grab_format) {
3263
        AVInputFormat *fmt1;
3264
        fmt1 = av_find_input_format(audio_grab_format);
3265
        ap->device = audio_device;
3266
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3267
            fprintf(stderr, "Could not find audio grab device\n");
3268
            exit(1);
3269
        }
3270
        input_files[nb_input_files] = ic;
3271

    
3272
        if (verbose >= 0)
3273
            dump_format(ic, nb_input_files, "", 0);
3274

    
3275
        nb_input_files++;
3276
    }
3277
}
3278

    
3279
/* same option as mencoder */
3280
static void opt_pass(const char *pass_str)
3281
{
3282
    int pass;
3283
    pass = atoi(pass_str);
3284
    if (pass != 1 && pass != 2) {
3285
        fprintf(stderr, "pass number can be only 1 or 2\n");
3286
        exit(1);
3287
    }
3288
    do_pass = pass;
3289
}
3290

    
3291
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3292
static int64_t getutime(void)
3293
{
3294
  return av_gettime();
3295
}
3296
#else
3297
static int64_t getutime(void)
3298
{
3299
    struct rusage rusage;
3300

    
3301
    getrusage(RUSAGE_SELF, &rusage);
3302
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3303
}
3304
#endif
3305

    
3306
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3307
extern int ffm_nopts;
3308
#endif
3309

    
3310
static void show_formats(void)
3311
{
3312
    AVInputFormat *ifmt;
3313
    AVOutputFormat *ofmt;
3314
    URLProtocol *up;
3315
    AVCodec *p, *p2;
3316
    const char **pp, *last_name;
3317

    
3318
    printf("File formats:\n");
3319
    last_name= "000";
3320
    for(;;){
3321
        int decode=0;
3322
        int encode=0;
3323
        const char *name=NULL;
3324
        const char *long_name=NULL;
3325

    
3326
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3327
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3328
                strcmp(ofmt->name, last_name)>0){
3329
                name= ofmt->name;
3330
                long_name= ofmt->long_name;
3331
                encode=1;
3332
            }
3333
        }
3334
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3335
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3336
                strcmp(ifmt->name, last_name)>0){
3337
                name= ifmt->name;
3338
                long_name= ifmt->long_name;
3339
                encode=0;
3340
            }
3341
            if(name && strcmp(ifmt->name, name)==0)
3342
                decode=1;
3343
        }
3344
        if(name==NULL)
3345
            break;
3346
        last_name= name;
3347

    
3348
        printf(
3349
            " %s%s %-15s %s\n",
3350
            decode ? "D":" ",
3351
            encode ? "E":" ",
3352
            name,
3353
            long_name ? long_name:" ");
3354
    }
3355
    printf("\n");
3356

    
3357
    printf("Codecs:\n");
3358
    last_name= "000";
3359
    for(;;){
3360
        int decode=0;
3361
        int encode=0;
3362
        int cap=0;
3363
        const char *type_str;
3364

    
3365
        p2=NULL;
3366
        for(p = first_avcodec; p != NULL; p = p->next) {
3367
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3368
                strcmp(p->name, last_name)>0){
3369
                p2= p;
3370
                decode= encode= cap=0;
3371
            }
3372
            if(p2 && strcmp(p->name, p2->name)==0){
3373
                if(p->decode) decode=1;
3374
                if(p->encode) encode=1;
3375
                cap |= p->capabilities;
3376
            }
3377
        }
3378
        if(p2==NULL)
3379
            break;
3380
        last_name= p2->name;
3381

    
3382
        switch(p2->type) {
3383
        case CODEC_TYPE_VIDEO:
3384
            type_str = "V";
3385
            break;
3386
        case CODEC_TYPE_AUDIO:
3387
            type_str = "A";
3388
            break;
3389
        case CODEC_TYPE_SUBTITLE:
3390
            type_str = "S";
3391
            break;
3392
        default:
3393
            type_str = "?";
3394
            break;
3395
        }
3396
        printf(
3397
            " %s%s%s%s%s%s %s",
3398
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3399
            encode ? "E":" ",
3400
            type_str,
3401
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3402
            cap & CODEC_CAP_DR1 ? "D":" ",
3403
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3404
            p2->name);
3405
       /* if(p2->decoder && decode==0)
3406
            printf(" use %s for decoding", p2->decoder->name);*/
3407
        printf("\n");
3408
    }
3409
    printf("\n");
3410

    
3411
    printf("Supported file protocols:\n");
3412
    for(up = first_protocol; up != NULL; up = up->next)
3413
        printf(" %s:", up->name);
3414
    printf("\n");
3415

    
3416
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3417
    printf("Motion estimation methods:\n");
3418
    pp = motion_str;
3419
    while (*pp) {
3420
        printf(" %s", *pp);
3421
        if ((pp - motion_str + 1) == ME_ZERO)
3422
            printf("(fastest)");
3423
        else if ((pp - motion_str + 1) == ME_FULL)
3424
            printf("(slowest)");
3425
        else if ((pp - motion_str + 1) == ME_EPZS)
3426
            printf("(default)");
3427
        pp++;
3428
    }
3429
    printf("\n\n");
3430
    printf(
3431
"Note, the names of encoders and decoders dont always match, so there are\n"
3432
"several cases where the above table shows encoder only or decoder only entries\n"
3433
"even though both encoding and decoding are supported for example, the h263\n"
3434
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3435
"worse\n");
3436
    exit(1);
3437
}
3438

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

    
3456
static void opt_inter_matrix(const char *arg)
3457
{
3458
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3459
    parse_matrix_coeffs(inter_matrix, arg);
3460
}
3461

    
3462
static void opt_intra_matrix(const char *arg)
3463
{
3464
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3465
    parse_matrix_coeffs(intra_matrix, arg);
3466
}
3467

    
3468
static void opt_target(const char *arg)
3469
{
3470
    int norm = -1;
3471
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3472

    
3473
    if(!strncmp(arg, "pal-", 4)) {
3474
        norm = 0;
3475
        arg += 4;
3476
    } else if(!strncmp(arg, "ntsc-", 5)) {
3477
        norm = 1;
3478
        arg += 5;
3479
    } else if(!strncmp(arg, "film-", 5)) {
3480
        norm = 2;
3481
        arg += 5;
3482
    } else {
3483
        int fr;
3484
        /* Calculate FR via float to avoid int overflow */
3485
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3486
        if(fr == 25000) {
3487
            norm = 0;
3488
        } else if((fr == 29970) || (fr == 23976)) {
3489
            norm = 1;
3490
        } else {
3491
            /* Try to determine PAL/NTSC by peeking in the input files */
3492
            if(nb_input_files) {
3493
                int i, j;
3494
                for(j = 0; j < nb_input_files; j++) {
3495
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3496
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3497
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3498
                            continue;
3499
                        fr = c->time_base.den * 1000 / c->time_base.num;
3500
                        if(fr == 25000) {
3501
                            norm = 0;
3502
                            break;
3503
                        } else if((fr == 29970) || (fr == 23976)) {
3504
                            norm = 1;
3505
                            break;
3506
                        }
3507
                    }
3508
                    if(norm >= 0)
3509
                        break;
3510
                }
3511
            }
3512
        }
3513
        if(verbose && norm >= 0)
3514
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3515
    }
3516

    
3517
    if(norm < 0) {
3518
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3519
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3520
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3521
        exit(1);
3522
    }
3523

    
3524
    if(!strcmp(arg, "vcd")) {
3525

    
3526
        opt_video_codec("mpeg1video");
3527
        opt_audio_codec("mp2");
3528
        opt_format("vcd");
3529

    
3530
        opt_frame_size(norm ? "352x240" : "352x288");
3531
        opt_frame_rate(frame_rates[norm]);
3532
        opt_default("gop", norm ? "18" : "15");
3533

    
3534
        opt_default("b", "1150000");
3535
        opt_default("maxrate", "1150000");
3536
        opt_default("minrate", "1150000");
3537
        opt_default("bufsize", "327680"); // 40*1024*8;
3538

    
3539
        audio_bit_rate = 224000;
3540
        audio_sample_rate = 44100;
3541

    
3542
        opt_default("packetsize", "2324");
3543
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3544

    
3545
        /* We have to offset the PTS, so that it is consistent with the SCR.
3546
           SCR starts at 36000, but the first two packs contain only padding
3547
           and the first pack from the other stream, respectively, may also have
3548
           been written before.
3549
           So the real data starts at SCR 36000+3*1200. */
3550
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3551
    } else if(!strcmp(arg, "svcd")) {
3552

    
3553
        opt_video_codec("mpeg2video");
3554
        opt_audio_codec("mp2");
3555
        opt_format("svcd");
3556

    
3557
        opt_frame_size(norm ? "480x480" : "480x576");
3558
        opt_frame_rate(frame_rates[norm]);
3559
        opt_default("gop", norm ? "18" : "15");
3560

    
3561
        opt_default("b", "2040000");
3562
        opt_default("maxrate", "2516000");
3563
        opt_default("minrate", "0"); //1145000;
3564
        opt_default("bufsize", "1835008"); //224*1024*8;
3565
        opt_default("flags", "+SCAN_OFFSET");
3566

    
3567

    
3568
        audio_bit_rate = 224000;
3569
        audio_sample_rate = 44100;
3570

    
3571
        opt_default("packetsize", "2324");
3572

    
3573
    } else if(!strcmp(arg, "dvd")) {
3574

    
3575
        opt_video_codec("mpeg2video");
3576
        opt_audio_codec("ac3");
3577
        opt_format("dvd");
3578

    
3579
        opt_frame_size(norm ? "720x480" : "720x576");
3580
        opt_frame_rate(frame_rates[norm]);
3581
        opt_default("gop", norm ? "18" : "15");
3582

    
3583
        opt_default("b", "6000000");
3584
        opt_default("maxrate", "9000000");
3585
        opt_default("minrate", "0"); //1500000;
3586
        opt_default("bufsize", "1835008"); //224*1024*8;
3587

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

    
3591
        audio_bit_rate = 448000;
3592
        audio_sample_rate = 48000;
3593

    
3594
    } else if(!strncmp(arg, "dv", 2)) {
3595

    
3596
        opt_format("dv");
3597

    
3598
        opt_frame_size(norm ? "720x480" : "720x576");
3599
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3600
                                             (norm ? "yuv411p" : "yuv420p"));
3601
        opt_frame_rate(frame_rates[norm]);
3602

    
3603
        audio_sample_rate = 48000;
3604
        audio_channels = 2;
3605

    
3606
    } else {
3607
        fprintf(stderr, "Unknown target: %s\n", arg);
3608
        exit(1);
3609
    }
3610
}
3611

    
3612
static void opt_video_bsf(const char *arg)
3613
{
3614
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3615
    AVBitStreamFilterContext **bsfp;
3616

    
3617
    if(!bsfc){
3618
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3619
        exit(1);
3620
    }
3621

    
3622
    bsfp= &video_bitstream_filters;
3623
    while(*bsfp)
3624
        bsfp= &(*bsfp)->next;
3625

    
3626
    *bsfp= bsfc;
3627
}
3628

    
3629
//FIXME avoid audio - video code duplication
3630
static void opt_audio_bsf(const char *arg)
3631
{
3632
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3633
    AVBitStreamFilterContext **bsfp;
3634

    
3635
    if(!bsfc){
3636
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3637
        exit(1);
3638
    }
3639

    
3640
    bsfp= &audio_bitstream_filters;
3641
    while(*bsfp)
3642
        bsfp= &(*bsfp)->next;
3643

    
3644
    *bsfp= bsfc;
3645
}
3646

    
3647
static void show_version(void)
3648
{
3649
    /* TODO: add function interface to avutil and avformat */
3650
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3651
           "libavutil   %d\n"
3652
           "libavcodec  %d\n"
3653
           "libavformat %d\n",
3654
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3655
    exit(1);
3656
}
3657

    
3658
static int opt_default(const char *opt, const char *arg){
3659
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3660
    if(!o)
3661
        o = av_set_string(avformat_opts, opt, arg);
3662
    if(!o)
3663
        return -1;
3664

    
3665
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3666

    
3667
    //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3668
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3669
    opt_names[opt_name_count++]= o->name;
3670

    
3671
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3672
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3673
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3674
        ffm_nopts = 1;
3675
#endif
3676

    
3677
    if(avctx_opts->debug)
3678
        av_log_set_level(AV_LOG_DEBUG);
3679
    return 0;
3680
}
3681

    
3682
const OptionDef options[] = {
3683
    /* main options */
3684
    { "L", 0, {(void*)show_license}, "show license" },
3685
    { "h", 0, {(void*)show_help}, "show help" },
3686
    { "version", 0, {(void*)show_version}, "show version" },
3687
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3688
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3689
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3690
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3691
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3692
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3693
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3694
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3695
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3696
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3697
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3698
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3699
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3700
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3701
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3702
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3703
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3704
      "add timings for benchmarking" },
3705
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3706
      "dump each input packet" },
3707
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3708
      "when dumping packets, also dump the payload" },
3709
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3710
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3711
    { "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)", "" },
3712
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3713
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3714
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3715
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3716
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3717
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3718
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3719
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3720
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3721

    
3722
    /* video options */
3723
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3724
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3725
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3726
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3727
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3728
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3729
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3730
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3731
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3732
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3733
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3734
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3735
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3736
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3737
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3738
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3739
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3740
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3741
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3742
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3743
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3744
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3745
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3746
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3747
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3748
      "method" },
3749
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3750
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3751
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3752
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3753
      "use same video quality as source (implies VBR)" },
3754
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3755
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3756
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3757
      "deinterlace pictures" },
3758
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3759
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3760
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3761
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3762
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3763
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3764
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3765
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3766
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3767
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3768

    
3769
    /* audio options */
3770
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3771
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3772
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3773
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3774
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3775
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3776
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3777
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3778
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3779
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3780

    
3781
    /* subtitle options */
3782
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3783
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3784
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3785

    
3786
    /* grab options */
3787
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3788
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3789
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3790
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3791

    
3792
    /* G.2 grab options */
3793
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3794
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3795

    
3796
    /* muxer options */
3797
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3798
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3799

    
3800
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3801
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3802

    
3803
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3804
    { NULL, },
3805
};
3806

    
3807
static void show_banner(void)
3808
{
3809
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
3810
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3811
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3812
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3813
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3814
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3815
#ifdef __GNUC__
3816
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3817
#else
3818
    fprintf(stderr, ", using a non-gcc compiler\n");
3819
#endif
3820
}
3821

    
3822
static void show_license(void)
3823
{
3824
    show_banner();
3825
#ifdef CONFIG_GPL
3826
    printf(
3827
    "FFmpeg is free software; you can redistribute it and/or modify\n"
3828
    "it under the terms of the GNU General Public License as published by\n"
3829
    "the Free Software Foundation; either version 2 of the License, or\n"
3830
    "(at your option) any later version.\n"
3831
    "\n"
3832
    "FFmpeg is distributed in the hope that it will be useful,\n"
3833
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3834
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3835
    "GNU General Public License for more details.\n"
3836
    "\n"
3837
    "You should have received a copy of the GNU General Public License\n"
3838
    "along with FFmpeg; if not, write to the Free Software\n"
3839
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3840
    );
3841
#else
3842
    printf(
3843
    "FFmpeg is free software; you can redistribute it and/or\n"
3844
    "modify it under the terms of the GNU Lesser General Public\n"
3845
    "License as published by the Free Software Foundation; either\n"
3846
    "version 2.1 of the License, or (at your option) any later version.\n"
3847
    "\n"
3848
    "FFmpeg is distributed in the hope that it will be useful,\n"
3849
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3850
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3851
    "Lesser General Public License for more details.\n"
3852
    "\n"
3853
    "You should have received a copy of the GNU Lesser General Public\n"
3854
    "License along with FFmpeg; if not, write to the Free Software\n"
3855
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3856
    );
3857
#endif
3858
    exit(1);
3859
}
3860

    
3861
static void show_help(void)
3862
{
3863
    show_banner();
3864
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3865
           "Hyper fast Audio and Video encoder\n");
3866
    printf("\n");
3867
    show_help_options(options, "Main options:\n",
3868
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3869
    show_help_options(options, "\nVideo options:\n",
3870
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3871
                      OPT_VIDEO);
3872
    show_help_options(options, "\nAdvanced Video options:\n",
3873
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3874
                      OPT_VIDEO | OPT_EXPERT);
3875
    show_help_options(options, "\nAudio options:\n",
3876
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3877
                      OPT_AUDIO);
3878
    show_help_options(options, "\nAdvanced Audio options:\n",
3879
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3880
                      OPT_AUDIO | OPT_EXPERT);
3881
    show_help_options(options, "\nSubtitle options:\n",
3882
                      OPT_SUBTITLE | OPT_GRAB,
3883
                      OPT_SUBTITLE);
3884
    show_help_options(options, "\nAudio/Video grab options:\n",
3885
                      OPT_GRAB,
3886
                      OPT_GRAB);
3887
    show_help_options(options, "\nAdvanced options:\n",
3888
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3889
                      OPT_EXPERT);
3890
    av_opt_show(avctx_opts, NULL);
3891
    av_opt_show(avformat_opts, NULL);
3892

    
3893
    exit(1);
3894
}
3895

    
3896
void parse_arg_file(const char *filename)
3897
{
3898
    opt_output_file(filename);
3899
}
3900

    
3901
int main(int argc, char **argv)
3902
{
3903
    int i;
3904
    int64_t ti;
3905

    
3906
    av_register_all();
3907

    
3908
    avctx_opts= avcodec_alloc_context();
3909
    avformat_opts = av_alloc_format_context();
3910

    
3911
    if (argc <= 1)
3912
        show_help();
3913
    else
3914
        show_banner();
3915

    
3916
    /* parse options */
3917
    parse_options(argc, argv, options);
3918

    
3919
    /* file converter / grab */
3920
    if (nb_output_files <= 0) {
3921
        fprintf(stderr, "Must supply at least one output file\n");
3922
        exit(1);
3923
    }
3924

    
3925
    if (nb_input_files == 0) {
3926
        input_sync = 1;
3927
        prepare_grab();
3928
    }
3929

    
3930
    ti = getutime();
3931
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3932
              stream_maps, nb_stream_maps);
3933
    ti = getutime() - ti;
3934
    if (do_benchmark) {
3935
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3936
    }
3937

    
3938
    /* close files */
3939
    for(i=0;i<nb_output_files;i++) {
3940
        /* maybe av_close_output_file ??? */
3941
        AVFormatContext *s = output_files[i];
3942
        int j;
3943
        if (!(s->oformat->flags & AVFMT_NOFILE))
3944
            url_fclose(&s->pb);
3945
        for(j=0;j<s->nb_streams;j++) {
3946
            av_free(s->streams[j]->codec);
3947
            av_free(s->streams[j]);
3948
        }
3949
        av_free(s);
3950
    }
3951
    for(i=0;i<nb_input_files;i++)
3952
        av_close_input_file(input_files[i]);
3953

    
3954
    av_free_static();
3955

    
3956
    if(intra_matrix)
3957
        av_free(intra_matrix);
3958
    if(inter_matrix)
3959
        av_free(inter_matrix);
3960

    
3961
#ifdef POWERPC_PERFORMANCE_REPORT
3962
    extern void powerpc_display_perf_report(void);
3963
    powerpc_display_perf_report();
3964
#endif /* POWERPC_PERFORMANCE_REPORT */
3965

    
3966
    if (received_sigterm) {
3967
        fprintf(stderr,
3968
            "Received signal %d: terminating.\n",
3969
            (int) received_sigterm);
3970
        exit (255);
3971
    }
3972

    
3973
    exit(0); /* not all OS-es handle main() return value */
3974
    return 0;
3975
}