Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 35f97369

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
                if(using_vhook) {
1547
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1548
                    exit(1);
1549
                }
1550
                codec->pix_fmt = icodec->pix_fmt;
1551
                codec->width = icodec->width;
1552
                codec->height = icodec->height;
1553
                codec->has_b_frames = icodec->has_b_frames;
1554
                break;
1555
            case CODEC_TYPE_SUBTITLE:
1556
                break;
1557
            default:
1558
                av_abort();
1559
            }
1560
        } else {
1561
            switch(codec->codec_type) {
1562
            case CODEC_TYPE_AUDIO:
1563
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1564
                    goto fail;
1565

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

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

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

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

    
1703
    if (!bit_buffer)
1704
        bit_buffer = av_malloc(bit_buffer_size);
1705
    if (!bit_buffer)
1706
        goto fail;
1707

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

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

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

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

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

    
1786
    /* compute buffer size max (should use a complete heuristic) */
1787
    for(i=0;i<nb_input_files;i++) {
1788
        file_table[i].buffer_size_max = 2048;
1789
    }
1790

    
1791
    /* set meta data information from input file if required */
1792
    for (i=0;i<nb_meta_data_maps;i++) {
1793
        AVFormatContext *out_file;
1794
        AVFormatContext *in_file;
1795

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

    
1809
        out_file = output_files[out_file_index];
1810
        in_file = input_files[in_file_index];
1811

    
1812
        strcpy(out_file->title, in_file->title);
1813
        strcpy(out_file->author, in_file->author);
1814
        strcpy(out_file->copyright, in_file->copyright);
1815
        strcpy(out_file->comment, in_file->comment);
1816
        strcpy(out_file->album, in_file->album);
1817
        out_file->year = in_file->year;
1818
        out_file->track = in_file->track;
1819
        strcpy(out_file->genre, in_file->genre);
1820
    }
1821

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

    
1832
    if ( !using_stdin && verbose >= 0) {
1833
        fprintf(stderr, "Press [q] to stop encoding\n");
1834
        url_set_interrupt_cb(decode_interrupt_cb);
1835
    }
1836
    term_init();
1837

    
1838
    stream_no_data = 0;
1839
    key = -1;
1840

    
1841
    for(; received_sigterm == 0;) {
1842
        int file_index, ist_index;
1843
        AVPacket pkt;
1844
        double ipts_min;
1845
        double opts_min;
1846

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

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

    
1893
        /* finish if recording time exhausted */
1894
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1895
            break;
1896

    
1897
        /* finish if limit size exhausted */
1898
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1899
            break;
1900

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

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

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

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

    
1943
            if (verbose >= 0)
1944
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1945
                        ist->file_index, ist->index);
1946

    
1947
            av_free_packet(&pkt);
1948
            goto redo;
1949
        }
1950

    
1951
    discard_packet:
1952
        av_free_packet(&pkt);
1953

    
1954
        /* dump report by using the output first video and audio streams */
1955
        print_report(output_files, ost_table, nb_ostreams, 0);
1956
    }
1957

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

    
1966
    term_exit();
1967

    
1968
    /* write the trailer if needed and close file */
1969
    for(i=0;i<nb_output_files;i++) {
1970
        os = output_files[i];
1971
        av_write_trailer(os);
1972
    }
1973

    
1974
    /* dump report by using the first video and audio streams */
1975
    print_report(output_files, ost_table, nb_ostreams, 1);
1976

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

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

    
1994
    /* finished ! */
1995

    
1996
    ret = 0;
1997
 fail1:
1998
    av_freep(&bit_buffer);
1999
    av_free(file_table);
2000

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

    
2034
#if 0
2035
int file_read(const char *filename)
2036
{
2037
    URLContext *h;
2038
    unsigned char buffer[1024];
2039
    int len, i;
2040

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

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

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

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

    
2078
static void opt_video_rc_override_string(char *arg)
2079
{
2080
    video_rc_override_string = arg;
2081
}
2082

    
2083
static void opt_me_threshold(const char *arg)
2084
{
2085
    me_threshold = atoi(arg);
2086
}
2087

    
2088
static void opt_verbose(const char *arg)
2089
{
2090
    verbose = atoi(arg);
2091
    av_log_level = atoi(arg);
2092
}
2093

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

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

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

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

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

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

    
2186

    
2187
#define SCALEBITS 10
2188
#define ONE_HALF  (1 << (SCALEBITS - 1))
2189
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2190

    
2191
#define RGB_TO_Y(r, g, b) \
2192
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2193
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2194

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

    
2199
#define RGB_TO_V(r1, g1, b1, shift)\
2200
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2201
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2202

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

    
2209
    r = (rgb >> 16);
2210
    g = ((rgb >> 8) & 255);
2211
    b = (rgb & 255);
2212

    
2213
    padcolor[0] = RGB_TO_Y(r,g,b);
2214
    padcolor[1] = RGB_TO_U(r,g,b,0);
2215
    padcolor[2] = RGB_TO_V(r,g,b,0);
2216
}
2217

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

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

    
2244

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

    
2258

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

    
2272

    
2273
static void opt_frame_pix_fmt(const char *arg)
2274
{
2275
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2276
}
2277

    
2278
static void opt_frame_aspect_ratio(const char *arg)
2279
{
2280
    int x = 0, y = 0;
2281
    double ar = 0;
2282
    const char *p;
2283

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

    
2294
    if (!ar) {
2295
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2296
        exit(1);
2297
    }
2298
    frame_aspect_ratio = ar;
2299
}
2300

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

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

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

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

    
2331
static void opt_top_field_first(const char *arg)
2332
{
2333
    top_field_first= atoi(arg);
2334
}
2335

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

    
2345
static void opt_audio_bitrate(const char *arg)
2346
{
2347
    audio_bit_rate = atoi(arg) * 1000;
2348
}
2349

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

    
2355
static void opt_audio_channels(const char *arg)
2356
{
2357
    audio_channels = atoi(arg);
2358
}
2359

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

    
2365
static void opt_grab_device(const char *arg)
2366
{
2367
    grab_device = av_strdup(arg);
2368
}
2369

    
2370
static void opt_video_channel(const char *arg)
2371
{
2372
    video_channel = strtol(arg, NULL, 0);
2373
}
2374

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

    
2380
static void opt_audio_device(const char *arg)
2381
{
2382
    audio_device = av_strdup(arg);
2383
}
2384

    
2385
static void opt_codec(int *pstream_copy, int *pcodec_id,
2386
                      int codec_type, const char *arg)
2387
{
2388
    AVCodec *p;
2389

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

    
2408
static void opt_audio_codec(const char *arg)
2409
{
2410
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2411
}
2412

    
2413
static void opt_audio_tag(const char *arg)
2414
{
2415
    char *tail;
2416
    audio_codec_tag= strtol(arg, &tail, 0);
2417

    
2418
    if(!tail || *tail)
2419
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2420
}
2421

    
2422
static void opt_video_tag(const char *arg)
2423
{
2424
    char *tail;
2425
    video_codec_tag= strtol(arg, &tail, 0);
2426

    
2427
    if(!tail || *tail)
2428
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2429
}
2430

    
2431
static void add_frame_hooker(const char *arg)
2432
{
2433
    int argc = 0;
2434
    char *argv[64];
2435
    int i;
2436
    char *args = av_strdup(arg);
2437

    
2438
    using_vhook = 1;
2439

    
2440
    argv[0] = strtok(args, " ");
2441
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2442
    }
2443

    
2444
    i = frame_hook_add(argc, argv);
2445

    
2446
    if (i != 0) {
2447
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2448
        exit(1);
2449
    }
2450
}
2451

    
2452
const char *motion_str[] = {
2453
    "zero",
2454
    "full",
2455
    "log",
2456
    "phods",
2457
    "epzs",
2458
    "x1",
2459
    "hex",
2460
    "umh",
2461
    "iter",
2462
    NULL,
2463
};
2464

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

    
2481
static void opt_video_codec(const char *arg)
2482
{
2483
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2484
}
2485

    
2486
static void opt_subtitle_codec(const char *arg)
2487
{
2488
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2489
}
2490

    
2491
static void opt_map(const char *arg)
2492
{
2493
    AVStreamMap *m;
2494
    const char *p;
2495

    
2496
    p = arg;
2497
    m = &stream_maps[nb_stream_maps++];
2498

    
2499
    m->file_index = strtol(arg, (char **)&p, 0);
2500
    if (*p)
2501
        p++;
2502

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

    
2516
static void opt_map_meta_data(const char *arg)
2517
{
2518
    AVMetaDataMap *m;
2519
    const char *p;
2520

    
2521
    p = arg;
2522
    m = &meta_data_maps[nb_meta_data_maps++];
2523

    
2524
    m->out_file = strtol(arg, (char **)&p, 0);
2525
    if (*p)
2526
        p++;
2527

    
2528
    m->in_file = strtol(p, (char **)&p, 0);
2529
}
2530

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

    
2536
static void opt_start_time(const char *arg)
2537
{
2538
    start_time = parse_date(arg, 1);
2539
}
2540

    
2541
static void opt_rec_timestamp(const char *arg)
2542
{
2543
    rec_timestamp = parse_date(arg, 0) / 1000000;
2544
}
2545

    
2546
static void opt_input_ts_offset(const char *arg)
2547
{
2548
    input_ts_offset = parse_date(arg, 1);
2549
}
2550

    
2551
static void opt_input_file(const char *filename)
2552
{
2553
    AVFormatContext *ic;
2554
    AVFormatParameters params, *ap = &params;
2555
    int err, i, ret, rfps, rfps_base;
2556
    int64_t timestamp;
2557

    
2558
    if (!strcmp(filename, "-"))
2559
        filename = "pipe:";
2560

    
2561
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2562
                   !strcmp( filename, "/dev/stdin" );
2563

    
2564
    /* get default parameters from command line */
2565
    ic = av_alloc_format_context();
2566

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

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

    
2597
    ic->loop_input = loop_input;
2598

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

    
2607
    timestamp = start_time;
2608
    /* add the stream start time */
2609
    if (ic->start_time != AV_NOPTS_VALUE)
2610
        timestamp += ic->start_time;
2611

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

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

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

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

    
2669
                    (float)rfps / rfps_base, rfps, rfps_base);
2670
            }
2671
            /* update the current frame rate to match the stream frame rate */
2672
            frame_rate      = rfps;
2673
            frame_rate_base = rfps_base;
2674

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

    
2692
    input_files[nb_input_files] = ic;
2693
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2694
    /* dump the file content */
2695
    if (verbose >= 0)
2696
        dump_format(ic, nb_input_files, filename, 0);
2697

    
2698
    nb_input_files++;
2699
    file_iformat = NULL;
2700
    file_oformat = NULL;
2701

    
2702
    grab_device = NULL;
2703
    video_channel = 0;
2704

    
2705
    rate_emu = 0;
2706
}
2707

    
2708
static void opt_grab(const char *arg)
2709
{
2710
    file_iformat = av_find_input_format(arg);
2711
    opt_input_file("");
2712
}
2713

    
2714
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2715
{
2716
    int has_video, has_audio, i, j;
2717
    AVFormatContext *ic;
2718

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

    
2745
static void new_video_stream(AVFormatContext *oc)
2746
{
2747
    AVStream *st;
2748
    AVCodecContext *video_enc;
2749
    int codec_id;
2750

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

    
2759
#if defined(HAVE_THREADS)
2760
    if(thread_count>1)
2761
        avcodec_thread_init(st->codec, thread_count);
2762
#endif
2763

    
2764
    video_enc = st->codec;
2765

    
2766
    if(video_codec_tag)
2767
        video_enc->codec_tag= video_codec_tag;
2768

    
2769
    if(   (video_global_header&1)
2770
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2771
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2772
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2773
    }
2774
    if(video_global_header&2){
2775
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2776
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2777
    }
2778

    
2779
    if (video_stream_copy) {
2780
        st->stream_copy = 1;
2781
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2782
    } else {
2783
        char *p;
2784
        int i;
2785
        AVCodec *codec;
2786

    
2787
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2788
        if (video_codec_id != CODEC_ID_NONE)
2789
            codec_id = video_codec_id;
2790

    
2791
        video_enc->codec_id = codec_id;
2792
        codec = avcodec_find_encoder(codec_id);
2793

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

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

    
2820
        video_enc->width = frame_width + frame_padright + frame_padleft;
2821
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2822
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2823
        video_enc->pix_fmt = frame_pix_fmt;
2824

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

    
2835
        if (intra_only)
2836
            video_enc->gop_size = 0;
2837
        if (video_qscale || same_quality) {
2838
            video_enc->flags |= CODEC_FLAG_QSCALE;
2839
            video_enc->global_quality=
2840
                st->quality = FF_QP2LAMBDA * video_qscale;
2841
        }
2842

    
2843
        if(intra_matrix)
2844
            video_enc->intra_matrix = intra_matrix;
2845
        if(inter_matrix)
2846
            video_enc->inter_matrix = inter_matrix;
2847

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

    
2882
        if(packet_size){
2883
            video_enc->rtp_mode= 1;
2884
            video_enc->rtp_payload_size= packet_size;
2885
        }
2886

    
2887
        if (do_psnr)
2888
            video_enc->flags|= CODEC_FLAG_PSNR;
2889

    
2890
        video_enc->me_method = me_method;
2891

    
2892
        /* two pass mode */
2893
        if (do_pass) {
2894
            if (do_pass == 1) {
2895
                video_enc->flags |= CODEC_FLAG_PASS1;
2896
            } else {
2897
                video_enc->flags |= CODEC_FLAG_PASS2;
2898
            }
2899
        }
2900
    }
2901

    
2902
    /* reset some key parameters */
2903
    video_disable = 0;
2904
    video_codec_id = CODEC_ID_NONE;
2905
    video_stream_copy = 0;
2906
}
2907

    
2908
static void new_audio_stream(AVFormatContext *oc)
2909
{
2910
    AVStream *st;
2911
    AVCodecContext *audio_enc;
2912
    int codec_id, i;
2913

    
2914
    st = av_new_stream(oc, oc->nb_streams);
2915
    if (!st) {
2916
        fprintf(stderr, "Could not alloc stream\n");
2917
        exit(1);
2918
    }
2919

    
2920
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2921
    audio_bitstream_filters= NULL;
2922

    
2923
#if defined(HAVE_THREADS)
2924
    if(thread_count>1)
2925
        avcodec_thread_init(st->codec, thread_count);
2926
#endif
2927

    
2928
    audio_enc = st->codec;
2929
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2930
    audio_enc->strict_std_compliance = strict;
2931

    
2932
    if(audio_codec_tag)
2933
        audio_enc->codec_tag= audio_codec_tag;
2934

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

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

    
2952
        if (audio_codec_id != CODEC_ID_NONE)
2953
            codec_id = audio_codec_id;
2954
        audio_enc->codec_id = codec_id;
2955

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

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

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

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

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

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

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

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

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

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

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

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

    
3052
    oc = av_alloc_format_context();
3053

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

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

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

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

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

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

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

    
3104
        oc->timestamp = rec_timestamp;
3105

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

    
3118
    output_files[nb_output_files++] = oc;
3119

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3261
        if (verbose >= 0)
3262
            dump_format(ic, nb_input_files, "", 0);
3263

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

    
3276
        if (verbose >= 0)
3277
            dump_format(ic, nb_input_files, "", 0);
3278

    
3279
        nb_input_files++;
3280
    }
3281
}
3282

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

    
3295
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3296
static int64_t getutime(void)
3297
{
3298
  return av_gettime();
3299
}
3300
#else
3301
static int64_t getutime(void)
3302
{
3303
    struct rusage rusage;
3304

    
3305
    getrusage(RUSAGE_SELF, &rusage);
3306
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3307
}
3308
#endif
3309

    
3310
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3311
extern int ffm_nopts;
3312
#endif
3313

    
3314
static void show_formats(void)
3315
{
3316
    AVInputFormat *ifmt;
3317
    AVOutputFormat *ofmt;
3318
    URLProtocol *up;
3319
    AVCodec *p, *p2;
3320
    const char **pp, *last_name;
3321

    
3322
    printf("File formats:\n");
3323
    last_name= "000";
3324
    for(;;){
3325
        int decode=0;
3326
        int encode=0;
3327
        const char *name=NULL;
3328
        const char *long_name=NULL;
3329

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

    
3352
        printf(
3353
            " %s%s %-15s %s\n",
3354
            decode ? "D":" ",
3355
            encode ? "E":" ",
3356
            name,
3357
            long_name ? long_name:" ");
3358
    }
3359
    printf("\n");
3360

    
3361
    printf("Codecs:\n");
3362
    last_name= "000";
3363
    for(;;){
3364
        int decode=0;
3365
        int encode=0;
3366
        int cap=0;
3367
        const char *type_str;
3368

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

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

    
3415
    printf("Supported file protocols:\n");
3416
    for(up = first_protocol; up != NULL; up = up->next)
3417
        printf(" %s:", up->name);
3418
    printf("\n");
3419

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

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

    
3460
static void opt_inter_matrix(const char *arg)
3461
{
3462
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3463
    parse_matrix_coeffs(inter_matrix, arg);
3464
}
3465

    
3466
static void opt_intra_matrix(const char *arg)
3467
{
3468
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3469
    parse_matrix_coeffs(intra_matrix, arg);
3470
}
3471

    
3472
static void opt_target(const char *arg)
3473
{
3474
    int norm = -1;
3475
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3476

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

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

    
3528
    if(!strcmp(arg, "vcd")) {
3529

    
3530
        opt_video_codec("mpeg1video");
3531
        opt_audio_codec("mp2");
3532
        opt_format("vcd");
3533

    
3534
        opt_frame_size(norm ? "352x240" : "352x288");
3535
        opt_frame_rate(frame_rates[norm]);
3536
        opt_default("gop", norm ? "18" : "15");
3537

    
3538
        opt_default("b", "1150000");
3539
        opt_default("maxrate", "1150000");
3540
        opt_default("minrate", "1150000");
3541
        opt_default("bufsize", "327680"); // 40*1024*8;
3542

    
3543
        audio_bit_rate = 224000;
3544
        audio_sample_rate = 44100;
3545
        audio_channels = 2;
3546

    
3547
        opt_default("packetsize", "2324");
3548
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3549

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

    
3558
        opt_video_codec("mpeg2video");
3559
        opt_audio_codec("mp2");
3560
        opt_format("svcd");
3561

    
3562
        opt_frame_size(norm ? "480x480" : "480x576");
3563
        opt_frame_rate(frame_rates[norm]);
3564
        opt_default("gop", norm ? "18" : "15");
3565

    
3566
        opt_default("b", "2040000");
3567
        opt_default("maxrate", "2516000");
3568
        opt_default("minrate", "0"); //1145000;
3569
        opt_default("bufsize", "1835008"); //224*1024*8;
3570
        opt_default("flags", "+SCAN_OFFSET");
3571

    
3572

    
3573
        audio_bit_rate = 224000;
3574
        audio_sample_rate = 44100;
3575

    
3576
        opt_default("packetsize", "2324");
3577

    
3578
    } else if(!strcmp(arg, "dvd")) {
3579

    
3580
        opt_video_codec("mpeg2video");
3581
        opt_audio_codec("ac3");
3582
        opt_format("dvd");
3583

    
3584
        opt_frame_size(norm ? "720x480" : "720x576");
3585
        opt_frame_rate(frame_rates[norm]);
3586
        opt_default("gop", norm ? "18" : "15");
3587

    
3588
        opt_default("b", "6000000");
3589
        opt_default("maxrate", "9000000");
3590
        opt_default("minrate", "0"); //1500000;
3591
        opt_default("bufsize", "1835008"); //224*1024*8;
3592

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

    
3596
        audio_bit_rate = 448000;
3597
        audio_sample_rate = 48000;
3598

    
3599
    } else if(!strncmp(arg, "dv", 2)) {
3600

    
3601
        opt_format("dv");
3602

    
3603
        opt_frame_size(norm ? "720x480" : "720x576");
3604
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3605
                                             (norm ? "yuv411p" : "yuv420p"));
3606
        opt_frame_rate(frame_rates[norm]);
3607

    
3608
        audio_sample_rate = 48000;
3609
        audio_channels = 2;
3610

    
3611
    } else {
3612
        fprintf(stderr, "Unknown target: %s\n", arg);
3613
        exit(1);
3614
    }
3615
}
3616

    
3617
static void opt_video_bsf(const char *arg)
3618
{
3619
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3620
    AVBitStreamFilterContext **bsfp;
3621

    
3622
    if(!bsfc){
3623
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3624
        exit(1);
3625
    }
3626

    
3627
    bsfp= &video_bitstream_filters;
3628
    while(*bsfp)
3629
        bsfp= &(*bsfp)->next;
3630

    
3631
    *bsfp= bsfc;
3632
}
3633

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

    
3640
    if(!bsfc){
3641
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3642
        exit(1);
3643
    }
3644

    
3645
    bsfp= &audio_bitstream_filters;
3646
    while(*bsfp)
3647
        bsfp= &(*bsfp)->next;
3648

    
3649
    *bsfp= bsfc;
3650
}
3651

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

    
3663
static int opt_default(const char *opt, const char *arg){
3664
    const AVOption *o= av_set_string(avctx_opts, opt, arg);
3665
    if(!o)
3666
        o = av_set_string(avformat_opts, opt, arg);
3667
    if(!o)
3668
        return -1;
3669

    
3670
//    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));
3671

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

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

    
3682
    if(avctx_opts->debug)
3683
        av_log_level = AV_LOG_DEBUG;
3684
    return 0;
3685
}
3686

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

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

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

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

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

    
3797
    /* G.2 grab options */
3798
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3799
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3800

    
3801
    /* muxer options */
3802
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3803
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3804

    
3805
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3806
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3807

    
3808
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3809
    { NULL, },
3810
};
3811

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

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

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

    
3898
    exit(1);
3899
}
3900

    
3901
void parse_arg_file(const char *filename)
3902
{
3903
    opt_output_file(filename);
3904
}
3905

    
3906
int main(int argc, char **argv)
3907
{
3908
    int i;
3909
    int64_t ti;
3910

    
3911
    av_register_all();
3912

    
3913
    avctx_opts= avcodec_alloc_context();
3914
    avformat_opts = av_alloc_format_context();
3915

    
3916
    if (argc <= 1)
3917
        show_help();
3918
    else
3919
        show_banner();
3920

    
3921
    /* parse options */
3922
    parse_options(argc, argv, options);
3923

    
3924
    /* file converter / grab */
3925
    if (nb_output_files <= 0) {
3926
        fprintf(stderr, "Must supply at least one output file\n");
3927
        exit(1);
3928
    }
3929

    
3930
    if (nb_input_files == 0) {
3931
        input_sync = 1;
3932
        prepare_grab();
3933
    }
3934

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

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

    
3959
    av_free_static();
3960

    
3961
    if(intra_matrix)
3962
        av_free(intra_matrix);
3963
    if(inter_matrix)
3964
        av_free(inter_matrix);
3965

    
3966
#ifdef CONFIG_POWERPC_PERF
3967
    extern void powerpc_display_perf_report(void);
3968
    powerpc_display_perf_report();
3969
#endif /* CONFIG_POWERPC_PERF */
3970

    
3971
    if (received_sigterm) {
3972
        fprintf(stderr,
3973
            "Received signal %d: terminating.\n",
3974
            (int) received_sigterm);
3975
        exit (255);
3976
    }
3977

    
3978
    exit(0); /* not all OS-es handle main() return value */
3979
    return 0;
3980
}