Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ab1c6dc9

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
                data_size= samples_size;
1070
                    /* XXX: could avoid copy if PCM 16 bits with same
1071
                       endianness as CPU */
1072
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1073
                                           ptr, len);
1074
                if (ret < 0)
1075
                    goto fail_decode;
1076
                ptr += ret;
1077
                len -= ret;
1078
                /* Some bug in mpeg audio decoder gives */
1079
                /* data_size < 0, it seems they are overflows */
1080
                if (data_size <= 0) {
1081
                    /* no audio frame */
1082
                    continue;
1083
                }
1084
                data_buf = (uint8_t *)samples;
1085
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1086
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1087
                break;}
1088
            case CODEC_TYPE_VIDEO:
1089
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1090
                    /* XXX: allocate picture correctly */
1091
                    avcodec_get_frame_defaults(&picture);
1092

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

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

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

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

    
1170
                ist->frame++;
1171
            }
1172

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

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

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

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

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

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

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

    
1242
                            opkt.stream_index= ost->index;
1243
                            if(pkt->pts != AV_NOPTS_VALUE)
1244
                                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);
1245
                            else
1246
                                opkt.pts= AV_NOPTS_VALUE;
1247

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

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

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

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

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

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

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

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

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

    
1355

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1947
    discard_packet:
1948
        av_free_packet(&pkt);
1949

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

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

    
1962
    term_exit();
1963

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

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

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

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

    
1990
    /* finished ! */
1991

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2182

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

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

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

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

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

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

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

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

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

    
2240

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

    
2254

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

    
2268

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2434
    using_vhook = 1;
2435

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

    
2440
    i = frame_hook_add(argc, argv);
2441

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2593
    ic->loop_input = loop_input;
2594

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

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

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

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

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

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

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

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

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

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

    
2698
    grab_device = NULL;
2699
    video_channel = 0;
2700

    
2701
    rate_emu = 0;
2702
}
2703

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

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

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

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

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

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

    
2760
    video_enc = st->codec;
2761

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2883
        if (do_psnr)
2884
            video_enc->flags|= CODEC_FLAG_PSNR;
2885

    
2886
        video_enc->me_method = me_method;
2887

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

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

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

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

    
2916
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2917
    audio_bitstream_filters= NULL;
2918

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

    
2924
    audio_enc = st->codec;
2925
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2926
    audio_enc->strict_std_compliance = strict;
2927

    
2928
    if(audio_codec_tag)
2929
        audio_enc->codec_tag= audio_codec_tag;
2930

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

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

    
2948
        if (audio_codec_id != CODEC_ID_NONE)
2949
            codec_id = audio_codec_id;
2950
        audio_enc->codec_id = codec_id;
2951

    
2952
        audio_enc->bit_rate = audio_bit_rate;
2953
        if (audio_qscale > QSCALE_NONE) {
2954
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2955
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2956
        }
2957
        audio_enc->thread_count = thread_count;
2958
        audio_enc->channels = audio_channels;
2959
    }
2960
    audio_enc->sample_rate = audio_sample_rate;
2961
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2962
    if (audio_language) {
2963
        pstrcpy(st->language, sizeof(st->language), audio_language);
2964
        av_free(audio_language);
2965
        audio_language = NULL;
2966
    }
2967

    
2968
    /* reset some key parameters */
2969
    audio_disable = 0;
2970
    audio_codec_id = CODEC_ID_NONE;
2971
    audio_stream_copy = 0;
2972
}
2973

    
2974
static void opt_new_subtitle_stream(void)
2975
{
2976
    AVFormatContext *oc;
2977
    AVStream *st;
2978
    AVCodecContext *subtitle_enc;
2979
    int i;
2980

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

    
2987
    st = av_new_stream(oc, oc->nb_streams);
2988
    if (!st) {
2989
        fprintf(stderr, "Could not alloc stream\n");
2990
        exit(1);
2991
    }
2992

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

    
3007
    if (subtitle_language) {
3008
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3009
        av_free(subtitle_language);
3010
        subtitle_language = NULL;
3011
    }
3012

    
3013
    subtitle_codec_id = CODEC_ID_NONE;
3014
    subtitle_stream_copy = 0;
3015
}
3016

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

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

    
3039
static void opt_output_file(const char *filename)
3040
{
3041
    AVFormatContext *oc;
3042
    int use_video, use_audio, input_has_video, input_has_audio, i;
3043
    AVFormatParameters params, *ap = &params;
3044

    
3045
    if (!strcmp(filename, "-"))
3046
        filename = "pipe:";
3047

    
3048
    oc = av_alloc_format_context();
3049

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

    
3059
    oc->oformat = file_oformat;
3060
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3061

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

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

    
3084
        /* manual disable */
3085
        if (audio_disable) {
3086
            use_audio = 0;
3087
        }
3088
        if (video_disable) {
3089
            use_video = 0;
3090
        }
3091

    
3092
        if (use_video) {
3093
            new_video_stream(oc);
3094
        }
3095

    
3096
        if (use_audio) {
3097
            new_audio_stream(oc);
3098
        }
3099

    
3100
        oc->timestamp = rec_timestamp;
3101

    
3102
        if (str_title)
3103
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3104
        if (str_author)
3105
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3106
        if (str_copyright)
3107
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3108
        if (str_comment)
3109
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3110
        if (str_album)
3111
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3112
    }
3113

    
3114
    output_files[nb_output_files++] = oc;
3115

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

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

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

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

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

    
3162
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3163
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3164
    oc->loop_output = loop_output;
3165

    
3166
    for(i=0; i<opt_name_count; i++){
3167
        const AVOption *opt;
3168
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3169
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3170
            av_set_double(oc, opt_names[i], d);
3171
    }
3172

    
3173
    /* reset some options */
3174
    file_oformat = NULL;
3175
    file_iformat = NULL;
3176
}
3177

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

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

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

    
3226
    if (has_video == 0 && has_audio == 0) {
3227
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3228
        exit(1);
3229
    }
3230

    
3231
    if (has_video) {
3232
        AVInputFormat *fmt1;
3233
#warning FIXME: find a better interface
3234
        if(video_device&&!strncmp(video_device,"x11:",4)) {
3235
            video_grab_format="x11grab";
3236
        }
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
        audio_channels = 2;
3542

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

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

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

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

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

    
3568

    
3569
        audio_bit_rate = 224000;
3570
        audio_sample_rate = 44100;
3571

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

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

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

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

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

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

    
3592
        audio_bit_rate = 448000;
3593
        audio_sample_rate = 48000;
3594

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

    
3597
        opt_format("dv");
3598

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

    
3604
        audio_sample_rate = 48000;
3605
        audio_channels = 2;
3606

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

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

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

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

    
3627
    *bsfp= bsfc;
3628
}
3629

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

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

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

    
3645
    *bsfp= bsfc;
3646
}
3647

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

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

    
3666
//    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));
3667

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

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

    
3678
    if(avctx_opts->debug)
3679
        av_log_level = AV_LOG_DEBUG;
3680
    return 0;
3681
}
3682

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

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

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

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

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

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

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

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

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

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

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

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

    
3894
    exit(1);
3895
}
3896

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

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

    
3907
    av_register_all();
3908

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

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

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

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

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

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

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

    
3955
    av_free_static();
3956

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

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

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

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