Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b2e3c528

History | View | Annotate | Download (121 KB)

1
/*
2
 * FFmpeg main 
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
#define HAVE_AV_CONFIG_H
20
#include "avformat.h"
21
#include "framehook.h"
22

    
23
#ifndef CONFIG_WIN32
24
#include <unistd.h>
25
#include <fcntl.h>
26
#include <sys/ioctl.h>
27
#include <sys/time.h>
28
#include <termios.h>
29
#include <sys/resource.h>
30
#include <signal.h>
31
#endif
32
#ifdef CONFIG_OS2
33
#include <sys/types.h>
34
#include <sys/select.h>
35
#include <stdlib.h>
36
#endif
37
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
38
#include <time.h>
39

    
40
#include "cmdutils.h"
41

    
42
#if !defined(INFINITY) && defined(HUGE_VAL)
43
#define INFINITY HUGE_VAL
44
#endif
45

    
46
/* select an input stream for an output stream */
47
typedef struct AVStreamMap {
48
    int file_index;
49
    int stream_index;
50
} AVStreamMap;
51

    
52
extern const OptionDef options[];
53

    
54
static void show_help(void);
55
static void show_license(void);
56

    
57
#define MAX_FILES 20
58

    
59
static AVFormatContext *input_files[MAX_FILES];
60
static int nb_input_files = 0;
61

    
62
static AVFormatContext *output_files[MAX_FILES];
63
static int nb_output_files = 0;
64

    
65
static AVStreamMap stream_maps[MAX_FILES];
66
static int nb_stream_maps;
67

    
68
static AVInputFormat *file_iformat;
69
static AVOutputFormat *file_oformat;
70
static AVImageFormat *image_format;
71
static int frame_width  = 160;
72
static int frame_height = 128;
73
static float frame_aspect_ratio = 0;
74
static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
75
static int frame_padtop  = 0;
76
static int frame_padbottom = 0;
77
static int frame_padleft  = 0;
78
static int frame_padright = 0;
79
static int padcolor[3] = {16,128,128}; /* default to black */
80
static int frame_topBand  = 0;
81
static int frame_bottomBand = 0;
82
static int frame_leftBand  = 0;
83
static int frame_rightBand = 0;
84
static int frame_rate = 25;
85
static int frame_rate_base = 1;
86
static int video_bit_rate = 200*1000;
87
static int video_bit_rate_tolerance = 4000*1000;
88
static float video_qscale = 0;
89
static int video_qmin = 2;
90
static int video_qmax = 31;
91
static int video_mb_qmin = 2;
92
static int video_mb_qmax = 31;
93
static int video_qdiff = 3;
94
static float video_qblur = 0.5;
95
static float video_qcomp = 0.5;
96
static uint16_t *intra_matrix = NULL;
97
static uint16_t *inter_matrix = NULL;
98
#if 0 //experimental, (can be removed)
99
static float video_rc_qsquish=1.0;
100
static float video_rc_qmod_amp=0;
101
static int video_rc_qmod_freq=0;
102
#endif
103
static char *video_rc_override_string=NULL;
104
static char *video_rc_eq="tex^qComp";
105
static int video_rc_buffer_size=0;
106
static float video_rc_buffer_aggressivity=1.0;
107
static int video_rc_max_rate=0;
108
static int video_rc_min_rate=0;
109
static float video_rc_initial_cplx=0;
110
static float video_b_qfactor = 1.25;
111
static float video_b_qoffset = 1.25;
112
static float video_i_qfactor = -0.8;
113
static float video_i_qoffset = 0.0;
114
static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
115
static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
116
static int me_method = ME_EPZS;
117
static int video_disable = 0;
118
static int video_codec_id = CODEC_ID_NONE;
119
static int same_quality = 0;
120
static int b_frames = 0;
121
static int mb_decision = FF_MB_DECISION_SIMPLE;
122
static int ildct_cmp = FF_CMP_VSAD;
123
static int mb_cmp = FF_CMP_SAD;
124
static int sub_cmp = FF_CMP_SAD;
125
static int cmp = FF_CMP_SAD;
126
static int pre_cmp = FF_CMP_SAD;
127
static int pre_me = 0;
128
static float lumi_mask = 0;
129
static float dark_mask = 0;
130
static float scplx_mask = 0;
131
static float tcplx_mask = 0;
132
static float p_mask = 0;
133
static int use_4mv = 0;
134
static int use_obmc = 0;
135
static int use_loop = 0;
136
static int use_aic = 0;
137
static int use_aiv = 0;
138
static int use_umv = 0;
139
static int use_ss = 0;
140
static int use_alt_scan = 0;
141
static int use_trell = 0;
142
static int use_scan_offset = 0;
143
static int qns = 0;
144
static int closed_gop = 0;
145
static int do_deinterlace = 0;
146
static int do_interlace_dct = 0;
147
static int do_interlace_me = 0;
148
static int workaround_bugs = FF_BUG_AUTODETECT;
149
static int error_resilience = 2;
150
static int error_concealment = 3;
151
static int dct_algo = 0;
152
static int idct_algo = 0;
153
static int use_part = 0;
154
static int packet_size = 0;
155
static int error_rate = 0;
156
static int strict = 0;
157
static int top_field_first = -1;
158
static int noise_reduction = 0;
159
static int sc_threshold = 0;
160
static int debug = 0;
161
static int debug_mv = 0;
162
extern int loop_input; /* currently a hack */
163

    
164
static int gop_size = 12;
165
static int intra_only = 0;
166
static int audio_sample_rate = 44100;
167
static int audio_bit_rate = 64000;
168
static int audio_disable = 0;
169
static int audio_channels = 1;
170
static int audio_codec_id = CODEC_ID_NONE;
171

    
172
static int64_t recording_time = 0;
173
static int64_t start_time = 0;
174
static int64_t rec_timestamp = 0;
175
static int file_overwrite = 0;
176
static char *str_title = NULL;
177
static char *str_author = NULL;
178
static char *str_copyright = NULL;
179
static char *str_comment = NULL;
180
static int do_benchmark = 0;
181
static int do_hex_dump = 0;
182
static int do_pkt_dump = 0;
183
static int do_psnr = 0;
184
static int do_vstats = 0;
185
static int do_pass = 0;
186
static int bitexact = 0;
187
static char *pass_logfilename = NULL;
188
static int audio_stream_copy = 0;
189
static int video_stream_copy = 0;
190

    
191
static int rate_emu = 0;
192

    
193
static char *video_grab_format = "video4linux";
194
static char *video_device = NULL;
195
static int  video_channel = 0;
196
static char *video_standard = "ntsc";
197

    
198
static char *audio_grab_format = "audio_device";
199
static char *audio_device = NULL;
200

    
201
static int using_stdin = 0;
202
static int using_vhook = 0;
203
static int verbose = 1;
204
static int thread_count= 1;
205
static int q_pressed = 0;
206

    
207
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
208

    
209
typedef struct AVOutputStream {
210
    int file_index;          /* file index */
211
    int index;               /* stream index in the output file */
212
    int source_index;        /* AVInputStream index */
213
    AVStream *st;            /* stream in the output file */
214
    int encoding_needed;     /* true if encoding needed for this stream */
215
    int frame_number;
216
    /* input pts and corresponding output pts
217
       for A/V sync */
218
    double sync_ipts;
219
    double sync_ipts_offset;
220
    int64_t sync_opts;
221
    /* video only */
222
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
223
    AVPicture pict_tmp;      /* temporary image for resampling */
224
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
225

    
226
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
227
    int topBand;             /* cropping area sizes */
228
    int leftBand;
229
    
230
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
231
    int padtop;              /* padding area sizes */
232
    int padbottom;
233
    int padleft;
234
    int padright;
235
    
236
    /* audio only */
237
    int audio_resample;
238
    ReSampleContext *resample; /* for audio resampling */
239
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
240
    FILE *logfile;
241
} AVOutputStream;
242

    
243
typedef struct AVInputStream {
244
    int file_index;
245
    int index;
246
    AVStream *st;
247
    int discard;             /* true if stream data should be discarded */
248
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
249
    int64_t sample_index;      /* current sample */
250

    
251
    int64_t       start;     /* time when read started */
252
    unsigned long frame;     /* current frame */
253
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
254
                                is not defined */
255
    int64_t       pts;       /* current pts */
256
} AVInputStream;
257

    
258
typedef struct AVInputFile {
259
    int eof_reached;      /* true if eof reached */
260
    int ist_index;        /* index of first stream in ist_table */
261
    int buffer_size;      /* current total buffer size */
262
    int buffer_size_max;  /* buffer size at which we consider we can stop
263
                             buffering */
264
    int nb_streams;       /* nb streams we are aware of */
265
} AVInputFile;
266

    
267
#ifndef CONFIG_WIN32
268

    
269
/* init terminal so that we can grab keys */
270
static struct termios oldtty;
271

    
272
static void term_exit(void)
273
{
274
    tcsetattr (0, TCSANOW, &oldtty);
275
}
276

    
277
static volatile sig_atomic_t received_sigterm = 0;
278

    
279
static void
280
sigterm_handler(int sig)
281
{
282
    received_sigterm = sig;
283
    term_exit();
284
}
285

    
286
static void term_init(void)
287
{
288
    struct termios tty;
289

    
290
    tcgetattr (0, &tty);
291
    oldtty = tty;
292

    
293
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
294
                          |INLCR|IGNCR|ICRNL|IXON);
295
    tty.c_oflag |= OPOST;
296
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
297
    tty.c_cflag &= ~(CSIZE|PARENB);
298
    tty.c_cflag |= CS8;
299
    tty.c_cc[VMIN] = 1;
300
    tty.c_cc[VTIME] = 0;
301
    
302
    tcsetattr (0, TCSANOW, &tty);
303

    
304
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
305
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
306
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
307
    /*
308
    register a function to be called at normal program termination
309
    */
310
    atexit(term_exit);
311
#ifdef CONFIG_BEOS_NETSERVER
312
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
313
#endif
314
}
315

    
316
/* read a key without blocking */
317
static int read_key(void)
318
{
319
    int n = 1;
320
    unsigned char ch;
321
#ifndef CONFIG_BEOS_NETSERVER
322
    struct timeval tv;
323
    fd_set rfds;
324

    
325
    FD_ZERO(&rfds);
326
    FD_SET(0, &rfds);
327
    tv.tv_sec = 0;
328
    tv.tv_usec = 0;
329
    n = select(1, &rfds, NULL, NULL, &tv);
330
#endif
331
    if (n > 0) {
332
        n = read(0, &ch, 1);
333
        if (n == 1)
334
            return ch;
335

    
336
        return n;
337
    }
338
    return -1;
339
}
340

    
341
static int decode_interrupt_cb(void)
342
{
343
    return q_pressed || (q_pressed = read_key() == 'q');
344
}
345

    
346
#else
347

    
348
static volatile int received_sigterm = 0;
349

    
350
/* no interactive support */
351
static void term_exit(void)
352
{
353
}
354

    
355
static void term_init(void)
356
{
357
}
358

    
359
static int read_key(void)
360
{
361
    return 0;
362
}
363

    
364
#endif
365

    
366
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
367
{
368
    int i, err;
369
    AVFormatContext *ic;
370

    
371
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
372
    if (err < 0)
373
        return err;
374
    /* copy stream format */
375
    s->nb_streams = ic->nb_streams;
376
    for(i=0;i<ic->nb_streams;i++) {
377
        AVStream *st;
378

    
379
        st = av_mallocz(sizeof(AVStream));
380
        memcpy(st, ic->streams[i], sizeof(AVStream));
381
        s->streams[i] = st;
382
    }
383

    
384
    av_close_input_file(ic);
385
    return 0;
386
}
387

    
388
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
389

    
390
static void do_audio_out(AVFormatContext *s, 
391
                         AVOutputStream *ost, 
392
                         AVInputStream *ist,
393
                         unsigned char *buf, int size)
394
{
395
    uint8_t *buftmp;
396
    static uint8_t *audio_buf = NULL;
397
    static uint8_t *audio_out = NULL;
398
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
399

    
400
    int size_out, frame_bytes, ret;
401
    AVCodecContext *enc;
402

    
403
    /* SC: dynamic allocation of buffers */
404
    if (!audio_buf)
405
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
406
    if (!audio_out)
407
        audio_out = av_malloc(audio_out_size);
408
    if (!audio_buf || !audio_out)
409
        return;               /* Should signal an error ! */
410

    
411
    
412
    enc = &ost->st->codec;
413

    
414
    if (ost->audio_resample) {
415
        buftmp = audio_buf;
416
        size_out = audio_resample(ost->resample, 
417
                                  (short *)buftmp, (short *)buf,
418
                                  size / (ist->st->codec.channels * 2));
419
        size_out = size_out * enc->channels * 2;
420
    } else {
421
        buftmp = buf;
422
        size_out = size;
423
    }
424

    
425
    /* now encode as many frames as possible */
426
    if (enc->frame_size > 1) {
427
        /* output resampled raw samples */
428
        fifo_write(&ost->fifo, buftmp, size_out, 
429
                   &ost->fifo.wptr);
430

    
431
        frame_bytes = enc->frame_size * 2 * enc->channels;
432
        
433
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
434
                     &ost->fifo.rptr) == 0) {
435
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
436
                                       (short *)audio_buf);
437
            av_write_frame(s, ost->index, audio_out, ret);
438
        }
439
    } else {
440
        /* output a pcm frame */
441
        /* XXX: change encoding codec API to avoid this ? */
442
        switch(enc->codec->id) {
443
        case CODEC_ID_PCM_S16LE:
444
        case CODEC_ID_PCM_S16BE:
445
        case CODEC_ID_PCM_U16LE:
446
        case CODEC_ID_PCM_U16BE:
447
            break;
448
        default:
449
            size_out = size_out >> 1;
450
            break;
451
        }
452
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
453
                                   (short *)buftmp);
454
        av_write_frame(s, ost->index, audio_out, ret);
455
    }
456
}
457

    
458
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
459
{
460
    AVCodecContext *dec;
461
    AVPicture *picture2;
462
    AVPicture picture_tmp;
463
    uint8_t *buf = 0;
464

    
465
    dec = &ist->st->codec;
466

    
467
    /* deinterlace : must be done before any resize */
468
    if (do_deinterlace || using_vhook) {
469
        int size;
470

    
471
        /* create temporary picture */
472
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
473
        buf = av_malloc(size);
474
        if (!buf)
475
            return;
476
        
477
        picture2 = &picture_tmp;
478
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
479

    
480
        if (do_deinterlace){
481
            if(avpicture_deinterlace(picture2, picture, 
482
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
483
                /* if error, do not deinterlace */
484
                av_free(buf);
485
                buf = NULL;
486
                picture2 = picture;
487
            }
488
        } else {
489
            if (img_convert(picture2, dec->pix_fmt, picture, 
490
                            dec->pix_fmt, dec->width, dec->height) < 0) {
491
                /* if error, do not copy */
492
                av_free(buf);
493
                buf = NULL;
494
                picture2 = picture;
495
            }
496
        }
497
    } else {
498
        picture2 = picture;
499
    }
500

    
501
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
502

    
503
    if (picture != picture2)
504
        *picture = *picture2;
505
    *bufp = buf;
506
}
507

    
508
/* we begin to correct av delay at this threshold */
509
#define AV_DELAY_MAX 0.100
510

    
511

    
512
/* Expects img to be yuv420 */
513
static void fill_pad_region(AVPicture* img, int height, int width,
514
        int padtop, int padbottom, int padleft, int padright, int *color) {
515
  
516
    int i, y, shift;
517
    uint8_t *optr;
518
    
519
    for (i = 0; i < 3; i++) {
520
        shift = (i == 0) ? 0 : 1;
521
        
522
        if (padtop || padleft) {
523
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
524
                            padleft) >> shift));
525
        }
526

    
527
        if (padleft || padright) {
528
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
529
                (img->linesize[i] - (padright >> shift));
530

    
531
            for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
532
                memset(optr, color[i], (padleft + padright) >> shift);
533
                optr += img->linesize[i];
534
            }
535
        }
536
      
537
        if (padbottom) {
538
            optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
539
            memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
540
        }
541
    }
542
}
543

    
544

    
545
static void do_video_out(AVFormatContext *s, 
546
                         AVOutputStream *ost, 
547
                         AVInputStream *ist,
548
                         AVFrame *in_picture,
549
                         int *frame_size, AVOutputStream *audio_sync)
550
{
551
    int nb_frames, i, ret;
552
    AVPicture *final_picture, *formatted_picture;
553
    AVPicture picture_format_temp, picture_crop_temp;
554
    static uint8_t *video_buffer= NULL;
555
    uint8_t *buf = NULL, *buf1 = NULL;
556
    AVCodecContext *enc, *dec;
557
    enum PixelFormat target_pixfmt;
558

    
559
#define VIDEO_BUFFER_SIZE (1024*1024)
560

    
561
    enc = &ost->st->codec;
562
    dec = &ist->st->codec;
563

    
564
    /* by default, we output a single frame */
565
    nb_frames = 1;
566

    
567
    *frame_size = 0;
568

    
569
    /* NOTE: the A/V sync is always done by considering the audio is
570
       the master clock. It is suffisant for transcoding or playing,
571
       but not for the general case */
572
    if (audio_sync) {
573
        /* compute the A-V delay and duplicate/remove frames if needed */
574
        double adelta, vdelta, av_delay;
575

    
576
        adelta = audio_sync->sync_ipts - ((double)audio_sync->sync_opts * 
577
            s->pts_num / s->pts_den);
578

    
579
        vdelta = ost->sync_ipts - ((double)ost->sync_opts *
580
            s->pts_num / s->pts_den);
581

    
582
        av_delay = adelta - vdelta;
583
        //            printf("delay=%f\n", av_delay);
584
        if (av_delay < -AV_DELAY_MAX)
585
            nb_frames = 2;
586
        else if (av_delay > AV_DELAY_MAX)
587
            nb_frames = 0;
588
    } else {
589
        double vdelta;
590

    
591
        vdelta = (double)(ost->st->pts.val) * s->pts_num / s->pts_den - (ost->sync_ipts - ost->sync_ipts_offset);
592
        if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
593
            if (vdelta < -AV_DELAY_MAX)
594
                nb_frames = 2;
595
            else if (vdelta > AV_DELAY_MAX)
596
                nb_frames = 0;
597
        } else {
598
            ost->sync_ipts_offset -= vdelta;
599
            if (!ost->sync_ipts_offset)
600
                ost->sync_ipts_offset = 0.000001; /* one microsecond */
601
        }
602
    }
603
    
604
#if defined(AVSYNC_DEBUG)
605
    {
606
        static char *action[] = { "drop frame", "copy frame", "dup frame" };
607
        if (audio_sync)
608
            fprintf(stderr, "Input APTS %12.6f, output APTS %12.6f, ",
609
                    (double) audio_sync->sync_ipts, 
610
                    (double) audio_sync->st->pts.val * s->pts_num / s->pts_den);
611
        fprintf(stderr, "Input VPTS %12.6f, output VPTS %12.6f: %s\n",
612
                (double) ost->sync_ipts, 
613
                (double) ost->st->pts.val * s->pts_num / s->pts_den,
614
                action[nb_frames]);
615
    }
616
#endif
617

    
618
    if (nb_frames <= 0) 
619
        return;
620

    
621
    if (!video_buffer)
622
        video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
623
    if (!video_buffer)
624
        return;
625

    
626
    /* convert pixel format if needed */
627
    target_pixfmt = ost->video_resample || ost->video_pad
628
        ? PIX_FMT_YUV420P : enc->pix_fmt;
629
    if (dec->pix_fmt != target_pixfmt) {
630
        int size;
631

    
632
        /* create temporary picture */
633
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
634
        buf = av_malloc(size);
635
        if (!buf)
636
            return;
637
        formatted_picture = &picture_format_temp;
638
        avpicture_fill(formatted_picture, buf, target_pixfmt, dec->width, dec->height);
639
        
640
        if (img_convert(formatted_picture, target_pixfmt, 
641
                        (AVPicture *)in_picture, dec->pix_fmt, 
642
                        dec->width, dec->height) < 0) {
643
            fprintf(stderr, "pixel format conversion not handled\n");
644
            goto the_end;
645
        }
646
    } else {
647
        formatted_picture = (AVPicture *)in_picture;
648
    }
649

    
650
    /* XXX: resampling could be done before raw format conversion in
651
       some cases to go faster */
652
    /* XXX: only works for YUV420P */
653
    if (ost->video_resample) {
654
        final_picture = &ost->pict_tmp;
655
        img_resample(ost->img_resample_ctx, final_picture, formatted_picture);
656
       
657
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
658
            fill_pad_region(final_picture, enc->height, enc->width,
659
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
660
                    padcolor);
661
        }
662
        
663
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
664
            int size;
665
            
666
            av_free(buf);
667
            /* create temporary picture */
668
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
669
            buf = av_malloc(size);
670
            if (!buf)
671
                return;
672
            final_picture = &picture_format_temp;
673
            avpicture_fill(final_picture, buf, enc->pix_fmt, enc->width, enc->height);
674
        
675
            if (img_convert(final_picture, enc->pix_fmt, 
676
                            &ost->pict_tmp, PIX_FMT_YUV420P, 
677
                            enc->width, enc->height) < 0) {
678
                fprintf(stderr, "pixel format conversion not handled\n");
679
                goto the_end;
680
            }
681
        }
682
    } else if (ost->video_crop) {
683
        picture_crop_temp.data[0] = formatted_picture->data[0] +
684
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
685

    
686
        picture_crop_temp.data[1] = formatted_picture->data[1] +
687
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
688
                (ost->leftBand >> 1);
689

    
690
        picture_crop_temp.data[2] = formatted_picture->data[2] +
691
                ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
692
                (ost->leftBand >> 1);
693

    
694
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
695
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
696
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
697
        final_picture = &picture_crop_temp;
698
    } else if (ost->video_pad) {
699
        final_picture = &ost->pict_tmp;
700

    
701
        for (i = 0; i < 3; i++) {
702
            uint8_t *optr, *iptr;
703
            int shift = (i == 0) ? 0 : 1;
704
            int y, yheight;
705
            
706
            /* set offset to start writing image into */
707
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
708
                            ost->padtop) + ost->padleft) >> shift);
709
            iptr = formatted_picture->data[i];
710

    
711
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
712
            for (y = 0; y < yheight; y++) {
713
                /* copy unpadded image row into padded image row */
714
                memcpy(optr, iptr, formatted_picture->linesize[i]);
715
                optr += final_picture->linesize[i];
716
                iptr += formatted_picture->linesize[i];
717
            }
718
        }
719

    
720
        fill_pad_region(final_picture, enc->height, enc->width,
721
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
722
                padcolor);
723
        
724
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
725
            int size;
726

    
727
            av_free(buf);
728
            /* create temporary picture */
729
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
730
            buf = av_malloc(size);
731
            if (!buf)
732
                return;
733
            final_picture = &picture_format_temp;
734
            avpicture_fill(final_picture, buf, enc->pix_fmt, enc->width, enc->height);
735

    
736
            if (img_convert(final_picture, enc->pix_fmt, 
737
                        &ost->pict_tmp, PIX_FMT_YUV420P, 
738
                        enc->width, enc->height) < 0) {
739
                fprintf(stderr, "pixel format conversion not handled\n");
740
                goto the_end;
741
            }
742
        }
743
    } else {
744
        final_picture = formatted_picture;
745
    }
746
    /* duplicates frame if needed */
747
    /* XXX: pb because no interleaving */
748
    for(i=0;i<nb_frames;i++) {
749
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
750
            /* raw pictures are written as AVPicture structure to
751
               avoid any copies. We support temorarily the older
752
               method. */
753
            AVFrame* old_frame = enc->coded_frame;
754
            enc->coded_frame = dec->coded_frame;
755
            av_write_frame(s, ost->index, 
756
                           (uint8_t *)final_picture, sizeof(AVPicture));
757
            enc->coded_frame = old_frame;
758
        } else {
759
            AVFrame big_picture;
760
            
761
            avcodec_get_frame_defaults(&big_picture);
762
            *(AVPicture*)&big_picture= *final_picture;
763
            /* better than nothing: use input picture interlaced
764
               settings */
765
            big_picture.interlaced_frame = in_picture->interlaced_frame;
766
            if(do_interlace_me || do_interlace_dct){
767
                if(top_field_first == -1)
768
                    big_picture.top_field_first = in_picture->top_field_first;
769
                else
770
                    big_picture.top_field_first = 1;
771
            }
772

    
773
            /* handles sameq here. This is not correct because it may
774
               not be a global option */
775
            if (same_quality) {
776
                big_picture.quality = ist->st->quality;
777
            }else
778
                big_picture.quality = ost->st->quality;
779
            ret = avcodec_encode_video(enc, 
780
                                       video_buffer, VIDEO_BUFFER_SIZE,
781
                                       &big_picture);
782
            //enc->frame_number = enc->real_pict_num;
783
            av_write_frame(s, ost->index, video_buffer, ret);
784
            *frame_size = ret;
785
            //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
786
            //        enc->frame_number-1, enc->real_pict_num, ret,
787
            //        enc->pict_type);
788
            /* if two pass, output log */
789
            if (ost->logfile && enc->stats_out) {
790
                fprintf(ost->logfile, "%s", enc->stats_out);
791
            }
792
        }
793
        ost->frame_number++;
794
    }
795
 the_end:
796
    av_free(buf);
797
    av_free(buf1);
798
}
799

    
800
static double psnr(double d){
801
    if(d==0) return INFINITY;
802
    return -10.0*log(d)/log(10.0);
803
}
804

    
805
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, 
806
                           int frame_size)
807
{
808
    static FILE *fvstats=NULL;
809
    static int64_t total_size = 0;
810
    char filename[40];
811
    time_t today2;
812
    struct tm *today;
813
    AVCodecContext *enc;
814
    int frame_number;
815
    int64_t ti;
816
    double ti1, bitrate, avg_bitrate;
817
    
818
    if (!fvstats) {
819
        today2 = time(NULL);
820
        today = localtime(&today2);
821
        sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
822
                                               today->tm_min,
823
                                               today->tm_sec);
824
        fvstats = fopen(filename,"w");
825
        if (!fvstats) {
826
            perror("fopen");
827
            exit(1);
828
        }
829
    }
830
    
831
    ti = MAXINT64;
832
    enc = &ost->st->codec;
833
    total_size += frame_size;
834
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
835
        frame_number = ost->frame_number;
836
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
837
        if (enc->flags&CODEC_FLAG_PSNR)
838
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
839
        
840
        fprintf(fvstats,"f_size= %6d ", frame_size);
841
        /* compute pts value */
842
        ti1 = (double)ost->st->pts.val * os->pts_num / os->pts_den;
843
        if (ti1 < 0.01)
844
            ti1 = 0.01;
845
    
846
        bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
847
        avg_bitrate = (double)(total_size * 8) / ti1 / 1000.0;
848
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
849
            (double)total_size / 1024, ti1, bitrate, avg_bitrate);
850
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));        
851
    }
852
}
853

    
854
static void print_report(AVFormatContext **output_files,
855
                         AVOutputStream **ost_table, int nb_ostreams,
856
                         int is_last_report)
857
{
858
    char buf[1024];
859
    AVOutputStream *ost;
860
    AVFormatContext *oc, *os;
861
    int64_t total_size;
862
    AVCodecContext *enc;
863
    int frame_number, vid, i;
864
    double bitrate, ti1, pts;
865
    static int64_t last_time = -1;
866
    
867
    if (!is_last_report) {
868
        int64_t cur_time;
869
        /* display the report every 0.5 seconds */
870
        cur_time = av_gettime();
871
        if (last_time == -1) {
872
            last_time = cur_time;
873
            return;
874
        } 
875
        if ((cur_time - last_time) < 500000)
876
            return;
877
        last_time = cur_time;
878
    }
879

    
880

    
881
    oc = output_files[0];
882

    
883
    total_size = url_ftell(&oc->pb);
884
    
885
    buf[0] = '\0';
886
    ti1 = 1e10;
887
    vid = 0;
888
    for(i=0;i<nb_ostreams;i++) {
889
        ost = ost_table[i];
890
        os = output_files[ost->file_index];
891
        enc = &ost->st->codec;
892
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
893
            sprintf(buf + strlen(buf), "q=%2.1f ",
894
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
895
        }
896
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
897
            frame_number = ost->frame_number;
898
            sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
899
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
900
            if(is_last_report)
901
                sprintf(buf + strlen(buf), "L");
902
            if (enc->flags&CODEC_FLAG_PSNR){
903
                int j;
904
                double error, error_sum=0;
905
                double scale, scale_sum=0;
906
                char type[3]= {'Y','U','V'};
907
                sprintf(buf + strlen(buf), "PSNR=");
908
                for(j=0; j<3; j++){
909
                    if(is_last_report){
910
                        error= enc->error[j];
911
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
912
                    }else{
913
                        error= enc->coded_frame->error[j];
914
                        scale= enc->width*enc->height*255.0*255.0;
915
                    }
916
                    if(j) scale/=4;
917
                    error_sum += error;
918
                    scale_sum += scale;
919
                    sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
920
                }
921
                sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
922
            }
923
            vid = 1;
924
        }
925
        /* compute min output value */
926
        pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
927
        if ((pts < ti1) && (pts > 0))
928
            ti1 = pts;
929
    }
930
    if (ti1 < 0.01)
931
        ti1 = 0.01;
932
    
933
    if (verbose || is_last_report) {
934
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
935
        
936
        sprintf(buf + strlen(buf), 
937
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
938
            (double)total_size / 1024, ti1, bitrate);
939
        
940
        fprintf(stderr, "%s    \r", buf);
941
        fflush(stderr);
942
    }
943
        
944
    if (is_last_report)
945
        fprintf(stderr, "\n");
946
}
947

    
948
/* pkt = NULL means EOF (needed to flush decoder buffers) */
949
static int output_packet(AVInputStream *ist, int ist_index,
950
                         AVOutputStream **ost_table, int nb_ostreams,
951
                         AVPacket *pkt)
952
{
953
    AVFormatContext *os;
954
    AVOutputStream *ost;
955
    uint8_t *ptr;
956
    int len, ret, i;
957
    uint8_t *data_buf;
958
    int data_size, got_picture;
959
    AVFrame picture;
960
    short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
961
    void *buffer_to_free;
962
    
963
    if (pkt && pkt->pts != AV_NOPTS_VALUE) {
964
        ist->pts = pkt->pts;
965
    } else {
966
        ist->pts = ist->next_pts;
967
    }
968
    
969
    if (pkt == NULL) {
970
        /* EOF handling */
971
        ptr = NULL;
972
        len = 0;
973
        goto handle_eof;
974
    }
975

    
976
    len = pkt->size;
977
    ptr = pkt->data;
978
    while (len > 0) {
979
    handle_eof:
980
        /* decode the packet if needed */
981
        data_buf = NULL; /* fail safe */
982
        data_size = 0;
983
        if (ist->decoding_needed) {
984
            switch(ist->st->codec.codec_type) {
985
            case CODEC_TYPE_AUDIO:
986
                    /* XXX: could avoid copy if PCM 16 bits with same
987
                       endianness as CPU */
988
                ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
989
                                           ptr, len);
990
                if (ret < 0)
991
                    goto fail_decode;
992
                ptr += ret;
993
                len -= ret;
994
                /* Some bug in mpeg audio decoder gives */
995
                /* data_size < 0, it seems they are overflows */
996
                if (data_size <= 0) {
997
                    /* no audio frame */
998
                    continue;
999
                }
1000
                data_buf = (uint8_t *)samples;
1001
                ist->next_pts += ((int64_t)AV_TIME_BASE * data_size) / 
1002
                    (2 * ist->st->codec.channels);
1003
                break;
1004
            case CODEC_TYPE_VIDEO:
1005
                    data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1006
                    /* XXX: allocate picture correctly */
1007
                    avcodec_get_frame_defaults(&picture);
1008

    
1009
                    ret = avcodec_decode_video(&ist->st->codec, 
1010
                                               &picture, &got_picture, ptr, len);
1011
                    ist->st->quality= picture.quality;
1012
                    if (ret < 0) 
1013
                        goto fail_decode;
1014
                    if (!got_picture) {
1015
                        /* no picture yet */
1016
                        goto discard_packet;
1017
                    }
1018
                    if (ist->st->codec.frame_rate_base != 0) {
1019
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1020
                                          ist->st->codec.frame_rate_base) /
1021
                            ist->st->codec.frame_rate;
1022
                    }
1023
                    len = 0;
1024
                    break;
1025
                default:
1026
                    goto fail_decode;
1027
                }
1028
            } else {
1029
                data_buf = ptr;
1030
                data_size = len;
1031
                ret = len;
1032
                len = 0;
1033
            }
1034

    
1035
            buffer_to_free = NULL;
1036
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1037
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1038
                                        &buffer_to_free);
1039
            }
1040

    
1041
            /* frame rate emulation */
1042
            if (ist->st->codec.rate_emu) {
1043
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1044
                int64_t now = av_gettime() - ist->start;
1045
                if (pts > now)
1046
                    usleep(pts - now);
1047

    
1048
                ist->frame++;
1049
            }
1050

    
1051
#if 0
1052
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1053
               is the one of the next displayed one */
1054
            /* XXX: add mpeg4 too ? */
1055
            if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1056
                if (ist->st->codec.pict_type != B_TYPE) {
1057
                    int64_t tmp;
1058
                    tmp = ist->last_ip_pts;
1059
                    ist->last_ip_pts  = ist->frac_pts.val;
1060
                    ist->frac_pts.val = tmp;
1061
                }
1062
            }
1063
#endif
1064
            /* if output time reached then transcode raw format, 
1065
               encode packets and output them */
1066
            if (start_time == 0 || ist->pts >= start_time)
1067
                for(i=0;i<nb_ostreams;i++) {
1068
                    int frame_size;
1069

    
1070
                    ost = ost_table[i];
1071
                    if (ost->source_index == ist_index) {
1072
                        os = output_files[ost->file_index];
1073

    
1074
#if 0
1075
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1076
                               (double)pkt->pts / AV_TIME_BASE, 
1077
                               ((double)ist->pts / AV_TIME_BASE) - 
1078
                               ((double)ost->st->pts.val * os->pts_num / os->pts_den));
1079
#endif
1080
                        /* set the input output pts pairs */
1081
                        ost->sync_ipts = (double)ist->pts / AV_TIME_BASE;
1082
                        /* XXX: take into account the various fifos,
1083
                           in particular for audio */
1084
                        ost->sync_opts = ost->st->pts.val;
1085
                        //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt->pts=%lld\n", ist->pts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt->pts); 
1086

    
1087
                        if (ost->encoding_needed) {
1088
                            switch(ost->st->codec.codec_type) {
1089
                            case CODEC_TYPE_AUDIO:
1090
                                do_audio_out(os, ost, ist, data_buf, data_size);
1091
                                break;
1092
                            case CODEC_TYPE_VIDEO:
1093
                                /* find an audio stream for synchro */
1094
                                {
1095
                                    int i;
1096
                                    AVOutputStream *audio_sync, *ost1;
1097
                                    audio_sync = NULL;
1098
                                    for(i=0;i<nb_ostreams;i++) {
1099
                                        ost1 = ost_table[i];
1100
                                        if (ost1->file_index == ost->file_index &&
1101
                                            ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1102
                                            audio_sync = ost1;
1103
                                            break;
1104
                                        }
1105
                                    }
1106

    
1107
                                    do_video_out(os, ost, ist, &picture, &frame_size, audio_sync);
1108
                                    if (do_vstats && frame_size)
1109
                                        do_video_stats(os, ost, frame_size);
1110
                                }
1111
                                break;
1112
                            default:
1113
                                av_abort();
1114
                            }
1115
                        } else {
1116
                            AVFrame avframe;
1117
                                                
1118
                            /* no reencoding needed : output the packet directly */
1119
                            /* force the input stream PTS */
1120
                        
1121
                            avcodec_get_frame_defaults(&avframe);
1122
                            ost->st->codec.coded_frame= &avframe;
1123
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1124
                        
1125
                            av_write_frame(os, ost->index, data_buf, data_size);
1126
                            ost->st->codec.frame_number++;
1127
                            ost->frame_number++;
1128
                        }
1129
                    }
1130
                }
1131
            av_free(buffer_to_free);
1132
        }
1133
 discard_packet:
1134
    return 0;
1135
 fail_decode:
1136
    return -1;
1137
}
1138

    
1139

    
1140
/*
1141
 * The following code is the main loop of the file converter
1142
 */
1143
static int av_encode(AVFormatContext **output_files,
1144
                     int nb_output_files,
1145
                     AVFormatContext **input_files,
1146
                     int nb_input_files,
1147
                     AVStreamMap *stream_maps, int nb_stream_maps)
1148
{
1149
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1150
    AVFormatContext *is, *os;
1151
    AVCodecContext *codec, *icodec;
1152
    AVOutputStream *ost, **ost_table = NULL;
1153
    AVInputStream *ist, **ist_table = NULL;
1154
    AVInputFile *file_table;
1155
    AVFormatContext *stream_no_data;
1156
    int key;
1157

    
1158
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1159
    if (!file_table)
1160
        goto fail;
1161

    
1162
    /* input stream init */
1163
    j = 0;
1164
    for(i=0;i<nb_input_files;i++) {
1165
        is = input_files[i];
1166
        file_table[i].ist_index = j;
1167
        file_table[i].nb_streams = is->nb_streams;
1168
        j += is->nb_streams;
1169
    }
1170
    nb_istreams = j;
1171

    
1172
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1173
    if (!ist_table)
1174
        goto fail;
1175
    
1176
    for(i=0;i<nb_istreams;i++) {
1177
        ist = av_mallocz(sizeof(AVInputStream));
1178
        if (!ist)
1179
            goto fail;
1180
        ist_table[i] = ist;
1181
    }
1182
    j = 0;
1183
    for(i=0;i<nb_input_files;i++) {
1184
        is = input_files[i];
1185
        for(k=0;k<is->nb_streams;k++) {
1186
            ist = ist_table[j++];
1187
            ist->st = is->streams[k];
1188
            ist->file_index = i;
1189
            ist->index = k;
1190
            ist->discard = 1; /* the stream is discarded by default
1191
                                 (changed later) */
1192

    
1193
            if (ist->st->codec.rate_emu) {
1194
                ist->start = av_gettime();
1195
                ist->frame = 0;
1196
            }
1197
        }
1198
    }
1199

    
1200
    /* output stream init */
1201
    nb_ostreams = 0;
1202
    for(i=0;i<nb_output_files;i++) {
1203
        os = output_files[i];
1204
        nb_ostreams += os->nb_streams;
1205
    }
1206
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1207
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1208
        exit(1);
1209
    }
1210

    
1211
    /* Sanity check the mapping args -- do the input files & streams exist? */
1212
    for(i=0;i<nb_stream_maps;i++) {
1213
        int fi = stream_maps[i].file_index;
1214
        int si = stream_maps[i].stream_index;
1215
        
1216
        if (fi < 0 || fi > nb_input_files - 1 ||
1217
            si < 0 || si > file_table[fi].nb_streams - 1) {
1218
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1219
            exit(1);
1220
        }
1221
    }
1222
    
1223
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1224
    if (!ost_table)
1225
        goto fail;
1226
    for(i=0;i<nb_ostreams;i++) {
1227
        ost = av_mallocz(sizeof(AVOutputStream));
1228
        if (!ost)
1229
            goto fail;
1230
        ost_table[i] = ost;
1231
    }
1232
    
1233
    n = 0;
1234
    for(k=0;k<nb_output_files;k++) {
1235
        os = output_files[k];
1236
        for(i=0;i<os->nb_streams;i++) {
1237
            int found;
1238
            ost = ost_table[n++];
1239
            ost->file_index = k;
1240
            ost->index = i;
1241
            ost->st = os->streams[i];
1242
            if (nb_stream_maps > 0) {
1243
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
1244
                    stream_maps[n-1].stream_index;
1245
                    
1246
                /* Sanity check that the stream types match */
1247
                if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1248
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1249
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1250
                        ost->file_index, ost->index);
1251
                    exit(1);
1252
                }
1253
                
1254
            } else {
1255
                /* get corresponding input stream index : we select the first one with the right type */
1256
                found = 0;
1257
                for(j=0;j<nb_istreams;j++) {
1258
                    ist = ist_table[j];
1259
                    if (ist->discard && 
1260
                        ist->st->codec.codec_type == ost->st->codec.codec_type) {
1261
                        ost->source_index = j;
1262
                        found = 1;
1263
                    }
1264
                }
1265
                
1266
                if (!found) {
1267
                    /* try again and reuse existing stream */
1268
                    for(j=0;j<nb_istreams;j++) {
1269
                        ist = ist_table[j];
1270
                        if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1271
                            ost->source_index = j;
1272
                            found = 1;
1273
                        }
1274
                    }
1275
                    if (!found) {
1276
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1277
                                ost->file_index, ost->index);
1278
                        exit(1);
1279
                    }
1280
                }
1281
            }
1282
            ist = ist_table[ost->source_index];
1283
            ist->discard = 0;
1284
        }
1285
    }
1286

    
1287
    /* for each output stream, we compute the right encoding parameters */
1288
    for(i=0;i<nb_ostreams;i++) {
1289
        ost = ost_table[i];
1290
        ist = ist_table[ost->source_index];
1291

    
1292
        codec = &ost->st->codec;
1293
        icodec = &ist->st->codec;
1294

    
1295
        if (ost->st->stream_copy) {
1296
            /* if stream_copy is selected, no need to decode or encode */
1297
            codec->codec_id = icodec->codec_id;
1298
            codec->codec_type = icodec->codec_type;
1299
            codec->codec_tag = icodec->codec_tag;
1300
            codec->bit_rate = icodec->bit_rate;
1301
            switch(codec->codec_type) {
1302
            case CODEC_TYPE_AUDIO:
1303
                codec->sample_rate = icodec->sample_rate;
1304
                codec->channels = icodec->channels;
1305
                codec->frame_size = icodec->frame_size;
1306
                break;
1307
            case CODEC_TYPE_VIDEO:
1308
                codec->frame_rate = icodec->frame_rate;
1309
                codec->frame_rate_base = icodec->frame_rate_base;
1310
                codec->width = icodec->width;
1311
                codec->height = icodec->height;
1312
                break;
1313
            default:
1314
                av_abort();
1315
            }
1316
        } else {
1317
            switch(codec->codec_type) {
1318
            case CODEC_TYPE_AUDIO:
1319
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1320
                    goto fail;
1321
                
1322
                if (codec->channels == icodec->channels &&
1323
                    codec->sample_rate == icodec->sample_rate) {
1324
                    ost->audio_resample = 0;
1325
                } else {
1326
                    if (codec->channels != icodec->channels &&
1327
                        icodec->codec_id == CODEC_ID_AC3) {
1328
                        /* Special case for 5:1 AC3 input */
1329
                        /* and mono or stereo output      */
1330
                        /* Request specific number of channels */
1331
                        icodec->channels = codec->channels;
1332
                        if (codec->sample_rate == icodec->sample_rate)
1333
                            ost->audio_resample = 0;
1334
                        else {
1335
                            ost->audio_resample = 1;
1336
                            ost->resample = audio_resample_init(codec->channels, icodec->channels,
1337
                                                        codec->sample_rate, 
1338
                                                        icodec->sample_rate);
1339
                            if(!ost->resample)
1340
                              {
1341
                                printf("Can't resample.  Aborting.\n");
1342
                                av_abort();
1343
                              }
1344
                        }
1345
                        /* Request specific number of channels */
1346
                        icodec->channels = codec->channels;
1347
                    } else {
1348
                        ost->audio_resample = 1; 
1349
                        ost->resample = audio_resample_init(codec->channels, icodec->channels,
1350
                                                        codec->sample_rate, 
1351
                                                        icodec->sample_rate);
1352
                        if(!ost->resample)
1353
                          {
1354
                            printf("Can't resample.  Aborting.\n");
1355
                            av_abort();
1356
                          }
1357
                    }
1358
                }
1359
                ist->decoding_needed = 1;
1360
                ost->encoding_needed = 1;
1361
                break;
1362
            case CODEC_TYPE_VIDEO:
1363
                if (codec->width == icodec->width &&
1364
                    codec->height == icodec->height &&
1365
                    frame_topBand == 0 &&
1366
                    frame_bottomBand == 0 &&
1367
                    frame_leftBand == 0 &&
1368
                    frame_rightBand == 0 && 
1369
                    frame_padtop == 0 &&
1370
                    frame_padbottom == 0 &&
1371
                    frame_padleft == 0 &&
1372
                    frame_padright == 0)
1373
                {
1374
                    ost->video_resample = 0;
1375
                    ost->video_crop = 0;
1376
                    ost->video_pad = 0;
1377
                } else if ((codec->width == icodec->width -
1378
                                (frame_leftBand + frame_rightBand)) &&
1379
                        (codec->height == icodec->height -
1380
                                (frame_topBand  + frame_bottomBand)))
1381
                {
1382
                    ost->video_resample = 0;
1383
                    ost->video_crop = 1;
1384
                    ost->topBand = frame_topBand;
1385
                    ost->leftBand = frame_leftBand;
1386
                } else if ((codec->width == icodec->width + 
1387
                                (frame_padleft + frame_padright)) &&
1388
                        (codec->height == icodec->height +
1389
                                (frame_padtop + frame_padbottom))) {
1390
                    ost->video_resample = 0;
1391
                    ost->video_crop = 0;
1392
                    ost->video_pad = 1;
1393
                    ost->padtop = frame_padtop;
1394
                    ost->padleft = frame_padleft;
1395
                    ost->padbottom = frame_padbottom;
1396
                    ost->padright = frame_padright;
1397
                    if( avpicture_alloc( &ost->pict_tmp, PIX_FMT_YUV420P,
1398
                                codec->width, codec->height ) )
1399
                        goto fail;
1400
                } else {
1401
                    ost->video_resample = 1;
1402
                    ost->video_crop = 0; // cropping is handled as part of resample
1403
                    if( avpicture_alloc( &ost->pict_tmp, PIX_FMT_YUV420P,
1404
                                         codec->width, codec->height ) )
1405
                        goto fail;
1406

    
1407
                    ost->img_resample_ctx = img_resample_full_init( 
1408
                                      ost->st->codec.width, ost->st->codec.height,
1409
                                      ist->st->codec.width, ist->st->codec.height,
1410
                                      frame_topBand, frame_bottomBand,
1411
                            frame_leftBand, frame_rightBand, 
1412
                            frame_padtop, frame_padbottom, 
1413
                            frame_padleft, frame_padright);
1414
                    
1415
                    ost->padtop = frame_padtop;
1416
                    ost->padleft = frame_padleft;
1417
                    ost->padbottom = frame_padbottom;
1418
                    ost->padright = frame_padright;
1419
                   
1420
                }
1421
                ost->encoding_needed = 1;
1422
                ist->decoding_needed = 1;
1423
                break;
1424
            default:
1425
                av_abort();
1426
            }
1427
            /* two pass mode */
1428
            if (ost->encoding_needed && 
1429
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1430
                char logfilename[1024];
1431
                FILE *f;
1432
                int size;
1433
                char *logbuffer;
1434
                
1435
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
1436
                         pass_logfilename ? 
1437
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1438
                if (codec->flags & CODEC_FLAG_PASS1) {
1439
                    f = fopen(logfilename, "w");
1440
                    if (!f) {
1441
                        perror(logfilename);
1442
                        exit(1);
1443
                    }
1444
                    ost->logfile = f;
1445
                } else {
1446
                    /* read the log file */
1447
                    f = fopen(logfilename, "r");
1448
                    if (!f) {
1449
                        perror(logfilename);
1450
                        exit(1);
1451
                    }
1452
                    fseek(f, 0, SEEK_END);
1453
                    size = ftell(f);
1454
                    fseek(f, 0, SEEK_SET);
1455
                    logbuffer = av_malloc(size + 1);
1456
                    if (!logbuffer) {
1457
                        fprintf(stderr, "Could not allocate log buffer\n");
1458
                        exit(1);
1459
                    }
1460
                    size = fread(logbuffer, 1, size, f);
1461
                    fclose(f);
1462
                    logbuffer[size] = '\0';
1463
                    codec->stats_in = logbuffer;
1464
                }
1465
            }
1466
        }
1467
    }
1468

    
1469
    /* dump the file output parameters - cannot be done before in case
1470
       of stream copy */
1471
    for(i=0;i<nb_output_files;i++) {
1472
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1473
    }
1474

    
1475
    /* dump the stream mapping */
1476
    fprintf(stderr, "Stream mapping:\n");
1477
    for(i=0;i<nb_ostreams;i++) {
1478
        ost = ost_table[i];
1479
        fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1480
                ist_table[ost->source_index]->file_index,
1481
                ist_table[ost->source_index]->index,
1482
                ost->file_index, 
1483
                ost->index);
1484
    }
1485

    
1486
    /* open each encoder */
1487
    for(i=0;i<nb_ostreams;i++) {
1488
        ost = ost_table[i];
1489
        if (ost->encoding_needed) {
1490
            AVCodec *codec;
1491
            codec = avcodec_find_encoder(ost->st->codec.codec_id);
1492
            if (!codec) {
1493
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
1494
                        ost->file_index, ost->index);
1495
                exit(1);
1496
            }
1497
            if (avcodec_open(&ost->st->codec, codec) < 0) {
1498
                fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
1499
                        ost->file_index, ost->index);
1500
                exit(1);
1501
            }
1502
        }
1503
    }
1504

    
1505
    /* open each decoder */
1506
    for(i=0;i<nb_istreams;i++) {
1507
        ist = ist_table[i];
1508
        if (ist->decoding_needed) {
1509
            AVCodec *codec;
1510
            codec = avcodec_find_decoder(ist->st->codec.codec_id);
1511
            if (!codec) {
1512
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1513
                        ist->st->codec.codec_id, ist->file_index, ist->index);
1514
                exit(1);
1515
            }
1516
            if (avcodec_open(&ist->st->codec, codec) < 0) {
1517
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1518
                        ist->file_index, ist->index);
1519
                exit(1);
1520
            }
1521
            //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1522
            //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1523
        }
1524
    }
1525

    
1526
    /* init pts */
1527
    for(i=0;i<nb_istreams;i++) {
1528
        ist = ist_table[i];
1529
        is = input_files[ist->file_index];
1530
        ist->pts = 0;
1531
        ist->next_pts = 0;
1532
    }
1533
    
1534
    /* compute buffer size max (should use a complete heuristic) */
1535
    for(i=0;i<nb_input_files;i++) {
1536
        file_table[i].buffer_size_max = 2048;
1537
    }
1538

    
1539
    /* open files and write file headers */
1540
    for(i=0;i<nb_output_files;i++) {
1541
        os = output_files[i];
1542
        if (av_write_header(os) < 0) {
1543
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1544
            ret = -EINVAL;
1545
            goto fail;
1546
        }
1547
    }
1548

    
1549
#ifndef CONFIG_WIN32
1550
    if ( !using_stdin ) {
1551
        fprintf(stderr, "Press [q] to stop encoding\n");
1552
        url_set_interrupt_cb(decode_interrupt_cb);
1553
    }
1554
#endif
1555
    term_init();
1556

    
1557
    stream_no_data = 0;
1558
    key = -1;
1559

    
1560
    for(; received_sigterm == 0;) {
1561
        int file_index, ist_index;
1562
        AVPacket pkt;
1563
        double pts_min;
1564
        
1565
    redo:
1566
        /* if 'q' pressed, exits */
1567
        if (!using_stdin) {
1568
            if (q_pressed)
1569
                break;
1570
            /* read_key() returns 0 on EOF */
1571
            key = read_key();
1572
            if (key == 'q')
1573
                break;
1574
        }
1575

    
1576
        /* select the stream that we must read now by looking at the
1577
           smallest output pts */
1578
        file_index = -1;
1579
        pts_min = 1e10;
1580
        for(i=0;i<nb_ostreams;i++) {
1581
            double pts;
1582
            ost = ost_table[i];
1583
            os = output_files[ost->file_index];
1584
            ist = ist_table[ost->source_index];
1585
            pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
1586
            if (!file_table[ist->file_index].eof_reached && 
1587
                pts < pts_min) {
1588
                pts_min = pts;
1589
                file_index = ist->file_index;
1590
            }
1591
        }
1592
        /* if none, if is finished */
1593
        if (file_index < 0) {
1594
            break;
1595
        }
1596

    
1597
        /* finish if recording time exhausted */
1598
        if (recording_time > 0 && pts_min >= (recording_time / 1000000.0))
1599
            break;
1600

    
1601
        /* read a frame from it and output it in the fifo */
1602
        is = input_files[file_index];
1603
        if (av_read_frame(is, &pkt) < 0) {
1604
            file_table[file_index].eof_reached = 1;
1605
            continue;
1606
        }
1607

    
1608
        if (!pkt.size) {
1609
            stream_no_data = is;
1610
        } else {
1611
            stream_no_data = 0;
1612
        }
1613
        if (do_pkt_dump) {
1614
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1615
        }
1616
        /* the following test is needed in case new streams appear
1617
           dynamically in stream : we ignore them */
1618
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1619
            goto discard_packet;
1620
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1621
        ist = ist_table[ist_index];
1622
        if (ist->discard)
1623
            goto discard_packet;
1624

    
1625
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1626
        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1627
            fprintf(stderr, "Error while decoding stream #%d.%d\n",
1628
                    ist->file_index, ist->index);
1629
            av_free_packet(&pkt);
1630
            goto redo;
1631
        }
1632
        
1633
    discard_packet:
1634
        av_free_packet(&pkt);
1635
        
1636
        /* dump report by using the output first video and audio streams */
1637
        print_report(output_files, ost_table, nb_ostreams, 0);
1638
    }
1639

    
1640
    /* at the end of stream, we must flush the decoder buffers */
1641
    for(i=0;i<nb_istreams;i++) {
1642
        ist = ist_table[i];
1643
        if (ist->decoding_needed) {
1644
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1645
        }
1646
    }
1647

    
1648
    term_exit();
1649

    
1650
    /* dump report by using the first video and audio streams */
1651
    print_report(output_files, ost_table, nb_ostreams, 1);
1652

    
1653
    /* write the trailer if needed and close file */
1654
    for(i=0;i<nb_output_files;i++) {
1655
        os = output_files[i];
1656
        av_write_trailer(os);
1657
    }
1658

    
1659
    /* close each encoder */
1660
    for(i=0;i<nb_ostreams;i++) {
1661
        ost = ost_table[i];
1662
        if (ost->encoding_needed) {
1663
            av_freep(&ost->st->codec.stats_in);
1664
            avcodec_close(&ost->st->codec);
1665
        }
1666
    }
1667
    
1668
    /* close each decoder */
1669
    for(i=0;i<nb_istreams;i++) {
1670
        ist = ist_table[i];
1671
        if (ist->decoding_needed) {
1672
            avcodec_close(&ist->st->codec);
1673
        }
1674
    }
1675

    
1676
    /* finished ! */
1677
    
1678
    ret = 0;
1679
 fail1:
1680
    av_free(file_table);
1681

    
1682
    if (ist_table) {
1683
        for(i=0;i<nb_istreams;i++) {
1684
            ist = ist_table[i];
1685
            av_free(ist);
1686
        }
1687
        av_free(ist_table);
1688
    }
1689
    if (ost_table) {
1690
        for(i=0;i<nb_ostreams;i++) {
1691
            ost = ost_table[i];
1692
            if (ost) {
1693
                if (ost->logfile) {
1694
                    fclose(ost->logfile);
1695
                    ost->logfile = NULL;
1696
                }
1697
                fifo_free(&ost->fifo); /* works even if fifo is not
1698
                                          initialized but set to zero */
1699
                av_free(ost->pict_tmp.data[0]);
1700
                if (ost->video_resample)
1701
                    img_resample_close(ost->img_resample_ctx);
1702
                if (ost->audio_resample)
1703
                    audio_resample_close(ost->resample);
1704
                av_free(ost);
1705
            }
1706
        }
1707
        av_free(ost_table);
1708
    }
1709
    return ret;
1710
 fail:
1711
    ret = -ENOMEM;
1712
    goto fail1;
1713
}
1714

    
1715
#if 0
1716
int file_read(const char *filename)
1717
{
1718
    URLContext *h;
1719
    unsigned char buffer[1024];
1720
    int len, i;
1721

1722
    if (url_open(&h, filename, O_RDONLY) < 0) {
1723
        printf("could not open '%s'\n", filename);
1724
        return -1;
1725
    }
1726
    for(;;) {
1727
        len = url_read(h, buffer, sizeof(buffer));
1728
        if (len <= 0)
1729
            break;
1730
        for(i=0;i<len;i++) putchar(buffer[i]);
1731
    }
1732
    url_close(h);
1733
    return 0;
1734
}
1735
#endif
1736

    
1737
static void opt_image_format(const char *arg)
1738
{
1739
    AVImageFormat *f;
1740
    
1741
    for(f = first_image_format; f != NULL; f = f->next) {
1742
        if (!strcmp(arg, f->name))
1743
            break;
1744
    }
1745
    if (!f) {
1746
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
1747
        exit(1);
1748
    }
1749
    image_format = f;
1750
}
1751

    
1752
static void opt_format(const char *arg)
1753
{
1754
    /* compatibility stuff for pgmyuv */
1755
    if (!strcmp(arg, "pgmyuv")) {
1756
        opt_image_format(arg);
1757
        arg = "image";
1758
    }
1759

    
1760
    file_iformat = av_find_input_format(arg);
1761
    file_oformat = guess_format(arg, NULL, NULL);
1762
    if (!file_iformat && !file_oformat) {
1763
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
1764
        exit(1);
1765
    }
1766
}
1767

    
1768
static void opt_video_bitrate(const char *arg)
1769
{
1770
    video_bit_rate = atoi(arg) * 1000;
1771
}
1772

    
1773
static void opt_video_bitrate_tolerance(const char *arg)
1774
{
1775
    video_bit_rate_tolerance = atoi(arg) * 1000;
1776
}
1777

    
1778
static void opt_video_bitrate_max(const char *arg)
1779
{
1780
    video_rc_max_rate = atoi(arg) * 1000;
1781
}
1782

    
1783
static void opt_video_bitrate_min(const char *arg)
1784
{
1785
    video_rc_min_rate = atoi(arg) * 1000;
1786
}
1787

    
1788
static void opt_video_buffer_size(const char *arg)
1789
{
1790
    video_rc_buffer_size = atoi(arg) * 8*1024;
1791
}
1792

    
1793
static void opt_video_rc_eq(char *arg)
1794
{
1795
    video_rc_eq = arg;
1796
}
1797

    
1798
static void opt_video_rc_override_string(char *arg)
1799
{
1800
    video_rc_override_string = arg;
1801
}
1802

    
1803

    
1804
static void opt_workaround_bugs(const char *arg)
1805
{
1806
    workaround_bugs = atoi(arg);
1807
}
1808

    
1809
static void opt_dct_algo(const char *arg)
1810
{
1811
    dct_algo = atoi(arg);
1812
}
1813

    
1814
static void opt_idct_algo(const char *arg)
1815
{
1816
    idct_algo = atoi(arg);
1817
}
1818

    
1819

    
1820
static void opt_error_resilience(const char *arg)
1821
{
1822
    error_resilience = atoi(arg);
1823
}
1824

    
1825
static void opt_error_concealment(const char *arg)
1826
{
1827
    error_concealment = atoi(arg);
1828
}
1829

    
1830
static void opt_debug(const char *arg)
1831
{
1832
    debug = atoi(arg);
1833
}
1834

    
1835
static void opt_vismv(const char *arg)
1836
{
1837
    debug_mv = atoi(arg);
1838
}
1839
    
1840
static void opt_verbose(const char *arg)
1841
{
1842
    verbose = atoi(arg);
1843
}
1844

    
1845
static void opt_frame_rate(const char *arg)
1846
{
1847
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
1848
        fprintf(stderr, "Incorrect frame rate\n");
1849
        exit(1);
1850
    }
1851
}
1852

    
1853
static void opt_frame_crop_top(const char *arg)
1854
{
1855
    frame_topBand = atoi(arg); 
1856
    if (frame_topBand < 0) {
1857
        fprintf(stderr, "Incorrect top crop size\n");
1858
        exit(1);
1859
    }
1860
    if ((frame_topBand % 2) != 0) {
1861
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
1862
        exit(1);
1863
    }
1864
    if ((frame_topBand) >= frame_height){
1865
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1866
        exit(1);
1867
    }
1868
    frame_height -= frame_topBand;
1869
}
1870

    
1871
static void opt_frame_crop_bottom(const char *arg)
1872
{
1873
    frame_bottomBand = atoi(arg);
1874
    if (frame_bottomBand < 0) {
1875
        fprintf(stderr, "Incorrect bottom crop size\n");
1876
        exit(1);
1877
    }
1878
    if ((frame_bottomBand % 2) != 0) {
1879
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
1880
        exit(1);        
1881
    }
1882
    if ((frame_bottomBand) >= frame_height){
1883
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1884
        exit(1);
1885
    }
1886
    frame_height -= frame_bottomBand;
1887
}
1888

    
1889
static void opt_frame_crop_left(const char *arg)
1890
{
1891
    frame_leftBand = atoi(arg);
1892
    if (frame_leftBand < 0) {
1893
        fprintf(stderr, "Incorrect left crop size\n");
1894
        exit(1);
1895
    }
1896
    if ((frame_leftBand % 2) != 0) {
1897
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
1898
        exit(1);
1899
    }
1900
    if ((frame_leftBand) >= frame_width){
1901
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1902
        exit(1);
1903
    }
1904
    frame_width -= frame_leftBand;
1905
}
1906

    
1907
static void opt_frame_crop_right(const char *arg)
1908
{
1909
    frame_rightBand = atoi(arg);
1910
    if (frame_rightBand < 0) {
1911
        fprintf(stderr, "Incorrect right crop size\n");
1912
        exit(1);
1913
    }
1914
    if ((frame_rightBand % 2) != 0) {
1915
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
1916
        exit(1);        
1917
    }
1918
    if ((frame_rightBand) >= frame_width){
1919
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1920
        exit(1);
1921
    }
1922
    frame_width -= frame_rightBand;
1923
}
1924

    
1925
static void opt_frame_size(const char *arg)
1926
{
1927
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
1928
        fprintf(stderr, "Incorrect frame size\n");
1929
        exit(1);
1930
    }
1931
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
1932
        fprintf(stderr, "Frame size must be a multiple of 2\n");
1933
        exit(1);
1934
    }
1935
}
1936

    
1937

    
1938
#define SCALEBITS 10
1939
#define ONE_HALF  (1 << (SCALEBITS - 1))
1940
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
1941

    
1942
#define RGB_TO_Y(r, g, b) \
1943
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
1944
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
1945

    
1946
#define RGB_TO_U(r1, g1, b1, shift)\
1947
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
1948
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1949

    
1950
#define RGB_TO_V(r1, g1, b1, shift)\
1951
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
1952
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
1953

    
1954
static void opt_pad_color(const char *arg) {
1955
    /* Input is expected to be six hex digits similar to
1956
       how colors are expressed in html tags (but without the #) */
1957
    int rgb = strtol(arg, NULL, 16);
1958
    int r,g,b;
1959
    
1960
    r = (rgb >> 16); 
1961
    g = ((rgb >> 8) & 255);
1962
    b = (rgb & 255);
1963

    
1964
    padcolor[0] = RGB_TO_Y(r,g,b);
1965
    padcolor[1] = RGB_TO_U(r,g,b,0);
1966
    padcolor[2] = RGB_TO_V(r,g,b,0);
1967
}
1968

    
1969
static void opt_frame_pad_top(const char *arg)
1970
{
1971
    frame_padtop = atoi(arg); 
1972
    if (frame_padtop < 0) {
1973
        fprintf(stderr, "Incorrect top pad size\n");
1974
        exit(1);
1975
    }
1976
    if ((frame_padtop % 2) != 0) {
1977
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
1978
        exit(1);
1979
    }
1980
}
1981

    
1982
static void opt_frame_pad_bottom(const char *arg)
1983
{
1984
    frame_padbottom = atoi(arg); 
1985
    if (frame_padbottom < 0) {
1986
        fprintf(stderr, "Incorrect bottom pad size\n");
1987
        exit(1);
1988
    }
1989
    if ((frame_padbottom % 2) != 0) {
1990
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
1991
        exit(1);
1992
    }
1993
}
1994

    
1995

    
1996
static void opt_frame_pad_left(const char *arg)
1997
{
1998
    frame_padleft = atoi(arg); 
1999
    if (frame_padleft < 0) {
2000
        fprintf(stderr, "Incorrect left pad size\n");
2001
        exit(1);
2002
    }
2003
    if ((frame_padleft % 2) != 0) {
2004
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2005
        exit(1);
2006
    }
2007
}
2008

    
2009

    
2010
static void opt_frame_pad_right(const char *arg)
2011
{
2012
    frame_padright = atoi(arg); 
2013
    if (frame_padright < 0) {
2014
        fprintf(stderr, "Incorrect right pad size\n");
2015
        exit(1);
2016
    }
2017
    if ((frame_padright % 2) != 0) {
2018
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2019
        exit(1);
2020
    }
2021
}
2022

    
2023

    
2024
static void opt_frame_pix_fmt(const char *arg)
2025
{
2026
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2027
}
2028

    
2029
static void opt_frame_aspect_ratio(const char *arg)
2030
{
2031
    int x = 0, y = 0;
2032
    double ar = 0;
2033
    const char *p;
2034
    
2035
    p = strchr(arg, ':');
2036
    if (p) {
2037
        x = strtol(arg, (char **)&arg, 10);
2038
        if (arg == p)
2039
            y = strtol(arg+1, (char **)&arg, 10);
2040
        if (x > 0 && y > 0)
2041
            ar = (double)x / (double)y;
2042
    } else
2043
        ar = strtod(arg, (char **)&arg);
2044

    
2045
    if (!ar) {
2046
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2047
        exit(1);
2048
    }
2049
    frame_aspect_ratio = ar;
2050
}
2051

    
2052
static void opt_gop_size(const char *arg)
2053
{
2054
    gop_size = atoi(arg);
2055
}
2056

    
2057
static void opt_b_frames(const char *arg)
2058
{
2059
    b_frames = atoi(arg);
2060
    if (b_frames > FF_MAX_B_FRAMES) {
2061
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2062
        exit(1);
2063
    } else if (b_frames < 1) {
2064
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2065
        exit(1);
2066
    }
2067
}
2068

    
2069
static void opt_mb_decision(const char *arg)
2070
{
2071
    mb_decision = atoi(arg);
2072
}
2073

    
2074
static void opt_mb_cmp(const char *arg)
2075
{
2076
    mb_cmp = atoi(arg);
2077
}
2078

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

    
2084
static void opt_sub_cmp(const char *arg)
2085
{
2086
    sub_cmp = atoi(arg);
2087
}
2088

    
2089
static void opt_cmp(const char *arg)
2090
{
2091
    cmp = atoi(arg);
2092
}
2093

    
2094
static void opt_pre_cmp(const char *arg)
2095
{
2096
    pre_cmp = atoi(arg);
2097
}
2098

    
2099
static void opt_pre_me(const char *arg)
2100
{
2101
    pre_me = atoi(arg);
2102
}
2103

    
2104
static void opt_lumi_mask(const char *arg)
2105
{
2106
    lumi_mask = atof(arg);
2107
}
2108

    
2109
static void opt_dark_mask(const char *arg)
2110
{
2111
    dark_mask = atof(arg);
2112
}
2113

    
2114
static void opt_scplx_mask(const char *arg)
2115
{
2116
    scplx_mask = atof(arg);
2117
}
2118

    
2119
static void opt_tcplx_mask(const char *arg)
2120
{
2121
    tcplx_mask = atof(arg);
2122
}
2123

    
2124
static void opt_p_mask(const char *arg)
2125
{
2126
    p_mask = atof(arg);
2127
}
2128

    
2129
static void opt_qscale(const char *arg)
2130
{
2131
    video_qscale = atof(arg);
2132
    if (video_qscale < 0.01 ||
2133
        video_qscale > 255) {
2134
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2135
        exit(1);
2136
    }
2137
}
2138

    
2139
static void opt_qmin(const char *arg)
2140
{
2141
    video_qmin = atoi(arg);
2142
    if (video_qmin < 0 ||
2143
        video_qmin > 31) {
2144
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2145
        exit(1);
2146
    }
2147
}
2148

    
2149
static void opt_qmax(const char *arg)
2150
{
2151
    video_qmax = atoi(arg);
2152
    if (video_qmax < 0 ||
2153
        video_qmax > 31) {
2154
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2155
        exit(1);
2156
    }
2157
}
2158

    
2159
static void opt_mb_qmin(const char *arg)
2160
{
2161
    video_mb_qmin = atoi(arg);
2162
    if (video_mb_qmin < 0 ||
2163
        video_mb_qmin > 31) {
2164
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2165
        exit(1);
2166
    }
2167
}
2168

    
2169
static void opt_mb_qmax(const char *arg)
2170
{
2171
    video_mb_qmax = atoi(arg);
2172
    if (video_mb_qmax < 0 ||
2173
        video_mb_qmax > 31) {
2174
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2175
        exit(1);
2176
    }
2177
}
2178

    
2179
static void opt_qdiff(const char *arg)
2180
{
2181
    video_qdiff = atoi(arg);
2182
    if (video_qdiff < 0 ||
2183
        video_qdiff > 31) {
2184
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2185
        exit(1);
2186
    }
2187
}
2188

    
2189
static void opt_qblur(const char *arg)
2190
{
2191
    video_qblur = atof(arg);
2192
}
2193

    
2194
static void opt_qcomp(const char *arg)
2195
{
2196
    video_qcomp = atof(arg);
2197
}
2198

    
2199
static void opt_rc_initial_cplx(const char *arg)
2200
{
2201
    video_rc_initial_cplx = atof(arg);
2202
}
2203
static void opt_b_qfactor(const char *arg)
2204
{
2205
    video_b_qfactor = atof(arg);
2206
}
2207
static void opt_i_qfactor(const char *arg)
2208
{
2209
    video_i_qfactor = atof(arg);
2210
}
2211
static void opt_b_qoffset(const char *arg)
2212
{
2213
    video_b_qoffset = atof(arg);
2214
}
2215
static void opt_i_qoffset(const char *arg)
2216
{
2217
    video_i_qoffset = atof(arg);
2218
}
2219

    
2220
static void opt_ibias(const char *arg)
2221
{
2222
    video_intra_quant_bias = atoi(arg);
2223
}
2224
static void opt_pbias(const char *arg)
2225
{
2226
    video_inter_quant_bias = atoi(arg);
2227
}
2228

    
2229
static void opt_packet_size(const char *arg)
2230
{
2231
    packet_size= atoi(arg);
2232
}
2233

    
2234
static void opt_error_rate(const char *arg)
2235
{
2236
    error_rate= atoi(arg);
2237
}
2238

    
2239
static void opt_strict(const char *arg)
2240
{
2241
    strict= atoi(arg);
2242
}
2243

    
2244
static void opt_top_field_first(const char *arg)
2245
{
2246
    top_field_first= atoi(arg);
2247
}
2248

    
2249
static void opt_noise_reduction(const char *arg)
2250
{
2251
    noise_reduction= atoi(arg);
2252
}
2253

    
2254
static void opt_qns(const char *arg)
2255
{
2256
    qns= atoi(arg);
2257
}
2258

    
2259
static void opt_sc_threshold(const char *arg)
2260
{
2261
    sc_threshold= atoi(arg);
2262
}
2263

    
2264
static void opt_thread_count(const char *arg)
2265
{
2266
    thread_count= atoi(arg);
2267
#if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2268
    fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2269
#endif
2270
}
2271

    
2272
static void opt_audio_bitrate(const char *arg)
2273
{
2274
    audio_bit_rate = atoi(arg) * 1000;
2275
}
2276

    
2277
static void opt_audio_rate(const char *arg)
2278
{
2279
    audio_sample_rate = atoi(arg);
2280
}
2281

    
2282
static void opt_audio_channels(const char *arg)
2283
{
2284
    audio_channels = atoi(arg);
2285
}
2286

    
2287
static void opt_video_device(const char *arg)
2288
{
2289
    video_device = av_strdup(arg);
2290
}
2291

    
2292
static void opt_video_channel(const char *arg)
2293
{
2294
    video_channel = strtol(arg, NULL, 0);
2295
}
2296

    
2297
static void opt_video_standard(const char *arg)
2298
{
2299
    video_standard = av_strdup(arg);
2300
}
2301

    
2302
static void opt_audio_device(const char *arg)
2303
{
2304
    audio_device = av_strdup(arg);
2305
}
2306

    
2307
static void opt_dv1394(const char *arg)
2308
{
2309
    video_grab_format = "dv1394";
2310
    audio_grab_format = NULL;
2311
}
2312

    
2313
static void opt_audio_codec(const char *arg)
2314
{
2315
    AVCodec *p;
2316

    
2317
    if (!strcmp(arg, "copy")) {
2318
        audio_stream_copy = 1;
2319
    } else {
2320
        p = first_avcodec;
2321
        while (p) {
2322
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2323
                break;
2324
            p = p->next;
2325
        }
2326
        if (p == NULL) {
2327
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2328
            exit(1);
2329
        } else {
2330
            audio_codec_id = p->id;
2331
        }
2332
    }
2333
}
2334

    
2335
static void add_frame_hooker(const char *arg)
2336
{
2337
    int argc = 0;
2338
    char *argv[64];
2339
    int i;
2340
    char *args = av_strdup(arg);
2341

    
2342
    using_vhook = 1;
2343

    
2344
    argv[0] = strtok(args, " ");
2345
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2346
    }
2347

    
2348
    i = frame_hook_add(argc, argv);
2349

    
2350
    if (i != 0) {
2351
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2352
        exit(1);
2353
    }
2354
}
2355

    
2356
const char *motion_str[] = {
2357
    "zero",
2358
    "full",
2359
    "log",
2360
    "phods",
2361
    "epzs",
2362
    "x1",
2363
    NULL,
2364
};
2365

    
2366
static void opt_motion_estimation(const char *arg)
2367
{
2368
    const char **p;
2369
    p = motion_str;
2370
    for(;;) {
2371
        if (!*p) {
2372
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2373
            exit(1);
2374
        }
2375
        if (!strcmp(*p, arg))
2376
            break;
2377
        p++;
2378
    }
2379
    me_method = (p - motion_str) + 1;
2380
}
2381

    
2382
static void opt_video_codec(const char *arg)
2383
{
2384
    AVCodec *p;
2385

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

    
2404
static void opt_map(const char *arg)
2405
{
2406
    AVStreamMap *m;
2407
    const char *p;
2408

    
2409
    p = arg;
2410
    m = &stream_maps[nb_stream_maps++];
2411

    
2412
    m->file_index = strtol(arg, (char **)&p, 0);
2413
    if (*p)
2414
        p++;
2415

    
2416
    m->stream_index = strtol(p, (char **)&p, 0);
2417
}
2418

    
2419
static void opt_recording_time(const char *arg)
2420
{
2421
    recording_time = parse_date(arg, 1);
2422
}
2423

    
2424
static void opt_start_time(const char *arg)
2425
{
2426
    start_time = parse_date(arg, 1);
2427
}
2428

    
2429
static void opt_rec_timestamp(const char *arg)
2430
{
2431
    rec_timestamp = parse_date(arg, 0) / 1000000;
2432
}
2433

    
2434
static void opt_input_file(const char *filename)
2435
{
2436
    AVFormatContext *ic;
2437
    AVFormatParameters params, *ap = &params;
2438
    int err, i, ret, rfps, rfps_base;
2439

    
2440
    if (!strcmp(filename, "-"))
2441
        filename = "pipe:";
2442

    
2443
    using_stdin |= !strcmp(filename, "pipe:" ) || 
2444
                   !strcmp( filename, "/dev/stdin" );
2445

    
2446
    /* get default parameters from command line */
2447
    memset(ap, 0, sizeof(*ap));
2448
    ap->sample_rate = audio_sample_rate;
2449
    ap->channels = audio_channels;
2450
    ap->frame_rate = frame_rate;
2451
    ap->frame_rate_base = frame_rate_base;
2452
    ap->width = frame_width + frame_padleft + frame_padright;
2453
    ap->height = frame_height + frame_padtop + frame_padbottom;
2454
    ap->image_format = image_format;
2455
    ap->pix_fmt = frame_pix_fmt;
2456

    
2457
    /* open the input file with generic libav function */
2458
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2459
    if (err < 0) {
2460
        print_error(filename, err);
2461
        exit(1);
2462
    }
2463
    
2464
    /* If not enough info to get the stream parameters, we decode the
2465
       first frames to get it. (used in mpeg case for example) */
2466
    ret = av_find_stream_info(ic);
2467
    if (ret < 0) {
2468
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2469
        exit(1);
2470
    }
2471

    
2472
    /* if seeking requested, we execute it */
2473
    if (start_time != 0) {
2474
        int64_t timestamp;
2475

    
2476
        timestamp = start_time;
2477
        /* add the stream start time */
2478
        if (ic->start_time != AV_NOPTS_VALUE)
2479
            timestamp += ic->start_time;
2480
        ret = av_seek_frame(ic, -1, timestamp);
2481
        if (ret < 0) {
2482
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2483
                    filename, (double)timestamp / AV_TIME_BASE);
2484
        }
2485
        /* reset seek info */
2486
        start_time = 0;
2487
    }
2488

    
2489
    /* update the current parameters so that they match the one of the input stream */
2490
    for(i=0;i<ic->nb_streams;i++) {
2491
        AVCodecContext *enc = &ic->streams[i]->codec;
2492
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2493
        if(thread_count>1)
2494
            avcodec_thread_init(enc, thread_count);
2495
#endif
2496
        enc->thread_count= thread_count;
2497
        switch(enc->codec_type) {
2498
        case CODEC_TYPE_AUDIO:
2499
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2500
            audio_channels = enc->channels;
2501
            audio_sample_rate = enc->sample_rate;
2502
            break;
2503
        case CODEC_TYPE_VIDEO:
2504
            frame_height = enc->height;
2505
            frame_width = enc->width;
2506
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2507
            frame_pix_fmt = enc->pix_fmt;
2508
            rfps      = ic->streams[i]->r_frame_rate;
2509
            rfps_base = ic->streams[i]->r_frame_rate_base;
2510
            enc->workaround_bugs = workaround_bugs;
2511
            enc->error_resilience = error_resilience; 
2512
            enc->error_concealment = error_concealment; 
2513
            enc->idct_algo = idct_algo;
2514
            enc->debug = debug;
2515
            enc->debug_mv = debug_mv;            
2516
            if(bitexact)
2517
                enc->flags|= CODEC_FLAG_BITEXACT;
2518

    
2519
            assert(enc->frame_rate_base == rfps_base); // should be true for now
2520
            if (enc->frame_rate != rfps) { 
2521
                fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2522
                    i, (float)enc->frame_rate / enc->frame_rate_base,
2523
                    (float)rfps / rfps_base);
2524
            }
2525
            /* update the current frame rate to match the stream frame rate */
2526
            frame_rate      = rfps;
2527
            frame_rate_base = rfps_base;
2528

    
2529
            enc->rate_emu = rate_emu;
2530
            break;
2531
        case CODEC_TYPE_DATA:
2532
            break;
2533
        default:
2534
            av_abort();
2535
        }
2536
    }
2537
    
2538
    input_files[nb_input_files] = ic;
2539
    /* dump the file content */
2540
    dump_format(ic, nb_input_files, filename, 0);
2541
    nb_input_files++;
2542
    file_iformat = NULL;
2543
    file_oformat = NULL;
2544
    image_format = NULL;
2545

    
2546
    rate_emu = 0;
2547
}
2548

    
2549
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2550
{
2551
    int has_video, has_audio, i, j;
2552
    AVFormatContext *ic;
2553

    
2554
    has_video = 0;
2555
    has_audio = 0;
2556
    for(j=0;j<nb_input_files;j++) {
2557
        ic = input_files[j];
2558
        for(i=0;i<ic->nb_streams;i++) {
2559
            AVCodecContext *enc = &ic->streams[i]->codec;
2560
            switch(enc->codec_type) {
2561
            case CODEC_TYPE_AUDIO:
2562
                has_audio = 1;
2563
                break;
2564
            case CODEC_TYPE_VIDEO:
2565
                has_video = 1;
2566
                break;
2567
            case CODEC_TYPE_DATA:
2568
                break;
2569
            default:
2570
                av_abort();
2571
            }
2572
        }
2573
    }
2574
    *has_video_ptr = has_video;
2575
    *has_audio_ptr = has_audio;
2576
}
2577

    
2578
static void opt_output_file(const char *filename)
2579
{
2580
    AVStream *st;
2581
    AVFormatContext *oc;
2582
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2583
    int codec_id;
2584
    AVFormatParameters params, *ap = &params;
2585

    
2586
    if (!strcmp(filename, "-"))
2587
        filename = "pipe:";
2588

    
2589
    oc = av_alloc_format_context();
2590

    
2591
    if (!file_oformat) {
2592
        file_oformat = guess_format(NULL, filename, NULL);
2593
        if (!file_oformat) {
2594
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2595
                    filename);
2596
            exit(1);
2597
        }
2598
    }
2599
    
2600
    oc->oformat = file_oformat;
2601

    
2602
    if (!strcmp(file_oformat->name, "ffm") && 
2603
        strstart(filename, "http:", NULL)) {
2604
        /* special case for files sent to ffserver: we get the stream
2605
           parameters from ffserver */
2606
        if (read_ffserver_streams(oc, filename) < 0) {
2607
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2608
            exit(1);
2609
        }
2610
    } else {
2611
        use_video = file_oformat->video_codec != CODEC_ID_NONE;
2612
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE;
2613

    
2614
        /* disable if no corresponding type found and at least one
2615
           input file */
2616
        if (nb_input_files > 0) {
2617
            check_audio_video_inputs(&input_has_video, &input_has_audio);
2618
            if (!input_has_video)
2619
                use_video = 0;
2620
            if (!input_has_audio)
2621
                use_audio = 0;
2622
        }
2623

    
2624
        /* manual disable */
2625
        if (audio_disable) {
2626
            use_audio = 0;
2627
        }
2628
        if (video_disable) {
2629
            use_video = 0;
2630
        }
2631
        
2632
        nb_streams = 0;
2633
        if (use_video) {
2634
            AVCodecContext *video_enc;
2635
            
2636
            st = av_mallocz(sizeof(AVStream));
2637
            if (!st) {
2638
                fprintf(stderr, "Could not alloc stream\n");
2639
                exit(1);
2640
            }
2641
            avcodec_get_context_defaults(&st->codec);
2642
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2643
            if(thread_count>1)
2644
                avcodec_thread_init(&st->codec, thread_count);
2645
#endif
2646

    
2647
            video_enc = &st->codec;
2648
            
2649
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2650
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2651
            if (video_stream_copy) {
2652
                st->stream_copy = 1;
2653
                video_enc->codec_type = CODEC_TYPE_VIDEO;
2654
            } else {
2655
                char *p;
2656
                int i;
2657
            
2658
                codec_id = file_oformat->video_codec;
2659
                if (video_codec_id != CODEC_ID_NONE)
2660
                    codec_id = video_codec_id;
2661
                
2662
                video_enc->codec_id = codec_id;
2663
                
2664
                video_enc->bit_rate = video_bit_rate;
2665
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2666
                video_enc->frame_rate = frame_rate; 
2667
                video_enc->frame_rate_base = frame_rate_base; 
2668
                
2669
                video_enc->width = frame_width + frame_padright + frame_padleft;
2670
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
2671
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2672
                video_enc->pix_fmt = frame_pix_fmt;
2673

    
2674
                if (!intra_only)
2675
                    video_enc->gop_size = gop_size;
2676
                else
2677
                    video_enc->gop_size = 0;
2678
                if (video_qscale || same_quality) {
2679
                    video_enc->flags |= CODEC_FLAG_QSCALE;
2680
                    st->quality = FF_QP2LAMBDA * video_qscale;
2681
                }
2682

    
2683
                if(intra_matrix)
2684
                    video_enc->intra_matrix = intra_matrix;
2685
                if(inter_matrix)
2686
                    video_enc->inter_matrix = inter_matrix;
2687

    
2688
                if(bitexact)
2689
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
2690

    
2691
                video_enc->mb_decision = mb_decision;
2692
                video_enc->mb_cmp = mb_cmp;
2693
                video_enc->ildct_cmp = ildct_cmp;
2694
                video_enc->me_sub_cmp = sub_cmp;
2695
                video_enc->me_cmp = cmp;
2696
                video_enc->me_pre_cmp = pre_cmp;
2697
                video_enc->pre_me = pre_me;
2698
                video_enc->lumi_masking = lumi_mask;
2699
                video_enc->dark_masking = dark_mask;
2700
                video_enc->spatial_cplx_masking = scplx_mask;
2701
                video_enc->temporal_cplx_masking = tcplx_mask;
2702
                video_enc->p_masking = p_mask;
2703
                video_enc->quantizer_noise_shaping= qns;
2704
                
2705
                if (use_umv) {
2706
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
2707
                }
2708
                if (use_ss) {
2709
                    video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
2710
                }
2711
                   if (use_aic) {
2712
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
2713
                }
2714
                   if (use_aiv) {
2715
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
2716
                }
2717
                if (use_4mv) {
2718
                    video_enc->flags |= CODEC_FLAG_4MV;
2719
                }
2720
                if (use_obmc) {
2721
                    video_enc->flags |= CODEC_FLAG_OBMC;
2722
                }
2723
                if (use_loop) {
2724
                    video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
2725
                }
2726
            
2727
                if(use_part) {
2728
                    video_enc->flags |= CODEC_FLAG_PART;
2729
                }
2730
                   if (use_alt_scan) {
2731
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
2732
                }
2733
                   if (use_trell) {
2734
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
2735
                }
2736
                   if (use_scan_offset) {
2737
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
2738
                }
2739
                   if (closed_gop) {
2740
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
2741
                }
2742
                if (b_frames) {
2743
                    video_enc->max_b_frames = b_frames;
2744
                    video_enc->b_frame_strategy = 0;
2745
                    video_enc->b_quant_factor = 2.0;
2746
                }
2747
                if (do_interlace_dct) {
2748
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
2749
                }
2750
                if (do_interlace_me) {
2751
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
2752
                }
2753
                video_enc->qmin = video_qmin;
2754
                video_enc->qmax = video_qmax;
2755
                video_enc->mb_qmin = video_mb_qmin;
2756
                video_enc->mb_qmax = video_mb_qmax;
2757
                video_enc->max_qdiff = video_qdiff;
2758
                video_enc->qblur = video_qblur;
2759
                video_enc->qcompress = video_qcomp;
2760
                video_enc->rc_eq = video_rc_eq;
2761
                video_enc->debug = debug;
2762
                video_enc->debug_mv = debug_mv;
2763
                video_enc->thread_count = thread_count;
2764
                p= video_rc_override_string;
2765
                for(i=0; p; i++){
2766
                    int start, end, q;
2767
                    int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2768
                    if(e!=3){
2769
                        fprintf(stderr, "error parsing rc_override\n");
2770
                        exit(1);
2771
                    }
2772
                    video_enc->rc_override= 
2773
                        av_realloc(video_enc->rc_override, 
2774
                                   sizeof(RcOverride)*(i+1));
2775
                    video_enc->rc_override[i].start_frame= start;
2776
                    video_enc->rc_override[i].end_frame  = end;
2777
                    if(q>0){
2778
                        video_enc->rc_override[i].qscale= q;
2779
                        video_enc->rc_override[i].quality_factor= 1.0;
2780
                    }
2781
                    else{
2782
                        video_enc->rc_override[i].qscale= 0;
2783
                        video_enc->rc_override[i].quality_factor= -q/100.0;
2784
                    }
2785
                    p= strchr(p, '/');
2786
                    if(p) p++;
2787
                }
2788
                video_enc->rc_override_count=i;
2789

    
2790
                video_enc->rc_max_rate = video_rc_max_rate;
2791
                video_enc->rc_min_rate = video_rc_min_rate;
2792
                video_enc->rc_buffer_size = video_rc_buffer_size;
2793
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2794
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
2795
                video_enc->i_quant_factor = video_i_qfactor;
2796
                video_enc->b_quant_factor = video_b_qfactor;
2797
                video_enc->i_quant_offset = video_i_qoffset;
2798
                video_enc->b_quant_offset = video_b_qoffset;
2799
                video_enc->intra_quant_bias = video_intra_quant_bias;
2800
                video_enc->inter_quant_bias = video_inter_quant_bias;
2801
                video_enc->dct_algo = dct_algo;
2802
                video_enc->idct_algo = idct_algo;
2803
                video_enc->strict_std_compliance = strict;
2804
                video_enc->error_rate = error_rate;
2805
                video_enc->noise_reduction= noise_reduction;
2806
                video_enc->scenechange_threshold= sc_threshold;
2807
                if(packet_size){
2808
                    video_enc->rtp_mode= 1;
2809
                    video_enc->rtp_payload_size= packet_size;
2810
                }
2811
            
2812
                if (do_psnr)
2813
                    video_enc->flags|= CODEC_FLAG_PSNR;
2814
            
2815
                video_enc->me_method = me_method;
2816

    
2817
                /* two pass mode */
2818
                if (do_pass) {
2819
                    if (do_pass == 1) {
2820
                        video_enc->flags |= CODEC_FLAG_PASS1;
2821
                    } else {
2822
                        video_enc->flags |= CODEC_FLAG_PASS2;
2823
                    }
2824
                }
2825
            }
2826
            oc->streams[nb_streams] = st;
2827
            nb_streams++;
2828
        }
2829
    
2830
        if (use_audio) {
2831
            AVCodecContext *audio_enc;
2832

    
2833
            st = av_mallocz(sizeof(AVStream));
2834
            if (!st) {
2835
                fprintf(stderr, "Could not alloc stream\n");
2836
                exit(1);
2837
            }
2838
            avcodec_get_context_defaults(&st->codec);
2839
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2840
            if(thread_count>1)
2841
                avcodec_thread_init(&st->codec, thread_count);
2842
#endif
2843

    
2844
            audio_enc = &st->codec;
2845
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
2846

    
2847
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2848
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2849
            if (audio_stream_copy) {
2850
                st->stream_copy = 1;
2851
            } else {
2852
                codec_id = file_oformat->audio_codec;
2853
                if (audio_codec_id != CODEC_ID_NONE)
2854
                    codec_id = audio_codec_id;
2855
                audio_enc->codec_id = codec_id;
2856
                
2857
                audio_enc->bit_rate = audio_bit_rate;
2858
                audio_enc->sample_rate = audio_sample_rate;
2859
                audio_enc->strict_std_compliance = strict;
2860
                audio_enc->thread_count = thread_count;
2861
                /* For audio codecs other than AC3 we limit */
2862
                /* the number of coded channels to stereo   */
2863
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
2864
                    audio_enc->channels = 2;
2865
                } else
2866
                    audio_enc->channels = audio_channels;
2867
            }
2868
            oc->streams[nb_streams] = st;
2869
            nb_streams++;
2870
        }
2871

    
2872
        oc->nb_streams = nb_streams;
2873

    
2874
        if (!nb_streams) {
2875
            fprintf(stderr, "No audio or video streams available\n");
2876
            exit(1);
2877
        }
2878

    
2879
        oc->timestamp = rec_timestamp;
2880
            
2881
        if (str_title)
2882
            pstrcpy(oc->title, sizeof(oc->title), str_title);
2883
        if (str_author)
2884
            pstrcpy(oc->author, sizeof(oc->author), str_author);
2885
        if (str_copyright)
2886
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
2887
        if (str_comment)
2888
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
2889
    }
2890

    
2891
    output_files[nb_output_files++] = oc;
2892

    
2893
    strcpy(oc->filename, filename);
2894

    
2895
    /* check filename in case of an image number is expected */
2896
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2897
        if (filename_number_test(oc->filename) < 0) {
2898
            print_error(oc->filename, AVERROR_NUMEXPECTED);
2899
            exit(1);
2900
        }
2901
    }
2902

    
2903
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2904
        /* test if it already exists to avoid loosing precious files */
2905
        if (!file_overwrite && 
2906
            (strchr(filename, ':') == NULL ||
2907
             strstart(filename, "file:", NULL))) {
2908
            if (url_exist(filename)) {
2909
                int c;
2910
                
2911
                if ( !using_stdin ) {
2912
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2913
                    fflush(stderr);
2914
                    c = getchar();
2915
                    if (toupper(c) != 'Y') {
2916
                        fprintf(stderr, "Not overwriting - exiting\n");
2917
                        exit(1);
2918
                    }
2919
                                }
2920
                                else {
2921
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2922
                    exit(1);
2923
                                }
2924
            }
2925
        }
2926
        
2927
        /* open the file */
2928
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
2929
            fprintf(stderr, "Could not open '%s'\n", filename);
2930
            exit(1);
2931
        }
2932
    }
2933

    
2934
    memset(ap, 0, sizeof(*ap));
2935
    ap->image_format = image_format;
2936
    if (av_set_parameters(oc, ap) < 0) {
2937
        fprintf(stderr, "%s: Invalid encoding parameters\n",
2938
                oc->filename);
2939
        exit(1);
2940
    }
2941

    
2942
    /* reset some options */
2943
    file_oformat = NULL;
2944
    file_iformat = NULL;
2945
    image_format = NULL;
2946
    audio_disable = 0;
2947
    video_disable = 0;
2948
    audio_codec_id = CODEC_ID_NONE;
2949
    video_codec_id = CODEC_ID_NONE;
2950
    audio_stream_copy = 0;
2951
    video_stream_copy = 0;
2952
}
2953

    
2954
/* prepare dummy protocols for grab */
2955
static void prepare_grab(void)
2956
{
2957
    int has_video, has_audio, i, j;
2958
    AVFormatContext *oc;
2959
    AVFormatContext *ic;
2960
    AVFormatParameters vp1, *vp = &vp1;
2961
    AVFormatParameters ap1, *ap = &ap1;
2962
    
2963
    /* see if audio/video inputs are needed */
2964
    has_video = 0;
2965
    has_audio = 0;
2966
    memset(ap, 0, sizeof(*ap));
2967
    memset(vp, 0, sizeof(*vp));
2968
    for(j=0;j<nb_output_files;j++) {
2969
        oc = output_files[j];
2970
        for(i=0;i<oc->nb_streams;i++) {
2971
            AVCodecContext *enc = &oc->streams[i]->codec;
2972
            switch(enc->codec_type) {
2973
            case CODEC_TYPE_AUDIO:
2974
                if (enc->sample_rate > ap->sample_rate)
2975
                    ap->sample_rate = enc->sample_rate;
2976
                if (enc->channels > ap->channels)
2977
                    ap->channels = enc->channels;
2978
                has_audio = 1;
2979
                break;
2980
            case CODEC_TYPE_VIDEO:
2981
                if (enc->width > vp->width)
2982
                    vp->width = enc->width;
2983
                if (enc->height > vp->height)
2984
                    vp->height = enc->height;
2985
                
2986
                assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
2987
                if (enc->frame_rate > vp->frame_rate){
2988
                    vp->frame_rate      = enc->frame_rate;
2989
                    vp->frame_rate_base = enc->frame_rate_base;
2990
                }
2991
                has_video = 1;
2992
                break;
2993
            default:
2994
                av_abort();
2995
            }
2996
        }
2997
    }
2998
    
2999
    if (has_video == 0 && has_audio == 0) {
3000
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3001
        exit(1);
3002
    }
3003
    
3004
    if (has_video) {
3005
        AVInputFormat *fmt1;
3006
        fmt1 = av_find_input_format(video_grab_format);
3007
        vp->device  = video_device;
3008
        vp->channel = video_channel;
3009
        vp->standard = video_standard;
3010
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3011
            fprintf(stderr, "Could not find video grab device\n");
3012
            exit(1);
3013
        }
3014
        /* If not enough info to get the stream parameters, we decode the
3015
           first frames to get it. */
3016
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3017
            fprintf(stderr, "Could not find video grab parameters\n");
3018
            exit(1);
3019
        }
3020
        /* by now video grab has one stream */
3021
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3022
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3023
        input_files[nb_input_files] = ic;
3024
        dump_format(ic, nb_input_files, "", 0);
3025
        nb_input_files++;
3026
    }
3027
    if (has_audio && audio_grab_format) {
3028
        AVInputFormat *fmt1;
3029
        fmt1 = av_find_input_format(audio_grab_format);
3030
        ap->device = audio_device;
3031
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3032
            fprintf(stderr, "Could not find audio grab device\n");
3033
            exit(1);
3034
        }
3035
        input_files[nb_input_files] = ic;
3036
        dump_format(ic, nb_input_files, "", 0);
3037
        nb_input_files++;
3038
    }
3039
}
3040

    
3041
/* same option as mencoder */
3042
static void opt_pass(const char *pass_str)
3043
{
3044
    int pass;
3045
    pass = atoi(pass_str);
3046
    if (pass != 1 && pass != 2) {
3047
        fprintf(stderr, "pass number can be only 1 or 2\n");
3048
        exit(1);
3049
    }
3050
    do_pass = pass;
3051
}
3052

    
3053
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3054
static int64_t getutime(void)
3055
{
3056
  return av_gettime();
3057
}
3058
#else
3059
static int64_t getutime(void)
3060
{
3061
    struct rusage rusage;
3062

    
3063
    getrusage(RUSAGE_SELF, &rusage);
3064
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3065
}
3066
#endif
3067

    
3068
extern int ffm_nopts;
3069

    
3070
static void opt_bitexact(void)
3071
{
3072
    bitexact=1;
3073
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3074
    ffm_nopts = 1;
3075
}
3076

    
3077
static void show_formats(void)
3078
{
3079
    AVInputFormat *ifmt;
3080
    AVOutputFormat *ofmt;
3081
    AVImageFormat *image_fmt;
3082
    URLProtocol *up;
3083
    AVCodec *p, *p2;
3084
    const char **pp, *last_name;
3085

    
3086
    printf("File formats:\n");
3087
    last_name= "000";
3088
    for(;;){
3089
        int decode=0;
3090
        int encode=0;
3091
        const char *name=NULL;
3092

    
3093
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3094
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3095
                strcmp(ofmt->name, last_name)>0){
3096
                name= ofmt->name;
3097
                encode=1;
3098
            }
3099
        }
3100
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3101
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3102
                strcmp(ifmt->name, last_name)>0){
3103
                name= ifmt->name;
3104
                encode=0;
3105
            }
3106
            if(name && strcmp(ifmt->name, name)==0)
3107
                decode=1;
3108
        }
3109
        if(name==NULL)
3110
            break;
3111
        last_name= name;
3112
        
3113
        printf(
3114
            " %s%s %s\n", 
3115
            decode ? "D":" ", 
3116
            encode ? "E":" ", 
3117
            name);
3118
    }
3119
    printf("\n");
3120

    
3121
    printf("Image formats:\n");
3122
    for(image_fmt = first_image_format; image_fmt != NULL; 
3123
        image_fmt = image_fmt->next) {
3124
        printf(
3125
            " %s%s %s\n",
3126
            image_fmt->img_read  ? "D":" ",
3127
            image_fmt->img_write ? "E":" ",
3128
            image_fmt->name);
3129
    }
3130
    printf("\n");
3131

    
3132
    printf("Codecs:\n");
3133
    last_name= "000";
3134
    for(;;){
3135
        int decode=0;
3136
        int encode=0;
3137
        int cap=0;
3138

    
3139
        p2=NULL;
3140
        for(p = first_avcodec; p != NULL; p = p->next) {
3141
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3142
                strcmp(p->name, last_name)>0){
3143
                p2= p;
3144
                decode= encode= cap=0;
3145
            }
3146
            if(p2 && strcmp(p->name, p2->name)==0){
3147
                if(p->decode) decode=1;
3148
                if(p->encode) encode=1;
3149
                cap |= p->capabilities;
3150
            }
3151
        }
3152
        if(p2==NULL)
3153
            break;
3154
        last_name= p2->name;
3155
        
3156
        printf(
3157
            " %s%s%s%s%s%s %s", 
3158
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3159
            encode ? "E":" ", 
3160
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3161
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3162
            cap & CODEC_CAP_DR1 ? "D":" ",
3163
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3164
            p2->name);
3165
       /* if(p2->decoder && decode==0)
3166
            printf(" use %s for decoding", p2->decoder->name);*/
3167
        printf("\n");
3168
    }
3169
    printf("\n");
3170

    
3171
    printf("Supported file protocols:\n");
3172
    for(up = first_protocol; up != NULL; up = up->next)
3173
        printf(" %s:", up->name);
3174
    printf("\n");
3175
    
3176
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3177
    printf("Motion estimation methods:\n");
3178
    pp = motion_str;
3179
    while (*pp) {
3180
        printf(" %s", *pp);
3181
        if ((pp - motion_str + 1) == ME_ZERO) 
3182
            printf("(fastest)");
3183
        else if ((pp - motion_str + 1) == ME_FULL) 
3184
            printf("(slowest)");
3185
        else if ((pp - motion_str + 1) == ME_EPZS) 
3186
            printf("(default)");
3187
        pp++;
3188
    }
3189
    printf("\n\n");
3190
    printf(
3191
"Note, the names of encoders and decoders dont always match, so there are\n"
3192
"several cases where the above table shows encoder only or decoder only entries\n"
3193
"even though both encoding and decoding are supported for example, the h263\n"
3194
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3195
"worse\n");
3196
    exit(1);
3197
}
3198

    
3199
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3200
{
3201
    int i;
3202
    const char *p = str;
3203
    for(i = 0;; i++) {
3204
        dest[i] = atoi(p);
3205
        if(i == 63)
3206
            break;
3207
        p = strchr(p, ',');
3208
        if(!p) {
3209
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3210
            exit(1);
3211
        }
3212
        p++;
3213
    }
3214
}
3215

    
3216
void opt_inter_matrix(const char *arg)
3217
{
3218
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3219
    parse_matrix_coeffs(inter_matrix, arg);
3220
}
3221

    
3222
void opt_intra_matrix(const char *arg)
3223
{
3224
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3225
    parse_matrix_coeffs(intra_matrix, arg);
3226
}
3227

    
3228
static void opt_target(const char *arg)
3229
{
3230
    int norm = -1;
3231

    
3232
    if(!strncmp(arg, "pal-", 4)) {
3233
        norm = 0;
3234
        arg += 4;
3235
    } else if(!strncmp(arg, "ntsc-", 5)) {
3236
        norm = 1;
3237
        arg += 5;
3238
    } else {
3239
        int fr;
3240
        /* Calculate FR via float to avoid int overflow */
3241
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3242
        if(fr == 25000) {
3243
            norm = 0;
3244
        } else if((fr == 29970) || (fr == 23976)) {
3245
            norm = 1;
3246
        } else {
3247
            /* Try to determine PAL/NTSC by peeking in the input files */
3248
            if(nb_input_files) {
3249
                int i, j;
3250
                for(j = 0; j < nb_input_files; j++) {
3251
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3252
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3253
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3254
                            continue;
3255
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3256
                        if(fr == 25000) {
3257
                            norm = 0;
3258
                            break;
3259
                        } else if((fr == 29970) || (fr == 23976)) {
3260
                            norm = 1;
3261
                            break;
3262
                        }
3263
                    }
3264
                    if(norm >= 0)
3265
                        break;
3266
                }
3267
            }
3268
        }
3269
        if(verbose && norm >= 0)
3270
            printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3271
    }
3272

    
3273
    if(norm < 0) {
3274
        fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3275
        fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3276
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3277
        exit(1);
3278
    }
3279

    
3280
    if(!strcmp(arg, "vcd")) {
3281

    
3282
        opt_video_codec("mpeg1video");
3283
        opt_audio_codec("mp2");
3284
        opt_format("vcd");
3285

    
3286
        opt_frame_size(norm ? "352x240" : "352x288");
3287

    
3288
        video_bit_rate = 1150000;
3289
        video_rc_max_rate = 1150000;
3290
        video_rc_min_rate = 1150000;
3291
        video_rc_buffer_size = 40*1024*8;
3292

    
3293
        audio_bit_rate = 224000;
3294
        audio_sample_rate = 44100;
3295

    
3296
    } else if(!strcmp(arg, "svcd")) {
3297

    
3298
        opt_video_codec("mpeg2video");
3299
        opt_audio_codec("mp2");
3300
        opt_format("svcd");
3301

    
3302
        opt_frame_size(norm ? "480x480" : "480x576");
3303
        opt_gop_size(norm ? "18" : "15");
3304

    
3305
        video_bit_rate = 2040000;
3306
        video_rc_max_rate = 2516000;
3307
        video_rc_min_rate = 0; //1145000;
3308
        video_rc_buffer_size = 224*1024*8;
3309
        use_scan_offset = 1;
3310

    
3311
        audio_bit_rate = 224000;
3312
        audio_sample_rate = 44100;
3313

    
3314
    } else if(!strcmp(arg, "dvd")) {
3315

    
3316
        opt_video_codec("mpeg2video");
3317
        opt_audio_codec("ac3");
3318
        opt_format("vob");
3319

    
3320
        opt_frame_size(norm ? "720x480" : "720x576");
3321
        opt_gop_size(norm ? "18" : "15");
3322

    
3323
        video_bit_rate = 6000000;
3324
        video_rc_max_rate = 9000000;
3325
        video_rc_min_rate = 0; //1500000;
3326
        video_rc_buffer_size = 224*1024*8;
3327

    
3328
        audio_bit_rate = 448000;
3329
        audio_sample_rate = 48000;
3330

    
3331
    } else {
3332
        fprintf(stderr, "Unknown target: %s\n", arg);
3333
        exit(1);
3334
    }
3335
}
3336

    
3337
const OptionDef options[] = {
3338
    /* main options */
3339
    { "L", 0, {(void*)show_license}, "show license" },
3340
    { "h", 0, {(void*)show_help}, "show help" },
3341
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3342
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3343
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3344
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3345
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3346
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3347
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3348
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3349
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3350
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3351
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3352
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3353
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3354
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3355
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3356
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3357
      "add timings for benchmarking" },
3358
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3359
      "dump each input packet" },
3360
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3361
      "when dumping packets, also dump the payload" },
3362
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3363
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3364
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3365
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3366
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3367
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3368

    
3369
    /* video options */
3370
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3371
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3372
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3373
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3374
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3375
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3376
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3377
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3378
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3379
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3380
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3381
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3382
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3383
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3384
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3385
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3386
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3387
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3388
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3389
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3390
    { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3391
    { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3392
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3393
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3394
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3395
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3396
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3397
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3398
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3399
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3400
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3401
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3402
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3403
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3404
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3405
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3406
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3407
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3408
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3409
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3410
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
3411
      "method" },
3412
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3413
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3414
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3415
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3416
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3417
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3418
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3419
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3420
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3421
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3422
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3423
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3424
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3425
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3426
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3427
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3428
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
3429
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3430
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3431
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3432
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3433
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3434
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3435
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3436
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3437
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3438
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
3439
      "use same video quality as source (implies VBR)" },
3440
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3441
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3442
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
3443
      "deinterlace pictures" },
3444
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
3445
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3446
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
3447
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
3448
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3449
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
3450
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3451
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3452
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3453
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3454
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3455
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3456
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3457
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3458
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3459
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3460
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3461
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3462
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3463
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3464
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3465

    
3466
    /* audio options */
3467
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3468
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3469
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3470
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3471
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3472

    
3473
    /* grab options */
3474
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3475
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3476
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3477
    { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3478
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3479
    { NULL, },
3480
};
3481

    
3482
static void show_banner(void)
3483
{
3484
    printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
3485
}
3486

    
3487
static void show_license(void)
3488
{
3489
    show_banner();
3490
    printf(
3491
#ifdef CONFIG_GPL
3492
    "This program is free software; you can redistribute it and/or modify\n"   
3493
    "it under the terms of the GNU General Public License as published by\n"
3494
    "the Free Software Foundation; either version 2 of the License, or\n"
3495
    "(at your option) any later version.\n"
3496
    "\n"
3497
    "This program is distributed in the hope that it will be useful,\n"
3498
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3499
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3500
    "GNU General Public License for more details.\n"
3501
    "\n"
3502
    "You should have received a copy of the GNU General Public License\n"
3503
    "along with this program; if not, write to the Free Software\n"
3504
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3505
#else
3506
    "This library is free software; you can redistribute it and/or\n"
3507
    "modify it under the terms of the GNU Lesser General Public\n"
3508
    "License as published by the Free Software Foundation; either\n"
3509
    "version 2 of the License, or (at your option) any later version.\n"
3510
    "\n"
3511
    "This library is distributed in the hope that it will be useful,\n"
3512
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3513
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3514
    "Lesser General Public License for more details.\n"
3515
    "\n"
3516
    "You should have received a copy of the GNU Lesser General Public\n"
3517
    "License along with this library; if not, write to the Free Software\n"
3518
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3519
#endif
3520
    );
3521
    exit(1);
3522
}
3523

    
3524
static void show_help(void)
3525
{
3526
    show_banner();
3527
    printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
3528
           "Hyper fast Audio and Video encoder\n");
3529
    printf("\n");
3530
    show_help_options(options, "Main options:\n",
3531
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3532
    show_help_options(options, "\nVideo options:\n",
3533
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3534
                      OPT_VIDEO);
3535
    show_help_options(options, "\nAdvanced Video options:\n",
3536
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3537
                      OPT_VIDEO | OPT_EXPERT);
3538
    show_help_options(options, "\nAudio options:\n",
3539
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3540
                      OPT_AUDIO);
3541
    show_help_options(options, "\nAdvanced Audio options:\n",
3542
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3543
                      OPT_AUDIO | OPT_EXPERT);
3544
    show_help_options(options, "\nAudio/Video grab options:\n",
3545
                      OPT_GRAB, 
3546
                      OPT_GRAB);
3547
    show_help_options(options, "\nAdvanced options:\n",
3548
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3549
                      OPT_EXPERT);
3550
    exit(1);
3551
}
3552

    
3553
void parse_arg_file(const char *filename)
3554
{
3555
    opt_output_file(filename);
3556
}
3557

    
3558
int main(int argc, char **argv)
3559
{
3560
    int i;
3561
    int64_t ti;
3562

    
3563
    av_register_all();
3564

    
3565
    if (argc <= 1)
3566
        show_help();
3567
    
3568
    /* parse options */
3569
    parse_options(argc, argv, options);
3570

    
3571
    /* file converter / grab */
3572
    if (nb_output_files <= 0) {
3573
        fprintf(stderr, "Must supply at least one output file\n");
3574
        exit(1);
3575
    }
3576
    
3577
    if (nb_input_files == 0) {
3578
        prepare_grab();
3579
    }
3580

    
3581
    ti = getutime();
3582
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
3583
              stream_maps, nb_stream_maps);
3584
    ti = getutime() - ti;
3585
    if (do_benchmark) {
3586
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3587
    }
3588

    
3589
    /* close files */
3590
    for(i=0;i<nb_output_files;i++) {
3591
        /* maybe av_close_output_file ??? */
3592
        AVFormatContext *s = output_files[i];
3593
        int j;
3594
        if (!(s->oformat->flags & AVFMT_NOFILE))
3595
            url_fclose(&s->pb);
3596
        for(j=0;j<s->nb_streams;j++)
3597
            av_free(s->streams[j]);
3598
        av_free(s);
3599
    }
3600
    for(i=0;i<nb_input_files;i++)
3601
        av_close_input_file(input_files[i]);
3602

    
3603
    av_free_static();
3604

    
3605
    if(intra_matrix)
3606
        av_free(intra_matrix);
3607
    if(inter_matrix)
3608
        av_free(inter_matrix);
3609
    
3610
#ifdef POWERPC_PERFORMANCE_REPORT
3611
    extern void powerpc_display_perf_report(void);
3612
    powerpc_display_perf_report();
3613
#endif /* POWERPC_PERFORMANCE_REPORT */
3614

    
3615
#ifndef CONFIG_WIN32
3616
    if (received_sigterm) {
3617
        fprintf(stderr,
3618
            "Received signal %d: terminating.\n",
3619
            (int) received_sigterm);
3620
        exit (255);
3621
    }
3622
#endif
3623
    exit(0); /* not all OS-es handle main() return value */
3624
    return 0;
3625
}