Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ bbd86179

History | View | Annotate | Download (134 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include "avformat.h"
31
#include "swscale.h"
32
#include "framehook.h"
33
#include "opt.h"
34
#include "fifo.h"
35
#include "avstring.h"
36

    
37
#ifdef __MINGW32__
38
#include <conio.h>
39
#else
40
#include <unistd.h>
41
#include <fcntl.h>
42
#include <sys/ioctl.h>
43
#include <sys/time.h>
44
#include <termios.h>
45
#include <sys/resource.h>
46
#endif
47
#ifdef CONFIG_OS2
48
#include <sys/types.h>
49
#include <sys/select.h>
50
#include <stdlib.h>
51
#endif
52
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
53
#include <time.h>
54

    
55
#include "version.h"
56
#include "cmdutils.h"
57

    
58
#undef NDEBUG
59
#include <assert.h>
60

    
61
#if !defined(INFINITY) && defined(HUGE_VAL)
62
#define INFINITY HUGE_VAL
63
#endif
64

    
65
#undef exit
66

    
67
/* select an input stream for an output stream */
68
typedef struct AVStreamMap {
69
    int file_index;
70
    int stream_index;
71
    int sync_file_index;
72
    int sync_stream_index;
73
} AVStreamMap;
74

    
75
/** select an input file for an output file */
76
typedef struct AVMetaDataMap {
77
    int out_file;
78
    int in_file;
79
} AVMetaDataMap;
80

    
81
extern const OptionDef options[];
82

    
83
static void show_help(void);
84
static void show_license(void);
85
static int opt_default(const char *opt, const char *arg);
86

    
87
#define MAX_FILES 20
88

    
89
static AVFormatContext *input_files[MAX_FILES];
90
static int64_t input_files_ts_offset[MAX_FILES];
91
static int nb_input_files = 0;
92

    
93
static AVFormatContext *output_files[MAX_FILES];
94
static int nb_output_files = 0;
95

    
96
static AVStreamMap stream_maps[MAX_FILES];
97
static int nb_stream_maps;
98

    
99
static AVMetaDataMap meta_data_maps[MAX_FILES];
100
static int nb_meta_data_maps;
101

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

    
145
static int intra_only = 0;
146
static int audio_sample_rate = 44100;
147
#define QSCALE_NONE -99999
148
static float audio_qscale = QSCALE_NONE;
149
static int audio_disable = 0;
150
static int audio_channels = 1;
151
static int audio_codec_id = CODEC_ID_NONE;
152
static int audio_codec_tag = 0;
153
static char *audio_language = NULL;
154

    
155
static int subtitle_codec_id = CODEC_ID_NONE;
156
static char *subtitle_language = NULL;
157

    
158
static float mux_preload= 0.5;
159
static float mux_max_delay= 0.7;
160

    
161
static int64_t recording_time = 0;
162
static int64_t start_time = 0;
163
static int64_t rec_timestamp = 0;
164
static int64_t input_ts_offset = 0;
165
static int file_overwrite = 0;
166
static char *str_title = NULL;
167
static char *str_author = NULL;
168
static char *str_copyright = NULL;
169
static char *str_comment = NULL;
170
static char *str_album = NULL;
171
static int do_benchmark = 0;
172
static int do_hex_dump = 0;
173
static int do_pkt_dump = 0;
174
static int do_psnr = 0;
175
static int do_pass = 0;
176
static char *pass_logfilename = NULL;
177
static int audio_stream_copy = 0;
178
static int video_stream_copy = 0;
179
static int subtitle_stream_copy = 0;
180
static int video_sync_method= 1;
181
static int audio_sync_method= 0;
182
static int copy_ts= 0;
183
static int opt_shortest = 0; //
184
static int video_global_header = 0;
185
static char *vstats_filename;
186
static FILE *fvstats;
187

    
188
static int rate_emu = 0;
189

    
190
static int  video_channel = 0;
191
static char *video_standard;
192

    
193
static int audio_volume = 256;
194

    
195
static int using_stdin = 0;
196
static int using_vhook = 0;
197
static int verbose = 1;
198
static int thread_count= 1;
199
static int q_pressed = 0;
200
static int64_t video_size = 0;
201
static int64_t audio_size = 0;
202
static int64_t extra_size = 0;
203
static int nb_frames_dup = 0;
204
static int nb_frames_drop = 0;
205
static int input_sync;
206
static uint64_t limit_filesize = 0; //
207

    
208
static int pgmyuv_compatibility_hack=0;
209
static int dts_delta_threshold = 10;
210

    
211
static int sws_flags = SWS_BICUBIC;
212

    
213
static const char **opt_names;
214
static int opt_name_count;
215
static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
216
static AVFormatContext *avformat_opts;
217
static struct SwsContext *sws_opts;
218
static int64_t timer_start;
219

    
220
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
221
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
222
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
223

    
224
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
225

    
226
struct AVInputStream;
227

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

    
246
    int video_crop;
247
    int topBand;             /* cropping area sizes */
248
    int leftBand;
249

    
250
    int video_pad;
251
    int padtop;              /* padding area sizes */
252
    int padbottom;
253
    int padleft;
254
    int padright;
255

    
256
    /* audio only */
257
    int audio_resample;
258
    ReSampleContext *resample; /* for audio resampling */
259
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
260
    FILE *logfile;
261
} AVOutputStream;
262

    
263
typedef struct AVInputStream {
264
    int file_index;
265
    int index;
266
    AVStream *st;
267
    int discard;             /* true if stream data should be discarded */
268
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
269
    int64_t sample_index;      /* current sample */
270

    
271
    int64_t       start;     /* time when read started */
272
    unsigned long frame;     /* current frame */
273
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
274
                                is not defined */
275
    int64_t       pts;       /* current pts */
276
    int is_start;            /* is 1 at the start and after a discontinuity */
277
} AVInputStream;
278

    
279
typedef struct AVInputFile {
280
    int eof_reached;      /* true if eof reached */
281
    int ist_index;        /* index of first stream in ist_table */
282
    int buffer_size;      /* current total buffer size */
283
    int nb_streams;       /* nb streams we are aware of */
284
} AVInputFile;
285

    
286
#ifndef __MINGW32__
287

    
288
/* init terminal so that we can grab keys */
289
static struct termios oldtty;
290
#endif
291

    
292
static void term_exit(void)
293
{
294
#ifndef __MINGW32__
295
    tcsetattr (0, TCSANOW, &oldtty);
296
#endif
297
}
298

    
299
static volatile sig_atomic_t received_sigterm = 0;
300

    
301
static void
302
sigterm_handler(int sig)
303
{
304
    received_sigterm = sig;
305
    term_exit();
306
}
307

    
308
static void term_init(void)
309
{
310
#ifndef __MINGW32__
311
    struct termios tty;
312

    
313
    tcgetattr (0, &tty);
314
    oldtty = tty;
315

    
316
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
317
                          |INLCR|IGNCR|ICRNL|IXON);
318
    tty.c_oflag |= OPOST;
319
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
320
    tty.c_cflag &= ~(CSIZE|PARENB);
321
    tty.c_cflag |= CS8;
322
    tty.c_cc[VMIN] = 1;
323
    tty.c_cc[VTIME] = 0;
324

    
325
    tcsetattr (0, TCSANOW, &tty);
326
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
327
#endif
328

    
329
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
330
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
331
    /*
332
    register a function to be called at normal program termination
333
    */
334
    atexit(term_exit);
335
#ifdef CONFIG_BEOS_NETSERVER
336
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
337
#endif
338
}
339

    
340
/* read a key without blocking */
341
static int read_key(void)
342
{
343
#ifdef __MINGW32__
344
    if(kbhit())
345
        return(getch());
346
#else
347
    int n = 1;
348
    unsigned char ch;
349
#ifndef CONFIG_BEOS_NETSERVER
350
    struct timeval tv;
351
    fd_set rfds;
352

    
353
    FD_ZERO(&rfds);
354
    FD_SET(0, &rfds);
355
    tv.tv_sec = 0;
356
    tv.tv_usec = 0;
357
    n = select(1, &rfds, NULL, NULL, &tv);
358
#endif
359
    if (n > 0) {
360
        n = read(0, &ch, 1);
361
        if (n == 1)
362
            return ch;
363

    
364
        return n;
365
    }
366
#endif
367
    return -1;
368
}
369

    
370
static int decode_interrupt_cb(void)
371
{
372
    return q_pressed || (q_pressed = read_key() == 'q');
373
}
374

    
375
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
376
{
377
    int i, err;
378
    AVFormatContext *ic;
379

    
380
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
381
    if (err < 0)
382
        return err;
383
    /* copy stream format */
384
    s->nb_streams = ic->nb_streams;
385
    for(i=0;i<ic->nb_streams;i++) {
386
        AVStream *st;
387

    
388
        // FIXME: a more elegant solution is needed
389
        st = av_mallocz(sizeof(AVStream));
390
        memcpy(st, ic->streams[i], sizeof(AVStream));
391
        st->codec = avcodec_alloc_context();
392
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
393
        s->streams[i] = st;
394
    }
395

    
396
    av_close_input_file(ic);
397
    return 0;
398
}
399

    
400
static double
401
get_sync_ipts(const AVOutputStream *ost)
402
{
403
    const AVInputStream *ist = ost->sync_ist;
404
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
405
}
406

    
407
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
408
    while(bsfc){
409
        AVPacket new_pkt= *pkt;
410
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
411
                                          &new_pkt.data, &new_pkt.size,
412
                                          pkt->data, pkt->size,
413
                                          pkt->flags & PKT_FLAG_KEY);
414
        if(a){
415
            av_free_packet(pkt);
416
            new_pkt.destruct= av_destruct_packet;
417
        }
418
        *pkt= new_pkt;
419

    
420
        bsfc= bsfc->next;
421
    }
422

    
423
    av_interleaved_write_frame(s, pkt);
424
}
425

    
426
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
427

    
428
static void do_audio_out(AVFormatContext *s,
429
                         AVOutputStream *ost,
430
                         AVInputStream *ist,
431
                         unsigned char *buf, int size)
432
{
433
    uint8_t *buftmp;
434
    static uint8_t *audio_buf = NULL;
435
    static uint8_t *audio_out = NULL;
436
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
437

    
438
    int size_out, frame_bytes, ret;
439
    AVCodecContext *enc= ost->st->codec;
440

    
441
    /* SC: dynamic allocation of buffers */
442
    if (!audio_buf)
443
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
444
    if (!audio_out)
445
        audio_out = av_malloc(audio_out_size);
446
    if (!audio_buf || !audio_out)
447
        return;               /* Should signal an error ! */
448

    
449
    if(audio_sync_method){
450
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
451
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
452
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
453
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
454

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

    
471
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
472
                        ist->is_start=0;
473
                    else
474
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
475

    
476
                    memset(input_tmp, 0, byte_delta);
477
                    memcpy(input_tmp + byte_delta, buf, size);
478
                    buf= input_tmp;
479
                    size += byte_delta;
480
                    if(verbose > 2)
481
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
482
                }
483
            }else if(audio_sync_method>1){
484
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
485
                assert(ost->audio_resample);
486
                if(verbose > 2)
487
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
488
//                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
489
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
490
            }
491
        }
492
    }else
493
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
494
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
495

    
496
    if (ost->audio_resample) {
497
        buftmp = audio_buf;
498
        size_out = audio_resample(ost->resample,
499
                                  (short *)buftmp, (short *)buf,
500
                                  size / (ist->st->codec->channels * 2));
501
        size_out = size_out * enc->channels * 2;
502
    } else {
503
        buftmp = buf;
504
        size_out = size;
505
    }
506

    
507
    /* now encode as many frames as possible */
508
    if (enc->frame_size > 1) {
509
        /* output resampled raw samples */
510
        av_fifo_write(&ost->fifo, buftmp, size_out);
511

    
512
        frame_bytes = enc->frame_size * 2 * enc->channels;
513

    
514
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
515
            AVPacket pkt;
516
            av_init_packet(&pkt);
517

    
518
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
519
                                       (short *)audio_buf);
520
            audio_size += ret;
521
            pkt.stream_index= ost->index;
522
            pkt.data= audio_out;
523
            pkt.size= ret;
524
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
525
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
526
            pkt.flags |= PKT_FLAG_KEY;
527
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
528

    
529
            ost->sync_opts += enc->frame_size;
530
        }
531
    } else {
532
        AVPacket pkt;
533
        av_init_packet(&pkt);
534

    
535
        ost->sync_opts += size_out / (2 * enc->channels);
536

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

    
575
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
576
{
577
    AVCodecContext *dec;
578
    AVPicture *picture2;
579
    AVPicture picture_tmp;
580
    uint8_t *buf = 0;
581

    
582
    dec = ist->st->codec;
583

    
584
    /* deinterlace : must be done before any resize */
585
    if (do_deinterlace || using_vhook) {
586
        int size;
587

    
588
        /* create temporary picture */
589
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
590
        buf = av_malloc(size);
591
        if (!buf)
592
            return;
593

    
594
        picture2 = &picture_tmp;
595
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
596

    
597
        if (do_deinterlace){
598
            if(avpicture_deinterlace(picture2, picture,
599
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
600
                /* if error, do not deinterlace */
601
                av_free(buf);
602
                buf = NULL;
603
                picture2 = picture;
604
            }
605
        } else {
606
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
607
        }
608
    } else {
609
        picture2 = picture;
610
    }
611

    
612
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
613
                       1000000 * ist->pts / AV_TIME_BASE);
614

    
615
    if (picture != picture2)
616
        *picture = *picture2;
617
    *bufp = buf;
618
}
619

    
620
/* we begin to correct av delay at this threshold */
621
#define AV_DELAY_MAX 0.100
622

    
623
static void do_subtitle_out(AVFormatContext *s,
624
                            AVOutputStream *ost,
625
                            AVInputStream *ist,
626
                            AVSubtitle *sub,
627
                            int64_t pts)
628
{
629
    static uint8_t *subtitle_out = NULL;
630
    int subtitle_out_max_size = 65536;
631
    int subtitle_out_size, nb, i;
632
    AVCodecContext *enc;
633
    AVPacket pkt;
634

    
635
    if (pts == AV_NOPTS_VALUE) {
636
        fprintf(stderr, "Subtitle packets must have a pts\n");
637
        return;
638
    }
639

    
640
    enc = ost->st->codec;
641

    
642
    if (!subtitle_out) {
643
        subtitle_out = av_malloc(subtitle_out_max_size);
644
    }
645

    
646
    /* Note: DVB subtitle need one packet to draw them and one other
647
       packet to clear them */
648
    /* XXX: signal it in the codec context ? */
649
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
650
        nb = 2;
651
    else
652
        nb = 1;
653

    
654
    for(i = 0; i < nb; i++) {
655
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
656
                                                    subtitle_out_max_size, sub);
657

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

    
675
static int bit_buffer_size= 1024*256;
676
static uint8_t *bit_buffer= NULL;
677

    
678
static void do_video_out(AVFormatContext *s,
679
                         AVOutputStream *ost,
680
                         AVInputStream *ist,
681
                         AVFrame *in_picture,
682
                         int *frame_size)
683
{
684
    int nb_frames, i, ret;
685
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
686
    AVFrame picture_crop_temp, picture_pad_temp;
687
    AVCodecContext *enc, *dec;
688

    
689
    avcodec_get_frame_defaults(&picture_crop_temp);
690
    avcodec_get_frame_defaults(&picture_pad_temp);
691

    
692
    enc = ost->st->codec;
693
    dec = ist->st->codec;
694

    
695
    /* by default, we output a single frame */
696
    nb_frames = 1;
697

    
698
    *frame_size = 0;
699

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

    
721
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
722
    if (nb_frames <= 0)
723
        return;
724

    
725
    if (ost->video_crop) {
726
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
727
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
728
            return;
729
        }
730
        formatted_picture = &picture_crop_temp;
731
    } else {
732
        formatted_picture = in_picture;
733
    }
734

    
735
    final_picture = formatted_picture;
736
    padding_src = formatted_picture;
737
    resampling_dst = &ost->pict_tmp;
738
    if (ost->video_pad) {
739
        final_picture = &ost->pict_tmp;
740
        if (ost->video_resample) {
741
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
742
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
743
                return;
744
            }
745
            resampling_dst = &picture_pad_temp;
746
        }
747
    }
748

    
749
    if (ost->video_resample) {
750
        padding_src = NULL;
751
        final_picture = &ost->pict_tmp;
752
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
753
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
754
    }
755

    
756
    if (ost->video_pad) {
757
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
758
                enc->height, enc->width, enc->pix_fmt,
759
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
760
    }
761

    
762
    /* duplicates frame if needed */
763
    for(i=0;i<nb_frames;i++) {
764
        AVPacket pkt;
765
        av_init_packet(&pkt);
766
        pkt.stream_index= ost->index;
767

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

    
781
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
782
            enc->coded_frame = old_frame;
783
        } else {
784
            AVFrame big_picture;
785

    
786
            big_picture= *final_picture;
787
            /* better than nothing: use input picture interlaced
788
               settings */
789
            big_picture.interlaced_frame = in_picture->interlaced_frame;
790
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
791
                if(top_field_first == -1)
792
                    big_picture.top_field_first = in_picture->top_field_first;
793
                else
794
                    big_picture.top_field_first = top_field_first;
795
            }
796

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

    
826
                if(enc->coded_frame && enc->coded_frame->key_frame)
827
                    pkt.flags |= PKT_FLAG_KEY;
828
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
829
                *frame_size = ret;
830
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
831
                //        enc->frame_number-1, enc->real_pict_num, ret,
832
                //        enc->pict_type);
833
                /* if two pass, output log */
834
                if (ost->logfile && enc->stats_out) {
835
                    fprintf(ost->logfile, "%s", enc->stats_out);
836
                }
837
            }
838
        }
839
        ost->sync_opts++;
840
        ost->frame_number++;
841
    }
842
}
843

    
844
static double psnr(double d){
845
    if(d==0) return INFINITY;
846
    return -10.0*log(d)/log(10.0);
847
}
848

    
849
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
850
                           int frame_size)
851
{
852
    AVCodecContext *enc;
853
    int frame_number;
854
    int64_t ti;
855
    double ti1, bitrate, avg_bitrate;
856

    
857
    /* this is executed just the first time do_video_stats is called */
858
    if (!fvstats) {
859
        fvstats = fopen(vstats_filename, "w");
860
        if (!fvstats) {
861
            perror("fopen");
862
            exit(1);
863
        }
864
    }
865

    
866
    ti = INT64_MAX;
867
    enc = ost->st->codec;
868
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
869
        frame_number = ost->frame_number;
870
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
871
        if (enc->flags&CODEC_FLAG_PSNR)
872
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
873

    
874
        fprintf(fvstats,"f_size= %6d ", frame_size);
875
        /* compute pts value */
876
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
877
        if (ti1 < 0.01)
878
            ti1 = 0.01;
879

    
880
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
881
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
882
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
883
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
884
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
885
    }
886
}
887

    
888
static void print_report(AVFormatContext **output_files,
889
                         AVOutputStream **ost_table, int nb_ostreams,
890
                         int is_last_report)
891
{
892
    char buf[1024];
893
    AVOutputStream *ost;
894
    AVFormatContext *oc, *os;
895
    int64_t total_size;
896
    AVCodecContext *enc;
897
    int frame_number, vid, i;
898
    double bitrate, ti1, pts;
899
    static int64_t last_time = -1;
900
    static int qp_histogram[52];
901

    
902
    if (!is_last_report) {
903
        int64_t cur_time;
904
        /* display the report every 0.5 seconds */
905
        cur_time = av_gettime();
906
        if (last_time == -1) {
907
            last_time = cur_time;
908
            return;
909
        }
910
        if ((cur_time - last_time) < 500000)
911
            return;
912
        last_time = cur_time;
913
    }
914

    
915

    
916
    oc = output_files[0];
917

    
918
    total_size = url_fsize(&oc->pb);
919
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
920
        total_size= url_ftell(&oc->pb);
921

    
922
    buf[0] = '\0';
923
    ti1 = 1e10;
924
    vid = 0;
925
    for(i=0;i<nb_ostreams;i++) {
926
        ost = ost_table[i];
927
        os = output_files[ost->file_index];
928
        enc = ost->st->codec;
929
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
930
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
931
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
932
        }
933
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
934
            float t = (av_gettime()-timer_start) / 1000000.0;
935

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

    
981
    if (verbose || is_last_report) {
982
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
983

    
984
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
985
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
986
            (double)total_size / 1024, ti1, bitrate);
987

    
988
        if (verbose > 1)
989
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
990
                  nb_frames_dup, nb_frames_drop);
991

    
992
        if (verbose >= 0)
993
            fprintf(stderr, "%s    \r", buf);
994

    
995
        fflush(stderr);
996
    }
997

    
998
    if (is_last_report && verbose >= 0){
999
        int64_t raw= audio_size + video_size + extra_size;
1000
        fprintf(stderr, "\n");
1001
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1002
                video_size/1024.0,
1003
                audio_size/1024.0,
1004
                extra_size/1024.0,
1005
                100.0*(total_size - raw)/raw
1006
        );
1007
    }
1008
}
1009

    
1010
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1011
static int output_packet(AVInputStream *ist, int ist_index,
1012
                         AVOutputStream **ost_table, int nb_ostreams,
1013
                         const AVPacket *pkt)
1014
{
1015
    AVFormatContext *os;
1016
    AVOutputStream *ost;
1017
    uint8_t *ptr;
1018
    int len, ret, i;
1019
    uint8_t *data_buf;
1020
    int data_size, got_picture;
1021
    AVFrame picture;
1022
    void *buffer_to_free;
1023
    static unsigned int samples_size= 0;
1024
    static short *samples= NULL;
1025
    AVSubtitle subtitle, *subtitle_to_free;
1026
    int got_subtitle;
1027

    
1028
    if(!pkt){
1029
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1030
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1031
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1032
    } else {
1033
//        assert(ist->pts == ist->next_pts);
1034
    }
1035

    
1036
    if (pkt == NULL) {
1037
        /* EOF handling */
1038
        ptr = NULL;
1039
        len = 0;
1040
        goto handle_eof;
1041
    }
1042

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

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

    
1130
        buffer_to_free = NULL;
1131
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1132
            pre_process_video_frame(ist, (AVPicture *)&picture,
1133
                                    &buffer_to_free);
1134
        }
1135

    
1136
        // preprocess audio (volume)
1137
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1138
            if (audio_volume != 256) {
1139
                short *volp;
1140
                volp = samples;
1141
                for(i=0;i<(data_size / sizeof(short));i++) {
1142
                    int v = ((*volp) * audio_volume + 128) >> 8;
1143
                    if (v < -32768) v = -32768;
1144
                    if (v >  32767) v = 32767;
1145
                    *volp++ = v;
1146
                }
1147
            }
1148
        }
1149

    
1150
        /* frame rate emulation */
1151
        if (ist->st->codec->rate_emu) {
1152
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1153
            int64_t now = av_gettime() - ist->start;
1154
            if (pts > now)
1155
                usleep(pts - now);
1156

    
1157
            ist->frame++;
1158
        }
1159

    
1160
#if 0
1161
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1162
           is the one of the next displayed one */
1163
        /* XXX: add mpeg4 too ? */
1164
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1165
            if (ist->st->codec->pict_type != B_TYPE) {
1166
                int64_t tmp;
1167
                tmp = ist->last_ip_pts;
1168
                ist->last_ip_pts  = ist->frac_pts.val;
1169
                ist->frac_pts.val = tmp;
1170
            }
1171
        }
1172
#endif
1173
        /* if output time reached then transcode raw format,
1174
           encode packets and output them */
1175
        if (start_time == 0 || ist->pts >= start_time)
1176
            for(i=0;i<nb_ostreams;i++) {
1177
                int frame_size;
1178

    
1179
                ost = ost_table[i];
1180
                if (ost->source_index == ist_index) {
1181
                    os = output_files[ost->file_index];
1182

    
1183
#if 0
1184
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1185
                           (double)pkt->pts / AV_TIME_BASE,
1186
                           ((double)ist->pts / AV_TIME_BASE) -
1187
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1188
#endif
1189
                    /* set the input output pts pairs */
1190
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1191

    
1192
                    if (ost->encoding_needed) {
1193
                        switch(ost->st->codec->codec_type) {
1194
                        case CODEC_TYPE_AUDIO:
1195
                            do_audio_out(os, ost, ist, data_buf, data_size);
1196
                            break;
1197
                        case CODEC_TYPE_VIDEO:
1198
                            do_video_out(os, ost, ist, &picture, &frame_size);
1199
                            video_size += frame_size;
1200
                            if (vstats_filename && frame_size)
1201
                                do_video_stats(os, ost, frame_size);
1202
                            break;
1203
                        case CODEC_TYPE_SUBTITLE:
1204
                            do_subtitle_out(os, ost, ist, &subtitle,
1205
                                            pkt->pts);
1206
                            break;
1207
                        default:
1208
                            abort();
1209
                        }
1210
                    } else {
1211
                        AVFrame avframe; //FIXME/XXX remove this
1212
                        AVPacket opkt;
1213
                        av_init_packet(&opkt);
1214

    
1215
                        /* no reencoding needed : output the packet directly */
1216
                        /* force the input stream PTS */
1217

    
1218
                        avcodec_get_frame_defaults(&avframe);
1219
                        ost->st->codec->coded_frame= &avframe;
1220
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1221

    
1222
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1223
                            audio_size += data_size;
1224
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1225
                            video_size += data_size;
1226
                            ost->sync_opts++;
1227
                        }
1228

    
1229
                        opkt.stream_index= ost->index;
1230
                        if(pkt->pts != AV_NOPTS_VALUE)
1231
                            opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1232
                        else
1233
                            opkt.pts= AV_NOPTS_VALUE;
1234

    
1235
                        {
1236
                            int64_t dts;
1237
                            if (pkt->dts == AV_NOPTS_VALUE)
1238
                                dts = ist->next_pts;
1239
                            else
1240
                                dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1241
                            opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1242
                        }
1243
                        opkt.flags= pkt->flags;
1244

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

    
1249
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1250
                        ost->st->codec->frame_number++;
1251
                        ost->frame_number++;
1252
                        av_free_packet(&opkt);
1253
                    }
1254
                }
1255
            }
1256
        av_free(buffer_to_free);
1257
        /* XXX: allocate the subtitles in the codec ? */
1258
        if (subtitle_to_free) {
1259
            if (subtitle_to_free->rects != NULL) {
1260
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1261
                    av_free(subtitle_to_free->rects[i].bitmap);
1262
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1263
                }
1264
                av_freep(&subtitle_to_free->rects);
1265
            }
1266
            subtitle_to_free->num_rects = 0;
1267
            subtitle_to_free = NULL;
1268
        }
1269
    }
1270
 discard_packet:
1271
    if (pkt == NULL) {
1272
        /* EOF handling */
1273

    
1274
        for(i=0;i<nb_ostreams;i++) {
1275
            ost = ost_table[i];
1276
            if (ost->source_index == ist_index) {
1277
                AVCodecContext *enc= ost->st->codec;
1278
                os = output_files[ost->file_index];
1279

    
1280
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1281
                    continue;
1282
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1283
                    continue;
1284

    
1285
                if (ost->encoding_needed) {
1286
                    for(;;) {
1287
                        AVPacket pkt;
1288
                        int fifo_bytes;
1289
                        av_init_packet(&pkt);
1290
                        pkt.stream_index= ost->index;
1291

    
1292
                        switch(ost->st->codec->codec_type) {
1293
                        case CODEC_TYPE_AUDIO:
1294
                            fifo_bytes = av_fifo_size(&ost->fifo);
1295
                            ret = 0;
1296
                            /* encode any samples remaining in fifo */
1297
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1298
                                int fs_tmp = enc->frame_size;
1299
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1300
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1301
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1302
                                }
1303
                                enc->frame_size = fs_tmp;
1304
                            }
1305
                            if(ret <= 0) {
1306
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1307
                            }
1308
                            audio_size += ret;
1309
                            pkt.flags |= PKT_FLAG_KEY;
1310
                            break;
1311
                        case CODEC_TYPE_VIDEO:
1312
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1313
                            video_size += ret;
1314
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1315
                                pkt.flags |= PKT_FLAG_KEY;
1316
                            if (ost->logfile && enc->stats_out) {
1317
                                fprintf(ost->logfile, "%s", enc->stats_out);
1318
                            }
1319
                            break;
1320
                        default:
1321
                            ret=-1;
1322
                        }
1323

    
1324
                        if(ret<=0)
1325
                            break;
1326
                        pkt.data= bit_buffer;
1327
                        pkt.size= ret;
1328
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1329
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1330
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1331
                    }
1332
                }
1333
            }
1334
        }
1335
    }
1336

    
1337
    return 0;
1338
 fail_decode:
1339
    return -1;
1340
}
1341

    
1342

    
1343
/*
1344
 * The following code is the main loop of the file converter
1345
 */
1346
static int av_encode(AVFormatContext **output_files,
1347
                     int nb_output_files,
1348
                     AVFormatContext **input_files,
1349
                     int nb_input_files,
1350
                     AVStreamMap *stream_maps, int nb_stream_maps)
1351
{
1352
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1353
    AVFormatContext *is, *os;
1354
    AVCodecContext *codec, *icodec;
1355
    AVOutputStream *ost, **ost_table = NULL;
1356
    AVInputStream *ist, **ist_table = NULL;
1357
    AVInputFile *file_table;
1358
    int key;
1359

    
1360
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1361
    if (!file_table)
1362
        goto fail;
1363

    
1364
    /* input stream init */
1365
    j = 0;
1366
    for(i=0;i<nb_input_files;i++) {
1367
        is = input_files[i];
1368
        file_table[i].ist_index = j;
1369
        file_table[i].nb_streams = is->nb_streams;
1370
        j += is->nb_streams;
1371
    }
1372
    nb_istreams = j;
1373

    
1374
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1375
    if (!ist_table)
1376
        goto fail;
1377

    
1378
    for(i=0;i<nb_istreams;i++) {
1379
        ist = av_mallocz(sizeof(AVInputStream));
1380
        if (!ist)
1381
            goto fail;
1382
        ist_table[i] = ist;
1383
    }
1384
    j = 0;
1385
    for(i=0;i<nb_input_files;i++) {
1386
        is = input_files[i];
1387
        for(k=0;k<is->nb_streams;k++) {
1388
            ist = ist_table[j++];
1389
            ist->st = is->streams[k];
1390
            ist->file_index = i;
1391
            ist->index = k;
1392
            ist->discard = 1; /* the stream is discarded by default
1393
                                 (changed later) */
1394

    
1395
            if (ist->st->codec->rate_emu) {
1396
                ist->start = av_gettime();
1397
                ist->frame = 0;
1398
            }
1399
        }
1400
    }
1401

    
1402
    /* output stream init */
1403
    nb_ostreams = 0;
1404
    for(i=0;i<nb_output_files;i++) {
1405
        os = output_files[i];
1406
        if (!os->nb_streams) {
1407
            fprintf(stderr, "Output file does not contain any stream\n");
1408
            exit(1);
1409
        }
1410
        nb_ostreams += os->nb_streams;
1411
    }
1412
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1413
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1414
        exit(1);
1415
    }
1416

    
1417
    /* Sanity check the mapping args -- do the input files & streams exist? */
1418
    for(i=0;i<nb_stream_maps;i++) {
1419
        int fi = stream_maps[i].file_index;
1420
        int si = stream_maps[i].stream_index;
1421

    
1422
        if (fi < 0 || fi > nb_input_files - 1 ||
1423
            si < 0 || si > file_table[fi].nb_streams - 1) {
1424
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1425
            exit(1);
1426
        }
1427
        fi = stream_maps[i].sync_file_index;
1428
        si = stream_maps[i].sync_stream_index;
1429
        if (fi < 0 || fi > nb_input_files - 1 ||
1430
            si < 0 || si > file_table[fi].nb_streams - 1) {
1431
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1432
            exit(1);
1433
        }
1434
    }
1435

    
1436
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1437
    if (!ost_table)
1438
        goto fail;
1439
    for(i=0;i<nb_ostreams;i++) {
1440
        ost = av_mallocz(sizeof(AVOutputStream));
1441
        if (!ost)
1442
            goto fail;
1443
        ost_table[i] = ost;
1444
    }
1445

    
1446
    n = 0;
1447
    for(k=0;k<nb_output_files;k++) {
1448
        os = output_files[k];
1449
        for(i=0;i<os->nb_streams;i++) {
1450
            int found;
1451
            ost = ost_table[n++];
1452
            ost->file_index = k;
1453
            ost->index = i;
1454
            ost->st = os->streams[i];
1455
            if (nb_stream_maps > 0) {
1456
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1457
                    stream_maps[n-1].stream_index;
1458

    
1459
                /* Sanity check that the stream types match */
1460
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1461
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1462
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1463
                        ost->file_index, ost->index);
1464
                    exit(1);
1465
                }
1466

    
1467
            } else {
1468
                /* get corresponding input stream index : we select the first one with the right type */
1469
                found = 0;
1470
                for(j=0;j<nb_istreams;j++) {
1471
                    ist = ist_table[j];
1472
                    if (ist->discard &&
1473
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1474
                        ost->source_index = j;
1475
                        found = 1;
1476
                        break;
1477
                    }
1478
                }
1479

    
1480
                if (!found) {
1481
                    /* try again and reuse existing stream */
1482
                    for(j=0;j<nb_istreams;j++) {
1483
                        ist = ist_table[j];
1484
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1485
                            ost->source_index = j;
1486
                            found = 1;
1487
                        }
1488
                    }
1489
                    if (!found) {
1490
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1491
                                ost->file_index, ost->index);
1492
                        exit(1);
1493
                    }
1494
                }
1495
            }
1496
            ist = ist_table[ost->source_index];
1497
            ist->discard = 0;
1498
            ost->sync_ist = (nb_stream_maps > 0) ?
1499
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1500
                         stream_maps[n-1].sync_stream_index] : ist;
1501
        }
1502
    }
1503

    
1504
    /* for each output stream, we compute the right encoding parameters */
1505
    for(i=0;i<nb_ostreams;i++) {
1506
        ost = ost_table[i];
1507
        ist = ist_table[ost->source_index];
1508

    
1509
        codec = ost->st->codec;
1510
        icodec = ist->st->codec;
1511

    
1512
        if (ost->st->stream_copy) {
1513
            /* if stream_copy is selected, no need to decode or encode */
1514
            codec->codec_id = icodec->codec_id;
1515
            codec->codec_type = icodec->codec_type;
1516
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1517
            codec->bit_rate = icodec->bit_rate;
1518
            codec->extradata= icodec->extradata;
1519
            codec->extradata_size= icodec->extradata_size;
1520
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1521
                codec->time_base = icodec->time_base;
1522
            else
1523
                codec->time_base = ist->st->time_base;
1524
            switch(codec->codec_type) {
1525
            case CODEC_TYPE_AUDIO:
1526
                codec->sample_rate = icodec->sample_rate;
1527
                codec->channels = icodec->channels;
1528
                codec->frame_size = icodec->frame_size;
1529
                codec->block_align= icodec->block_align;
1530
                break;
1531
            case CODEC_TYPE_VIDEO:
1532
                if(using_vhook) {
1533
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1534
                    exit(1);
1535
                }
1536
                codec->pix_fmt = icodec->pix_fmt;
1537
                codec->width = icodec->width;
1538
                codec->height = icodec->height;
1539
                codec->has_b_frames = icodec->has_b_frames;
1540
                break;
1541
            case CODEC_TYPE_SUBTITLE:
1542
                break;
1543
            default:
1544
                abort();
1545
            }
1546
        } else {
1547
            switch(codec->codec_type) {
1548
            case CODEC_TYPE_AUDIO:
1549
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1550
                    goto fail;
1551

    
1552
                if (codec->channels == icodec->channels &&
1553
                    codec->sample_rate == icodec->sample_rate) {
1554
                    ost->audio_resample = 0;
1555
                } else {
1556
                    if (codec->channels != icodec->channels &&
1557
                        (icodec->codec_id == CODEC_ID_AC3 ||
1558
                         icodec->codec_id == CODEC_ID_DTS)) {
1559
                        /* Special case for 5:1 AC3 and DTS input */
1560
                        /* and mono or stereo output      */
1561
                        /* Request specific number of channels */
1562
                        icodec->channels = codec->channels;
1563
                        if (codec->sample_rate == icodec->sample_rate)
1564
                            ost->audio_resample = 0;
1565
                        else {
1566
                            ost->audio_resample = 1;
1567
                        }
1568
                    } else {
1569
                        ost->audio_resample = 1;
1570
                    }
1571
                }
1572
                if(audio_sync_method>1)
1573
                    ost->audio_resample = 1;
1574

    
1575
                if(ost->audio_resample){
1576
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1577
                                                    codec->sample_rate, icodec->sample_rate);
1578
                    if(!ost->resample){
1579
                        printf("Can't resample.  Aborting.\n");
1580
                        abort();
1581
                    }
1582
                }
1583
                ist->decoding_needed = 1;
1584
                ost->encoding_needed = 1;
1585
                break;
1586
            case CODEC_TYPE_VIDEO:
1587
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1588
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1589
                ost->video_resample = ((codec->width != icodec->width -
1590
                                (frame_leftBand + frame_rightBand) +
1591
                                (frame_padleft + frame_padright)) ||
1592
                        (codec->height != icodec->height -
1593
                                (frame_topBand  + frame_bottomBand) +
1594
                                (frame_padtop + frame_padbottom)) ||
1595
                        (codec->pix_fmt != icodec->pix_fmt));
1596
                if (ost->video_crop) {
1597
                    ost->topBand = frame_topBand;
1598
                    ost->leftBand = frame_leftBand;
1599
                }
1600
                if (ost->video_pad) {
1601
                    ost->padtop = frame_padtop;
1602
                    ost->padleft = frame_padleft;
1603
                    ost->padbottom = frame_padbottom;
1604
                    ost->padright = frame_padright;
1605
                    if (!ost->video_resample) {
1606
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1607
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1608
                                         codec->width, codec->height ) )
1609
                            goto fail;
1610
                    }
1611
                }
1612
                if (ost->video_resample) {
1613
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1614
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1615
                                         codec->width, codec->height ) ) {
1616
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1617
                        exit(1);
1618
                    }
1619
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1620
                    ost->img_resample_ctx = sws_getContext(
1621
                            icodec->width - (frame_leftBand + frame_rightBand),
1622
                            icodec->height - (frame_topBand + frame_bottomBand),
1623
                            icodec->pix_fmt,
1624
                            codec->width - (frame_padleft + frame_padright),
1625
                            codec->height - (frame_padtop + frame_padbottom),
1626
                            codec->pix_fmt,
1627
                            sws_flags, NULL, NULL, NULL);
1628
                    if (ost->img_resample_ctx == NULL) {
1629
                        fprintf(stderr, "Cannot get resampling context\n");
1630
                        exit(1);
1631
                    }
1632
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1633
                }
1634
                ost->encoding_needed = 1;
1635
                ist->decoding_needed = 1;
1636
                break;
1637
            case CODEC_TYPE_SUBTITLE:
1638
                ost->encoding_needed = 1;
1639
                ist->decoding_needed = 1;
1640
                break;
1641
            default:
1642
                abort();
1643
                break;
1644
            }
1645
            /* two pass mode */
1646
            if (ost->encoding_needed &&
1647
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1648
                char logfilename[1024];
1649
                FILE *f;
1650
                int size;
1651
                char *logbuffer;
1652

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

    
1691
    if (!bit_buffer)
1692
        bit_buffer = av_malloc(bit_buffer_size);
1693
    if (!bit_buffer)
1694
        goto fail;
1695

    
1696
    /* dump the file output parameters - cannot be done before in case
1697
       of stream copy */
1698
    for(i=0;i<nb_output_files;i++) {
1699
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1700
    }
1701

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

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

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

    
1761
    /* init pts */
1762
    for(i=0;i<nb_istreams;i++) {
1763
        ist = ist_table[i];
1764
        is = input_files[ist->file_index];
1765
        ist->pts = 0;
1766
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1767
        if(ist->st->start_time == AV_NOPTS_VALUE)
1768
            ist->next_pts=0;
1769
        if(input_files_ts_offset[ist->file_index])
1770
            ist->next_pts= AV_NOPTS_VALUE;
1771
        ist->is_start = 1;
1772
    }
1773

    
1774
    /* set meta data information from input file if required */
1775
    for (i=0;i<nb_meta_data_maps;i++) {
1776
        AVFormatContext *out_file;
1777
        AVFormatContext *in_file;
1778

    
1779
        int out_file_index = meta_data_maps[i].out_file;
1780
        int in_file_index = meta_data_maps[i].in_file;
1781
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1782
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1783
            ret = AVERROR(EINVAL);
1784
            goto fail;
1785
        }
1786
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1787
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1788
            ret = AVERROR(EINVAL);
1789
            goto fail;
1790
        }
1791

    
1792
        out_file = output_files[out_file_index];
1793
        in_file = input_files[in_file_index];
1794

    
1795
        strcpy(out_file->title, in_file->title);
1796
        strcpy(out_file->author, in_file->author);
1797
        strcpy(out_file->copyright, in_file->copyright);
1798
        strcpy(out_file->comment, in_file->comment);
1799
        strcpy(out_file->album, in_file->album);
1800
        out_file->year = in_file->year;
1801
        out_file->track = in_file->track;
1802
        strcpy(out_file->genre, in_file->genre);
1803
    }
1804

    
1805
    /* open files and write file headers */
1806
    for(i=0;i<nb_output_files;i++) {
1807
        os = output_files[i];
1808
        if (av_write_header(os) < 0) {
1809
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1810
            ret = AVERROR(EINVAL);
1811
            goto fail;
1812
        }
1813
    }
1814

    
1815
    if ( !using_stdin && verbose >= 0) {
1816
        fprintf(stderr, "Press [q] to stop encoding\n");
1817
        url_set_interrupt_cb(decode_interrupt_cb);
1818
    }
1819
    term_init();
1820

    
1821
    key = -1;
1822
    timer_start = av_gettime();
1823

    
1824
    for(; received_sigterm == 0;) {
1825
        int file_index, ist_index;
1826
        AVPacket pkt;
1827
        double ipts_min;
1828
        double opts_min;
1829

    
1830
    redo:
1831
        ipts_min= 1e100;
1832
        opts_min= 1e100;
1833
        /* if 'q' pressed, exits */
1834
        if (!using_stdin) {
1835
            if (q_pressed)
1836
                break;
1837
            /* read_key() returns 0 on EOF */
1838
            key = read_key();
1839
            if (key == 'q')
1840
                break;
1841
        }
1842

    
1843
        /* select the stream that we must read now by looking at the
1844
           smallest output pts */
1845
        file_index = -1;
1846
        for(i=0;i<nb_ostreams;i++) {
1847
            double ipts, opts;
1848
            ost = ost_table[i];
1849
            os = output_files[ost->file_index];
1850
            ist = ist_table[ost->source_index];
1851
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1852
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1853
            else
1854
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1855
            ipts = (double)ist->pts;
1856
            if (!file_table[ist->file_index].eof_reached){
1857
                if(ipts < ipts_min) {
1858
                    ipts_min = ipts;
1859
                    if(input_sync ) file_index = ist->file_index;
1860
                }
1861
                if(opts < opts_min) {
1862
                    opts_min = opts;
1863
                    if(!input_sync) file_index = ist->file_index;
1864
                }
1865
            }
1866
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1867
                file_index= -1;
1868
                break;
1869
            }
1870
        }
1871
        /* if none, if is finished */
1872
        if (file_index < 0) {
1873
            break;
1874
        }
1875

    
1876
        /* finish if recording time exhausted */
1877
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1878
            break;
1879

    
1880
        /* finish if limit size exhausted */
1881
        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1882
            break;
1883

    
1884
        /* read a frame from it and output it in the fifo */
1885
        is = input_files[file_index];
1886
        if (av_read_frame(is, &pkt) < 0) {
1887
            file_table[file_index].eof_reached = 1;
1888
            if (opt_shortest) break; else continue; //
1889
        }
1890

    
1891
        if (do_pkt_dump) {
1892
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1893
        }
1894
        /* the following test is needed in case new streams appear
1895
           dynamically in stream : we ignore them */
1896
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1897
            goto discard_packet;
1898
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1899
        ist = ist_table[ist_index];
1900
        if (ist->discard)
1901
            goto discard_packet;
1902

    
1903
//        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1904
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1905
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1906
            if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1907
                input_files_ts_offset[ist->file_index]-= delta;
1908
                if (verbose > 2)
1909
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1910
                for(i=0; i<file_table[file_index].nb_streams; i++){
1911
                    int index= file_table[file_index].ist_index + i;
1912
                    ist_table[index]->next_pts += delta;
1913
                    ist_table[index]->is_start=1;
1914
                }
1915
            }
1916
        }
1917

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

    
1921
            if (verbose >= 0)
1922
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1923
                        ist->file_index, ist->index);
1924

    
1925
            av_free_packet(&pkt);
1926
            goto redo;
1927
        }
1928

    
1929
    discard_packet:
1930
        av_free_packet(&pkt);
1931

    
1932
        /* dump report by using the output first video and audio streams */
1933
        print_report(output_files, ost_table, nb_ostreams, 0);
1934
    }
1935

    
1936
    /* at the end of stream, we must flush the decoder buffers */
1937
    for(i=0;i<nb_istreams;i++) {
1938
        ist = ist_table[i];
1939
        if (ist->decoding_needed) {
1940
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1941
        }
1942
    }
1943

    
1944
    term_exit();
1945

    
1946
    /* write the trailer if needed and close file */
1947
    for(i=0;i<nb_output_files;i++) {
1948
        os = output_files[i];
1949
        av_write_trailer(os);
1950
    }
1951

    
1952
    /* dump report by using the first video and audio streams */
1953
    print_report(output_files, ost_table, nb_ostreams, 1);
1954

    
1955
    /* close each encoder */
1956
    for(i=0;i<nb_ostreams;i++) {
1957
        ost = ost_table[i];
1958
        if (ost->encoding_needed) {
1959
            av_freep(&ost->st->codec->stats_in);
1960
            avcodec_close(ost->st->codec);
1961
        }
1962
    }
1963

    
1964
    /* close each decoder */
1965
    for(i=0;i<nb_istreams;i++) {
1966
        ist = ist_table[i];
1967
        if (ist->decoding_needed) {
1968
            avcodec_close(ist->st->codec);
1969
        }
1970
    }
1971

    
1972
    /* finished ! */
1973

    
1974
    ret = 0;
1975
 fail1:
1976
    av_freep(&bit_buffer);
1977
    av_free(file_table);
1978

    
1979
    if (ist_table) {
1980
        for(i=0;i<nb_istreams;i++) {
1981
            ist = ist_table[i];
1982
            av_free(ist);
1983
        }
1984
        av_free(ist_table);
1985
    }
1986
    if (ost_table) {
1987
        for(i=0;i<nb_ostreams;i++) {
1988
            ost = ost_table[i];
1989
            if (ost) {
1990
                if (ost->logfile) {
1991
                    fclose(ost->logfile);
1992
                    ost->logfile = NULL;
1993
                }
1994
                av_fifo_free(&ost->fifo); /* works even if fifo is not
1995
                                             initialized but set to zero */
1996
                av_free(ost->pict_tmp.data[0]);
1997
                if (ost->video_resample)
1998
                    sws_freeContext(ost->img_resample_ctx);
1999
                if (ost->audio_resample)
2000
                    audio_resample_close(ost->resample);
2001
                av_free(ost);
2002
            }
2003
        }
2004
        av_free(ost_table);
2005
    }
2006
    return ret;
2007
 fail:
2008
    ret = AVERROR(ENOMEM);
2009
    goto fail1;
2010
}
2011

    
2012
#if 0
2013
int file_read(const char *filename)
2014
{
2015
    URLContext *h;
2016
    unsigned char buffer[1024];
2017
    int len, i;
2018

2019
    if (url_open(&h, filename, O_RDONLY) < 0) {
2020
        printf("could not open '%s'\n", filename);
2021
        return -1;
2022
    }
2023
    for(;;) {
2024
        len = url_read(h, buffer, sizeof(buffer));
2025
        if (len <= 0)
2026
            break;
2027
        for(i=0;i<len;i++) putchar(buffer[i]);
2028
    }
2029
    url_close(h);
2030
    return 0;
2031
}
2032
#endif
2033

    
2034
static void opt_format(const char *arg)
2035
{
2036
    /* compatibility stuff for pgmyuv */
2037
    if (!strcmp(arg, "pgmyuv")) {
2038
        pgmyuv_compatibility_hack=1;
2039
//        opt_image_format(arg);
2040
        arg = "image2";
2041
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2042
    }
2043

    
2044
    file_iformat = av_find_input_format(arg);
2045
    file_oformat = guess_format(arg, NULL, NULL);
2046
    if (!file_iformat && !file_oformat) {
2047
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2048
        exit(1);
2049
    }
2050
}
2051

    
2052
static void opt_video_rc_eq(char *arg)
2053
{
2054
    video_rc_eq = arg;
2055
}
2056

    
2057
static void opt_video_rc_override_string(char *arg)
2058
{
2059
    video_rc_override_string = arg;
2060
}
2061

    
2062
static void opt_me_threshold(const char *arg)
2063
{
2064
    me_threshold = atoi(arg);
2065
}
2066

    
2067
static void opt_verbose(const char *arg)
2068
{
2069
    verbose = atoi(arg);
2070
    av_log_level = atoi(arg);
2071
}
2072

    
2073
static void opt_frame_rate(const char *arg)
2074
{
2075
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2076
        fprintf(stderr, "Incorrect frame rate\n");
2077
        exit(1);
2078
    }
2079
}
2080

    
2081
static void opt_frame_crop_top(const char *arg)
2082
{
2083
    frame_topBand = atoi(arg);
2084
    if (frame_topBand < 0) {
2085
        fprintf(stderr, "Incorrect top crop size\n");
2086
        exit(1);
2087
    }
2088
    if ((frame_topBand % 2) != 0) {
2089
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2090
        exit(1);
2091
    }
2092
    if ((frame_topBand) >= frame_height){
2093
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2094
        exit(1);
2095
    }
2096
    frame_height -= frame_topBand;
2097
}
2098

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

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

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

    
2153
static void opt_frame_size(const char *arg)
2154
{
2155
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2156
        fprintf(stderr, "Incorrect frame size\n");
2157
        exit(1);
2158
    }
2159
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2160
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2161
        exit(1);
2162
    }
2163
}
2164

    
2165

    
2166
#define SCALEBITS 10
2167
#define ONE_HALF  (1 << (SCALEBITS - 1))
2168
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2169

    
2170
#define RGB_TO_Y(r, g, b) \
2171
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2172
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2173

    
2174
#define RGB_TO_U(r1, g1, b1, shift)\
2175
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2176
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2177

    
2178
#define RGB_TO_V(r1, g1, b1, shift)\
2179
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2180
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2181

    
2182
static void opt_pad_color(const char *arg) {
2183
    /* Input is expected to be six hex digits similar to
2184
       how colors are expressed in html tags (but without the #) */
2185
    int rgb = strtol(arg, NULL, 16);
2186
    int r,g,b;
2187

    
2188
    r = (rgb >> 16);
2189
    g = ((rgb >> 8) & 255);
2190
    b = (rgb & 255);
2191

    
2192
    padcolor[0] = RGB_TO_Y(r,g,b);
2193
    padcolor[1] = RGB_TO_U(r,g,b,0);
2194
    padcolor[2] = RGB_TO_V(r,g,b,0);
2195
}
2196

    
2197
static void opt_frame_pad_top(const char *arg)
2198
{
2199
    frame_padtop = atoi(arg);
2200
    if (frame_padtop < 0) {
2201
        fprintf(stderr, "Incorrect top pad size\n");
2202
        exit(1);
2203
    }
2204
    if ((frame_padtop % 2) != 0) {
2205
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2206
        exit(1);
2207
    }
2208
}
2209

    
2210
static void opt_frame_pad_bottom(const char *arg)
2211
{
2212
    frame_padbottom = atoi(arg);
2213
    if (frame_padbottom < 0) {
2214
        fprintf(stderr, "Incorrect bottom pad size\n");
2215
        exit(1);
2216
    }
2217
    if ((frame_padbottom % 2) != 0) {
2218
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2219
        exit(1);
2220
    }
2221
}
2222

    
2223

    
2224
static void opt_frame_pad_left(const char *arg)
2225
{
2226
    frame_padleft = atoi(arg);
2227
    if (frame_padleft < 0) {
2228
        fprintf(stderr, "Incorrect left pad size\n");
2229
        exit(1);
2230
    }
2231
    if ((frame_padleft % 2) != 0) {
2232
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2233
        exit(1);
2234
    }
2235
}
2236

    
2237

    
2238
static void opt_frame_pad_right(const char *arg)
2239
{
2240
    frame_padright = atoi(arg);
2241
    if (frame_padright < 0) {
2242
        fprintf(stderr, "Incorrect right pad size\n");
2243
        exit(1);
2244
    }
2245
    if ((frame_padright % 2) != 0) {
2246
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2247
        exit(1);
2248
    }
2249
}
2250

    
2251
void list_pix_fmts(void)
2252
{
2253
    int i;
2254
    char pix_fmt_str[128];
2255
    for (i=-1; i < PIX_FMT_NB; i++) {
2256
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2257
        fprintf(stdout, "%s\n", pix_fmt_str);
2258
    }
2259
}
2260

    
2261
static void opt_frame_pix_fmt(const char *arg)
2262
{
2263
    if (strcmp(arg, "list"))
2264
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2265
    else {
2266
        list_pix_fmts();
2267
        exit(0);
2268
    }
2269
}
2270

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

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

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

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

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

    
2314
static void opt_strict(const char *arg)
2315
{
2316
    strict= atoi(arg);
2317
}
2318

    
2319
static void opt_top_field_first(const char *arg)
2320
{
2321
    top_field_first= atoi(arg);
2322
}
2323

    
2324
static void opt_thread_count(const char *arg)
2325
{
2326
    thread_count= atoi(arg);
2327
#if !defined(HAVE_THREADS)
2328
    if (verbose >= 0)
2329
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2330
#endif
2331
}
2332

    
2333
static void opt_audio_rate(const char *arg)
2334
{
2335
    audio_sample_rate = atoi(arg);
2336
}
2337

    
2338
static void opt_audio_channels(const char *arg)
2339
{
2340
    audio_channels = atoi(arg);
2341
}
2342

    
2343
static void opt_video_channel(const char *arg)
2344
{
2345
    video_channel = strtol(arg, NULL, 0);
2346
}
2347

    
2348
static void opt_video_standard(const char *arg)
2349
{
2350
    video_standard = av_strdup(arg);
2351
}
2352

    
2353
static void opt_codec(int *pstream_copy, int *pcodec_id,
2354
                      int codec_type, const char *arg)
2355
{
2356
    AVCodec *p;
2357

    
2358
    if (!strcmp(arg, "copy")) {
2359
        *pstream_copy = 1;
2360
    } else {
2361
        p = first_avcodec;
2362
        while (p) {
2363
            if (!strcmp(p->name, arg) && p->type == codec_type)
2364
                break;
2365
            p = p->next;
2366
        }
2367
        if (p == NULL) {
2368
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2369
            exit(1);
2370
        } else {
2371
            *pcodec_id = p->id;
2372
        }
2373
    }
2374
}
2375

    
2376
static void opt_audio_codec(const char *arg)
2377
{
2378
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2379
}
2380

    
2381
static void opt_audio_tag(const char *arg)
2382
{
2383
    char *tail;
2384
    audio_codec_tag= strtol(arg, &tail, 0);
2385

    
2386
    if(!tail || *tail)
2387
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2388
}
2389

    
2390
static void opt_video_tag(const char *arg)
2391
{
2392
    char *tail;
2393
    video_codec_tag= strtol(arg, &tail, 0);
2394

    
2395
    if(!tail || *tail)
2396
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2397
}
2398

    
2399
static void add_frame_hooker(const char *arg)
2400
{
2401
    int argc = 0;
2402
    char *argv[64];
2403
    int i;
2404
    char *args = av_strdup(arg);
2405

    
2406
    using_vhook = 1;
2407

    
2408
    argv[0] = strtok(args, " ");
2409
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2410
    }
2411

    
2412
    i = frame_hook_add(argc, argv);
2413

    
2414
    if (i != 0) {
2415
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2416
        exit(1);
2417
    }
2418
}
2419

    
2420
const char *motion_str[] = {
2421
    "zero",
2422
    "full",
2423
    "log",
2424
    "phods",
2425
    "epzs",
2426
    "x1",
2427
    "hex",
2428
    "umh",
2429
    "iter",
2430
    NULL,
2431
};
2432

    
2433
static void opt_motion_estimation(const char *arg)
2434
{
2435
    const char **p;
2436
    p = motion_str;
2437
    for(;;) {
2438
        if (!*p) {
2439
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2440
            exit(1);
2441
        }
2442
        if (!strcmp(*p, arg))
2443
            break;
2444
        p++;
2445
    }
2446
    me_method = (p - motion_str) + 1;
2447
}
2448

    
2449
static void opt_video_codec(const char *arg)
2450
{
2451
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2452
}
2453

    
2454
static void opt_subtitle_codec(const char *arg)
2455
{
2456
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2457
}
2458

    
2459
static void opt_map(const char *arg)
2460
{
2461
    AVStreamMap *m;
2462
    const char *p;
2463

    
2464
    p = arg;
2465
    m = &stream_maps[nb_stream_maps++];
2466

    
2467
    m->file_index = strtol(arg, (char **)&p, 0);
2468
    if (*p)
2469
        p++;
2470

    
2471
    m->stream_index = strtol(p, (char **)&p, 0);
2472
    if (*p) {
2473
        p++;
2474
        m->sync_file_index = strtol(p, (char **)&p, 0);
2475
        if (*p)
2476
            p++;
2477
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2478
    } else {
2479
        m->sync_file_index = m->file_index;
2480
        m->sync_stream_index = m->stream_index;
2481
    }
2482
}
2483

    
2484
static void opt_map_meta_data(const char *arg)
2485
{
2486
    AVMetaDataMap *m;
2487
    const char *p;
2488

    
2489
    p = arg;
2490
    m = &meta_data_maps[nb_meta_data_maps++];
2491

    
2492
    m->out_file = strtol(arg, (char **)&p, 0);
2493
    if (*p)
2494
        p++;
2495

    
2496
    m->in_file = strtol(p, (char **)&p, 0);
2497
}
2498

    
2499
static void opt_recording_time(const char *arg)
2500
{
2501
    recording_time = parse_date(arg, 1);
2502
}
2503

    
2504
static void opt_start_time(const char *arg)
2505
{
2506
    start_time = parse_date(arg, 1);
2507
}
2508

    
2509
static void opt_rec_timestamp(const char *arg)
2510
{
2511
    rec_timestamp = parse_date(arg, 0) / 1000000;
2512
}
2513

    
2514
static void opt_input_ts_offset(const char *arg)
2515
{
2516
    input_ts_offset = parse_date(arg, 1);
2517
}
2518

    
2519
static void opt_input_file(const char *filename)
2520
{
2521
    AVFormatContext *ic;
2522
    AVFormatParameters params, *ap = &params;
2523
    int err, i, ret, rfps, rfps_base;
2524
    int64_t timestamp;
2525

    
2526
    if (!strcmp(filename, "-"))
2527
        filename = "pipe:";
2528

    
2529
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2530
                   !strcmp( filename, "/dev/stdin" );
2531

    
2532
    /* get default parameters from command line */
2533
    ic = av_alloc_format_context();
2534

    
2535
    memset(ap, 0, sizeof(*ap));
2536
    ap->prealloced_context = 1;
2537
    ap->sample_rate = audio_sample_rate;
2538
    ap->channels = audio_channels;
2539
    ap->time_base.den = frame_rate.num;
2540
    ap->time_base.num = frame_rate.den;
2541
    ap->width = frame_width + frame_padleft + frame_padright;
2542
    ap->height = frame_height + frame_padtop + frame_padbottom;
2543
    ap->pix_fmt = frame_pix_fmt;
2544
    ap->channel = video_channel;
2545
    ap->standard = video_standard;
2546
    ap->video_codec_id = video_codec_id;
2547
    ap->audio_codec_id = audio_codec_id;
2548
    if(pgmyuv_compatibility_hack)
2549
        ap->video_codec_id= CODEC_ID_PGMYUV;
2550

    
2551
    for(i=0; i<opt_name_count; i++){
2552
        const AVOption *opt;
2553
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2554
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2555
            av_set_double(ic, opt_names[i], d);
2556
    }
2557
    /* open the input file with generic libav function */
2558
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2559
    if (err < 0) {
2560
        print_error(filename, err);
2561
        exit(1);
2562
    }
2563

    
2564
    ic->loop_input = loop_input;
2565

    
2566
    /* If not enough info to get the stream parameters, we decode the
2567
       first frames to get it. (used in mpeg case for example) */
2568
    ret = av_find_stream_info(ic);
2569
    if (ret < 0 && verbose >= 0) {
2570
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2571
        exit(1);
2572
    }
2573

    
2574
    timestamp = start_time;
2575
    /* add the stream start time */
2576
    if (ic->start_time != AV_NOPTS_VALUE)
2577
        timestamp += ic->start_time;
2578

    
2579
    /* if seeking requested, we execute it */
2580
    if (start_time != 0) {
2581
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2582
        if (ret < 0) {
2583
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2584
                    filename, (double)timestamp / AV_TIME_BASE);
2585
        }
2586
        /* reset seek info */
2587
        start_time = 0;
2588
    }
2589

    
2590
    /* update the current parameters so that they match the one of the input stream */
2591
    for(i=0;i<ic->nb_streams;i++) {
2592
        int j;
2593
        AVCodecContext *enc = ic->streams[i]->codec;
2594
        if(thread_count>1)
2595
            avcodec_thread_init(enc, thread_count);
2596
        enc->thread_count= thread_count;
2597
        switch(enc->codec_type) {
2598
        case CODEC_TYPE_AUDIO:
2599
            for(j=0; j<opt_name_count; j++){
2600
                const AVOption *opt;
2601
                double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2602
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2603
                    av_set_double(enc, opt_names[j], d);
2604
            }
2605
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2606
            audio_channels = enc->channels;
2607
            audio_sample_rate = enc->sample_rate;
2608
            if(audio_disable)
2609
                ic->streams[i]->discard= AVDISCARD_ALL;
2610
            break;
2611
        case CODEC_TYPE_VIDEO:
2612
            for(j=0; j<opt_name_count; j++){
2613
                const AVOption *opt;
2614
                double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2615
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2616
                    av_set_double(enc, opt_names[j], d);
2617
            }
2618
            frame_height = enc->height;
2619
            frame_width = enc->width;
2620
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2621
            frame_pix_fmt = enc->pix_fmt;
2622
            rfps      = ic->streams[i]->r_frame_rate.num;
2623
            rfps_base = ic->streams[i]->r_frame_rate.den;
2624
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2625
            if(me_threshold)
2626
                enc->debug |= FF_DEBUG_MV;
2627

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

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

    
2634
                    (float)rfps / rfps_base, rfps, rfps_base);
2635
            }
2636
            /* update the current frame rate to match the stream frame rate */
2637
            frame_rate.num = rfps;
2638
            frame_rate.den = rfps_base;
2639

    
2640
            enc->rate_emu = rate_emu;
2641
            if(video_disable)
2642
                ic->streams[i]->discard= AVDISCARD_ALL;
2643
            else if(video_discard)
2644
                ic->streams[i]->discard= video_discard;
2645
            break;
2646
        case CODEC_TYPE_DATA:
2647
            break;
2648
        case CODEC_TYPE_SUBTITLE:
2649
            break;
2650
        case CODEC_TYPE_UNKNOWN:
2651
            break;
2652
        default:
2653
            abort();
2654
        }
2655
    }
2656

    
2657
    input_files[nb_input_files] = ic;
2658
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2659
    /* dump the file content */
2660
    if (verbose >= 0)
2661
        dump_format(ic, nb_input_files, filename, 0);
2662

    
2663
    nb_input_files++;
2664
    file_iformat = NULL;
2665
    file_oformat = NULL;
2666

    
2667
    video_channel = 0;
2668

    
2669
    rate_emu = 0;
2670
}
2671

    
2672
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2673
{
2674
    int has_video, has_audio, i, j;
2675
    AVFormatContext *ic;
2676

    
2677
    has_video = 0;
2678
    has_audio = 0;
2679
    for(j=0;j<nb_input_files;j++) {
2680
        ic = input_files[j];
2681
        for(i=0;i<ic->nb_streams;i++) {
2682
            AVCodecContext *enc = ic->streams[i]->codec;
2683
            switch(enc->codec_type) {
2684
            case CODEC_TYPE_AUDIO:
2685
                has_audio = 1;
2686
                break;
2687
            case CODEC_TYPE_VIDEO:
2688
                has_video = 1;
2689
                break;
2690
            case CODEC_TYPE_DATA:
2691
            case CODEC_TYPE_UNKNOWN:
2692
            case CODEC_TYPE_SUBTITLE:
2693
                break;
2694
            default:
2695
                abort();
2696
            }
2697
        }
2698
    }
2699
    *has_video_ptr = has_video;
2700
    *has_audio_ptr = has_audio;
2701
}
2702

    
2703
static void new_video_stream(AVFormatContext *oc)
2704
{
2705
    AVStream *st;
2706
    AVCodecContext *video_enc;
2707
    int codec_id;
2708

    
2709
    st = av_new_stream(oc, oc->nb_streams);
2710
    if (!st) {
2711
        fprintf(stderr, "Could not alloc stream\n");
2712
        exit(1);
2713
    }
2714
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2715
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2716
    video_bitstream_filters= NULL;
2717

    
2718
    if(thread_count>1)
2719
        avcodec_thread_init(st->codec, thread_count);
2720

    
2721
    video_enc = st->codec;
2722

    
2723
    if(video_codec_tag)
2724
        video_enc->codec_tag= video_codec_tag;
2725

    
2726
    if(   (video_global_header&1)
2727
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2728
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2729
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2730
    }
2731
    if(video_global_header&2){
2732
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2733
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2734
    }
2735

    
2736
    if (video_stream_copy) {
2737
        st->stream_copy = 1;
2738
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2739
    } else {
2740
        char *p;
2741
        int i;
2742
        AVCodec *codec;
2743

    
2744
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2745
        if (video_codec_id != CODEC_ID_NONE)
2746
            codec_id = video_codec_id;
2747

    
2748
        video_enc->codec_id = codec_id;
2749
        codec = avcodec_find_encoder(codec_id);
2750

    
2751
        for(i=0; i<opt_name_count; i++){
2752
             const AVOption *opt;
2753
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2754
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2755
                 av_set_double(video_enc, opt_names[i], d);
2756
        }
2757

    
2758
        video_enc->time_base.den = frame_rate.num;
2759
        video_enc->time_base.num = frame_rate.den;
2760
        if(codec && codec->supported_framerates){
2761
            const AVRational *p= codec->supported_framerates;
2762
            AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2763
            const AVRational *best=NULL;
2764
            AVRational best_error= (AVRational){INT_MAX, 1};
2765
            for(; p->den!=0; p++){
2766
                AVRational error= av_sub_q(req, *p);
2767
                if(error.num <0) error.num *= -1;
2768
                if(av_cmp_q(error, best_error) < 0){
2769
                    best_error= error;
2770
                    best= p;
2771
                }
2772
            }
2773
            video_enc->time_base.den= best->num;
2774
            video_enc->time_base.num= best->den;
2775
        }
2776

    
2777
        video_enc->width = frame_width + frame_padright + frame_padleft;
2778
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2779
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2780
        video_enc->pix_fmt = frame_pix_fmt;
2781

    
2782
        if(codec && codec->pix_fmts){
2783
            const enum PixelFormat *p= codec->pix_fmts;
2784
            for(; *p!=-1; p++){
2785
                if(*p == video_enc->pix_fmt)
2786
                    break;
2787
            }
2788
            if(*p == -1)
2789
                video_enc->pix_fmt = codec->pix_fmts[0];
2790
        }
2791

    
2792
        if (intra_only)
2793
            video_enc->gop_size = 0;
2794
        if (video_qscale || same_quality) {
2795
            video_enc->flags |= CODEC_FLAG_QSCALE;
2796
            video_enc->global_quality=
2797
                st->quality = FF_QP2LAMBDA * video_qscale;
2798
        }
2799

    
2800
        if(intra_matrix)
2801
            video_enc->intra_matrix = intra_matrix;
2802
        if(inter_matrix)
2803
            video_enc->inter_matrix = inter_matrix;
2804

    
2805
        video_enc->max_qdiff = video_qdiff;
2806
        video_enc->rc_eq = video_rc_eq;
2807
        video_enc->thread_count = thread_count;
2808
        p= video_rc_override_string;
2809
        for(i=0; p; i++){
2810
            int start, end, q;
2811
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2812
            if(e!=3){
2813
                fprintf(stderr, "error parsing rc_override\n");
2814
                exit(1);
2815
            }
2816
            video_enc->rc_override=
2817
                av_realloc(video_enc->rc_override,
2818
                           sizeof(RcOverride)*(i+1));
2819
            video_enc->rc_override[i].start_frame= start;
2820
            video_enc->rc_override[i].end_frame  = end;
2821
            if(q>0){
2822
                video_enc->rc_override[i].qscale= q;
2823
                video_enc->rc_override[i].quality_factor= 1.0;
2824
            }
2825
            else{
2826
                video_enc->rc_override[i].qscale= 0;
2827
                video_enc->rc_override[i].quality_factor= -q/100.0;
2828
            }
2829
            p= strchr(p, '/');
2830
            if(p) p++;
2831
        }
2832
        video_enc->rc_override_count=i;
2833
        if (!video_enc->rc_initial_buffer_occupancy)
2834
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2835
        video_enc->me_threshold= me_threshold;
2836
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2837
        video_enc->strict_std_compliance = strict;
2838

    
2839
        if (do_psnr)
2840
            video_enc->flags|= CODEC_FLAG_PSNR;
2841

    
2842
        video_enc->me_method = me_method;
2843

    
2844
        /* two pass mode */
2845
        if (do_pass) {
2846
            if (do_pass == 1) {
2847
                video_enc->flags |= CODEC_FLAG_PASS1;
2848
            } else {
2849
                video_enc->flags |= CODEC_FLAG_PASS2;
2850
            }
2851
        }
2852
    }
2853

    
2854
    /* reset some key parameters */
2855
    video_disable = 0;
2856
    video_codec_id = CODEC_ID_NONE;
2857
    video_stream_copy = 0;
2858
}
2859

    
2860
static void new_audio_stream(AVFormatContext *oc)
2861
{
2862
    AVStream *st;
2863
    AVCodecContext *audio_enc;
2864
    int codec_id, i;
2865

    
2866
    st = av_new_stream(oc, oc->nb_streams);
2867
    if (!st) {
2868
        fprintf(stderr, "Could not alloc stream\n");
2869
        exit(1);
2870
    }
2871
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2872

    
2873
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2874
    audio_bitstream_filters= NULL;
2875

    
2876
    if(thread_count>1)
2877
        avcodec_thread_init(st->codec, thread_count);
2878

    
2879
    audio_enc = st->codec;
2880
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2881
    audio_enc->strict_std_compliance = strict;
2882

    
2883
    if(audio_codec_tag)
2884
        audio_enc->codec_tag= audio_codec_tag;
2885

    
2886
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2887
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2888
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2889
    }
2890
    if (audio_stream_copy) {
2891
        st->stream_copy = 1;
2892
        audio_enc->channels = audio_channels;
2893
    } else {
2894
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2895

    
2896
        for(i=0; i<opt_name_count; i++){
2897
            const AVOption *opt;
2898
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2899
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2900
                av_set_double(audio_enc, opt_names[i], d);
2901
        }
2902

    
2903
        if (audio_codec_id != CODEC_ID_NONE)
2904
            codec_id = audio_codec_id;
2905
        audio_enc->codec_id = codec_id;
2906

    
2907
        if (audio_qscale > QSCALE_NONE) {
2908
            audio_enc->flags |= CODEC_FLAG_QSCALE;
2909
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2910
        }
2911
        audio_enc->thread_count = thread_count;
2912
        audio_enc->channels = audio_channels;
2913
    }
2914
    audio_enc->sample_rate = audio_sample_rate;
2915
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2916
    if (audio_language) {
2917
        av_strlcpy(st->language, audio_language, sizeof(st->language));
2918
        av_free(audio_language);
2919
        audio_language = NULL;
2920
    }
2921

    
2922
    /* reset some key parameters */
2923
    audio_disable = 0;
2924
    audio_codec_id = CODEC_ID_NONE;
2925
    audio_stream_copy = 0;
2926
}
2927

    
2928
static void opt_new_subtitle_stream(void)
2929
{
2930
    AVFormatContext *oc;
2931
    AVStream *st;
2932
    AVCodecContext *subtitle_enc;
2933
    int i;
2934

    
2935
    if (nb_output_files <= 0) {
2936
        fprintf(stderr, "At least one output file must be specified\n");
2937
        exit(1);
2938
    }
2939
    oc = output_files[nb_output_files - 1];
2940

    
2941
    st = av_new_stream(oc, oc->nb_streams);
2942
    if (!st) {
2943
        fprintf(stderr, "Could not alloc stream\n");
2944
        exit(1);
2945
    }
2946
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2947

    
2948
    subtitle_enc = st->codec;
2949
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2950
    if (subtitle_stream_copy) {
2951
        st->stream_copy = 1;
2952
    } else {
2953
        for(i=0; i<opt_name_count; i++){
2954
             const AVOption *opt;
2955
             double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2956
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2957
                 av_set_double(subtitle_enc, opt_names[i], d);
2958
        }
2959
        subtitle_enc->codec_id = subtitle_codec_id;
2960
    }
2961

    
2962
    if (subtitle_language) {
2963
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2964
        av_free(subtitle_language);
2965
        subtitle_language = NULL;
2966
    }
2967

    
2968
    subtitle_codec_id = CODEC_ID_NONE;
2969
    subtitle_stream_copy = 0;
2970
}
2971

    
2972
static void opt_new_audio_stream(void)
2973
{
2974
    AVFormatContext *oc;
2975
    if (nb_output_files <= 0) {
2976
        fprintf(stderr, "At least one output file must be specified\n");
2977
        exit(1);
2978
    }
2979
    oc = output_files[nb_output_files - 1];
2980
    new_audio_stream(oc);
2981
}
2982

    
2983
static void opt_new_video_stream(void)
2984
{
2985
    AVFormatContext *oc;
2986
    if (nb_output_files <= 0) {
2987
        fprintf(stderr, "At least one output file must be specified\n");
2988
        exit(1);
2989
    }
2990
    oc = output_files[nb_output_files - 1];
2991
    new_video_stream(oc);
2992
}
2993

    
2994
static void opt_output_file(const char *filename)
2995
{
2996
    AVFormatContext *oc;
2997
    int use_video, use_audio, input_has_video, input_has_audio, i;
2998
    AVFormatParameters params, *ap = &params;
2999

    
3000
    if (!strcmp(filename, "-"))
3001
        filename = "pipe:";
3002

    
3003
    oc = av_alloc_format_context();
3004

    
3005
    if (!file_oformat) {
3006
        file_oformat = guess_format(NULL, filename, NULL);
3007
        if (!file_oformat) {
3008
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3009
                    filename);
3010
            exit(1);
3011
        }
3012
    }
3013

    
3014
    oc->oformat = file_oformat;
3015
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3016

    
3017
    if (!strcmp(file_oformat->name, "ffm") &&
3018
        av_strstart(filename, "http:", NULL)) {
3019
        /* special case for files sent to ffserver: we get the stream
3020
           parameters from ffserver */
3021
        if (read_ffserver_streams(oc, filename) < 0) {
3022
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3023
            exit(1);
3024
        }
3025
    } else {
3026
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3027
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3028

    
3029
        /* disable if no corresponding type found and at least one
3030
           input file */
3031
        if (nb_input_files > 0) {
3032
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3033
            if (!input_has_video)
3034
                use_video = 0;
3035
            if (!input_has_audio)
3036
                use_audio = 0;
3037
        }
3038

    
3039
        /* manual disable */
3040
        if (audio_disable) {
3041
            use_audio = 0;
3042
        }
3043
        if (video_disable) {
3044
            use_video = 0;
3045
        }
3046

    
3047
        if (use_video) {
3048
            new_video_stream(oc);
3049
        }
3050

    
3051
        if (use_audio) {
3052
            new_audio_stream(oc);
3053
        }
3054

    
3055
        oc->timestamp = rec_timestamp;
3056

    
3057
        if (str_title)
3058
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3059
        if (str_author)
3060
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3061
        if (str_copyright)
3062
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3063
        if (str_comment)
3064
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3065
        if (str_album)
3066
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3067
    }
3068

    
3069
    output_files[nb_output_files++] = oc;
3070

    
3071
    /* check filename in case of an image number is expected */
3072
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3073
        if (!av_filename_number_test(oc->filename)) {
3074
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3075
            exit(1);
3076
        }
3077
    }
3078

    
3079
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3080
        /* test if it already exists to avoid loosing precious files */
3081
        if (!file_overwrite &&
3082
            (strchr(filename, ':') == NULL ||
3083
             av_strstart(filename, "file:", NULL))) {
3084
            if (url_exist(filename)) {
3085
                int c;
3086

    
3087
                if ( !using_stdin ) {
3088
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3089
                    fflush(stderr);
3090
                    c = getchar();
3091
                    if (toupper(c) != 'Y') {
3092
                        fprintf(stderr, "Not overwriting - exiting\n");
3093
                        exit(1);
3094
                    }
3095
                                }
3096
                                else {
3097
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3098
                    exit(1);
3099
                                }
3100
            }
3101
        }
3102

    
3103
        /* open the file */
3104
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3105
            fprintf(stderr, "Could not open '%s'\n", filename);
3106
            exit(1);
3107
        }
3108
    }
3109

    
3110
    memset(ap, 0, sizeof(*ap));
3111
    if (av_set_parameters(oc, ap) < 0) {
3112
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3113
                oc->filename);
3114
        exit(1);
3115
    }
3116

    
3117
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3118
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3119
    oc->loop_output = loop_output;
3120

    
3121
    for(i=0; i<opt_name_count; i++){
3122
        const AVOption *opt;
3123
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3124
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3125
            av_set_double(oc, opt_names[i], d);
3126
    }
3127

    
3128
    /* reset some options */
3129
    file_oformat = NULL;
3130
    file_iformat = NULL;
3131
}
3132

    
3133
/* same option as mencoder */
3134
static void opt_pass(const char *pass_str)
3135
{
3136
    int pass;
3137
    pass = atoi(pass_str);
3138
    if (pass != 1 && pass != 2) {
3139
        fprintf(stderr, "pass number can be only 1 or 2\n");
3140
        exit(1);
3141
    }
3142
    do_pass = pass;
3143
}
3144

    
3145
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3146
static int64_t getutime(void)
3147
{
3148
  return av_gettime();
3149
}
3150
#else
3151
static int64_t getutime(void)
3152
{
3153
    struct rusage rusage;
3154

    
3155
    getrusage(RUSAGE_SELF, &rusage);
3156
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3157
}
3158
#endif
3159

    
3160
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3161
extern int ffm_nopts;
3162
#endif
3163

    
3164
static void show_formats(void)
3165
{
3166
    AVInputFormat *ifmt;
3167
    AVOutputFormat *ofmt;
3168
    URLProtocol *up;
3169
    AVCodec *p, *p2;
3170
    const char **pp, *last_name;
3171

    
3172
    printf("File formats:\n");
3173
    last_name= "000";
3174
    for(;;){
3175
        int decode=0;
3176
        int encode=0;
3177
        const char *name=NULL;
3178
        const char *long_name=NULL;
3179

    
3180
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3181
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3182
                strcmp(ofmt->name, last_name)>0){
3183
                name= ofmt->name;
3184
                long_name= ofmt->long_name;
3185
                encode=1;
3186
            }
3187
        }
3188
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3189
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3190
                strcmp(ifmt->name, last_name)>0){
3191
                name= ifmt->name;
3192
                long_name= ifmt->long_name;
3193
                encode=0;
3194
            }
3195
            if(name && strcmp(ifmt->name, name)==0)
3196
                decode=1;
3197
        }
3198
        if(name==NULL)
3199
            break;
3200
        last_name= name;
3201

    
3202
        printf(
3203
            " %s%s %-15s %s\n",
3204
            decode ? "D":" ",
3205
            encode ? "E":" ",
3206
            name,
3207
            long_name ? long_name:" ");
3208
    }
3209
    printf("\n");
3210

    
3211
    printf("Codecs:\n");
3212
    last_name= "000";
3213
    for(;;){
3214
        int decode=0;
3215
        int encode=0;
3216
        int cap=0;
3217
        const char *type_str;
3218

    
3219
        p2=NULL;
3220
        for(p = first_avcodec; p != NULL; p = p->next) {
3221
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3222
                strcmp(p->name, last_name)>0){
3223
                p2= p;
3224
                decode= encode= cap=0;
3225
            }
3226
            if(p2 && strcmp(p->name, p2->name)==0){
3227
                if(p->decode) decode=1;
3228
                if(p->encode) encode=1;
3229
                cap |= p->capabilities;
3230
            }
3231
        }
3232
        if(p2==NULL)
3233
            break;
3234
        last_name= p2->name;
3235

    
3236
        switch(p2->type) {
3237
        case CODEC_TYPE_VIDEO:
3238
            type_str = "V";
3239
            break;
3240
        case CODEC_TYPE_AUDIO:
3241
            type_str = "A";
3242
            break;
3243
        case CODEC_TYPE_SUBTITLE:
3244
            type_str = "S";
3245
            break;
3246
        default:
3247
            type_str = "?";
3248
            break;
3249
        }
3250
        printf(
3251
            " %s%s%s%s%s%s %s",
3252
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3253
            encode ? "E":" ",
3254
            type_str,
3255
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3256
            cap & CODEC_CAP_DR1 ? "D":" ",
3257
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3258
            p2->name);
3259
       /* if(p2->decoder && decode==0)
3260
            printf(" use %s for decoding", p2->decoder->name);*/
3261
        printf("\n");
3262
    }
3263
    printf("\n");
3264

    
3265
    printf("Supported file protocols:\n");
3266
    for(up = first_protocol; up != NULL; up = up->next)
3267
        printf(" %s:", up->name);
3268
    printf("\n");
3269

    
3270
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3271
    printf("Motion estimation methods:\n");
3272
    pp = motion_str;
3273
    while (*pp) {
3274
        printf(" %s", *pp);
3275
        if ((pp - motion_str + 1) == ME_ZERO)
3276
            printf("(fastest)");
3277
        else if ((pp - motion_str + 1) == ME_FULL)
3278
            printf("(slowest)");
3279
        else if ((pp - motion_str + 1) == ME_EPZS)
3280
            printf("(default)");
3281
        pp++;
3282
    }
3283
    printf("\n\n");
3284
    printf(
3285
"Note, the names of encoders and decoders do not always match, so there are\n"
3286
"several cases where the above table shows encoder only or decoder only entries\n"
3287
"even though both encoding and decoding are supported. For example, the h263\n"
3288
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3289
"worse.\n");
3290
    exit(1);
3291
}
3292

    
3293
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3294
{
3295
    int i;
3296
    const char *p = str;
3297
    for(i = 0;; i++) {
3298
        dest[i] = atoi(p);
3299
        if(i == 63)
3300
            break;
3301
        p = strchr(p, ',');
3302
        if(!p) {
3303
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3304
            exit(1);
3305
        }
3306
        p++;
3307
    }
3308
}
3309

    
3310
static void opt_inter_matrix(const char *arg)
3311
{
3312
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3313
    parse_matrix_coeffs(inter_matrix, arg);
3314
}
3315

    
3316
static void opt_intra_matrix(const char *arg)
3317
{
3318
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3319
    parse_matrix_coeffs(intra_matrix, arg);
3320
}
3321

    
3322
static void opt_target(const char *arg)
3323
{
3324
    int norm = -1;
3325
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3326

    
3327
    if(!strncmp(arg, "pal-", 4)) {
3328
        norm = 0;
3329
        arg += 4;
3330
    } else if(!strncmp(arg, "ntsc-", 5)) {
3331
        norm = 1;
3332
        arg += 5;
3333
    } else if(!strncmp(arg, "film-", 5)) {
3334
        norm = 2;
3335
        arg += 5;
3336
    } else {
3337
        int fr;
3338
        /* Calculate FR via float to avoid int overflow */
3339
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3340
        if(fr == 25000) {
3341
            norm = 0;
3342
        } else if((fr == 29970) || (fr == 23976)) {
3343
            norm = 1;
3344
        } else {
3345
            /* Try to determine PAL/NTSC by peeking in the input files */
3346
            if(nb_input_files) {
3347
                int i, j;
3348
                for(j = 0; j < nb_input_files; j++) {
3349
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3350
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3351
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3352
                            continue;
3353
                        fr = c->time_base.den * 1000 / c->time_base.num;
3354
                        if(fr == 25000) {
3355
                            norm = 0;
3356
                            break;
3357
                        } else if((fr == 29970) || (fr == 23976)) {
3358
                            norm = 1;
3359
                            break;
3360
                        }
3361
                    }
3362
                    if(norm >= 0)
3363
                        break;
3364
                }
3365
            }
3366
        }
3367
        if(verbose && norm >= 0)
3368
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3369
    }
3370

    
3371
    if(norm < 0) {
3372
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3373
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3374
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3375
        exit(1);
3376
    }
3377

    
3378
    if(!strcmp(arg, "vcd")) {
3379

    
3380
        opt_video_codec("mpeg1video");
3381
        opt_audio_codec("mp2");
3382
        opt_format("vcd");
3383

    
3384
        opt_frame_size(norm ? "352x240" : "352x288");
3385
        opt_frame_rate(frame_rates[norm]);
3386
        opt_default("gop", norm ? "18" : "15");
3387

    
3388
        opt_default("b", "1150000");
3389
        opt_default("maxrate", "1150000");
3390
        opt_default("minrate", "1150000");
3391
        opt_default("bufsize", "327680"); // 40*1024*8;
3392

    
3393
        opt_default("ab", "224000");
3394
        audio_sample_rate = 44100;
3395
        audio_channels = 2;
3396

    
3397
        opt_default("packetsize", "2324");
3398
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3399

    
3400
        /* We have to offset the PTS, so that it is consistent with the SCR.
3401
           SCR starts at 36000, but the first two packs contain only padding
3402
           and the first pack from the other stream, respectively, may also have
3403
           been written before.
3404
           So the real data starts at SCR 36000+3*1200. */
3405
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3406
    } else if(!strcmp(arg, "svcd")) {
3407

    
3408
        opt_video_codec("mpeg2video");
3409
        opt_audio_codec("mp2");
3410
        opt_format("svcd");
3411

    
3412
        opt_frame_size(norm ? "480x480" : "480x576");
3413
        opt_frame_rate(frame_rates[norm]);
3414
        opt_default("gop", norm ? "18" : "15");
3415

    
3416
        opt_default("b", "2040000");
3417
        opt_default("maxrate", "2516000");
3418
        opt_default("minrate", "0"); //1145000;
3419
        opt_default("bufsize", "1835008"); //224*1024*8;
3420
        opt_default("flags", "+SCAN_OFFSET");
3421

    
3422

    
3423
        opt_default("ab", "224000");
3424
        audio_sample_rate = 44100;
3425

    
3426
        opt_default("packetsize", "2324");
3427

    
3428
    } else if(!strcmp(arg, "dvd")) {
3429

    
3430
        opt_video_codec("mpeg2video");
3431
        opt_audio_codec("ac3");
3432
        opt_format("dvd");
3433

    
3434
        opt_frame_size(norm ? "720x480" : "720x576");
3435
        opt_frame_rate(frame_rates[norm]);
3436
        opt_default("gop", norm ? "18" : "15");
3437

    
3438
        opt_default("b", "6000000");
3439
        opt_default("maxrate", "9000000");
3440
        opt_default("minrate", "0"); //1500000;
3441
        opt_default("bufsize", "1835008"); //224*1024*8;
3442

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

    
3446
        opt_default("ab", "448000");
3447
        audio_sample_rate = 48000;
3448

    
3449
    } else if(!strncmp(arg, "dv", 2)) {
3450

    
3451
        opt_format("dv");
3452

    
3453
        opt_frame_size(norm ? "720x480" : "720x576");
3454
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3455
                                             (norm ? "yuv411p" : "yuv420p"));
3456
        opt_frame_rate(frame_rates[norm]);
3457

    
3458
        audio_sample_rate = 48000;
3459
        audio_channels = 2;
3460

    
3461
    } else {
3462
        fprintf(stderr, "Unknown target: %s\n", arg);
3463
        exit(1);
3464
    }
3465
}
3466

    
3467
static void opt_vstats_file (const char *arg)
3468
{
3469
    av_free (vstats_filename);
3470
    vstats_filename=av_strdup (arg);
3471
}
3472

    
3473
static void opt_vstats (void)
3474
{
3475
    char filename[40];
3476
    time_t today2 = time(NULL);
3477
    struct tm *today = localtime(&today2);
3478

    
3479
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3480
             today->tm_sec);
3481
    opt_vstats_file(filename);
3482
}
3483

    
3484
static void opt_video_bsf(const char *arg)
3485
{
3486
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3487
    AVBitStreamFilterContext **bsfp;
3488

    
3489
    if(!bsfc){
3490
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3491
        exit(1);
3492
    }
3493

    
3494
    bsfp= &video_bitstream_filters;
3495
    while(*bsfp)
3496
        bsfp= &(*bsfp)->next;
3497

    
3498
    *bsfp= bsfc;
3499
}
3500

    
3501
//FIXME avoid audio - video code duplication
3502
static void opt_audio_bsf(const char *arg)
3503
{
3504
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3505
    AVBitStreamFilterContext **bsfp;
3506

    
3507
    if(!bsfc){
3508
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3509
        exit(1);
3510
    }
3511

    
3512
    bsfp= &audio_bitstream_filters;
3513
    while(*bsfp)
3514
        bsfp= &(*bsfp)->next;
3515

    
3516
    *bsfp= bsfc;
3517
}
3518

    
3519
static void show_version(void)
3520
{
3521
    /* TODO: add function interface to avutil and avformat */
3522
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3523
           "libavutil   %d\n"
3524
           "libavcodec  %d\n"
3525
           "libavformat %d\n",
3526
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3527
    exit(1);
3528
}
3529

    
3530
static int opt_default(const char *opt, const char *arg){
3531
    int type;
3532
    const AVOption *o= NULL;
3533
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3534

    
3535
    for(type=0; type<CODEC_TYPE_NB; type++){
3536
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3537
        if(o2)
3538
            o = av_set_string(avctx_opts[type], opt, arg);
3539
    }
3540
    if(!o)
3541
        o = av_set_string(avformat_opts, opt, arg);
3542
    if(!o)
3543
        o = av_set_string(sws_opts, opt, arg);
3544
    if(!o){
3545
        if(opt[0] == 'a')
3546
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3547
        else if(opt[0] == 'v')
3548
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3549
        else if(opt[0] == 's')
3550
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3551
    }
3552
    if(!o)
3553
        return -1;
3554

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

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

    
3561
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3562
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3563
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3564
        ffm_nopts = 1;
3565
#endif
3566

    
3567
    if(avctx_opts[0]->debug)
3568
        av_log_level = AV_LOG_DEBUG;
3569
    return 0;
3570
}
3571

    
3572
const OptionDef options[] = {
3573
    /* main options */
3574
    { "L", 0, {(void*)show_license}, "show license" },
3575
    { "h", 0, {(void*)show_help}, "show help" },
3576
    { "version", 0, {(void*)show_version}, "show version" },
3577
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3578
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3579
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3580
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3581
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3582
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3583
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3584
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3585
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3586
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3587
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3588
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3589
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3590
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3591
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3592
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3593
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3594
      "add timings for benchmarking" },
3595
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3596
      "dump each input packet" },
3597
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3598
      "when dumping packets, also dump the payload" },
3599
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3600
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3601
    { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3602
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3603
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3604
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3605
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3606
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3607
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3608
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3609
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3610
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3611

    
3612
    /* video options */
3613
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3614
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3615
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3616
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3617
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3618
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3619
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3620
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3621
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3622
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3623
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3624
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3625
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3626
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3627
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3628
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3629
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3630
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3631
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3632
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3633
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3634
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3635
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3636
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3637
      "method" },
3638
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3639
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3640
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3641
      "use same video quality as source (implies VBR)" },
3642
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3643
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3644
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3645
      "deinterlace pictures" },
3646
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3647
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3648
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3649
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3650
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3651
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3652
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3653
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3654
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3655
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3656
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3657

    
3658
    /* audio options */
3659
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3660
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3661
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3662
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3663
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3664
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3665
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3666
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3667
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3668
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3669

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

    
3675
    /* grab options */
3676
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3677
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3678
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3679

    
3680
    /* muxer options */
3681
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3682
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3683

    
3684
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3685
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3686

    
3687
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3688
    { NULL, },
3689
};
3690

    
3691
static void show_banner(void)
3692
{
3693
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3694
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3695
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3696
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3697
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3698
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3699
#ifdef __GNUC__
3700
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3701
#else
3702
    fprintf(stderr, ", using a non-gcc compiler\n");
3703
#endif
3704
}
3705

    
3706
static void show_license(void)
3707
{
3708
    show_banner();
3709
#ifdef CONFIG_GPL
3710
    printf(
3711
    "FFmpeg is free software; you can redistribute it and/or modify\n"
3712
    "it under the terms of the GNU General Public License as published by\n"
3713
    "the Free Software Foundation; either version 2 of the License, or\n"
3714
    "(at your option) any later version.\n"
3715
    "\n"
3716
    "FFmpeg is distributed in the hope that it will be useful,\n"
3717
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3718
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3719
    "GNU General Public License for more details.\n"
3720
    "\n"
3721
    "You should have received a copy of the GNU General Public License\n"
3722
    "along with FFmpeg; if not, write to the Free Software\n"
3723
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3724
    );
3725
#else
3726
    printf(
3727
    "FFmpeg is free software; you can redistribute it and/or\n"
3728
    "modify it under the terms of the GNU Lesser General Public\n"
3729
    "License as published by the Free Software Foundation; either\n"
3730
    "version 2.1 of the License, or (at your option) any later version.\n"
3731
    "\n"
3732
    "FFmpeg is distributed in the hope that it will be useful,\n"
3733
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3734
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3735
    "Lesser General Public License for more details.\n"
3736
    "\n"
3737
    "You should have received a copy of the GNU Lesser General Public\n"
3738
    "License along with FFmpeg; if not, write to the Free Software\n"
3739
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3740
    );
3741
#endif
3742
    exit(1);
3743
}
3744

    
3745
/**
3746
 * Trivial log callback.
3747
 * Only suitable for show_help and similar since it lacks prefix handling.
3748
 */
3749
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3750
{
3751
    vfprintf(stdout, fmt, vl);
3752
}
3753

    
3754
static void show_help(void)
3755
{
3756
    av_log_set_callback(log_callback_help);
3757
    show_banner();
3758
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3759
           "Hyper fast Audio and Video encoder\n");
3760
    printf("\n");
3761
    show_help_options(options, "Main options:\n",
3762
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3763
    show_help_options(options, "\nVideo options:\n",
3764
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3765
                      OPT_VIDEO);
3766
    show_help_options(options, "\nAdvanced Video options:\n",
3767
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3768
                      OPT_VIDEO | OPT_EXPERT);
3769
    show_help_options(options, "\nAudio options:\n",
3770
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3771
                      OPT_AUDIO);
3772
    show_help_options(options, "\nAdvanced Audio options:\n",
3773
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3774
                      OPT_AUDIO | OPT_EXPERT);
3775
    show_help_options(options, "\nSubtitle options:\n",
3776
                      OPT_SUBTITLE | OPT_GRAB,
3777
                      OPT_SUBTITLE);
3778
    show_help_options(options, "\nAudio/Video grab options:\n",
3779
                      OPT_GRAB,
3780
                      OPT_GRAB);
3781
    show_help_options(options, "\nAdvanced options:\n",
3782
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3783
                      OPT_EXPERT);
3784
    av_opt_show(avctx_opts[0], NULL);
3785
    av_opt_show(avformat_opts, NULL);
3786
    av_opt_show(sws_opts, NULL);
3787

    
3788
    exit(1);
3789
}
3790

    
3791
void parse_arg_file(const char *filename)
3792
{
3793
    opt_output_file(filename);
3794
}
3795

    
3796
int main(int argc, char **argv)
3797
{
3798
    int i;
3799
    int64_t ti;
3800

    
3801
    av_register_all();
3802

    
3803
    for(i=0; i<CODEC_TYPE_NB; i++){
3804
        avctx_opts[i]= avcodec_alloc_context2(i);
3805
    }
3806
    avformat_opts = av_alloc_format_context();
3807
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3808

    
3809
    if (argc <= 1)
3810
        show_help();
3811
    else
3812
        show_banner();
3813

    
3814
    /* parse options */
3815
    parse_options(argc, argv, options);
3816

    
3817
    /* file converter / grab */
3818
    if (nb_output_files <= 0) {
3819
        fprintf(stderr, "Must supply at least one output file\n");
3820
        exit(1);
3821
    }
3822

    
3823
    if (nb_input_files == 0) {
3824
        fprintf(stderr, "Must supply at least one input file\n");
3825
        exit(1);
3826
    }
3827

    
3828
    ti = getutime();
3829
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3830
              stream_maps, nb_stream_maps);
3831
    ti = getutime() - ti;
3832
    if (do_benchmark) {
3833
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3834
    }
3835

    
3836
    /* close files */
3837
    for(i=0;i<nb_output_files;i++) {
3838
        /* maybe av_close_output_file ??? */
3839
        AVFormatContext *s = output_files[i];
3840
        int j;
3841
        if (!(s->oformat->flags & AVFMT_NOFILE))
3842
            url_fclose(&s->pb);
3843
        for(j=0;j<s->nb_streams;j++) {
3844
            av_free(s->streams[j]->codec);
3845
            av_free(s->streams[j]);
3846
        }
3847
        av_free(s);
3848
    }
3849
    for(i=0;i<nb_input_files;i++)
3850
        av_close_input_file(input_files[i]);
3851

    
3852
    av_free_static();
3853

    
3854
    av_free(intra_matrix);
3855
    av_free(inter_matrix);
3856

    
3857
    if (fvstats)
3858
        fclose(fvstats);
3859
    av_free(vstats_filename);
3860

    
3861
    av_free(opt_names);
3862

    
3863
    av_free(video_standard);
3864

    
3865
#ifdef CONFIG_POWERPC_PERF
3866
    extern void powerpc_display_perf_report(void);
3867
    powerpc_display_perf_report();
3868
#endif /* CONFIG_POWERPC_PERF */
3869

    
3870
    if (received_sigterm) {
3871
        fprintf(stderr,
3872
            "Received signal %d: terminating.\n",
3873
            (int) received_sigterm);
3874
        exit (255);
3875
    }
3876

    
3877
    exit(0); /* not all OS-es handle main() return value */
3878
    return 0;
3879
}