Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a9f3cb93

History | View | Annotate | Download (154 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
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavcodec/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/pixdesc.h"
42
#include "libavutil/avstring.h"
43
#include "libavutil/libm.h"
44
#include "libavformat/os_support.h"
45

    
46
#if CONFIG_AVFILTER
47
# include "libavfilter/avfilter.h"
48
# include "libavfilter/avfiltergraph.h"
49
# include "libavfilter/graphparser.h"
50
# include "libavfilter/vsrc_buffer.h"
51
#endif
52

    
53
#if HAVE_SYS_RESOURCE_H
54
#include <sys/types.h>
55
#include <sys/time.h>
56
#include <sys/resource.h>
57
#elif HAVE_GETPROCESSTIMES
58
#include <windows.h>
59
#endif
60
#if HAVE_GETPROCESSMEMORYINFO
61
#include <windows.h>
62
#include <psapi.h>
63
#endif
64

    
65
#if HAVE_SYS_SELECT_H
66
#include <sys/select.h>
67
#endif
68

    
69
#if HAVE_TERMIOS_H
70
#include <fcntl.h>
71
#include <sys/ioctl.h>
72
#include <sys/time.h>
73
#include <termios.h>
74
#elif HAVE_CONIO_H
75
#include <conio.h>
76
#endif
77
#include <time.h>
78

    
79
#include "cmdutils.h"
80

    
81
#undef NDEBUG
82
#include <assert.h>
83

    
84
const char program_name[] = "FFmpeg";
85
const int program_birth_year = 2000;
86

    
87
/* select an input stream for an output stream */
88
typedef struct AVStreamMap {
89
    int file_index;
90
    int stream_index;
91
    int sync_file_index;
92
    int sync_stream_index;
93
} AVStreamMap;
94

    
95
/** select an input file for an output file */
96
typedef struct AVMetaDataMap {
97
    int out_file;
98
    int in_file;
99
} AVMetaDataMap;
100

    
101
static const OptionDef options[];
102

    
103
#define MAX_FILES 100
104

    
105
static const char *last_asked_format = NULL;
106
static AVFormatContext *input_files[MAX_FILES];
107
static int64_t input_files_ts_offset[MAX_FILES];
108
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
109
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
110
static int nb_input_files = 0;
111
static int nb_icodecs;
112

    
113
static AVFormatContext *output_files[MAX_FILES];
114
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
115
static int nb_output_files = 0;
116
static int nb_ocodecs;
117

    
118
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
119
static int nb_stream_maps;
120

    
121
static AVMetaDataMap meta_data_maps[MAX_FILES];
122
static int nb_meta_data_maps;
123

    
124
static int frame_width  = 0;
125
static int frame_height = 0;
126
static float frame_aspect_ratio = 0;
127
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
128
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
129
static int frame_topBand  = 0;
130
static int frame_bottomBand = 0;
131
static int frame_leftBand  = 0;
132
static int frame_rightBand = 0;
133
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
134
static AVRational frame_rate;
135
static float video_qscale = 0;
136
static uint16_t *intra_matrix = NULL;
137
static uint16_t *inter_matrix = NULL;
138
static const char *video_rc_override_string=NULL;
139
static int video_disable = 0;
140
static int video_discard = 0;
141
static char *video_codec_name = NULL;
142
static int video_codec_tag = 0;
143
static char *video_language = NULL;
144
static int same_quality = 0;
145
static int do_deinterlace = 0;
146
static int top_field_first = -1;
147
static int me_threshold = 0;
148
static int intra_dc_precision = 8;
149
static int loop_input = 0;
150
static int loop_output = AVFMT_NOOUTPUTLOOP;
151
static int qp_hist = 0;
152
#if CONFIG_AVFILTER
153
static char *vfilters = NULL;
154
AVFilterGraph *graph = NULL;
155
#endif
156

    
157
static int intra_only = 0;
158
static int audio_sample_rate = 44100;
159
static int64_t channel_layout = 0;
160
#define QSCALE_NONE -99999
161
static float audio_qscale = QSCALE_NONE;
162
static int audio_disable = 0;
163
static int audio_channels = 1;
164
static char  *audio_codec_name = NULL;
165
static int audio_codec_tag = 0;
166
static char *audio_language = NULL;
167

    
168
static int subtitle_disable = 0;
169
static char *subtitle_codec_name = NULL;
170
static char *subtitle_language = NULL;
171
static int subtitle_codec_tag = 0;
172

    
173
static float mux_preload= 0.5;
174
static float mux_max_delay= 0.7;
175

    
176
static int64_t recording_time = INT64_MAX;
177
static int64_t start_time = 0;
178
static int64_t rec_timestamp = 0;
179
static int64_t input_ts_offset = 0;
180
static int file_overwrite = 0;
181
static int metadata_count;
182
static AVMetadataTag *metadata;
183
static int do_benchmark = 0;
184
static int do_hex_dump = 0;
185
static int do_pkt_dump = 0;
186
static int do_psnr = 0;
187
static int do_pass = 0;
188
static char *pass_logfilename_prefix = NULL;
189
static int audio_stream_copy = 0;
190
static int video_stream_copy = 0;
191
static int subtitle_stream_copy = 0;
192
static int video_sync_method= -1;
193
static int audio_sync_method= 0;
194
static float audio_drift_threshold= 0.1;
195
static int copy_ts= 0;
196
static int opt_shortest = 0;
197
static int video_global_header = 0;
198
static char *vstats_filename;
199
static FILE *vstats_file;
200
static int opt_programid = 0;
201
static int copy_initial_nonkeyframes = 0;
202

    
203
static int rate_emu = 0;
204

    
205
static int  video_channel = 0;
206
static char *video_standard;
207

    
208
static int audio_volume = 256;
209

    
210
static int exit_on_error = 0;
211
static int using_stdin = 0;
212
static int verbose = 1;
213
static int thread_count= 1;
214
static int q_pressed = 0;
215
static int64_t video_size = 0;
216
static int64_t audio_size = 0;
217
static int64_t extra_size = 0;
218
static int nb_frames_dup = 0;
219
static int nb_frames_drop = 0;
220
static int input_sync;
221
static uint64_t limit_filesize = 0;
222
static int force_fps = 0;
223

    
224
static int pgmyuv_compatibility_hack=0;
225
static float dts_delta_threshold = 10;
226

    
227
static unsigned int sws_flags = SWS_BICUBIC;
228

    
229
static int64_t timer_start;
230

    
231
static uint8_t *audio_buf;
232
static uint8_t *audio_out;
233
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
234

    
235
static short *samples;
236

    
237
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
238
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
239
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
240
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
241

    
242
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
243

    
244
struct AVInputStream;
245

    
246
typedef struct AVOutputStream {
247
    int file_index;          /* file index */
248
    int index;               /* stream index in the output file */
249
    int source_index;        /* AVInputStream index */
250
    AVStream *st;            /* stream in the output file */
251
    int encoding_needed;     /* true if encoding needed for this stream */
252
    int frame_number;
253
    /* input pts and corresponding output pts
254
       for A/V sync */
255
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
256
    struct AVInputStream *sync_ist; /* input stream to sync against */
257
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
258
    /* video only */
259
    int video_resample;
260
    AVFrame pict_tmp;      /* temporary image for resampling */
261
    struct SwsContext *img_resample_ctx; /* for image resampling */
262
    int resample_height;
263
    int resample_width;
264
    int resample_pix_fmt;
265

    
266
    /* full frame size of first frame */
267
    int original_height;
268
    int original_width;
269

    
270
    /* cropping area sizes */
271
    int video_crop;
272
    int topBand;
273
    int bottomBand;
274
    int leftBand;
275
    int rightBand;
276

    
277
    /* cropping area of first frame */
278
    int original_topBand;
279
    int original_bottomBand;
280
    int original_leftBand;
281
    int original_rightBand;
282

    
283
    /* audio only */
284
    int audio_resample;
285
    ReSampleContext *resample; /* for audio resampling */
286
    int reformat_pair;
287
    AVAudioConvert *reformat_ctx;
288
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
289
    FILE *logfile;
290
} AVOutputStream;
291

    
292
typedef struct AVInputStream {
293
    int file_index;
294
    int index;
295
    AVStream *st;
296
    int discard;             /* true if stream data should be discarded */
297
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
298
    int64_t sample_index;      /* current sample */
299

    
300
    int64_t       start;     /* time when read started */
301
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
302
                                is not defined */
303
    int64_t       pts;       /* current pts */
304
    int is_start;            /* is 1 at the start and after a discontinuity */
305
    int showed_multi_packet_warning;
306
    int is_past_recording_time;
307
#if CONFIG_AVFILTER
308
    AVFilterContext *out_video_filter;
309
    AVFilterContext *input_video_filter;
310
    AVFrame *filter_frame;
311
    int has_filter_frame;
312
    AVFilterPicRef *picref;
313
#endif
314
} AVInputStream;
315

    
316
typedef struct AVInputFile {
317
    int eof_reached;      /* true if eof reached */
318
    int ist_index;        /* index of first stream in ist_table */
319
    int buffer_size;      /* current total buffer size */
320
    int nb_streams;       /* nb streams we are aware of */
321
} AVInputFile;
322

    
323
#if HAVE_TERMIOS_H
324

    
325
/* init terminal so that we can grab keys */
326
static struct termios oldtty;
327
#endif
328

    
329
#if CONFIG_AVFILTER
330
typedef struct {
331
    int pix_fmt;
332
} FilterOutPriv;
333

    
334

    
335
static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
336
{
337
    FilterOutPriv *priv = ctx->priv;
338

    
339
    if(!opaque) return -1;
340

    
341
    priv->pix_fmt = *((int *)opaque);
342

    
343
    return 0;
344
}
345

    
346
static void output_end_frame(AVFilterLink *link)
347
{
348
}
349

    
350
static int output_query_formats(AVFilterContext *ctx)
351
{
352
    FilterOutPriv *priv = ctx->priv;
353
    enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
354

    
355
    avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
356
    return 0;
357
}
358

    
359
static int get_filtered_video_pic(AVFilterContext *ctx,
360
                                  AVFilterPicRef **picref, AVFrame *pic2,
361
                                  uint64_t *pts)
362
{
363
    AVFilterPicRef *pic;
364

    
365
    if(avfilter_request_frame(ctx->inputs[0]))
366
        return -1;
367
    if(!(pic = ctx->inputs[0]->cur_pic))
368
        return -1;
369
    *picref = pic;
370
    ctx->inputs[0]->cur_pic = NULL;
371

    
372
    *pts          = pic->pts;
373

    
374
    memcpy(pic2->data,     pic->data,     sizeof(pic->data));
375
    memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
376
    pic2->interlaced_frame = pic->interlaced;
377
    pic2->top_field_first  = pic->top_field_first;
378

    
379
    return 1;
380
}
381

    
382
static AVFilter output_filter =
383
{
384
    .name      = "ffmpeg_output",
385

    
386
    .priv_size = sizeof(FilterOutPriv),
387
    .init      = output_init,
388

    
389
    .query_formats = output_query_formats,
390

    
391
    .inputs    = (AVFilterPad[]) {{ .name          = "default",
392
                                    .type          = AVMEDIA_TYPE_VIDEO,
393
                                    .end_frame     = output_end_frame,
394
                                    .min_perms     = AV_PERM_READ, },
395
                                  { .name = NULL }},
396
    .outputs   = (AVFilterPad[]) {{ .name = NULL }},
397
};
398

    
399
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
400
{
401
    AVFilterContext *last_filter, *filter;
402
    /** filter graph containing all filters including input & output */
403
    AVCodecContext *codec = ost->st->codec;
404
    AVCodecContext *icodec = ist->st->codec;
405
    char args[255];
406

    
407
    graph = av_mallocz(sizeof(AVFilterGraph));
408

    
409
    if (!(ist->input_video_filter = avfilter_open(avfilter_get_by_name("buffer"), "src")))
410
        return -1;
411
    if (!(ist->out_video_filter = avfilter_open(&output_filter, "out")))
412
        return -1;
413

    
414
    snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
415
             ist->st->codec->height, ist->st->codec->pix_fmt);
416
    if (avfilter_init_filter(ist->input_video_filter, args, NULL))
417
        return -1;
418
    if (avfilter_init_filter(ist->out_video_filter, NULL, &codec->pix_fmt))
419
        return -1;
420

    
421
    /* add input and output filters to the overall graph */
422
    avfilter_graph_add_filter(graph, ist->input_video_filter);
423
    avfilter_graph_add_filter(graph, ist->out_video_filter);
424

    
425
    last_filter = ist->input_video_filter;
426

    
427
    if (ost->video_crop) {
428
        snprintf(args, 255, "%d:%d:%d:%d", ost->leftBand, ost->topBand,
429
                 codec->width,
430
                 codec->height);
431
        filter = avfilter_open(avfilter_get_by_name("crop"), NULL);
432
        if (!filter)
433
            return -1;
434
        if (avfilter_init_filter(filter, args, NULL))
435
            return -1;
436
        if (avfilter_link(last_filter, 0, filter, 0))
437
            return -1;
438
        last_filter = filter;
439
        avfilter_graph_add_filter(graph, last_filter);
440
    }
441

    
442
    if((codec->width !=
443
        icodec->width - (frame_leftBand + frame_rightBand)) ||
444
       (codec->height != icodec->height - (frame_topBand  + frame_bottomBand))) {
445
        snprintf(args, 255, "%d:%d:flags=0x%X",
446
                 codec->width,
447
                 codec->height,
448
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
449
        filter = avfilter_open(avfilter_get_by_name("scale"), NULL);
450
        if (!filter)
451
            return -1;
452
        if (avfilter_init_filter(filter, args, NULL))
453
            return -1;
454
        if (avfilter_link(last_filter, 0, filter, 0))
455
            return -1;
456
        last_filter = filter;
457
        avfilter_graph_add_filter(graph, last_filter);
458
    }
459

    
460
    if (vfilters) {
461
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
462
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
463

    
464
        outputs->name    = av_strdup("in");
465
        outputs->filter  = last_filter;
466
        outputs->pad_idx = 0;
467
        outputs->next    = NULL;
468

    
469
        inputs->name    = av_strdup("out");
470
        inputs->filter  = ist->out_video_filter;
471
        inputs->pad_idx = 0;
472
        inputs->next    = NULL;
473

    
474
        if (avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL) < 0)
475
            return -1;
476
        av_freep(&vfilters);
477
    } else {
478
        if (avfilter_link(last_filter, 0, ist->out_video_filter, 0) < 0)
479
            return -1;
480
    }
481

    
482
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
483
    graph->scale_sws_opts = av_strdup(args);
484

    
485
    /* configure all the filter links */
486
    if (avfilter_graph_check_validity(graph, NULL))
487
        return -1;
488
    if (avfilter_graph_config_formats(graph, NULL))
489
        return -1;
490
    if (avfilter_graph_config_links(graph, NULL))
491
        return -1;
492

    
493
    codec->width = ist->out_video_filter->inputs[0]->w;
494
    codec->height = ist->out_video_filter->inputs[0]->h;
495

    
496
    return 0;
497
}
498
#endif /* CONFIG_AVFILTER */
499

    
500
static void term_exit(void)
501
{
502
#if HAVE_TERMIOS_H
503
    tcsetattr (0, TCSANOW, &oldtty);
504
#endif
505
}
506

    
507
static volatile int received_sigterm = 0;
508

    
509
static void
510
sigterm_handler(int sig)
511
{
512
    received_sigterm = sig;
513
    term_exit();
514
}
515

    
516
static void term_init(void)
517
{
518
#if HAVE_TERMIOS_H
519
    struct termios tty;
520

    
521
    tcgetattr (0, &tty);
522
    oldtty = tty;
523
    atexit(term_exit);
524

    
525
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
526
                          |INLCR|IGNCR|ICRNL|IXON);
527
    tty.c_oflag |= OPOST;
528
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
529
    tty.c_cflag &= ~(CSIZE|PARENB);
530
    tty.c_cflag |= CS8;
531
    tty.c_cc[VMIN] = 1;
532
    tty.c_cc[VTIME] = 0;
533

    
534
    tcsetattr (0, TCSANOW, &tty);
535
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
536
#endif
537

    
538
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
539
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
540
#ifdef SIGXCPU
541
    signal(SIGXCPU, sigterm_handler);
542
#endif
543

    
544
#if CONFIG_BEOS_NETSERVER
545
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
546
#endif
547
}
548

    
549
/* read a key without blocking */
550
static int read_key(void)
551
{
552
#if HAVE_TERMIOS_H
553
    int n = 1;
554
    unsigned char ch;
555
#if !CONFIG_BEOS_NETSERVER
556
    struct timeval tv;
557
    fd_set rfds;
558

    
559
    FD_ZERO(&rfds);
560
    FD_SET(0, &rfds);
561
    tv.tv_sec = 0;
562
    tv.tv_usec = 0;
563
    n = select(1, &rfds, NULL, NULL, &tv);
564
#endif
565
    if (n > 0) {
566
        n = read(0, &ch, 1);
567
        if (n == 1)
568
            return ch;
569

    
570
        return n;
571
    }
572
#elif HAVE_CONIO_H
573
    if(kbhit())
574
        return(getch());
575
#endif
576
    return -1;
577
}
578

    
579
static int decode_interrupt_cb(void)
580
{
581
    return q_pressed || (q_pressed = read_key() == 'q');
582
}
583

    
584
static int av_exit(int ret)
585
{
586
    int i;
587

    
588
    /* close files */
589
    for(i=0;i<nb_output_files;i++) {
590
        /* maybe av_close_output_file ??? */
591
        AVFormatContext *s = output_files[i];
592
        int j;
593
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
594
            url_fclose(s->pb);
595
        for(j=0;j<s->nb_streams;j++) {
596
            av_metadata_free(&s->streams[j]->metadata);
597
            av_free(s->streams[j]->codec);
598
            av_free(s->streams[j]);
599
        }
600
        for(j=0;j<s->nb_programs;j++) {
601
            av_metadata_free(&s->programs[j]->metadata);
602
        }
603
        for(j=0;j<s->nb_chapters;j++) {
604
            av_metadata_free(&s->chapters[j]->metadata);
605
        }
606
        av_metadata_free(&s->metadata);
607
        av_free(s);
608
    }
609
    for(i=0;i<nb_input_files;i++)
610
        av_close_input_file(input_files[i]);
611

    
612
    av_free(intra_matrix);
613
    av_free(inter_matrix);
614

    
615
    if (vstats_file)
616
        fclose(vstats_file);
617
    av_free(vstats_filename);
618

    
619
    av_free(opt_names);
620

    
621
    av_free(video_codec_name);
622
    av_free(audio_codec_name);
623
    av_free(subtitle_codec_name);
624

    
625
    av_free(video_standard);
626

    
627
#if CONFIG_POWERPC_PERF
628
    void powerpc_display_perf_report(void);
629
    powerpc_display_perf_report();
630
#endif /* CONFIG_POWERPC_PERF */
631

    
632
    for (i=0;i<AVMEDIA_TYPE_NB;i++)
633
        av_free(avcodec_opts[i]);
634
    av_free(avformat_opts);
635
    av_free(sws_opts);
636
    av_free(audio_buf);
637
    av_free(audio_out);
638
    allocated_audio_buf_size= allocated_audio_out_size= 0;
639
    av_free(samples);
640

    
641
#if CONFIG_AVFILTER
642
    avfilter_uninit();
643
#endif
644

    
645
    if (received_sigterm) {
646
        fprintf(stderr,
647
            "Received signal %d: terminating.\n",
648
            (int) received_sigterm);
649
        exit (255);
650
    }
651

    
652
    exit(ret); /* not all OS-es handle main() return value */
653
    return ret;
654
}
655

    
656
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
657
{
658
    if(codec && codec->sample_fmts){
659
        const enum SampleFormat *p= codec->sample_fmts;
660
        for(; *p!=-1; p++){
661
            if(*p == st->codec->sample_fmt)
662
                break;
663
        }
664
        if(*p == -1)
665
            st->codec->sample_fmt = codec->sample_fmts[0];
666
    }
667
}
668

    
669
static void choose_sample_rate(AVStream *st, AVCodec *codec)
670
{
671
    if(codec && codec->supported_samplerates){
672
        const int *p= codec->supported_samplerates;
673
        int best;
674
        int best_dist=INT_MAX;
675
        for(; *p; p++){
676
            int dist= abs(st->codec->sample_rate - *p);
677
            if(dist < best_dist){
678
                best_dist= dist;
679
                best= *p;
680
            }
681
        }
682
        if(best_dist){
683
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
684
        }
685
        st->codec->sample_rate= best;
686
    }
687
}
688

    
689
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
690
{
691
    if(codec && codec->pix_fmts){
692
        const enum PixelFormat *p= codec->pix_fmts;
693
        for(; *p!=-1; p++){
694
            if(*p == st->codec->pix_fmt)
695
                break;
696
        }
697
        if(*p == -1
698
           && !(   st->codec->codec_id==CODEC_ID_MJPEG
699
                && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL
700
                && (   st->codec->pix_fmt == PIX_FMT_YUV420P
701
                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))
702
            st->codec->pix_fmt = codec->pix_fmts[0];
703
    }
704
}
705

    
706
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
707
{
708
    int i, err;
709
    AVFormatContext *ic;
710
    int nopts = 0;
711

    
712
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
713
    if (err < 0)
714
        return err;
715
    /* copy stream format */
716
    s->nb_streams = ic->nb_streams;
717
    for(i=0;i<ic->nb_streams;i++) {
718
        AVStream *st;
719
        AVCodec *codec;
720

    
721
        // FIXME: a more elegant solution is needed
722
        st = av_mallocz(sizeof(AVStream));
723
        memcpy(st, ic->streams[i], sizeof(AVStream));
724
        st->codec = avcodec_alloc_context();
725
        if (!st->codec) {
726
            print_error(filename, AVERROR(ENOMEM));
727
            av_exit(1);
728
        }
729
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
730
        s->streams[i] = st;
731

    
732
        codec = avcodec_find_encoder(st->codec->codec_id);
733
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
734
            if (audio_stream_copy) {
735
                st->stream_copy = 1;
736
            } else
737
                choose_sample_fmt(st, codec);
738
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
739
            if (video_stream_copy) {
740
                st->stream_copy = 1;
741
            } else
742
                choose_pixel_fmt(st, codec);
743
        }
744

    
745
        if(!st->codec->thread_count)
746
            st->codec->thread_count = 1;
747
        if(st->codec->thread_count>1)
748
            avcodec_thread_init(st->codec, st->codec->thread_count);
749

    
750
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
751
            nopts = 1;
752
    }
753

    
754
    if (!nopts)
755
        s->timestamp = av_gettime();
756

    
757
    av_close_input_file(ic);
758
    return 0;
759
}
760

    
761
static double
762
get_sync_ipts(const AVOutputStream *ost)
763
{
764
    const AVInputStream *ist = ost->sync_ist;
765
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
766
}
767

    
768
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
769
    int ret;
770

    
771
    while(bsfc){
772
        AVPacket new_pkt= *pkt;
773
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
774
                                          &new_pkt.data, &new_pkt.size,
775
                                          pkt->data, pkt->size,
776
                                          pkt->flags & AV_PKT_FLAG_KEY);
777
        if(a>0){
778
            av_free_packet(pkt);
779
            new_pkt.destruct= av_destruct_packet;
780
        } else if(a<0){
781
            fprintf(stderr, "%s failed for stream %d, codec %s",
782
                    bsfc->filter->name, pkt->stream_index,
783
                    avctx->codec ? avctx->codec->name : "copy");
784
            print_error("", a);
785
            if (exit_on_error)
786
                av_exit(1);
787
        }
788
        *pkt= new_pkt;
789

    
790
        bsfc= bsfc->next;
791
    }
792

    
793
    ret= av_interleaved_write_frame(s, pkt);
794
    if(ret < 0){
795
        print_error("av_interleaved_write_frame()", ret);
796
        av_exit(1);
797
    }
798
}
799

    
800
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
801

    
802
static void do_audio_out(AVFormatContext *s,
803
                         AVOutputStream *ost,
804
                         AVInputStream *ist,
805
                         unsigned char *buf, int size)
806
{
807
    uint8_t *buftmp;
808
    int64_t audio_out_size, audio_buf_size;
809
    int64_t allocated_for_size= size;
810

    
811
    int size_out, frame_bytes, ret;
812
    AVCodecContext *enc= ost->st->codec;
813
    AVCodecContext *dec= ist->st->codec;
814
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
815
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
816
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
817

    
818
need_realloc:
819
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
820
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
821
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
822
    audio_buf_size*= osize*enc->channels;
823

    
824
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
825
    if(coded_bps > 8*osize)
826
        audio_out_size= audio_out_size * coded_bps / (8*osize);
827
    audio_out_size += FF_MIN_BUFFER_SIZE;
828

    
829
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
830
        fprintf(stderr, "Buffer sizes too large\n");
831
        av_exit(1);
832
    }
833

    
834
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
835
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
836
    if (!audio_buf || !audio_out){
837
        fprintf(stderr, "Out of memory in do_audio_out\n");
838
        av_exit(1);
839
    }
840

    
841
    if (enc->channels != dec->channels)
842
        ost->audio_resample = 1;
843

    
844
    if (ost->audio_resample && !ost->resample) {
845
        if (dec->sample_fmt != SAMPLE_FMT_S16)
846
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
847
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
848
                                               enc->sample_rate, dec->sample_rate,
849
                                               enc->sample_fmt,  dec->sample_fmt,
850
                                               16, 10, 0, 0.8);
851
        if (!ost->resample) {
852
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
853
                    dec->channels, dec->sample_rate,
854
                    enc->channels, enc->sample_rate);
855
            av_exit(1);
856
        }
857
    }
858

    
859
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
860
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
861
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
862
        if (ost->reformat_ctx)
863
            av_audio_convert_free(ost->reformat_ctx);
864
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
865
                                                   dec->sample_fmt, 1, NULL, 0);
866
        if (!ost->reformat_ctx) {
867
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
868
                avcodec_get_sample_fmt_name(dec->sample_fmt),
869
                avcodec_get_sample_fmt_name(enc->sample_fmt));
870
            av_exit(1);
871
        }
872
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
873
    }
874

    
875
    if(audio_sync_method){
876
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
877
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
878
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
879
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
880

    
881
        //FIXME resample delay
882
        if(fabs(delta) > 50){
883
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
884
                if(byte_delta < 0){
885
                    byte_delta= FFMAX(byte_delta, -size);
886
                    size += byte_delta;
887
                    buf  -= byte_delta;
888
                    if(verbose > 2)
889
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
890
                    if(!size)
891
                        return;
892
                    ist->is_start=0;
893
                }else{
894
                    static uint8_t *input_tmp= NULL;
895
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
896

    
897
                    if(byte_delta > allocated_for_size - size){
898
                        allocated_for_size= byte_delta + (int64_t)size;
899
                        goto need_realloc;
900
                    }
901
                    ist->is_start=0;
902

    
903
                    memset(input_tmp, 0, byte_delta);
904
                    memcpy(input_tmp + byte_delta, buf, size);
905
                    buf= input_tmp;
906
                    size += byte_delta;
907
                    if(verbose > 2)
908
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
909
                }
910
            }else if(audio_sync_method>1){
911
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
912
                assert(ost->audio_resample);
913
                if(verbose > 2)
914
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
915
//                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));
916
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
917
            }
918
        }
919
    }else
920
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
921
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
922

    
923
    if (ost->audio_resample) {
924
        buftmp = audio_buf;
925
        size_out = audio_resample(ost->resample,
926
                                  (short *)buftmp, (short *)buf,
927
                                  size / (ist->st->codec->channels * isize));
928
        size_out = size_out * enc->channels * osize;
929
    } else {
930
        buftmp = buf;
931
        size_out = size;
932
    }
933

    
934
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
935
        const void *ibuf[6]= {buftmp};
936
        void *obuf[6]= {audio_buf};
937
        int istride[6]= {isize};
938
        int ostride[6]= {osize};
939
        int len= size_out/istride[0];
940
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
941
            printf("av_audio_convert() failed\n");
942
            if (exit_on_error)
943
                av_exit(1);
944
            return;
945
        }
946
        buftmp = audio_buf;
947
        size_out = len*osize;
948
    }
949

    
950
    /* now encode as many frames as possible */
951
    if (enc->frame_size > 1) {
952
        /* output resampled raw samples */
953
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
954
            fprintf(stderr, "av_fifo_realloc2() failed\n");
955
            av_exit(1);
956
        }
957
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
958

    
959
        frame_bytes = enc->frame_size * osize * enc->channels;
960

    
961
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
962
            AVPacket pkt;
963
            av_init_packet(&pkt);
964

    
965
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
966

    
967
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
968

    
969
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
970
                                       (short *)audio_buf);
971
            if (ret < 0) {
972
                fprintf(stderr, "Audio encoding failed\n");
973
                av_exit(1);
974
            }
975
            audio_size += ret;
976
            pkt.stream_index= ost->index;
977
            pkt.data= audio_out;
978
            pkt.size= ret;
979
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
980
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
981
            pkt.flags |= AV_PKT_FLAG_KEY;
982
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
983

    
984
            ost->sync_opts += enc->frame_size;
985
        }
986
    } else {
987
        AVPacket pkt;
988
        av_init_packet(&pkt);
989

    
990
        ost->sync_opts += size_out / (osize * enc->channels);
991

    
992
        /* output a pcm frame */
993
        /* determine the size of the coded buffer */
994
        size_out /= osize;
995
        if (coded_bps)
996
            size_out = size_out*coded_bps/8;
997

    
998
        if(size_out > audio_out_size){
999
            fprintf(stderr, "Internal error, buffer size too small\n");
1000
            av_exit(1);
1001
        }
1002

    
1003
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1004
        ret = avcodec_encode_audio(enc, audio_out, size_out,
1005
                                   (short *)buftmp);
1006
        if (ret < 0) {
1007
            fprintf(stderr, "Audio encoding failed\n");
1008
            av_exit(1);
1009
        }
1010
        audio_size += ret;
1011
        pkt.stream_index= ost->index;
1012
        pkt.data= audio_out;
1013
        pkt.size= ret;
1014
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1015
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1016
        pkt.flags |= AV_PKT_FLAG_KEY;
1017
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1018
    }
1019
}
1020

    
1021
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1022
{
1023
    AVCodecContext *dec;
1024
    AVPicture *picture2;
1025
    AVPicture picture_tmp;
1026
    uint8_t *buf = 0;
1027

    
1028
    dec = ist->st->codec;
1029

    
1030
    /* deinterlace : must be done before any resize */
1031
    if (do_deinterlace) {
1032
        int size;
1033

    
1034
        /* create temporary picture */
1035
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1036
        buf = av_malloc(size);
1037
        if (!buf)
1038
            return;
1039

    
1040
        picture2 = &picture_tmp;
1041
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1042

    
1043
        if(avpicture_deinterlace(picture2, picture,
1044
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1045
            /* if error, do not deinterlace */
1046
            fprintf(stderr, "Deinterlacing failed\n");
1047
            av_free(buf);
1048
            buf = NULL;
1049
            picture2 = picture;
1050
        }
1051
    } else {
1052
        picture2 = picture;
1053
    }
1054

    
1055
    if (picture != picture2)
1056
        *picture = *picture2;
1057
    *bufp = buf;
1058
}
1059

    
1060
/* we begin to correct av delay at this threshold */
1061
#define AV_DELAY_MAX 0.100
1062

    
1063
static void do_subtitle_out(AVFormatContext *s,
1064
                            AVOutputStream *ost,
1065
                            AVInputStream *ist,
1066
                            AVSubtitle *sub,
1067
                            int64_t pts)
1068
{
1069
    static uint8_t *subtitle_out = NULL;
1070
    int subtitle_out_max_size = 1024 * 1024;
1071
    int subtitle_out_size, nb, i;
1072
    AVCodecContext *enc;
1073
    AVPacket pkt;
1074

    
1075
    if (pts == AV_NOPTS_VALUE) {
1076
        fprintf(stderr, "Subtitle packets must have a pts\n");
1077
        if (exit_on_error)
1078
            av_exit(1);
1079
        return;
1080
    }
1081

    
1082
    enc = ost->st->codec;
1083

    
1084
    if (!subtitle_out) {
1085
        subtitle_out = av_malloc(subtitle_out_max_size);
1086
    }
1087

    
1088
    /* Note: DVB subtitle need one packet to draw them and one other
1089
       packet to clear them */
1090
    /* XXX: signal it in the codec context ? */
1091
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1092
        nb = 2;
1093
    else
1094
        nb = 1;
1095

    
1096
    for(i = 0; i < nb; i++) {
1097
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1098
        // start_display_time is required to be 0
1099
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1100
        sub->end_display_time -= sub->start_display_time;
1101
        sub->start_display_time = 0;
1102
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1103
                                                    subtitle_out_max_size, sub);
1104
        if (subtitle_out_size < 0) {
1105
            fprintf(stderr, "Subtitle encoding failed\n");
1106
            av_exit(1);
1107
        }
1108

    
1109
        av_init_packet(&pkt);
1110
        pkt.stream_index = ost->index;
1111
        pkt.data = subtitle_out;
1112
        pkt.size = subtitle_out_size;
1113
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1114
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1115
            /* XXX: the pts correction is handled here. Maybe handling
1116
               it in the codec would be better */
1117
            if (i == 0)
1118
                pkt.pts += 90 * sub->start_display_time;
1119
            else
1120
                pkt.pts += 90 * sub->end_display_time;
1121
        }
1122
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1123
    }
1124
}
1125

    
1126
static int bit_buffer_size= 1024*256;
1127
static uint8_t *bit_buffer= NULL;
1128

    
1129
static void do_video_out(AVFormatContext *s,
1130
                         AVOutputStream *ost,
1131
                         AVInputStream *ist,
1132
                         AVFrame *in_picture,
1133
                         int *frame_size)
1134
{
1135
    int nb_frames, i, ret;
1136
#if !CONFIG_AVFILTER
1137
    int64_t topBand, bottomBand, leftBand, rightBand;
1138
#endif
1139
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1140
    AVFrame picture_crop_temp, picture_pad_temp;
1141
    AVCodecContext *enc, *dec;
1142
    double sync_ipts;
1143

    
1144
    avcodec_get_frame_defaults(&picture_crop_temp);
1145
    avcodec_get_frame_defaults(&picture_pad_temp);
1146

    
1147
    enc = ost->st->codec;
1148
    dec = ist->st->codec;
1149

    
1150
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1151

    
1152
    /* by default, we output a single frame */
1153
    nb_frames = 1;
1154

    
1155
    *frame_size = 0;
1156

    
1157
    if(video_sync_method){
1158
        double vdelta = sync_ipts - ost->sync_opts;
1159
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1160
        if (vdelta < -1.1)
1161
            nb_frames = 0;
1162
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1163
            if(vdelta<=-0.6){
1164
                nb_frames=0;
1165
            }else if(vdelta>0.6)
1166
            ost->sync_opts= lrintf(sync_ipts);
1167
        }else if (vdelta > 1.1)
1168
            nb_frames = lrintf(vdelta);
1169
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1170
        if (nb_frames == 0){
1171
            ++nb_frames_drop;
1172
            if (verbose>2)
1173
                fprintf(stderr, "*** drop!\n");
1174
        }else if (nb_frames > 1) {
1175
            nb_frames_dup += nb_frames - 1;
1176
            if (verbose>2)
1177
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1178
        }
1179
    }else
1180
        ost->sync_opts= lrintf(sync_ipts);
1181

    
1182
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1183
    if (nb_frames <= 0)
1184
        return;
1185

    
1186
#if CONFIG_AVFILTER
1187
    formatted_picture = in_picture;
1188
#else
1189
    if (ost->video_crop) {
1190
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1191
            fprintf(stderr, "error cropping picture\n");
1192
            if (exit_on_error)
1193
                av_exit(1);
1194
            return;
1195
        }
1196
        formatted_picture = &picture_crop_temp;
1197
    } else {
1198
        formatted_picture = in_picture;
1199
    }
1200
#endif
1201

    
1202
    final_picture = formatted_picture;
1203
    padding_src = formatted_picture;
1204
    resampling_dst = &ost->pict_tmp;
1205

    
1206
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1207
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1208
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1209

    
1210
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1211
        if(!ost->video_resample)
1212
            av_exit(1);
1213
    }
1214

    
1215
#if !CONFIG_AVFILTER
1216
    if (ost->video_resample) {
1217
        padding_src = NULL;
1218
        final_picture = &ost->pict_tmp;
1219
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1220
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1221
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1222

    
1223
            /* keep bands proportional to the frame size */
1224
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
1225
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1226
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
1227
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
1228

    
1229
            /* sanity check to ensure no bad band sizes sneak in */
1230
            assert(topBand    <= INT_MAX && topBand    >= 0);
1231
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
1232
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
1233
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
1234

    
1235
            ost->topBand    = topBand;
1236
            ost->bottomBand = bottomBand;
1237
            ost->leftBand   = leftBand;
1238
            ost->rightBand  = rightBand;
1239

    
1240
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1241
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1242
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1243

    
1244
            /* initialize a new scaler context */
1245
            sws_freeContext(ost->img_resample_ctx);
1246
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1247
            ost->img_resample_ctx = sws_getContext(
1248
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1249
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1250
                ist->st->codec->pix_fmt,
1251
                ost->st->codec->width,
1252
                ost->st->codec->height,
1253
                ost->st->codec->pix_fmt,
1254
                sws_flags, NULL, NULL, NULL);
1255
            if (ost->img_resample_ctx == NULL) {
1256
                fprintf(stderr, "Cannot get resampling context\n");
1257
                av_exit(1);
1258
            }
1259
        }
1260
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1261
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1262
    }
1263
#endif
1264

    
1265
    /* duplicates frame if needed */
1266
    for(i=0;i<nb_frames;i++) {
1267
        AVPacket pkt;
1268
        av_init_packet(&pkt);
1269
        pkt.stream_index= ost->index;
1270

    
1271
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1272
            /* raw pictures are written as AVPicture structure to
1273
               avoid any copies. We support temorarily the older
1274
               method. */
1275
            AVFrame* old_frame = enc->coded_frame;
1276
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1277
            pkt.data= (uint8_t *)final_picture;
1278
            pkt.size=  sizeof(AVPicture);
1279
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1280
            pkt.flags |= AV_PKT_FLAG_KEY;
1281

    
1282
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1283
            enc->coded_frame = old_frame;
1284
        } else {
1285
            AVFrame big_picture;
1286

    
1287
            big_picture= *final_picture;
1288
            /* better than nothing: use input picture interlaced
1289
               settings */
1290
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1291
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1292
                if(top_field_first == -1)
1293
                    big_picture.top_field_first = in_picture->top_field_first;
1294
                else
1295
                    big_picture.top_field_first = top_field_first;
1296
            }
1297

    
1298
            /* handles sameq here. This is not correct because it may
1299
               not be a global option */
1300
            if (same_quality) {
1301
                big_picture.quality = ist->st->quality;
1302
            }else
1303
                big_picture.quality = ost->st->quality;
1304
            if(!me_threshold)
1305
                big_picture.pict_type = 0;
1306
//            big_picture.pts = AV_NOPTS_VALUE;
1307
            big_picture.pts= ost->sync_opts;
1308
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1309
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1310
            ret = avcodec_encode_video(enc,
1311
                                       bit_buffer, bit_buffer_size,
1312
                                       &big_picture);
1313
            if (ret < 0) {
1314
                fprintf(stderr, "Video encoding failed\n");
1315
                av_exit(1);
1316
            }
1317

    
1318
            if(ret>0){
1319
                pkt.data= bit_buffer;
1320
                pkt.size= ret;
1321
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1322
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1323
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1324
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1325
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1326

    
1327
                if(enc->coded_frame->key_frame)
1328
                    pkt.flags |= AV_PKT_FLAG_KEY;
1329
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1330
                *frame_size = ret;
1331
                video_size += ret;
1332
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1333
                //        enc->frame_number-1, ret, enc->pict_type);
1334
                /* if two pass, output log */
1335
                if (ost->logfile && enc->stats_out) {
1336
                    fprintf(ost->logfile, "%s", enc->stats_out);
1337
                }
1338
            }
1339
        }
1340
        ost->sync_opts++;
1341
        ost->frame_number++;
1342
    }
1343
}
1344

    
1345
static double psnr(double d){
1346
    return -10.0*log(d)/log(10.0);
1347
}
1348

    
1349
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1350
                           int frame_size)
1351
{
1352
    AVCodecContext *enc;
1353
    int frame_number;
1354
    double ti1, bitrate, avg_bitrate;
1355

    
1356
    /* this is executed just the first time do_video_stats is called */
1357
    if (!vstats_file) {
1358
        vstats_file = fopen(vstats_filename, "w");
1359
        if (!vstats_file) {
1360
            perror("fopen");
1361
            av_exit(1);
1362
        }
1363
    }
1364

    
1365
    enc = ost->st->codec;
1366
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1367
        frame_number = ost->frame_number;
1368
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1369
        if (enc->flags&CODEC_FLAG_PSNR)
1370
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1371

    
1372
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1373
        /* compute pts value */
1374
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1375
        if (ti1 < 0.01)
1376
            ti1 = 0.01;
1377

    
1378
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1379
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1380
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1381
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1382
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1383
    }
1384
}
1385

    
1386
static void print_report(AVFormatContext **output_files,
1387
                         AVOutputStream **ost_table, int nb_ostreams,
1388
                         int is_last_report)
1389
{
1390
    char buf[1024];
1391
    AVOutputStream *ost;
1392
    AVFormatContext *oc;
1393
    int64_t total_size;
1394
    AVCodecContext *enc;
1395
    int frame_number, vid, i;
1396
    double bitrate, ti1, pts;
1397
    static int64_t last_time = -1;
1398
    static int qp_histogram[52];
1399

    
1400
    if (!is_last_report) {
1401
        int64_t cur_time;
1402
        /* display the report every 0.5 seconds */
1403
        cur_time = av_gettime();
1404
        if (last_time == -1) {
1405
            last_time = cur_time;
1406
            return;
1407
        }
1408
        if ((cur_time - last_time) < 500000)
1409
            return;
1410
        last_time = cur_time;
1411
    }
1412

    
1413

    
1414
    oc = output_files[0];
1415

    
1416
    total_size = url_fsize(oc->pb);
1417
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1418
        total_size= url_ftell(oc->pb);
1419

    
1420
    buf[0] = '\0';
1421
    ti1 = 1e10;
1422
    vid = 0;
1423
    for(i=0;i<nb_ostreams;i++) {
1424
        ost = ost_table[i];
1425
        enc = ost->st->codec;
1426
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1427
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1428
                     !ost->st->stream_copy ?
1429
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1430
        }
1431
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1432
            float t = (av_gettime()-timer_start) / 1000000.0;
1433

    
1434
            frame_number = ost->frame_number;
1435
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1436
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1437
                     !ost->st->stream_copy ?
1438
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1439
            if(is_last_report)
1440
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1441
            if(qp_hist){
1442
                int j;
1443
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1444
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1445
                    qp_histogram[qp]++;
1446
                for(j=0; j<32; j++)
1447
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1448
            }
1449
            if (enc->flags&CODEC_FLAG_PSNR){
1450
                int j;
1451
                double error, error_sum=0;
1452
                double scale, scale_sum=0;
1453
                char type[3]= {'Y','U','V'};
1454
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1455
                for(j=0; j<3; j++){
1456
                    if(is_last_report){
1457
                        error= enc->error[j];
1458
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1459
                    }else{
1460
                        error= enc->coded_frame->error[j];
1461
                        scale= enc->width*enc->height*255.0*255.0;
1462
                    }
1463
                    if(j) scale/=4;
1464
                    error_sum += error;
1465
                    scale_sum += scale;
1466
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1467
                }
1468
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1469
            }
1470
            vid = 1;
1471
        }
1472
        /* compute min output value */
1473
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1474
        if ((pts < ti1) && (pts > 0))
1475
            ti1 = pts;
1476
    }
1477
    if (ti1 < 0.01)
1478
        ti1 = 0.01;
1479

    
1480
    if (verbose || is_last_report) {
1481
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1482

    
1483
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1484
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1485
            (double)total_size / 1024, ti1, bitrate);
1486

    
1487
        if (nb_frames_dup || nb_frames_drop)
1488
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1489
                  nb_frames_dup, nb_frames_drop);
1490

    
1491
        if (verbose >= 0)
1492
            fprintf(stderr, "%s    \r", buf);
1493

    
1494
        fflush(stderr);
1495
    }
1496

    
1497
    if (is_last_report && verbose >= 0){
1498
        int64_t raw= audio_size + video_size + extra_size;
1499
        fprintf(stderr, "\n");
1500
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1501
                video_size/1024.0,
1502
                audio_size/1024.0,
1503
                extra_size/1024.0,
1504
                100.0*(total_size - raw)/raw
1505
        );
1506
    }
1507
}
1508

    
1509
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1510
static int output_packet(AVInputStream *ist, int ist_index,
1511
                         AVOutputStream **ost_table, int nb_ostreams,
1512
                         const AVPacket *pkt)
1513
{
1514
    AVFormatContext *os;
1515
    AVOutputStream *ost;
1516
    int ret, i;
1517
    int got_picture;
1518
    AVFrame picture;
1519
    void *buffer_to_free;
1520
    static unsigned int samples_size= 0;
1521
    AVSubtitle subtitle, *subtitle_to_free;
1522
    int got_subtitle;
1523
#if CONFIG_AVFILTER
1524
    int loop;
1525
#endif
1526

    
1527
    AVPacket avpkt;
1528
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1529

    
1530
    if(ist->next_pts == AV_NOPTS_VALUE)
1531
        ist->next_pts= ist->pts;
1532

    
1533
    if (pkt == NULL) {
1534
        /* EOF handling */
1535
        av_init_packet(&avpkt);
1536
        avpkt.data = NULL;
1537
        avpkt.size = 0;
1538
        goto handle_eof;
1539
    } else {
1540
        avpkt = *pkt;
1541
    }
1542

    
1543
    if(pkt->dts != AV_NOPTS_VALUE)
1544
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1545

    
1546
    //while we have more to decode or while the decoder did output something on EOF
1547
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1548
        uint8_t *data_buf, *decoded_data_buf;
1549
        int data_size, decoded_data_size;
1550
    handle_eof:
1551
        ist->pts= ist->next_pts;
1552

    
1553
        if(avpkt.size && avpkt.size != pkt->size &&
1554
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1555
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1556
            ist->showed_multi_packet_warning=1;
1557
        }
1558

    
1559
        /* decode the packet if needed */
1560
        decoded_data_buf = NULL; /* fail safe */
1561
        decoded_data_size= 0;
1562
        data_buf  = avpkt.data;
1563
        data_size = avpkt.size;
1564
        subtitle_to_free = NULL;
1565
        if (ist->decoding_needed) {
1566
            switch(ist->st->codec->codec_type) {
1567
            case AVMEDIA_TYPE_AUDIO:{
1568
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1569
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1570
                    av_free(samples);
1571
                    samples= av_malloc(samples_size);
1572
                }
1573
                decoded_data_size= samples_size;
1574
                    /* XXX: could avoid copy if PCM 16 bits with same
1575
                       endianness as CPU */
1576
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1577
                                            &avpkt);
1578
                if (ret < 0)
1579
                    goto fail_decode;
1580
                avpkt.data += ret;
1581
                avpkt.size -= ret;
1582
                data_size   = ret;
1583
                /* Some bug in mpeg audio decoder gives */
1584
                /* decoded_data_size < 0, it seems they are overflows */
1585
                if (decoded_data_size <= 0) {
1586
                    /* no audio frame */
1587
                    continue;
1588
                }
1589
                decoded_data_buf = (uint8_t *)samples;
1590
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1591
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1592
                break;}
1593
            case AVMEDIA_TYPE_VIDEO:
1594
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1595
                    /* XXX: allocate picture correctly */
1596
                    avcodec_get_frame_defaults(&picture);
1597

    
1598
                    ret = avcodec_decode_video2(ist->st->codec,
1599
                                                &picture, &got_picture, &avpkt);
1600
                    ist->st->quality= picture.quality;
1601
                    if (ret < 0)
1602
                        goto fail_decode;
1603
                    if (!got_picture) {
1604
                        /* no picture yet */
1605
                        goto discard_packet;
1606
                    }
1607
                    if (ist->st->codec->time_base.num != 0) {
1608
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1609
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1610
                                          ist->st->codec->time_base.num * ticks) /
1611
                            ist->st->codec->time_base.den;
1612
                    }
1613
                    avpkt.size = 0;
1614
                    break;
1615
            case AVMEDIA_TYPE_SUBTITLE:
1616
                ret = avcodec_decode_subtitle2(ist->st->codec,
1617
                                               &subtitle, &got_subtitle, &avpkt);
1618
                if (ret < 0)
1619
                    goto fail_decode;
1620
                if (!got_subtitle) {
1621
                    goto discard_packet;
1622
                }
1623
                subtitle_to_free = &subtitle;
1624
                avpkt.size = 0;
1625
                break;
1626
            default:
1627
                goto fail_decode;
1628
            }
1629
        } else {
1630
            switch(ist->st->codec->codec_type) {
1631
            case AVMEDIA_TYPE_AUDIO:
1632
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1633
                    ist->st->codec->sample_rate;
1634
                break;
1635
            case AVMEDIA_TYPE_VIDEO:
1636
                if (ist->st->codec->time_base.num != 0) {
1637
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1638
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1639
                                      ist->st->codec->time_base.num * ticks) /
1640
                        ist->st->codec->time_base.den;
1641
                }
1642
                break;
1643
            }
1644
            ret = avpkt.size;
1645
            avpkt.size = 0;
1646
        }
1647

    
1648
        buffer_to_free = NULL;
1649
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1650
            pre_process_video_frame(ist, (AVPicture *)&picture,
1651
                                    &buffer_to_free);
1652
        }
1653

    
1654
#if CONFIG_AVFILTER
1655
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1656
            // add it to be filtered
1657
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1658
                                     ist->pts,
1659
                                     ist->st->codec->sample_aspect_ratio);
1660
        }
1661
#endif
1662

    
1663
        // preprocess audio (volume)
1664
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1665
            if (audio_volume != 256) {
1666
                short *volp;
1667
                volp = samples;
1668
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1669
                    int v = ((*volp) * audio_volume + 128) >> 8;
1670
                    if (v < -32768) v = -32768;
1671
                    if (v >  32767) v = 32767;
1672
                    *volp++ = v;
1673
                }
1674
            }
1675
        }
1676

    
1677
        /* frame rate emulation */
1678
        if (rate_emu) {
1679
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1680
            int64_t now = av_gettime() - ist->start;
1681
            if (pts > now)
1682
                usleep(pts - now);
1683
        }
1684
#if CONFIG_AVFILTER
1685
        loop = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1686
            !ist->out_video_filter || avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1687
#endif
1688
        /* if output time reached then transcode raw format,
1689
           encode packets and output them */
1690
        if (start_time == 0 || ist->pts >= start_time)
1691
#if CONFIG_AVFILTER
1692
        while(loop) {
1693
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->out_video_filter)
1694
                get_filtered_video_pic(ist->out_video_filter, &ist->picref, &picture, &ist->pts);
1695
#endif
1696
            for(i=0;i<nb_ostreams;i++) {
1697
                int frame_size;
1698

    
1699
                ost = ost_table[i];
1700
                if (ost->source_index == ist_index) {
1701
                    os = output_files[ost->file_index];
1702

    
1703
                    /* set the input output pts pairs */
1704
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1705

    
1706
                    if (ost->encoding_needed) {
1707
                        assert(ist->decoding_needed);
1708
                        switch(ost->st->codec->codec_type) {
1709
                        case AVMEDIA_TYPE_AUDIO:
1710
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1711
                            break;
1712
                        case AVMEDIA_TYPE_VIDEO:
1713
#if CONFIG_AVFILTER
1714
                            ost->st->codec->sample_aspect_ratio = ist->picref->pixel_aspect;
1715
#endif
1716
                            do_video_out(os, ost, ist, &picture, &frame_size);
1717
                            if (vstats_filename && frame_size)
1718
                                do_video_stats(os, ost, frame_size);
1719
                            break;
1720
                        case AVMEDIA_TYPE_SUBTITLE:
1721
                            do_subtitle_out(os, ost, ist, &subtitle,
1722
                                            pkt->pts);
1723
                            break;
1724
                        default:
1725
                            abort();
1726
                        }
1727
                    } else {
1728
                        AVFrame avframe; //FIXME/XXX remove this
1729
                        AVPacket opkt;
1730
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1731

    
1732
                        av_init_packet(&opkt);
1733

    
1734
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1735
                            continue;
1736

    
1737
                        /* no reencoding needed : output the packet directly */
1738
                        /* force the input stream PTS */
1739

    
1740
                        avcodec_get_frame_defaults(&avframe);
1741
                        ost->st->codec->coded_frame= &avframe;
1742
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1743

    
1744
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1745
                            audio_size += data_size;
1746
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1747
                            video_size += data_size;
1748
                            ost->sync_opts++;
1749
                        }
1750

    
1751
                        opkt.stream_index= ost->index;
1752
                        if(pkt->pts != AV_NOPTS_VALUE)
1753
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1754
                        else
1755
                            opkt.pts= AV_NOPTS_VALUE;
1756

    
1757
                        if (pkt->dts == AV_NOPTS_VALUE)
1758
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1759
                        else
1760
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1761
                        opkt.dts -= ost_tb_start_time;
1762

    
1763
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1764
                        opkt.flags= pkt->flags;
1765

    
1766
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1767
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1768
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1769
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1770
                           ) {
1771
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1772
                                opkt.destruct= av_destruct_packet;
1773
                        } else {
1774
                            opkt.data = data_buf;
1775
                            opkt.size = data_size;
1776
                        }
1777

    
1778
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1779
                        ost->st->codec->frame_number++;
1780
                        ost->frame_number++;
1781
                        av_free_packet(&opkt);
1782
                    }
1783
                }
1784
#if CONFIG_AVFILTER
1785
                loop =  (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1786
                        ist->out_video_filter && avfilter_poll_frame(ist->out_video_filter->inputs[0]);
1787
#endif
1788
            }
1789

    
1790
#if CONFIG_AVFILTER
1791
            if(ist->picref)
1792
                avfilter_unref_pic(ist->picref);
1793
        }
1794
#endif
1795
        av_free(buffer_to_free);
1796
        /* XXX: allocate the subtitles in the codec ? */
1797
        if (subtitle_to_free) {
1798
            if (subtitle_to_free->rects != NULL) {
1799
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1800
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1801
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1802
                    av_freep(&subtitle_to_free->rects[i]);
1803
                }
1804
                av_freep(&subtitle_to_free->rects);
1805
            }
1806
            subtitle_to_free->num_rects = 0;
1807
            subtitle_to_free = NULL;
1808
        }
1809
    }
1810
 discard_packet:
1811
    if (pkt == NULL) {
1812
        /* EOF handling */
1813

    
1814
        for(i=0;i<nb_ostreams;i++) {
1815
            ost = ost_table[i];
1816
            if (ost->source_index == ist_index) {
1817
                AVCodecContext *enc= ost->st->codec;
1818
                os = output_files[ost->file_index];
1819

    
1820
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1821
                    continue;
1822
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1823
                    continue;
1824

    
1825
                if (ost->encoding_needed) {
1826
                    for(;;) {
1827
                        AVPacket pkt;
1828
                        int fifo_bytes;
1829
                        av_init_packet(&pkt);
1830
                        pkt.stream_index= ost->index;
1831

    
1832
                        switch(ost->st->codec->codec_type) {
1833
                        case AVMEDIA_TYPE_AUDIO:
1834
                            fifo_bytes = av_fifo_size(ost->fifo);
1835
                            ret = 0;
1836
                            /* encode any samples remaining in fifo */
1837
                            if (fifo_bytes > 0) {
1838
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1839
                                int fs_tmp = enc->frame_size;
1840

    
1841
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1842
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1843
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1844
                                } else { /* pad */
1845
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1846
                                    if (samples_size < frame_bytes)
1847
                                        av_exit(1);
1848
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1849
                                }
1850

    
1851
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1852
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1853
                                                          ost->st->time_base.num, enc->sample_rate);
1854
                                enc->frame_size = fs_tmp;
1855
                            }
1856
                            if(ret <= 0) {
1857
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1858
                            }
1859
                            if (ret < 0) {
1860
                                fprintf(stderr, "Audio encoding failed\n");
1861
                                av_exit(1);
1862
                            }
1863
                            audio_size += ret;
1864
                            pkt.flags |= AV_PKT_FLAG_KEY;
1865
                            break;
1866
                        case AVMEDIA_TYPE_VIDEO:
1867
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1868
                            if (ret < 0) {
1869
                                fprintf(stderr, "Video encoding failed\n");
1870
                                av_exit(1);
1871
                            }
1872
                            video_size += ret;
1873
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1874
                                pkt.flags |= AV_PKT_FLAG_KEY;
1875
                            if (ost->logfile && enc->stats_out) {
1876
                                fprintf(ost->logfile, "%s", enc->stats_out);
1877
                            }
1878
                            break;
1879
                        default:
1880
                            ret=-1;
1881
                        }
1882

    
1883
                        if(ret<=0)
1884
                            break;
1885
                        pkt.data= bit_buffer;
1886
                        pkt.size= ret;
1887
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1888
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1889
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1890
                    }
1891
                }
1892
            }
1893
        }
1894
    }
1895

    
1896
    return 0;
1897
 fail_decode:
1898
    return -1;
1899
}
1900

    
1901
static void print_sdp(AVFormatContext **avc, int n)
1902
{
1903
    char sdp[2048];
1904

    
1905
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1906
    printf("SDP:\n%s\n", sdp);
1907
    fflush(stdout);
1908
}
1909

    
1910
static int copy_chapters(int infile, int outfile)
1911
{
1912
    AVFormatContext *is = input_files[infile];
1913
    AVFormatContext *os = output_files[outfile];
1914
    int i;
1915

    
1916
    for (i = 0; i < is->nb_chapters; i++) {
1917
        AVChapter *in_ch = is->chapters[i], *out_ch;
1918
        AVMetadataTag *t = NULL;
1919
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1920
                                      AV_TIME_BASE_Q, in_ch->time_base);
1921
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1922
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1923

    
1924

    
1925
        if (in_ch->end < ts_off)
1926
            continue;
1927
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1928
            break;
1929

    
1930
        out_ch = av_mallocz(sizeof(AVChapter));
1931
        if (!out_ch)
1932
            return AVERROR(ENOMEM);
1933

    
1934
        out_ch->id        = in_ch->id;
1935
        out_ch->time_base = in_ch->time_base;
1936
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1937
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1938

    
1939
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1940
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1941

    
1942
        os->nb_chapters++;
1943
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1944
        if (!os->chapters)
1945
            return AVERROR(ENOMEM);
1946
        os->chapters[os->nb_chapters - 1] = out_ch;
1947
    }
1948
    return 0;
1949
}
1950

    
1951
/*
1952
 * The following code is the main loop of the file converter
1953
 */
1954
static int av_transcode(AVFormatContext **output_files,
1955
                        int nb_output_files,
1956
                        AVFormatContext **input_files,
1957
                        int nb_input_files,
1958
                        AVStreamMap *stream_maps, int nb_stream_maps)
1959
{
1960
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1961
    AVFormatContext *is, *os;
1962
    AVCodecContext *codec, *icodec;
1963
    AVOutputStream *ost, **ost_table = NULL;
1964
    AVInputStream *ist, **ist_table = NULL;
1965
    AVInputFile *file_table;
1966
    char error[1024];
1967
    int key;
1968
    int want_sdp = 1;
1969
    uint8_t no_packet[MAX_FILES]={0};
1970
    int no_packet_count=0;
1971

    
1972
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1973
    if (!file_table)
1974
        goto fail;
1975

    
1976
    /* input stream init */
1977
    j = 0;
1978
    for(i=0;i<nb_input_files;i++) {
1979
        is = input_files[i];
1980
        file_table[i].ist_index = j;
1981
        file_table[i].nb_streams = is->nb_streams;
1982
        j += is->nb_streams;
1983
    }
1984
    nb_istreams = j;
1985

    
1986
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1987
    if (!ist_table)
1988
        goto fail;
1989

    
1990
    for(i=0;i<nb_istreams;i++) {
1991
        ist = av_mallocz(sizeof(AVInputStream));
1992
        if (!ist)
1993
            goto fail;
1994
        ist_table[i] = ist;
1995
    }
1996
    j = 0;
1997
    for(i=0;i<nb_input_files;i++) {
1998
        is = input_files[i];
1999
        for(k=0;k<is->nb_streams;k++) {
2000
            ist = ist_table[j++];
2001
            ist->st = is->streams[k];
2002
            ist->file_index = i;
2003
            ist->index = k;
2004
            ist->discard = 1; /* the stream is discarded by default
2005
                                 (changed later) */
2006

    
2007
            if (rate_emu) {
2008
                ist->start = av_gettime();
2009
            }
2010
        }
2011
    }
2012

    
2013
    /* output stream init */
2014
    nb_ostreams = 0;
2015
    for(i=0;i<nb_output_files;i++) {
2016
        os = output_files[i];
2017
        if (!os->nb_streams) {
2018
            dump_format(output_files[i], i, output_files[i]->filename, 1);
2019
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2020
            av_exit(1);
2021
        }
2022
        nb_ostreams += os->nb_streams;
2023
    }
2024
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2025
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2026
        av_exit(1);
2027
    }
2028

    
2029
    /* Sanity check the mapping args -- do the input files & streams exist? */
2030
    for(i=0;i<nb_stream_maps;i++) {
2031
        int fi = stream_maps[i].file_index;
2032
        int si = stream_maps[i].stream_index;
2033

    
2034
        if (fi < 0 || fi > nb_input_files - 1 ||
2035
            si < 0 || si > file_table[fi].nb_streams - 1) {
2036
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2037
            av_exit(1);
2038
        }
2039
        fi = stream_maps[i].sync_file_index;
2040
        si = stream_maps[i].sync_stream_index;
2041
        if (fi < 0 || fi > nb_input_files - 1 ||
2042
            si < 0 || si > file_table[fi].nb_streams - 1) {
2043
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2044
            av_exit(1);
2045
        }
2046
    }
2047

    
2048
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2049
    if (!ost_table)
2050
        goto fail;
2051
    for(i=0;i<nb_ostreams;i++) {
2052
        ost = av_mallocz(sizeof(AVOutputStream));
2053
        if (!ost)
2054
            goto fail;
2055
        ost_table[i] = ost;
2056
    }
2057

    
2058
    n = 0;
2059
    for(k=0;k<nb_output_files;k++) {
2060
        os = output_files[k];
2061
        for(i=0;i<os->nb_streams;i++,n++) {
2062
            int found;
2063
            ost = ost_table[n];
2064
            ost->file_index = k;
2065
            ost->index = i;
2066
            ost->st = os->streams[i];
2067
            if (nb_stream_maps > 0) {
2068
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2069
                    stream_maps[n].stream_index;
2070

    
2071
                /* Sanity check that the stream types match */
2072
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2073
                    int i= ost->file_index;
2074
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2075
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2076
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2077
                        ost->file_index, ost->index);
2078
                    av_exit(1);
2079
                }
2080

    
2081
            } else {
2082
                int best_nb_frames=-1;
2083
                    /* get corresponding input stream index : we select the first one with the right type */
2084
                    found = 0;
2085
                    for(j=0;j<nb_istreams;j++) {
2086
                        int skip=0;
2087
                        ist = ist_table[j];
2088
                        if(opt_programid){
2089
                            int pi,si;
2090
                            AVFormatContext *f= input_files[ ist->file_index ];
2091
                            skip=1;
2092
                            for(pi=0; pi<f->nb_programs; pi++){
2093
                                AVProgram *p= f->programs[pi];
2094
                                if(p->id == opt_programid)
2095
                                    for(si=0; si<p->nb_stream_indexes; si++){
2096
                                        if(f->streams[ p->stream_index[si] ] == ist->st)
2097
                                            skip=0;
2098
                                    }
2099
                            }
2100
                        }
2101
                        if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2102
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
2103
                            if(best_nb_frames < ist->st->codec_info_nb_frames){
2104
                                best_nb_frames= ist->st->codec_info_nb_frames;
2105
                                ost->source_index = j;
2106
                                found = 1;
2107
                            }
2108
                        }
2109
                    }
2110

    
2111
                if (!found) {
2112
                    if(! opt_programid) {
2113
                        /* try again and reuse existing stream */
2114
                        for(j=0;j<nb_istreams;j++) {
2115
                            ist = ist_table[j];
2116
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2117
                                && ist->st->discard != AVDISCARD_ALL) {
2118
                                ost->source_index = j;
2119
                                found = 1;
2120
                            }
2121
                        }
2122
                    }
2123
                    if (!found) {
2124
                        int i= ost->file_index;
2125
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2126
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2127
                                ost->file_index, ost->index);
2128
                        av_exit(1);
2129
                    }
2130
                }
2131
            }
2132
            ist = ist_table[ost->source_index];
2133
            ist->discard = 0;
2134
            ost->sync_ist = (nb_stream_maps > 0) ?
2135
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2136
                         stream_maps[n].sync_stream_index] : ist;
2137
        }
2138
    }
2139

    
2140
    /* for each output stream, we compute the right encoding parameters */
2141
    for(i=0;i<nb_ostreams;i++) {
2142
        AVMetadataTag *t = NULL;
2143
        ost = ost_table[i];
2144
        os = output_files[ost->file_index];
2145
        ist = ist_table[ost->source_index];
2146

    
2147
        codec = ost->st->codec;
2148
        icodec = ist->st->codec;
2149

    
2150
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2151
            av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2152
        }
2153

    
2154
        ost->st->disposition = ist->st->disposition;
2155
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2156
        codec->chroma_sample_location = icodec->chroma_sample_location;
2157

    
2158
        if (ost->st->stream_copy) {
2159
            /* if stream_copy is selected, no need to decode or encode */
2160
            codec->codec_id = icodec->codec_id;
2161
            codec->codec_type = icodec->codec_type;
2162

    
2163
            if(!codec->codec_tag){
2164
                if(   !os->oformat->codec_tag
2165
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2166
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2167
                    codec->codec_tag = icodec->codec_tag;
2168
            }
2169

    
2170
            codec->bit_rate = icodec->bit_rate;
2171
            codec->extradata= icodec->extradata;
2172
            codec->extradata_size= icodec->extradata_size;
2173
            if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2174
                codec->time_base = icodec->time_base;
2175
                codec->time_base.num *= icodec->ticks_per_frame;
2176
            }else
2177
                codec->time_base = ist->st->time_base;
2178
            switch(codec->codec_type) {
2179
            case AVMEDIA_TYPE_AUDIO:
2180
                if(audio_volume != 256) {
2181
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2182
                    av_exit(1);
2183
                }
2184
                codec->channel_layout = icodec->channel_layout;
2185
                codec->sample_rate = icodec->sample_rate;
2186
                codec->channels = icodec->channels;
2187
                codec->frame_size = icodec->frame_size;
2188
                codec->block_align= icodec->block_align;
2189
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2190
                    codec->block_align= 0;
2191
                if(codec->codec_id == CODEC_ID_AC3)
2192
                    codec->block_align= 0;
2193
                break;
2194
            case AVMEDIA_TYPE_VIDEO:
2195
                codec->pix_fmt = icodec->pix_fmt;
2196
                codec->width = icodec->width;
2197
                codec->height = icodec->height;
2198
                codec->has_b_frames = icodec->has_b_frames;
2199
                break;
2200
            case AVMEDIA_TYPE_SUBTITLE:
2201
                codec->width = icodec->width;
2202
                codec->height = icodec->height;
2203
                break;
2204
            default:
2205
                abort();
2206
            }
2207
        } else {
2208
            switch(codec->codec_type) {
2209
            case AVMEDIA_TYPE_AUDIO:
2210
                ost->fifo= av_fifo_alloc(1024);
2211
                if(!ost->fifo)
2212
                    goto fail;
2213
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2214
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2215
                icodec->request_channels = codec->channels;
2216
                ist->decoding_needed = 1;
2217
                ost->encoding_needed = 1;
2218
                break;
2219
            case AVMEDIA_TYPE_VIDEO:
2220
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2221
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2222
                    av_exit(1);
2223
                }
2224
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2225
                ost->video_resample = ((codec->width != icodec->width -
2226
                                (frame_leftBand + frame_rightBand)) ||
2227
                        (codec->height != icodec->height -
2228
                                (frame_topBand  + frame_bottomBand)) ||
2229
                        (codec->pix_fmt != icodec->pix_fmt));
2230
                if (ost->video_crop) {
2231
                    ost->topBand    = ost->original_topBand    = frame_topBand;
2232
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2233
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
2234
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
2235
                }
2236
                if (ost->video_resample) {
2237
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2238
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2239
                                         codec->width, codec->height)) {
2240
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2241
                        av_exit(1);
2242
                    }
2243
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2244
                    ost->img_resample_ctx = sws_getContext(
2245
                            icodec->width - (frame_leftBand + frame_rightBand),
2246
                            icodec->height - (frame_topBand + frame_bottomBand),
2247
                            icodec->pix_fmt,
2248
                            codec->width,
2249
                            codec->height,
2250
                            codec->pix_fmt,
2251
                            sws_flags, NULL, NULL, NULL);
2252
                    if (ost->img_resample_ctx == NULL) {
2253
                        fprintf(stderr, "Cannot get resampling context\n");
2254
                        av_exit(1);
2255
                    }
2256

    
2257
#if !CONFIG_AVFILTER
2258
                    ost->original_height = icodec->height;
2259
                    ost->original_width  = icodec->width;
2260
#endif
2261
                    codec->bits_per_raw_sample= 0;
2262
                }
2263
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2264
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2265
                ost->resample_pix_fmt= icodec->pix_fmt;
2266
                ost->encoding_needed = 1;
2267
                ist->decoding_needed = 1;
2268

    
2269
#if CONFIG_AVFILTER
2270
                if (configure_filters(ist, ost)) {
2271
                    fprintf(stderr, "Error opening filters!\n");
2272
                    exit(1);
2273
                }
2274
#endif
2275
                break;
2276
            case AVMEDIA_TYPE_SUBTITLE:
2277
                ost->encoding_needed = 1;
2278
                ist->decoding_needed = 1;
2279
                break;
2280
            default:
2281
                abort();
2282
                break;
2283
            }
2284
            /* two pass mode */
2285
            if (ost->encoding_needed &&
2286
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2287
                char logfilename[1024];
2288
                FILE *f;
2289

    
2290
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2291
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2292
                         i);
2293
                if (codec->flags & CODEC_FLAG_PASS1) {
2294
                    f = fopen(logfilename, "w");
2295
                    if (!f) {
2296
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2297
                        av_exit(1);
2298
                    }
2299
                    ost->logfile = f;
2300
                } else {
2301
                    char  *logbuffer;
2302
                    size_t logbuffer_size;
2303
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2304
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2305
                        av_exit(1);
2306
                    }
2307
                    codec->stats_in = logbuffer;
2308
                }
2309
            }
2310
        }
2311
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2312
            int size= codec->width * codec->height;
2313
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2314
        }
2315
    }
2316

    
2317
    if (!bit_buffer)
2318
        bit_buffer = av_malloc(bit_buffer_size);
2319
    if (!bit_buffer) {
2320
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2321
                bit_buffer_size);
2322
        ret = AVERROR(ENOMEM);
2323
        goto fail;
2324
    }
2325

    
2326
    /* open each encoder */
2327
    for(i=0;i<nb_ostreams;i++) {
2328
        ost = ost_table[i];
2329
        if (ost->encoding_needed) {
2330
            AVCodec *codec = output_codecs[i];
2331
            if (!codec)
2332
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2333
            if (!codec) {
2334
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2335
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2336
                ret = AVERROR(EINVAL);
2337
                goto dump_format;
2338
            }
2339
            if (avcodec_open(ost->st->codec, codec) < 0) {
2340
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2341
                        ost->file_index, ost->index);
2342
                ret = AVERROR(EINVAL);
2343
                goto dump_format;
2344
            }
2345
            extra_size += ost->st->codec->extradata_size;
2346
        }
2347
    }
2348

    
2349
    /* open each decoder */
2350
    for(i=0;i<nb_istreams;i++) {
2351
        ist = ist_table[i];
2352
        if (ist->decoding_needed) {
2353
            AVCodec *codec = input_codecs[i];
2354
            if (!codec)
2355
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2356
            if (!codec) {
2357
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2358
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2359
                ret = AVERROR(EINVAL);
2360
                goto dump_format;
2361
            }
2362
            if (avcodec_open(ist->st->codec, codec) < 0) {
2363
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2364
                        ist->file_index, ist->index);
2365
                ret = AVERROR(EINVAL);
2366
                goto dump_format;
2367
            }
2368
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2369
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2370
        }
2371
    }
2372

    
2373
    /* init pts */
2374
    for(i=0;i<nb_istreams;i++) {
2375
        AVStream *st;
2376
        ist = ist_table[i];
2377
        st= ist->st;
2378
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2379
        ist->next_pts = AV_NOPTS_VALUE;
2380
        ist->is_start = 1;
2381
    }
2382

    
2383
    /* set meta data information from input file if required */
2384
    for (i=0;i<nb_meta_data_maps;i++) {
2385
        AVFormatContext *out_file;
2386
        AVFormatContext *in_file;
2387
        AVMetadataTag *mtag;
2388

    
2389
        int out_file_index = meta_data_maps[i].out_file;
2390
        int in_file_index = meta_data_maps[i].in_file;
2391
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2392
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2393
                     out_file_index, out_file_index, in_file_index);
2394
            ret = AVERROR(EINVAL);
2395
            goto dump_format;
2396
        }
2397
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2398
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2399
                     in_file_index, out_file_index, in_file_index);
2400
            ret = AVERROR(EINVAL);
2401
            goto dump_format;
2402
        }
2403

    
2404
        out_file = output_files[out_file_index];
2405
        in_file = input_files[in_file_index];
2406

    
2407

    
2408
        mtag=NULL;
2409
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2410
            av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2411
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2412
                                    in_file->iformat->metadata_conv);
2413
    }
2414

    
2415
    /* copy chapters from the first input file that has them*/
2416
    for (i = 0; i < nb_input_files; i++) {
2417
        if (!input_files[i]->nb_chapters)
2418
            continue;
2419

    
2420
        for (j = 0; j < nb_output_files; j++)
2421
            if ((ret = copy_chapters(i, j)) < 0)
2422
                goto dump_format;
2423
    }
2424

    
2425
    /* open files and write file headers */
2426
    for(i=0;i<nb_output_files;i++) {
2427
        os = output_files[i];
2428
        if (av_write_header(os) < 0) {
2429
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2430
            ret = AVERROR(EINVAL);
2431
            goto dump_format;
2432
        }
2433
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2434
            want_sdp = 0;
2435
        }
2436
    }
2437

    
2438
 dump_format:
2439
    /* dump the file output parameters - cannot be done before in case
2440
       of stream copy */
2441
    for(i=0;i<nb_output_files;i++) {
2442
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2443
    }
2444

    
2445
    /* dump the stream mapping */
2446
    if (verbose >= 0) {
2447
        fprintf(stderr, "Stream mapping:\n");
2448
        for(i=0;i<nb_ostreams;i++) {
2449
            ost = ost_table[i];
2450
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2451
                    ist_table[ost->source_index]->file_index,
2452
                    ist_table[ost->source_index]->index,
2453
                    ost->file_index,
2454
                    ost->index);
2455
            if (ost->sync_ist != ist_table[ost->source_index])
2456
                fprintf(stderr, " [sync #%d.%d]",
2457
                        ost->sync_ist->file_index,
2458
                        ost->sync_ist->index);
2459
            fprintf(stderr, "\n");
2460
        }
2461
    }
2462

    
2463
    if (ret) {
2464
        fprintf(stderr, "%s\n", error);
2465
        goto fail;
2466
    }
2467

    
2468
    if (want_sdp) {
2469
        print_sdp(output_files, nb_output_files);
2470
    }
2471

    
2472
    if (!using_stdin && verbose >= 0) {
2473
        fprintf(stderr, "Press [q] to stop encoding\n");
2474
        url_set_interrupt_cb(decode_interrupt_cb);
2475
    }
2476
    term_init();
2477

    
2478
    timer_start = av_gettime();
2479

    
2480
    for(; received_sigterm == 0;) {
2481
        int file_index, ist_index;
2482
        AVPacket pkt;
2483
        double ipts_min;
2484
        double opts_min;
2485

    
2486
    redo:
2487
        ipts_min= 1e100;
2488
        opts_min= 1e100;
2489
        /* if 'q' pressed, exits */
2490
        if (!using_stdin) {
2491
            if (q_pressed)
2492
                break;
2493
            /* read_key() returns 0 on EOF */
2494
            key = read_key();
2495
            if (key == 'q')
2496
                break;
2497
        }
2498

    
2499
        /* select the stream that we must read now by looking at the
2500
           smallest output pts */
2501
        file_index = -1;
2502
        for(i=0;i<nb_ostreams;i++) {
2503
            double ipts, opts;
2504
            ost = ost_table[i];
2505
            os = output_files[ost->file_index];
2506
            ist = ist_table[ost->source_index];
2507
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2508
                continue;
2509
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2510
            ipts = (double)ist->pts;
2511
            if (!file_table[ist->file_index].eof_reached){
2512
                if(ipts < ipts_min) {
2513
                    ipts_min = ipts;
2514
                    if(input_sync ) file_index = ist->file_index;
2515
                }
2516
                if(opts < opts_min) {
2517
                    opts_min = opts;
2518
                    if(!input_sync) file_index = ist->file_index;
2519
                }
2520
            }
2521
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2522
                file_index= -1;
2523
                break;
2524
            }
2525
        }
2526
        /* if none, if is finished */
2527
        if (file_index < 0) {
2528
            if(no_packet_count){
2529
                no_packet_count=0;
2530
                memset(no_packet, 0, sizeof(no_packet));
2531
                usleep(10000);
2532
                continue;
2533
            }
2534
            break;
2535
        }
2536

    
2537
        /* finish if limit size exhausted */
2538
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2539
            break;
2540

    
2541
        /* read a frame from it and output it in the fifo */
2542
        is = input_files[file_index];
2543
        ret= av_read_frame(is, &pkt);
2544
        if(ret == AVERROR(EAGAIN)){
2545
            no_packet[file_index]=1;
2546
            no_packet_count++;
2547
            continue;
2548
        }
2549
        if (ret < 0) {
2550
            file_table[file_index].eof_reached = 1;
2551
            if (opt_shortest)
2552
                break;
2553
            else
2554
                continue;
2555
        }
2556

    
2557
        no_packet_count=0;
2558
        memset(no_packet, 0, sizeof(no_packet));
2559

    
2560
        if (do_pkt_dump) {
2561
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2562
        }
2563
        /* the following test is needed in case new streams appear
2564
           dynamically in stream : we ignore them */
2565
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2566
            goto discard_packet;
2567
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2568
        ist = ist_table[ist_index];
2569
        if (ist->discard)
2570
            goto discard_packet;
2571

    
2572
        if (pkt.dts != AV_NOPTS_VALUE)
2573
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2574
        if (pkt.pts != AV_NOPTS_VALUE)
2575
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2576

    
2577
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2578
            if(pkt.pts != AV_NOPTS_VALUE)
2579
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2580
            if(pkt.dts != AV_NOPTS_VALUE)
2581
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2582
        }
2583

    
2584
//        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);
2585
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2586
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2587
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2588
            int64_t delta= pkt_dts - ist->next_pts;
2589
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2590
                input_files_ts_offset[ist->file_index]-= delta;
2591
                if (verbose > 2)
2592
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2593
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2594
                if(pkt.pts != AV_NOPTS_VALUE)
2595
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2596
            }
2597
        }
2598

    
2599
        /* finish if recording time exhausted */
2600
        if (recording_time != INT64_MAX &&
2601
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2602
            ist->is_past_recording_time = 1;
2603
            goto discard_packet;
2604
        }
2605

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

    
2609
            if (verbose >= 0)
2610
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2611
                        ist->file_index, ist->index);
2612
            if (exit_on_error)
2613
                av_exit(1);
2614
            av_free_packet(&pkt);
2615
            goto redo;
2616
        }
2617

    
2618
    discard_packet:
2619
        av_free_packet(&pkt);
2620

    
2621
        /* dump report by using the output first video and audio streams */
2622
        print_report(output_files, ost_table, nb_ostreams, 0);
2623
    }
2624

    
2625
    /* at the end of stream, we must flush the decoder buffers */
2626
    for(i=0;i<nb_istreams;i++) {
2627
        ist = ist_table[i];
2628
        if (ist->decoding_needed) {
2629
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2630
        }
2631
    }
2632

    
2633
    term_exit();
2634

    
2635
    /* write the trailer if needed and close file */
2636
    for(i=0;i<nb_output_files;i++) {
2637
        os = output_files[i];
2638
        av_write_trailer(os);
2639
    }
2640

    
2641
    /* dump report by using the first video and audio streams */
2642
    print_report(output_files, ost_table, nb_ostreams, 1);
2643

    
2644
    /* close each encoder */
2645
    for(i=0;i<nb_ostreams;i++) {
2646
        ost = ost_table[i];
2647
        if (ost->encoding_needed) {
2648
            av_freep(&ost->st->codec->stats_in);
2649
            avcodec_close(ost->st->codec);
2650
        }
2651
    }
2652

    
2653
    /* close each decoder */
2654
    for(i=0;i<nb_istreams;i++) {
2655
        ist = ist_table[i];
2656
        if (ist->decoding_needed) {
2657
            avcodec_close(ist->st->codec);
2658
        }
2659
    }
2660
#if CONFIG_AVFILTER
2661
    if (graph) {
2662
        avfilter_graph_destroy(graph);
2663
        av_freep(&graph);
2664
    }
2665
#endif
2666

    
2667
    /* finished ! */
2668
    ret = 0;
2669

    
2670
 fail:
2671
    av_freep(&bit_buffer);
2672
    av_free(file_table);
2673

    
2674
    if (ist_table) {
2675
        for(i=0;i<nb_istreams;i++) {
2676
            ist = ist_table[i];
2677
            av_free(ist);
2678
        }
2679
        av_free(ist_table);
2680
    }
2681
    if (ost_table) {
2682
        for(i=0;i<nb_ostreams;i++) {
2683
            ost = ost_table[i];
2684
            if (ost) {
2685
                if (ost->logfile) {
2686
                    fclose(ost->logfile);
2687
                    ost->logfile = NULL;
2688
                }
2689
                av_fifo_free(ost->fifo); /* works even if fifo is not
2690
                                             initialized but set to zero */
2691
                av_free(ost->pict_tmp.data[0]);
2692
                if (ost->video_resample)
2693
                    sws_freeContext(ost->img_resample_ctx);
2694
                if (ost->resample)
2695
                    audio_resample_close(ost->resample);
2696
                if (ost->reformat_ctx)
2697
                    av_audio_convert_free(ost->reformat_ctx);
2698
                av_free(ost);
2699
            }
2700
        }
2701
        av_free(ost_table);
2702
    }
2703
    return ret;
2704
}
2705

    
2706
static void opt_format(const char *arg)
2707
{
2708
    /* compatibility stuff for pgmyuv */
2709
    if (!strcmp(arg, "pgmyuv")) {
2710
        pgmyuv_compatibility_hack=1;
2711
//        opt_image_format(arg);
2712
        arg = "image2";
2713
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2714
    }
2715

    
2716
    last_asked_format = arg;
2717
}
2718

    
2719
static void opt_video_rc_override_string(const char *arg)
2720
{
2721
    video_rc_override_string = arg;
2722
}
2723

    
2724
static int opt_me_threshold(const char *opt, const char *arg)
2725
{
2726
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2727
    return 0;
2728
}
2729

    
2730
static int opt_verbose(const char *opt, const char *arg)
2731
{
2732
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2733
    return 0;
2734
}
2735

    
2736
static int opt_frame_rate(const char *opt, const char *arg)
2737
{
2738
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2739
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2740
        av_exit(1);
2741
    }
2742
    return 0;
2743
}
2744

    
2745
static int opt_bitrate(const char *opt, const char *arg)
2746
{
2747
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2748

    
2749
    opt_default(opt, arg);
2750

    
2751
    if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2752
        fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2753

    
2754
    return 0;
2755
}
2756

    
2757
static void opt_frame_crop_top(const char *arg)
2758
{
2759
    frame_topBand = atoi(arg);
2760
    if (frame_topBand < 0) {
2761
        fprintf(stderr, "Incorrect top crop size\n");
2762
        av_exit(1);
2763
    }
2764
    if ((frame_topBand) >= frame_height){
2765
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2766
        av_exit(1);
2767
    }
2768
    frame_height -= frame_topBand;
2769
}
2770

    
2771
static void opt_frame_crop_bottom(const char *arg)
2772
{
2773
    frame_bottomBand = atoi(arg);
2774
    if (frame_bottomBand < 0) {
2775
        fprintf(stderr, "Incorrect bottom crop size\n");
2776
        av_exit(1);
2777
    }
2778
    if ((frame_bottomBand) >= frame_height){
2779
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2780
        av_exit(1);
2781
    }
2782
    frame_height -= frame_bottomBand;
2783
}
2784

    
2785
static void opt_frame_crop_left(const char *arg)
2786
{
2787
    frame_leftBand = atoi(arg);
2788
    if (frame_leftBand < 0) {
2789
        fprintf(stderr, "Incorrect left crop size\n");
2790
        av_exit(1);
2791
    }
2792
    if ((frame_leftBand) >= frame_width){
2793
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2794
        av_exit(1);
2795
    }
2796
    frame_width -= frame_leftBand;
2797
}
2798

    
2799
static void opt_frame_crop_right(const char *arg)
2800
{
2801
    frame_rightBand = atoi(arg);
2802
    if (frame_rightBand < 0) {
2803
        fprintf(stderr, "Incorrect right crop size\n");
2804
        av_exit(1);
2805
    }
2806
    if ((frame_rightBand) >= frame_width){
2807
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2808
        av_exit(1);
2809
    }
2810
    frame_width -= frame_rightBand;
2811
}
2812

    
2813
static void opt_frame_size(const char *arg)
2814
{
2815
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2816
        fprintf(stderr, "Incorrect frame size\n");
2817
        av_exit(1);
2818
    }
2819
}
2820

    
2821
static void opt_pad(const char *arg) {
2822
    fprintf(stderr, "Please use vfilters=pad\n");
2823
    av_exit(1);
2824
}
2825

    
2826
static void opt_frame_pix_fmt(const char *arg)
2827
{
2828
    if (strcmp(arg, "list")) {
2829
        frame_pix_fmt = av_get_pix_fmt(arg);
2830
        if (frame_pix_fmt == PIX_FMT_NONE) {
2831
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2832
            av_exit(1);
2833
        }
2834
    } else {
2835
        show_pix_fmts();
2836
        av_exit(0);
2837
    }
2838
}
2839

    
2840
static void opt_frame_aspect_ratio(const char *arg)
2841
{
2842
    int x = 0, y = 0;
2843
    double ar = 0;
2844
    const char *p;
2845
    char *end;
2846

    
2847
    p = strchr(arg, ':');
2848
    if (p) {
2849
        x = strtol(arg, &end, 10);
2850
        if (end == p)
2851
            y = strtol(end+1, &end, 10);
2852
        if (x > 0 && y > 0)
2853
            ar = (double)x / (double)y;
2854
    } else
2855
        ar = strtod(arg, NULL);
2856

    
2857
    if (!ar) {
2858
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2859
        av_exit(1);
2860
    }
2861
    frame_aspect_ratio = ar;
2862
}
2863

    
2864
static int opt_metadata(const char *opt, const char *arg)
2865
{
2866
    char *mid= strchr(arg, '=');
2867

    
2868
    if(!mid){
2869
        fprintf(stderr, "Missing =\n");
2870
        av_exit(1);
2871
    }
2872
    *mid++= 0;
2873

    
2874
    metadata_count++;
2875
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2876
    metadata[metadata_count-1].key  = av_strdup(arg);
2877
    metadata[metadata_count-1].value= av_strdup(mid);
2878

    
2879
    return 0;
2880
}
2881

    
2882
static void opt_qscale(const char *arg)
2883
{
2884
    video_qscale = atof(arg);
2885
    if (video_qscale <= 0 ||
2886
        video_qscale > 255) {
2887
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2888
        av_exit(1);
2889
    }
2890
}
2891

    
2892
static void opt_top_field_first(const char *arg)
2893
{
2894
    top_field_first= atoi(arg);
2895
}
2896

    
2897
static int opt_thread_count(const char *opt, const char *arg)
2898
{
2899
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2900
#if !HAVE_THREADS
2901
    if (verbose >= 0)
2902
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2903
#endif
2904
    return 0;
2905
}
2906

    
2907
static void opt_audio_sample_fmt(const char *arg)
2908
{
2909
    if (strcmp(arg, "list"))
2910
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2911
    else {
2912
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2913
        av_exit(0);
2914
    }
2915
}
2916

    
2917
static int opt_audio_rate(const char *opt, const char *arg)
2918
{
2919
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2920
    return 0;
2921
}
2922

    
2923
static int opt_audio_channels(const char *opt, const char *arg)
2924
{
2925
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2926
    return 0;
2927
}
2928

    
2929
static void opt_video_channel(const char *arg)
2930
{
2931
    video_channel = strtol(arg, NULL, 0);
2932
}
2933

    
2934
static void opt_video_standard(const char *arg)
2935
{
2936
    video_standard = av_strdup(arg);
2937
}
2938

    
2939
static void opt_codec(int *pstream_copy, char **pcodec_name,
2940
                      int codec_type, const char *arg)
2941
{
2942
    av_freep(pcodec_name);
2943
    if (!strcmp(arg, "copy")) {
2944
        *pstream_copy = 1;
2945
    } else {
2946
        *pcodec_name = av_strdup(arg);
2947
    }
2948
}
2949

    
2950
static void opt_audio_codec(const char *arg)
2951
{
2952
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2953
}
2954

    
2955
static void opt_audio_tag(const char *arg)
2956
{
2957
    char *tail;
2958
    audio_codec_tag= strtol(arg, &tail, 0);
2959

    
2960
    if(!tail || *tail)
2961
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2962
}
2963

    
2964
static void opt_video_tag(const char *arg)
2965
{
2966
    char *tail;
2967
    video_codec_tag= strtol(arg, &tail, 0);
2968

    
2969
    if(!tail || *tail)
2970
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2971
}
2972

    
2973
static void opt_video_codec(const char *arg)
2974
{
2975
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2976
}
2977

    
2978
static void opt_subtitle_codec(const char *arg)
2979
{
2980
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2981
}
2982

    
2983
static void opt_subtitle_tag(const char *arg)
2984
{
2985
    char *tail;
2986
    subtitle_codec_tag= strtol(arg, &tail, 0);
2987

    
2988
    if(!tail || *tail)
2989
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2990
}
2991

    
2992
static void opt_map(const char *arg)
2993
{
2994
    AVStreamMap *m;
2995
    char *p;
2996

    
2997
    m = &stream_maps[nb_stream_maps++];
2998

    
2999
    m->file_index = strtol(arg, &p, 0);
3000
    if (*p)
3001
        p++;
3002

    
3003
    m->stream_index = strtol(p, &p, 0);
3004
    if (*p) {
3005
        p++;
3006
        m->sync_file_index = strtol(p, &p, 0);
3007
        if (*p)
3008
            p++;
3009
        m->sync_stream_index = strtol(p, &p, 0);
3010
    } else {
3011
        m->sync_file_index = m->file_index;
3012
        m->sync_stream_index = m->stream_index;
3013
    }
3014
}
3015

    
3016
static void opt_map_meta_data(const char *arg)
3017
{
3018
    AVMetaDataMap *m;
3019
    char *p;
3020

    
3021
    m = &meta_data_maps[nb_meta_data_maps++];
3022

    
3023
    m->out_file = strtol(arg, &p, 0);
3024
    if (*p)
3025
        p++;
3026

    
3027
    m->in_file = strtol(p, &p, 0);
3028
}
3029

    
3030
static void opt_input_ts_scale(const char *arg)
3031
{
3032
    unsigned int stream;
3033
    double scale;
3034
    char *p;
3035

    
3036
    stream = strtol(arg, &p, 0);
3037
    if (*p)
3038
        p++;
3039
    scale= strtod(p, &p);
3040

    
3041
    if(stream >= MAX_STREAMS)
3042
        av_exit(1);
3043

    
3044
    input_files_ts_scale[nb_input_files][stream]= scale;
3045
}
3046

    
3047
static int opt_recording_time(const char *opt, const char *arg)
3048
{
3049
    recording_time = parse_time_or_die(opt, arg, 1);
3050
    return 0;
3051
}
3052

    
3053
static int opt_start_time(const char *opt, const char *arg)
3054
{
3055
    start_time = parse_time_or_die(opt, arg, 1);
3056
    return 0;
3057
}
3058

    
3059
static int opt_rec_timestamp(const char *opt, const char *arg)
3060
{
3061
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3062
    return 0;
3063
}
3064

    
3065
static int opt_input_ts_offset(const char *opt, const char *arg)
3066
{
3067
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3068
    return 0;
3069
}
3070

    
3071
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3072
{
3073
    const char *codec_string = encoder ? "encoder" : "decoder";
3074
    AVCodec *codec;
3075

    
3076
    if(!name)
3077
        return CODEC_ID_NONE;
3078
    codec = encoder ?
3079
        avcodec_find_encoder_by_name(name) :
3080
        avcodec_find_decoder_by_name(name);
3081
    if(!codec) {
3082
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3083
        av_exit(1);
3084
    }
3085
    if(codec->type != type) {
3086
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3087
        av_exit(1);
3088
    }
3089
    return codec->id;
3090
}
3091

    
3092
static void opt_input_file(const char *filename)
3093
{
3094
    AVFormatContext *ic;
3095
    AVFormatParameters params, *ap = &params;
3096
    AVInputFormat *file_iformat = NULL;
3097
    int err, i, ret, rfps, rfps_base;
3098
    int64_t timestamp;
3099

    
3100
    if (last_asked_format) {
3101
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3102
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3103
            av_exit(1);
3104
        }
3105
        last_asked_format = NULL;
3106
    }
3107

    
3108
    if (!strcmp(filename, "-"))
3109
        filename = "pipe:";
3110

    
3111
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3112
                    !strcmp(filename, "/dev/stdin");
3113

    
3114
    /* get default parameters from command line */
3115
    ic = avformat_alloc_context();
3116
    if (!ic) {
3117
        print_error(filename, AVERROR(ENOMEM));
3118
        av_exit(1);
3119
    }
3120

    
3121
    memset(ap, 0, sizeof(*ap));
3122
    ap->prealloced_context = 1;
3123
    ap->sample_rate = audio_sample_rate;
3124
    ap->channels = audio_channels;
3125
    ap->time_base.den = frame_rate.num;
3126
    ap->time_base.num = frame_rate.den;
3127
    ap->width = frame_width;
3128
    ap->height = frame_height;
3129
    ap->pix_fmt = frame_pix_fmt;
3130
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3131
    ap->channel = video_channel;
3132
    ap->standard = video_standard;
3133

    
3134
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3135

    
3136
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
3137
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
3138
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3139
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3140

    
3141
    if(pgmyuv_compatibility_hack)
3142
        ic->video_codec_id= CODEC_ID_PGMYUV;
3143

    
3144
    /* open the input file with generic libav function */
3145
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3146
    if (err < 0) {
3147
        print_error(filename, err);
3148
        av_exit(1);
3149
    }
3150
    if(opt_programid) {
3151
        int i, j;
3152
        int found=0;
3153
        for(i=0; i<ic->nb_streams; i++){
3154
            ic->streams[i]->discard= AVDISCARD_ALL;
3155
        }
3156
        for(i=0; i<ic->nb_programs; i++){
3157
            AVProgram *p= ic->programs[i];
3158
            if(p->id != opt_programid){
3159
                p->discard = AVDISCARD_ALL;
3160
            }else{
3161
                found=1;
3162
                for(j=0; j<p->nb_stream_indexes; j++){
3163
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3164
                }
3165
            }
3166
        }
3167
        if(!found){
3168
            fprintf(stderr, "Specified program id not found\n");
3169
            av_exit(1);
3170
        }
3171
        opt_programid=0;
3172
    }
3173

    
3174
    ic->loop_input = loop_input;
3175

    
3176
    /* If not enough info to get the stream parameters, we decode the
3177
       first frames to get it. (used in mpeg case for example) */
3178
    ret = av_find_stream_info(ic);
3179
    if (ret < 0 && verbose >= 0) {
3180
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3181
        av_exit(1);
3182
    }
3183

    
3184
    timestamp = start_time;
3185
    /* add the stream start time */
3186
    if (ic->start_time != AV_NOPTS_VALUE)
3187
        timestamp += ic->start_time;
3188

    
3189
    /* if seeking requested, we execute it */
3190
    if (start_time != 0) {
3191
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3192
        if (ret < 0) {
3193
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3194
                    filename, (double)timestamp / AV_TIME_BASE);
3195
        }
3196
        /* reset seek info */
3197
        start_time = 0;
3198
    }
3199

    
3200
    /* update the current parameters so that they match the one of the input stream */
3201
    for(i=0;i<ic->nb_streams;i++) {
3202
        AVStream *st = ic->streams[i];
3203
        AVCodecContext *enc = st->codec;
3204
        avcodec_thread_init(enc, thread_count);
3205
        switch(enc->codec_type) {
3206
        case AVMEDIA_TYPE_AUDIO:
3207
            set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3208
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3209
            channel_layout = enc->channel_layout;
3210
            audio_channels = enc->channels;
3211
            audio_sample_rate = enc->sample_rate;
3212
            audio_sample_fmt = enc->sample_fmt;
3213
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3214
            if(audio_disable)
3215
                st->discard= AVDISCARD_ALL;
3216
            break;
3217
        case AVMEDIA_TYPE_VIDEO:
3218
            set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3219
            frame_height = enc->height;
3220
            frame_width = enc->width;
3221
            if(ic->streams[i]->sample_aspect_ratio.num)
3222
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3223
            else
3224
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
3225
            frame_aspect_ratio *= (float) enc->width / enc->height;
3226
            frame_pix_fmt = enc->pix_fmt;
3227
            rfps      = ic->streams[i]->r_frame_rate.num;
3228
            rfps_base = ic->streams[i]->r_frame_rate.den;
3229
            if(enc->lowres) {
3230
                enc->flags |= CODEC_FLAG_EMU_EDGE;
3231
                frame_height >>= enc->lowres;
3232
                frame_width  >>= enc->lowres;
3233
            }
3234
            if(me_threshold)
3235
                enc->debug |= FF_DEBUG_MV;
3236

    
3237
            if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) {
3238

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

    
3243
                    (float)rfps / rfps_base, rfps, rfps_base);
3244
            }
3245
            /* update the current frame rate to match the stream frame rate */
3246
            frame_rate.num = rfps;
3247
            frame_rate.den = rfps_base;
3248

    
3249
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3250
            if(video_disable)
3251
                st->discard= AVDISCARD_ALL;
3252
            else if(video_discard)
3253
                st->discard= video_discard;
3254
            break;
3255
        case AVMEDIA_TYPE_DATA:
3256
            break;
3257
        case AVMEDIA_TYPE_SUBTITLE:
3258
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3259
            if(subtitle_disable)
3260
                st->discard = AVDISCARD_ALL;
3261
            break;
3262
        case AVMEDIA_TYPE_ATTACHMENT:
3263
        case AVMEDIA_TYPE_UNKNOWN:
3264
            nb_icodecs++;
3265
            break;
3266
        default:
3267
            abort();
3268
        }
3269
    }
3270

    
3271
    input_files[nb_input_files] = ic;
3272
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3273
    /* dump the file content */
3274
    if (verbose >= 0)
3275
        dump_format(ic, nb_input_files, filename, 0);
3276

    
3277
    nb_input_files++;
3278

    
3279
    video_channel = 0;
3280

    
3281
    av_freep(&video_codec_name);
3282
    av_freep(&audio_codec_name);
3283
    av_freep(&subtitle_codec_name);
3284
}
3285

    
3286
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3287
                                         int *has_subtitle_ptr)
3288
{
3289
    int has_video, has_audio, has_subtitle, i, j;
3290
    AVFormatContext *ic;
3291

    
3292
    has_video = 0;
3293
    has_audio = 0;
3294
    has_subtitle = 0;
3295
    for(j=0;j<nb_input_files;j++) {
3296
        ic = input_files[j];
3297
        for(i=0;i<ic->nb_streams;i++) {
3298
            AVCodecContext *enc = ic->streams[i]->codec;
3299
            switch(enc->codec_type) {
3300
            case AVMEDIA_TYPE_AUDIO:
3301
                has_audio = 1;
3302
                break;
3303
            case AVMEDIA_TYPE_VIDEO:
3304
                has_video = 1;
3305
                break;
3306
            case AVMEDIA_TYPE_SUBTITLE:
3307
                has_subtitle = 1;
3308
                break;
3309
            case AVMEDIA_TYPE_DATA:
3310
            case AVMEDIA_TYPE_ATTACHMENT:
3311
            case AVMEDIA_TYPE_UNKNOWN:
3312
                break;
3313
            default:
3314
                abort();
3315
            }
3316
        }
3317
    }
3318
    *has_video_ptr = has_video;
3319
    *has_audio_ptr = has_audio;
3320
    *has_subtitle_ptr = has_subtitle;
3321
}
3322

    
3323
static void new_video_stream(AVFormatContext *oc)
3324
{
3325
    AVStream *st;
3326
    AVCodecContext *video_enc;
3327
    enum CodecID codec_id;
3328

    
3329
    st = av_new_stream(oc, oc->nb_streams);
3330
    if (!st) {
3331
        fprintf(stderr, "Could not alloc stream\n");
3332
        av_exit(1);
3333
    }
3334
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3335
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3336
    video_bitstream_filters= NULL;
3337

    
3338
    avcodec_thread_init(st->codec, thread_count);
3339

    
3340
    video_enc = st->codec;
3341

    
3342
    if(video_codec_tag)
3343
        video_enc->codec_tag= video_codec_tag;
3344

    
3345
    if(   (video_global_header&1)
3346
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3347
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3348
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3349
    }
3350
    if(video_global_header&2){
3351
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3352
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3353
    }
3354

    
3355
    if (video_stream_copy) {
3356
        st->stream_copy = 1;
3357
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3358
        video_enc->sample_aspect_ratio =
3359
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3360
    } else {
3361
        const char *p;
3362
        int i;
3363
        AVCodec *codec;
3364
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3365

    
3366
        if (video_codec_name) {
3367
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3368
            codec = avcodec_find_encoder_by_name(video_codec_name);
3369
            output_codecs[nb_ocodecs] = codec;
3370
        } else {
3371
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3372
            codec = avcodec_find_encoder(codec_id);
3373
        }
3374

    
3375
        video_enc->codec_id = codec_id;
3376

    
3377
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3378

    
3379
        if (codec && codec->supported_framerates && !force_fps)
3380
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3381
        video_enc->time_base.den = fps.num;
3382
        video_enc->time_base.num = fps.den;
3383

    
3384
        video_enc->width = frame_width;
3385
        video_enc->height = frame_height;
3386
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3387
        video_enc->pix_fmt = frame_pix_fmt;
3388
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3389

    
3390
        choose_pixel_fmt(st, codec);
3391

    
3392
        if (intra_only)
3393
            video_enc->gop_size = 0;
3394
        if (video_qscale || same_quality) {
3395
            video_enc->flags |= CODEC_FLAG_QSCALE;
3396
            video_enc->global_quality=
3397
                st->quality = FF_QP2LAMBDA * video_qscale;
3398
        }
3399

    
3400
        if(intra_matrix)
3401
            video_enc->intra_matrix = intra_matrix;
3402
        if(inter_matrix)
3403
            video_enc->inter_matrix = inter_matrix;
3404

    
3405
        p= video_rc_override_string;
3406
        for(i=0; p; i++){
3407
            int start, end, q;
3408
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3409
            if(e!=3){
3410
                fprintf(stderr, "error parsing rc_override\n");
3411
                av_exit(1);
3412
            }
3413
            video_enc->rc_override=
3414
                av_realloc(video_enc->rc_override,
3415
                           sizeof(RcOverride)*(i+1));
3416
            video_enc->rc_override[i].start_frame= start;
3417
            video_enc->rc_override[i].end_frame  = end;
3418
            if(q>0){
3419
                video_enc->rc_override[i].qscale= q;
3420
                video_enc->rc_override[i].quality_factor= 1.0;
3421
            }
3422
            else{
3423
                video_enc->rc_override[i].qscale= 0;
3424
                video_enc->rc_override[i].quality_factor= -q/100.0;
3425
            }
3426
            p= strchr(p, '/');
3427
            if(p) p++;
3428
        }
3429
        video_enc->rc_override_count=i;
3430
        if (!video_enc->rc_initial_buffer_occupancy)
3431
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3432
        video_enc->me_threshold= me_threshold;
3433
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3434

    
3435
        if (do_psnr)
3436
            video_enc->flags|= CODEC_FLAG_PSNR;
3437

    
3438
        /* two pass mode */
3439
        if (do_pass) {
3440
            if (do_pass == 1) {
3441
                video_enc->flags |= CODEC_FLAG_PASS1;
3442
            } else {
3443
                video_enc->flags |= CODEC_FLAG_PASS2;
3444
            }
3445
        }
3446
    }
3447
    nb_ocodecs++;
3448
    if (video_language) {
3449
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3450
        av_freep(&video_language);
3451
    }
3452

    
3453
    /* reset some key parameters */
3454
    video_disable = 0;
3455
    av_freep(&video_codec_name);
3456
    video_stream_copy = 0;
3457
    frame_pix_fmt = PIX_FMT_NONE;
3458
}
3459

    
3460
static void new_audio_stream(AVFormatContext *oc)
3461
{
3462
    AVStream *st;
3463
    AVCodecContext *audio_enc;
3464
    enum CodecID codec_id;
3465

    
3466
    st = av_new_stream(oc, oc->nb_streams);
3467
    if (!st) {
3468
        fprintf(stderr, "Could not alloc stream\n");
3469
        av_exit(1);
3470
    }
3471
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3472

    
3473
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3474
    audio_bitstream_filters= NULL;
3475

    
3476
    avcodec_thread_init(st->codec, thread_count);
3477

    
3478
    audio_enc = st->codec;
3479
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3480

    
3481
    if(audio_codec_tag)
3482
        audio_enc->codec_tag= audio_codec_tag;
3483

    
3484
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3485
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3486
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3487
    }
3488
    if (audio_stream_copy) {
3489
        st->stream_copy = 1;
3490
        audio_enc->channels = audio_channels;
3491
        audio_enc->sample_rate = audio_sample_rate;
3492
    } else {
3493
        AVCodec *codec;
3494

    
3495
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3496

    
3497
        if (audio_codec_name) {
3498
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3499
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3500
            output_codecs[nb_ocodecs] = codec;
3501
        } else {
3502
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3503
            codec = avcodec_find_encoder(codec_id);
3504
        }
3505
        audio_enc->codec_id = codec_id;
3506

    
3507
        if (audio_qscale > QSCALE_NONE) {
3508
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3509
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3510
        }
3511
        audio_enc->channels = audio_channels;
3512
        audio_enc->sample_fmt = audio_sample_fmt;
3513
        audio_enc->sample_rate = audio_sample_rate;
3514
        audio_enc->channel_layout = channel_layout;
3515
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3516
            audio_enc->channel_layout = 0;
3517
        choose_sample_fmt(st, codec);
3518
        choose_sample_rate(st, codec);
3519
    }
3520
    nb_ocodecs++;
3521
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3522
    if (audio_language) {
3523
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3524
        av_freep(&audio_language);
3525
    }
3526

    
3527
    /* reset some key parameters */
3528
    audio_disable = 0;
3529
    av_freep(&audio_codec_name);
3530
    audio_stream_copy = 0;
3531
}
3532

    
3533
static void new_subtitle_stream(AVFormatContext *oc)
3534
{
3535
    AVStream *st;
3536
    AVCodecContext *subtitle_enc;
3537

    
3538
    st = av_new_stream(oc, oc->nb_streams);
3539
    if (!st) {
3540
        fprintf(stderr, "Could not alloc stream\n");
3541
        av_exit(1);
3542
    }
3543
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3544

    
3545
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3546
    subtitle_bitstream_filters= NULL;
3547

    
3548
    subtitle_enc = st->codec;
3549
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3550

    
3551
    if(subtitle_codec_tag)
3552
        subtitle_enc->codec_tag= subtitle_codec_tag;
3553

    
3554
    if (subtitle_stream_copy) {
3555
        st->stream_copy = 1;
3556
    } else {
3557
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3558
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3559
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3560
    }
3561
    nb_ocodecs++;
3562

    
3563
    if (subtitle_language) {
3564
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3565
        av_freep(&subtitle_language);
3566
    }
3567

    
3568
    subtitle_disable = 0;
3569
    av_freep(&subtitle_codec_name);
3570
    subtitle_stream_copy = 0;
3571
}
3572

    
3573
static void opt_new_audio_stream(void)
3574
{
3575
    AVFormatContext *oc;
3576
    if (nb_output_files <= 0) {
3577
        fprintf(stderr, "At least one output file must be specified\n");
3578
        av_exit(1);
3579
    }
3580
    oc = output_files[nb_output_files - 1];
3581
    new_audio_stream(oc);
3582
}
3583

    
3584
static void opt_new_video_stream(void)
3585
{
3586
    AVFormatContext *oc;
3587
    if (nb_output_files <= 0) {
3588
        fprintf(stderr, "At least one output file must be specified\n");
3589
        av_exit(1);
3590
    }
3591
    oc = output_files[nb_output_files - 1];
3592
    new_video_stream(oc);
3593
}
3594

    
3595
static void opt_new_subtitle_stream(void)
3596
{
3597
    AVFormatContext *oc;
3598
    if (nb_output_files <= 0) {
3599
        fprintf(stderr, "At least one output file must be specified\n");
3600
        av_exit(1);
3601
    }
3602
    oc = output_files[nb_output_files - 1];
3603
    new_subtitle_stream(oc);
3604
}
3605

    
3606
static void opt_output_file(const char *filename)
3607
{
3608
    AVFormatContext *oc;
3609
    int err, use_video, use_audio, use_subtitle;
3610
    int input_has_video, input_has_audio, input_has_subtitle;
3611
    AVFormatParameters params, *ap = &params;
3612
    AVOutputFormat *file_oformat;
3613

    
3614
    if (!strcmp(filename, "-"))
3615
        filename = "pipe:";
3616

    
3617
    oc = avformat_alloc_context();
3618
    if (!oc) {
3619
        print_error(filename, AVERROR(ENOMEM));
3620
        av_exit(1);
3621
    }
3622

    
3623
    if (last_asked_format) {
3624
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3625
        if (!file_oformat) {
3626
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3627
            av_exit(1);
3628
        }
3629
        last_asked_format = NULL;
3630
    } else {
3631
        file_oformat = av_guess_format(NULL, filename, NULL);
3632
        if (!file_oformat) {
3633
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3634
                    filename);
3635
            av_exit(1);
3636
        }
3637
    }
3638

    
3639
    oc->oformat = file_oformat;
3640
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3641

    
3642
    if (!strcmp(file_oformat->name, "ffm") &&
3643
        av_strstart(filename, "http:", NULL)) {
3644
        /* special case for files sent to ffserver: we get the stream
3645
           parameters from ffserver */
3646
        int err = read_ffserver_streams(oc, filename);
3647
        if (err < 0) {
3648
            print_error(filename, err);
3649
            av_exit(1);
3650
        }
3651
    } else {
3652
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3653
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3654
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3655

    
3656
        /* disable if no corresponding type found and at least one
3657
           input file */
3658
        if (nb_input_files > 0) {
3659
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3660
                                         &input_has_subtitle);
3661
            if (!input_has_video)
3662
                use_video = 0;
3663
            if (!input_has_audio)
3664
                use_audio = 0;
3665
            if (!input_has_subtitle)
3666
                use_subtitle = 0;
3667
        }
3668

    
3669
        /* manual disable */
3670
        if (audio_disable) {
3671
            use_audio = 0;
3672
        }
3673
        if (video_disable) {
3674
            use_video = 0;
3675
        }
3676
        if (subtitle_disable) {
3677
            use_subtitle = 0;
3678
        }
3679

    
3680
        if (use_video) {
3681
            new_video_stream(oc);
3682
        }
3683

    
3684
        if (use_audio) {
3685
            new_audio_stream(oc);
3686
        }
3687

    
3688
        if (use_subtitle) {
3689
            new_subtitle_stream(oc);
3690
        }
3691

    
3692
        oc->timestamp = rec_timestamp;
3693

    
3694
        for(; metadata_count>0; metadata_count--){
3695
            av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
3696
                                            metadata[metadata_count-1].value, 0);
3697
        }
3698
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3699
    }
3700

    
3701
    output_files[nb_output_files++] = oc;
3702

    
3703
    /* check filename in case of an image number is expected */
3704
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3705
        if (!av_filename_number_test(oc->filename)) {
3706
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3707
            av_exit(1);
3708
        }
3709
    }
3710

    
3711
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3712
        /* test if it already exists to avoid loosing precious files */
3713
        if (!file_overwrite &&
3714
            (strchr(filename, ':') == NULL ||
3715
             filename[1] == ':' ||
3716
             av_strstart(filename, "file:", NULL))) {
3717
            if (url_exist(filename)) {
3718
                if (!using_stdin) {
3719
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3720
                    fflush(stderr);
3721
                    if (!read_yesno()) {
3722
                        fprintf(stderr, "Not overwriting - exiting\n");
3723
                        av_exit(1);
3724
                    }
3725
                }
3726
                else {
3727
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3728
                    av_exit(1);
3729
                }
3730
            }
3731
        }
3732

    
3733
        /* open the file */
3734
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3735
            print_error(filename, err);
3736
            av_exit(1);
3737
        }
3738
    }
3739

    
3740
    memset(ap, 0, sizeof(*ap));
3741
    if (av_set_parameters(oc, ap) < 0) {
3742
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3743
                oc->filename);
3744
        av_exit(1);
3745
    }
3746

    
3747
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3748
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3749
    oc->loop_output = loop_output;
3750
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3751

    
3752
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3753
}
3754

    
3755
/* same option as mencoder */
3756
static void opt_pass(const char *pass_str)
3757
{
3758
    int pass;
3759
    pass = atoi(pass_str);
3760
    if (pass != 1 && pass != 2) {
3761
        fprintf(stderr, "pass number can be only 1 or 2\n");
3762
        av_exit(1);
3763
    }
3764
    do_pass = pass;
3765
}
3766

    
3767
static int64_t getutime(void)
3768
{
3769
#if HAVE_GETRUSAGE
3770
    struct rusage rusage;
3771

    
3772
    getrusage(RUSAGE_SELF, &rusage);
3773
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3774
#elif HAVE_GETPROCESSTIMES
3775
    HANDLE proc;
3776
    FILETIME c, e, k, u;
3777
    proc = GetCurrentProcess();
3778
    GetProcessTimes(proc, &c, &e, &k, &u);
3779
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3780
#else
3781
    return av_gettime();
3782
#endif
3783
}
3784

    
3785
static int64_t getmaxrss(void)
3786
{
3787
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3788
    struct rusage rusage;
3789
    getrusage(RUSAGE_SELF, &rusage);
3790
    return (int64_t)rusage.ru_maxrss * 1024;
3791
#elif HAVE_GETPROCESSMEMORYINFO
3792
    HANDLE proc;
3793
    PROCESS_MEMORY_COUNTERS memcounters;
3794
    proc = GetCurrentProcess();
3795
    memcounters.cb = sizeof(memcounters);
3796
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3797
    return memcounters.PeakPagefileUsage;
3798
#else
3799
    return 0;
3800
#endif
3801
}
3802

    
3803
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3804
{
3805
    int i;
3806
    const char *p = str;
3807
    for(i = 0;; i++) {
3808
        dest[i] = atoi(p);
3809
        if(i == 63)
3810
            break;
3811
        p = strchr(p, ',');
3812
        if(!p) {
3813
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3814
            av_exit(1);
3815
        }
3816
        p++;
3817
    }
3818
}
3819

    
3820
static void opt_inter_matrix(const char *arg)
3821
{
3822
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3823
    parse_matrix_coeffs(inter_matrix, arg);
3824
}
3825

    
3826
static void opt_intra_matrix(const char *arg)
3827
{
3828
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3829
    parse_matrix_coeffs(intra_matrix, arg);
3830
}
3831

    
3832
/**
3833
 * Trivial log callback.
3834
 * Only suitable for show_help and similar since it lacks prefix handling.
3835
 */
3836
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3837
{
3838
    vfprintf(stdout, fmt, vl);
3839
}
3840

    
3841
static void show_usage(void)
3842
{
3843
    printf("Hyper fast Audio and Video encoder\n");
3844
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3845
    printf("\n");
3846
}
3847

    
3848
static void show_help(void)
3849
{
3850
    av_log_set_callback(log_callback_help);
3851
    show_usage();
3852
    show_help_options(options, "Main options:\n",
3853
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3854
    show_help_options(options, "\nAdvanced options:\n",
3855
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3856
                      OPT_EXPERT);
3857
    show_help_options(options, "\nVideo options:\n",
3858
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3859
                      OPT_VIDEO);
3860
    show_help_options(options, "\nAdvanced Video options:\n",
3861
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3862
                      OPT_VIDEO | OPT_EXPERT);
3863
    show_help_options(options, "\nAudio options:\n",
3864
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3865
                      OPT_AUDIO);
3866
    show_help_options(options, "\nAdvanced Audio options:\n",
3867
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3868
                      OPT_AUDIO | OPT_EXPERT);
3869
    show_help_options(options, "\nSubtitle options:\n",
3870
                      OPT_SUBTITLE | OPT_GRAB,
3871
                      OPT_SUBTITLE);
3872
    show_help_options(options, "\nAudio/Video grab options:\n",
3873
                      OPT_GRAB,
3874
                      OPT_GRAB);
3875
    printf("\n");
3876
    av_opt_show(avcodec_opts[0], NULL);
3877
    printf("\n");
3878
    av_opt_show(avformat_opts, NULL);
3879
    printf("\n");
3880
    av_opt_show(sws_opts, NULL);
3881
}
3882

    
3883
static void opt_target(const char *arg)
3884
{
3885
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3886
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3887

    
3888
    if(!strncmp(arg, "pal-", 4)) {
3889
        norm = PAL;
3890
        arg += 4;
3891
    } else if(!strncmp(arg, "ntsc-", 5)) {
3892
        norm = NTSC;
3893
        arg += 5;
3894
    } else if(!strncmp(arg, "film-", 5)) {
3895
        norm = FILM;
3896
        arg += 5;
3897
    } else {
3898
        int fr;
3899
        /* Calculate FR via float to avoid int overflow */
3900
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3901
        if(fr == 25000) {
3902
            norm = PAL;
3903
        } else if((fr == 29970) || (fr == 23976)) {
3904
            norm = NTSC;
3905
        } else {
3906
            /* Try to determine PAL/NTSC by peeking in the input files */
3907
            if(nb_input_files) {
3908
                int i, j;
3909
                for(j = 0; j < nb_input_files; j++) {
3910
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3911
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3912
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3913
                            continue;
3914
                        fr = c->time_base.den * 1000 / c->time_base.num;
3915
                        if(fr == 25000) {
3916
                            norm = PAL;
3917
                            break;
3918
                        } else if((fr == 29970) || (fr == 23976)) {
3919
                            norm = NTSC;
3920
                            break;
3921
                        }
3922
                    }
3923
                    if(norm != UNKNOWN)
3924
                        break;
3925
                }
3926
            }
3927
        }
3928
        if(verbose && norm != UNKNOWN)
3929
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3930
    }
3931

    
3932
    if(norm == UNKNOWN) {
3933
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3934
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3935
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3936
        av_exit(1);
3937
    }
3938

    
3939
    if(!strcmp(arg, "vcd")) {
3940

    
3941
        opt_video_codec("mpeg1video");
3942
        opt_audio_codec("mp2");
3943
        opt_format("vcd");
3944

    
3945
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3946
        opt_frame_rate(NULL, frame_rates[norm]);
3947
        opt_default("g", norm == PAL ? "15" : "18");
3948

    
3949
        opt_default("b", "1150000");
3950
        opt_default("maxrate", "1150000");
3951
        opt_default("minrate", "1150000");
3952
        opt_default("bufsize", "327680"); // 40*1024*8;
3953

    
3954
        opt_default("ab", "224000");
3955
        audio_sample_rate = 44100;
3956
        audio_channels = 2;
3957

    
3958
        opt_default("packetsize", "2324");
3959
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3960

    
3961
        /* We have to offset the PTS, so that it is consistent with the SCR.
3962
           SCR starts at 36000, but the first two packs contain only padding
3963
           and the first pack from the other stream, respectively, may also have
3964
           been written before.
3965
           So the real data starts at SCR 36000+3*1200. */
3966
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3967
    } else if(!strcmp(arg, "svcd")) {
3968

    
3969
        opt_video_codec("mpeg2video");
3970
        opt_audio_codec("mp2");
3971
        opt_format("svcd");
3972

    
3973
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3974
        opt_frame_rate(NULL, frame_rates[norm]);
3975
        opt_default("g", norm == PAL ? "15" : "18");
3976

    
3977
        opt_default("b", "2040000");
3978
        opt_default("maxrate", "2516000");
3979
        opt_default("minrate", "0"); //1145000;
3980
        opt_default("bufsize", "1835008"); //224*1024*8;
3981
        opt_default("flags", "+scan_offset");
3982

    
3983

    
3984
        opt_default("ab", "224000");
3985
        audio_sample_rate = 44100;
3986

    
3987
        opt_default("packetsize", "2324");
3988

    
3989
    } else if(!strcmp(arg, "dvd")) {
3990

    
3991
        opt_video_codec("mpeg2video");
3992
        opt_audio_codec("ac3");
3993
        opt_format("dvd");
3994

    
3995
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3996
        opt_frame_rate(NULL, frame_rates[norm]);
3997
        opt_default("g", norm == PAL ? "15" : "18");
3998

    
3999
        opt_default("b", "6000000");
4000
        opt_default("maxrate", "9000000");
4001
        opt_default("minrate", "0"); //1500000;
4002
        opt_default("bufsize", "1835008"); //224*1024*8;
4003

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

    
4007
        opt_default("ab", "448000");
4008
        audio_sample_rate = 48000;
4009

    
4010
    } else if(!strncmp(arg, "dv", 2)) {
4011

    
4012
        opt_format("dv");
4013

    
4014
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4015
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4016
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4017
        opt_frame_rate(NULL, frame_rates[norm]);
4018

    
4019
        audio_sample_rate = 48000;
4020
        audio_channels = 2;
4021

    
4022
    } else {
4023
        fprintf(stderr, "Unknown target: %s\n", arg);
4024
        av_exit(1);
4025
    }
4026
}
4027

    
4028
static void opt_vstats_file (const char *arg)
4029
{
4030
    av_free (vstats_filename);
4031
    vstats_filename=av_strdup (arg);
4032
}
4033

    
4034
static void opt_vstats (void)
4035
{
4036
    char filename[40];
4037
    time_t today2 = time(NULL);
4038
    struct tm *today = localtime(&today2);
4039

    
4040
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4041
             today->tm_sec);
4042
    opt_vstats_file(filename);
4043
}
4044

    
4045
static int opt_bsf(const char *opt, const char *arg)
4046
{
4047
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4048
    AVBitStreamFilterContext **bsfp;
4049

    
4050
    if(!bsfc){
4051
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4052
        av_exit(1);
4053
    }
4054

    
4055
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4056
          *opt == 'a' ? &audio_bitstream_filters :
4057
                        &subtitle_bitstream_filters;
4058
    while(*bsfp)
4059
        bsfp= &(*bsfp)->next;
4060

    
4061
    *bsfp= bsfc;
4062

    
4063
    return 0;
4064
}
4065

    
4066
static int opt_preset(const char *opt, const char *arg)
4067
{
4068
    FILE *f=NULL;
4069
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4070
    int i;
4071
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
4072
                           getenv("HOME"),
4073
                           FFMPEG_DATADIR,
4074
                         };
4075

    
4076
    if (*opt != 'f') {
4077
        for(i=0; i<3 && !f; i++){
4078
            if(!base[i])
4079
                continue;
4080
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4081
            f= fopen(filename, "r");
4082
            if(!f){
4083
                char *codec_name= *opt == 'v' ? video_codec_name :
4084
                                  *opt == 'a' ? audio_codec_name :
4085
                                                subtitle_codec_name;
4086
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4087
                f= fopen(filename, "r");
4088
            }
4089
        }
4090
    } else {
4091
        av_strlcpy(filename, arg, sizeof(filename));
4092
        f= fopen(filename, "r");
4093
    }
4094

    
4095
    if(!f){
4096
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4097
        av_exit(1);
4098
    }
4099

    
4100
    while(!feof(f)){
4101
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4102
        if(line[0] == '#' && !e)
4103
            continue;
4104
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4105
        if(e){
4106
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4107
            av_exit(1);
4108
        }
4109
        if(!strcmp(tmp, "acodec")){
4110
            opt_audio_codec(tmp2);
4111
        }else if(!strcmp(tmp, "vcodec")){
4112
            opt_video_codec(tmp2);
4113
        }else if(!strcmp(tmp, "scodec")){
4114
            opt_subtitle_codec(tmp2);
4115
        }else if(opt_default(tmp, tmp2) < 0){
4116
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4117
            av_exit(1);
4118
        }
4119
    }
4120

    
4121
    fclose(f);
4122

    
4123
    return 0;
4124
}
4125

    
4126
static const OptionDef options[] = {
4127
    /* main options */
4128
#include "cmdutils_common_opts.h"
4129
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4130
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4131
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4132
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4133
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4134
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4135
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4136
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4137
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4138
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4139
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
4140
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4141
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4142
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4143
      "add timings for benchmarking" },
4144
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4145
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4146
      "dump each input packet" },
4147
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4148
      "when dumping packets, also dump the payload" },
4149
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4150
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4151
    { "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)", "" },
4152
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4153
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4154
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4155
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4156
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4157
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4158
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4159
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4160
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4161
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4162
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4163
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4164
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4165

    
4166
    /* video options */
4167
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4168
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4169
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4170
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4171
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4172
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4173
    { "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" },
4174
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4175
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4176
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4177
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4178
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set top pad band size (in pixels)", "size" },
4179
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set bottom pad band size (in pixels)", "size" },
4180
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set left pad band size (in pixels)", "size" },
4181
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set right pad band size (in pixels)", "size" },
4182
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4183
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4184
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4185
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4186
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4187
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4188
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4189
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4190
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4191
      "use same video quality as source (implies VBR)" },
4192
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4193
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4194
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4195
      "deinterlace pictures" },
4196
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4197
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4198
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4199
#if CONFIG_AVFILTER
4200
    { "vfilters", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4201
#endif
4202
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4203
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4204
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4205
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4206
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4207
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4208
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4209
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4210
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4211

    
4212
    /* audio options */
4213
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4214
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4215
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4216
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4217
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4218
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4219
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4220
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4221
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4222
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4223
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4224
    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4225

    
4226
    /* subtitle options */
4227
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4228
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4229
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4230
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4231
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4232

    
4233
    /* grab options */
4234
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4235
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4236
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4237

    
4238
    /* muxer options */
4239
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4240
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4241

    
4242
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4243
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4244
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4245

    
4246
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4247
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4248
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4249
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4250

    
4251
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4252
    { NULL, },
4253
};
4254

    
4255
int main(int argc, char **argv)
4256
{
4257
    int i;
4258
    int64_t ti;
4259

    
4260
    avcodec_register_all();
4261
#if CONFIG_AVDEVICE
4262
    avdevice_register_all();
4263
#endif
4264
#if CONFIG_AVFILTER
4265
    avfilter_register_all();
4266
#endif
4267
    av_register_all();
4268

    
4269
#if HAVE_ISATTY
4270
    if(isatty(STDIN_FILENO))
4271
        url_set_interrupt_cb(decode_interrupt_cb);
4272
#endif
4273

    
4274
    for(i=0; i<AVMEDIA_TYPE_NB; i++){
4275
        avcodec_opts[i]= avcodec_alloc_context2(i);
4276
    }
4277
    avformat_opts = avformat_alloc_context();
4278
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4279

    
4280
    show_banner();
4281

    
4282
    /* parse options */
4283
    parse_options(argc, argv, options, opt_output_file);
4284

    
4285
    if(nb_output_files <= 0 && nb_input_files == 0) {
4286
        show_usage();
4287
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4288
        av_exit(1);
4289
    }
4290

    
4291
    /* file converter / grab */
4292
    if (nb_output_files <= 0) {
4293
        fprintf(stderr, "At least one output file must be specified\n");
4294
        av_exit(1);
4295
    }
4296

    
4297
    if (nb_input_files == 0) {
4298
        fprintf(stderr, "At least one input file must be specified\n");
4299
        av_exit(1);
4300
    }
4301

    
4302
    ti = getutime();
4303
    if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4304
                     stream_maps, nb_stream_maps) < 0)
4305
        av_exit(1);
4306
    ti = getutime() - ti;
4307
    if (do_benchmark) {
4308
        int maxrss = getmaxrss() / 1024;
4309
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4310
    }
4311

    
4312
    return av_exit(0);
4313
}