Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 2912e87a

History | View | Annotate | Download (159 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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 "libavutil/audioconvert.h"
40
#include "libavutil/parseutils.h"
41
#include "libavutil/samplefmt.h"
42
#include "libavutil/colorspace.h"
43
#include "libavutil/fifo.h"
44
#include "libavutil/intreadwrite.h"
45
#include "libavutil/pixdesc.h"
46
#include "libavutil/avstring.h"
47
#include "libavutil/libm.h"
48
#include "libavformat/os_support.h"
49

    
50
#if CONFIG_AVFILTER
51
# include "libavfilter/avfilter.h"
52
# include "libavfilter/avfiltergraph.h"
53
# include "libavfilter/vsrc_buffer.h"
54
#endif
55

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

    
68
#if HAVE_SYS_SELECT_H
69
#include <sys/select.h>
70
#endif
71

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

    
86
const char program_name[] = "FFmpeg";
87
const int program_birth_year = 2000;
88

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

    
97
/**
98
 * select an input file for an output file
99
 */
100
typedef struct AVMetaDataMap {
101
    int  file;      //< file index
102
    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
103
    int  index;     //< stream/chapter/program number
104
} AVMetaDataMap;
105

    
106
typedef struct AVChapterMap {
107
    int in_file;
108
    int out_file;
109
} AVChapterMap;
110

    
111
static const OptionDef options[];
112

    
113
#define MAX_FILES 100
114
#if !FF_API_MAX_STREAMS
115
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
116
#endif
117

    
118
static const char *last_asked_format = NULL;
119
static AVFormatContext *input_files[MAX_FILES];
120
static int64_t input_files_ts_offset[MAX_FILES];
121
static double *input_files_ts_scale[MAX_FILES] = {NULL};
122
static AVCodec **input_codecs = NULL;
123
static int nb_input_files = 0;
124
static int nb_input_codecs = 0;
125
static int nb_input_files_ts_scale[MAX_FILES] = {0};
126

    
127
static AVFormatContext *output_files[MAX_FILES];
128
static AVCodec **output_codecs = NULL;
129
static int nb_output_files = 0;
130
static int nb_output_codecs = 0;
131

    
132
static AVStreamMap *stream_maps = NULL;
133
static int nb_stream_maps;
134

    
135
/* first item specifies output metadata, second is input */
136
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137
static int nb_meta_data_maps;
138
static int metadata_global_autocopy   = 1;
139
static int metadata_streams_autocopy  = 1;
140
static int metadata_chapters_autocopy = 1;
141

    
142
static AVChapterMap *chapter_maps = NULL;
143
static int nb_chapter_maps;
144

    
145
/* indexed by output file stream index */
146
static int *streamid_map = NULL;
147
static int nb_streamid_map = 0;
148

    
149
static int frame_width  = 0;
150
static int frame_height = 0;
151
static float frame_aspect_ratio = 0;
152
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153
static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
154
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
155
static AVRational frame_rate;
156
static float video_qscale = 0;
157
static uint16_t *intra_matrix = NULL;
158
static uint16_t *inter_matrix = NULL;
159
static const char *video_rc_override_string=NULL;
160
static int video_disable = 0;
161
static int video_discard = 0;
162
static char *video_codec_name = NULL;
163
static unsigned int video_codec_tag = 0;
164
static char *video_language = NULL;
165
static int same_quality = 0;
166
static int do_deinterlace = 0;
167
static int top_field_first = -1;
168
static int me_threshold = 0;
169
static int intra_dc_precision = 8;
170
static int loop_input = 0;
171
static int loop_output = AVFMT_NOOUTPUTLOOP;
172
static int qp_hist = 0;
173
#if CONFIG_AVFILTER
174
static char *vfilters = NULL;
175
static AVFilterGraph *graph = NULL;
176
#endif
177

    
178
static int intra_only = 0;
179
static int audio_sample_rate = 44100;
180
static int64_t channel_layout = 0;
181
#define QSCALE_NONE -99999
182
static float audio_qscale = QSCALE_NONE;
183
static int audio_disable = 0;
184
static int audio_channels = 1;
185
static char  *audio_codec_name = NULL;
186
static unsigned int audio_codec_tag = 0;
187
static char *audio_language = NULL;
188

    
189
static int subtitle_disable = 0;
190
static char *subtitle_codec_name = NULL;
191
static char *subtitle_language = NULL;
192
static unsigned int subtitle_codec_tag = 0;
193

    
194
static float mux_preload= 0.5;
195
static float mux_max_delay= 0.7;
196

    
197
static int64_t recording_time = INT64_MAX;
198
static int64_t start_time = 0;
199
static int64_t recording_timestamp = 0;
200
static int64_t input_ts_offset = 0;
201
static int file_overwrite = 0;
202
static AVMetadata *metadata;
203
static int do_benchmark = 0;
204
static int do_hex_dump = 0;
205
static int do_pkt_dump = 0;
206
static int do_psnr = 0;
207
static int do_pass = 0;
208
static char *pass_logfilename_prefix = NULL;
209
static int audio_stream_copy = 0;
210
static int video_stream_copy = 0;
211
static int subtitle_stream_copy = 0;
212
static int video_sync_method= -1;
213
static int audio_sync_method= 0;
214
static float audio_drift_threshold= 0.1;
215
static int copy_ts= 0;
216
static int copy_tb;
217
static int opt_shortest = 0;
218
static int video_global_header = 0;
219
static char *vstats_filename;
220
static FILE *vstats_file;
221
static int opt_programid = 0;
222
static int copy_initial_nonkeyframes = 0;
223

    
224
static int rate_emu = 0;
225

    
226
static int  video_channel = 0;
227
static char *video_standard;
228

    
229
static int audio_volume = 256;
230

    
231
static int exit_on_error = 0;
232
static int using_stdin = 0;
233
static int verbose = 1;
234
static int thread_count= 1;
235
static int q_pressed = 0;
236
static int64_t video_size = 0;
237
static int64_t audio_size = 0;
238
static int64_t extra_size = 0;
239
static int nb_frames_dup = 0;
240
static int nb_frames_drop = 0;
241
static int input_sync;
242
static uint64_t limit_filesize = 0;
243
static int force_fps = 0;
244
static char *forced_key_frames = NULL;
245

    
246
static float dts_delta_threshold = 10;
247

    
248
static unsigned int sws_flags = SWS_BICUBIC;
249

    
250
static int64_t timer_start;
251

    
252
static uint8_t *audio_buf;
253
static uint8_t *audio_out;
254
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
255

    
256
static short *samples;
257

    
258
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
259
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
260
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
261

    
262
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263

    
264
struct AVInputStream;
265

    
266
typedef struct AVOutputStream {
267
    int file_index;          /* file index */
268
    int index;               /* stream index in the output file */
269
    int source_index;        /* AVInputStream index */
270
    AVStream *st;            /* stream in the output file */
271
    int encoding_needed;     /* true if encoding needed for this stream */
272
    int frame_number;
273
    /* input pts and corresponding output pts
274
       for A/V sync */
275
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
276
    struct AVInputStream *sync_ist; /* input stream to sync against */
277
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
278
    AVBitStreamFilterContext *bitstream_filters;
279
    /* video only */
280
    int video_resample;
281
    AVFrame pict_tmp;      /* temporary image for resampling */
282
    struct SwsContext *img_resample_ctx; /* for image resampling */
283
    int resample_height;
284
    int resample_width;
285
    int resample_pix_fmt;
286

    
287
    /* full frame size of first frame */
288
    int original_height;
289
    int original_width;
290

    
291
    /* forced key frames */
292
    int64_t *forced_kf_pts;
293
    int forced_kf_count;
294
    int forced_kf_index;
295

    
296
    /* audio only */
297
    int audio_resample;
298
    ReSampleContext *resample; /* for audio resampling */
299
    int resample_sample_fmt;
300
    int resample_channels;
301
    int resample_sample_rate;
302
    int reformat_pair;
303
    AVAudioConvert *reformat_ctx;
304
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
305
    FILE *logfile;
306
} AVOutputStream;
307

    
308
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
310

    
311
typedef struct AVInputStream {
312
    int file_index;
313
    int index;
314
    AVStream *st;
315
    int discard;             /* true if stream data should be discarded */
316
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
317
    int64_t sample_index;      /* current sample */
318

    
319
    int64_t       start;     /* time when read started */
320
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
321
                                is not defined */
322
    int64_t       pts;       /* current pts */
323
    PtsCorrectionContext pts_ctx;
324
    int is_start;            /* is 1 at the start and after a discontinuity */
325
    int showed_multi_packet_warning;
326
    int is_past_recording_time;
327
#if CONFIG_AVFILTER
328
    AVFilterContext *output_video_filter;
329
    AVFilterContext *input_video_filter;
330
    AVFrame *filter_frame;
331
    int has_filter_frame;
332
    AVFilterBufferRef *picref;
333
#endif
334
} AVInputStream;
335

    
336
typedef struct AVInputFile {
337
    int eof_reached;      /* true if eof reached */
338
    int ist_index;        /* index of first stream in ist_table */
339
    int buffer_size;      /* current total buffer size */
340
    int nb_streams;       /* nb streams we are aware of */
341
} AVInputFile;
342

    
343
#if HAVE_TERMIOS_H
344

    
345
/* init terminal so that we can grab keys */
346
static struct termios oldtty;
347
#endif
348

    
349
#if CONFIG_AVFILTER
350

    
351
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
352
{
353
    AVFilterContext *last_filter, *filter;
354
    /** filter graph containing all filters including input & output */
355
    AVCodecContext *codec = ost->st->codec;
356
    AVCodecContext *icodec = ist->st->codec;
357
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
358
    char args[255];
359
    int ret;
360

    
361
    graph = avfilter_graph_alloc();
362

    
363
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
364
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
365
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
366
                                       "src", args, NULL, graph);
367
    if (ret < 0)
368
        return ret;
369
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
370
                                       "out", NULL, &ffsink_ctx, graph);
371
    if (ret < 0)
372
        return ret;
373
    last_filter = ist->input_video_filter;
374

    
375
    if (codec->width  != icodec->width || codec->height != icodec->height) {
376
        snprintf(args, 255, "%d:%d:flags=0x%X",
377
                 codec->width,
378
                 codec->height,
379
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
380
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
381
                                                NULL, args, NULL, graph)) < 0)
382
            return ret;
383
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
384
            return ret;
385
        last_filter = filter;
386
    }
387

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

    
391
    if (vfilters) {
392
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
394

    
395
        outputs->name    = av_strdup("in");
396
        outputs->filter_ctx = last_filter;
397
        outputs->pad_idx = 0;
398
        outputs->next    = NULL;
399

    
400
        inputs->name    = av_strdup("out");
401
        inputs->filter_ctx = ist->output_video_filter;
402
        inputs->pad_idx = 0;
403
        inputs->next    = NULL;
404

    
405
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
406
            return ret;
407
        av_freep(&vfilters);
408
    } else {
409
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
410
            return ret;
411
    }
412

    
413
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
414
        return ret;
415

    
416
    codec->width  = ist->output_video_filter->inputs[0]->w;
417
    codec->height = ist->output_video_filter->inputs[0]->h;
418

    
419
    return 0;
420
}
421
#endif /* CONFIG_AVFILTER */
422

    
423
static void term_exit(void)
424
{
425
    av_log(NULL, AV_LOG_QUIET, "");
426
#if HAVE_TERMIOS_H
427
    tcsetattr (0, TCSANOW, &oldtty);
428
#endif
429
}
430

    
431
static volatile int received_sigterm = 0;
432

    
433
static void
434
sigterm_handler(int sig)
435
{
436
    received_sigterm = sig;
437
    term_exit();
438
}
439

    
440
static void term_init(void)
441
{
442
#if HAVE_TERMIOS_H
443
    struct termios tty;
444

    
445
    tcgetattr (0, &tty);
446
    oldtty = tty;
447
    atexit(term_exit);
448

    
449
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
450
                          |INLCR|IGNCR|ICRNL|IXON);
451
    tty.c_oflag |= OPOST;
452
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
453
    tty.c_cflag &= ~(CSIZE|PARENB);
454
    tty.c_cflag |= CS8;
455
    tty.c_cc[VMIN] = 1;
456
    tty.c_cc[VTIME] = 0;
457

    
458
    tcsetattr (0, TCSANOW, &tty);
459
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
460
#endif
461

    
462
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
463
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
464
#ifdef SIGXCPU
465
    signal(SIGXCPU, sigterm_handler);
466
#endif
467
}
468

    
469
/* read a key without blocking */
470
static int read_key(void)
471
{
472
#if HAVE_TERMIOS_H
473
    int n = 1;
474
    unsigned char ch;
475
    struct timeval tv;
476
    fd_set rfds;
477

    
478
    FD_ZERO(&rfds);
479
    FD_SET(0, &rfds);
480
    tv.tv_sec = 0;
481
    tv.tv_usec = 0;
482
    n = select(1, &rfds, NULL, NULL, &tv);
483
    if (n > 0) {
484
        n = read(0, &ch, 1);
485
        if (n == 1)
486
            return ch;
487

    
488
        return n;
489
    }
490
#elif HAVE_CONIO_H
491
    if(kbhit())
492
        return(getch());
493
#endif
494
    return -1;
495
}
496

    
497
static int decode_interrupt_cb(void)
498
{
499
    return q_pressed || (q_pressed = read_key() == 'q');
500
}
501

    
502
static int ffmpeg_exit(int ret)
503
{
504
    int i;
505

    
506
    /* close files */
507
    for(i=0;i<nb_output_files;i++) {
508
        AVFormatContext *s = output_files[i];
509
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
510
            avio_close(s->pb);
511
        avformat_free_context(s);
512
        av_free(output_streams_for_file[i]);
513
    }
514
    for(i=0;i<nb_input_files;i++) {
515
        av_close_input_file(input_files[i]);
516
        av_free(input_files_ts_scale[i]);
517
    }
518

    
519
    av_free(intra_matrix);
520
    av_free(inter_matrix);
521

    
522
    if (vstats_file)
523
        fclose(vstats_file);
524
    av_free(vstats_filename);
525

    
526
    av_free(streamid_map);
527
    av_free(input_codecs);
528
    av_free(output_codecs);
529
    av_free(stream_maps);
530
    av_free(meta_data_maps);
531

    
532
    av_free(video_codec_name);
533
    av_free(audio_codec_name);
534
    av_free(subtitle_codec_name);
535

    
536
    av_free(video_standard);
537

    
538
    uninit_opts();
539
    av_free(audio_buf);
540
    av_free(audio_out);
541
    allocated_audio_buf_size= allocated_audio_out_size= 0;
542
    av_free(samples);
543

    
544
#if CONFIG_AVFILTER
545
    avfilter_uninit();
546
#endif
547

    
548
    if (received_sigterm) {
549
        fprintf(stderr,
550
            "Received signal %d: terminating.\n",
551
            (int) received_sigterm);
552
        exit (255);
553
    }
554

    
555
    exit(ret); /* not all OS-es handle main() return value */
556
    return ret;
557
}
558

    
559
/* similar to ff_dynarray_add() and av_fast_realloc() */
560
static void *grow_array(void *array, int elem_size, int *size, int new_size)
561
{
562
    if (new_size >= INT_MAX / elem_size) {
563
        fprintf(stderr, "Array too big.\n");
564
        ffmpeg_exit(1);
565
    }
566
    if (*size < new_size) {
567
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
568
        if (!tmp) {
569
            fprintf(stderr, "Could not alloc buffer.\n");
570
            ffmpeg_exit(1);
571
        }
572
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
573
        *size = new_size;
574
        return tmp;
575
    }
576
    return array;
577
}
578

    
579
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
580
{
581
    if(codec && codec->sample_fmts){
582
        const enum AVSampleFormat *p= codec->sample_fmts;
583
        for(; *p!=-1; p++){
584
            if(*p == st->codec->sample_fmt)
585
                break;
586
        }
587
        if (*p == -1) {
588
            av_log(NULL, AV_LOG_WARNING,
589
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
590
                   av_get_sample_fmt_name(st->codec->sample_fmt),
591
                   codec->name,
592
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
593
            st->codec->sample_fmt = codec->sample_fmts[0];
594
        }
595
    }
596
}
597

    
598
static void choose_sample_rate(AVStream *st, AVCodec *codec)
599
{
600
    if(codec && codec->supported_samplerates){
601
        const int *p= codec->supported_samplerates;
602
        int best=0;
603
        int best_dist=INT_MAX;
604
        for(; *p; p++){
605
            int dist= abs(st->codec->sample_rate - *p);
606
            if(dist < best_dist){
607
                best_dist= dist;
608
                best= *p;
609
            }
610
        }
611
        if(best_dist){
612
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
613
        }
614
        st->codec->sample_rate= best;
615
    }
616
}
617

    
618
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
619
{
620
    if(codec && codec->pix_fmts){
621
        const enum PixelFormat *p= codec->pix_fmts;
622
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
623
            if(st->codec->codec_id==CODEC_ID_MJPEG){
624
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
625
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
626
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
627
            }
628
        }
629
        for(; *p!=-1; p++){
630
            if(*p == st->codec->pix_fmt)
631
                break;
632
        }
633
        if(*p == -1)
634
            st->codec->pix_fmt = codec->pix_fmts[0];
635
    }
636
}
637

    
638
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
639
{
640
    int idx = oc->nb_streams - 1;
641
    AVOutputStream *ost;
642

    
643
    output_streams_for_file[file_idx] =
644
        grow_array(output_streams_for_file[file_idx],
645
                   sizeof(*output_streams_for_file[file_idx]),
646
                   &nb_output_streams_for_file[file_idx],
647
                   oc->nb_streams);
648
    ost = output_streams_for_file[file_idx][idx] =
649
        av_mallocz(sizeof(AVOutputStream));
650
    if (!ost) {
651
        fprintf(stderr, "Could not alloc output stream\n");
652
        ffmpeg_exit(1);
653
    }
654
    ost->file_index = file_idx;
655
    ost->index = idx;
656
    return ost;
657
}
658

    
659
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
660
{
661
    int i, err;
662
    AVFormatContext *ic;
663
    int nopts = 0;
664

    
665
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
666
    if (err < 0)
667
        return err;
668
    /* copy stream format */
669
    s->nb_streams = 0;
670
    for(i=0;i<ic->nb_streams;i++) {
671
        AVStream *st;
672
        AVCodec *codec;
673

    
674
        s->nb_streams++;
675

    
676
        // FIXME: a more elegant solution is needed
677
        st = av_mallocz(sizeof(AVStream));
678
        memcpy(st, ic->streams[i], sizeof(AVStream));
679
        st->codec = avcodec_alloc_context();
680
        if (!st->codec) {
681
            print_error(filename, AVERROR(ENOMEM));
682
            ffmpeg_exit(1);
683
        }
684
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
685
        s->streams[i] = st;
686

    
687
        codec = avcodec_find_encoder(st->codec->codec_id);
688
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
689
            if (audio_stream_copy) {
690
                st->stream_copy = 1;
691
            } else
692
                choose_sample_fmt(st, codec);
693
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
694
            if (video_stream_copy) {
695
                st->stream_copy = 1;
696
            } else
697
                choose_pixel_fmt(st, codec);
698
        }
699

    
700
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
701
            nopts = 1;
702

    
703
        new_output_stream(s, nb_output_files);
704
    }
705

    
706
    if (!nopts)
707
        s->timestamp = av_gettime();
708

    
709
    av_close_input_file(ic);
710
    return 0;
711
}
712

    
713
static double
714
get_sync_ipts(const AVOutputStream *ost)
715
{
716
    const AVInputStream *ist = ost->sync_ist;
717
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
718
}
719

    
720
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
721
    int ret;
722

    
723
    while(bsfc){
724
        AVPacket new_pkt= *pkt;
725
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
726
                                          &new_pkt.data, &new_pkt.size,
727
                                          pkt->data, pkt->size,
728
                                          pkt->flags & AV_PKT_FLAG_KEY);
729
        if(a>0){
730
            av_free_packet(pkt);
731
            new_pkt.destruct= av_destruct_packet;
732
        } else if(a<0){
733
            fprintf(stderr, "%s failed for stream %d, codec %s",
734
                    bsfc->filter->name, pkt->stream_index,
735
                    avctx->codec ? avctx->codec->name : "copy");
736
            print_error("", a);
737
            if (exit_on_error)
738
                ffmpeg_exit(1);
739
        }
740
        *pkt= new_pkt;
741

    
742
        bsfc= bsfc->next;
743
    }
744

    
745
    ret= av_interleaved_write_frame(s, pkt);
746
    if(ret < 0){
747
        print_error("av_interleaved_write_frame()", ret);
748
        ffmpeg_exit(1);
749
    }
750
}
751

    
752
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
753

    
754
static void do_audio_out(AVFormatContext *s,
755
                         AVOutputStream *ost,
756
                         AVInputStream *ist,
757
                         unsigned char *buf, int size)
758
{
759
    uint8_t *buftmp;
760
    int64_t audio_out_size, audio_buf_size;
761
    int64_t allocated_for_size= size;
762

    
763
    int size_out, frame_bytes, ret, resample_changed;
764
    AVCodecContext *enc= ost->st->codec;
765
    AVCodecContext *dec= ist->st->codec;
766
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
767
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
768
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
769

    
770
need_realloc:
771
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
772
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
773
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
774
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
775
    audio_buf_size*= osize*enc->channels;
776

    
777
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
778
    if(coded_bps > 8*osize)
779
        audio_out_size= audio_out_size * coded_bps / (8*osize);
780
    audio_out_size += FF_MIN_BUFFER_SIZE;
781

    
782
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
783
        fprintf(stderr, "Buffer sizes too large\n");
784
        ffmpeg_exit(1);
785
    }
786

    
787
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
788
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
789
    if (!audio_buf || !audio_out){
790
        fprintf(stderr, "Out of memory in do_audio_out\n");
791
        ffmpeg_exit(1);
792
    }
793

    
794
    if (enc->channels != dec->channels)
795
        ost->audio_resample = 1;
796

    
797
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
798
                       ost->resample_channels    != dec->channels   ||
799
                       ost->resample_sample_rate != dec->sample_rate;
800

    
801
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
802
        if (resample_changed) {
803
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
804
                   ist->file_index, ist->index,
805
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
806
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
807
            ost->resample_sample_fmt  = dec->sample_fmt;
808
            ost->resample_channels    = dec->channels;
809
            ost->resample_sample_rate = dec->sample_rate;
810
            if (ost->resample)
811
                audio_resample_close(ost->resample);
812
        }
813
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
814
        if (audio_sync_method <= 1 &&
815
            ost->resample_sample_fmt  == enc->sample_fmt &&
816
            ost->resample_channels    == enc->channels   &&
817
            ost->resample_sample_rate == enc->sample_rate) {
818
            ost->resample = NULL;
819
            ost->audio_resample = 0;
820
        } else {
821
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
822
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
823
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
824
                                                   enc->sample_rate, dec->sample_rate,
825
                                                   enc->sample_fmt,  dec->sample_fmt,
826
                                                   16, 10, 0, 0.8);
827
            if (!ost->resample) {
828
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
829
                        dec->channels, dec->sample_rate,
830
                        enc->channels, enc->sample_rate);
831
                ffmpeg_exit(1);
832
            }
833
        }
834
    }
835

    
836
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
837
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
838
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
839
        if (ost->reformat_ctx)
840
            av_audio_convert_free(ost->reformat_ctx);
841
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
842
                                                   dec->sample_fmt, 1, NULL, 0);
843
        if (!ost->reformat_ctx) {
844
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
845
                av_get_sample_fmt_name(dec->sample_fmt),
846
                av_get_sample_fmt_name(enc->sample_fmt));
847
            ffmpeg_exit(1);
848
        }
849
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
850
    }
851

    
852
    if(audio_sync_method){
853
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
854
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
855
        double idelta= delta*dec->sample_rate / enc->sample_rate;
856
        int byte_delta= ((int)idelta)*2*dec->channels;
857

    
858
        //FIXME resample delay
859
        if(fabs(delta) > 50){
860
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
861
                if(byte_delta < 0){
862
                    byte_delta= FFMAX(byte_delta, -size);
863
                    size += byte_delta;
864
                    buf  -= byte_delta;
865
                    if(verbose > 2)
866
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
867
                    if(!size)
868
                        return;
869
                    ist->is_start=0;
870
                }else{
871
                    static uint8_t *input_tmp= NULL;
872
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
873

    
874
                    if(byte_delta > allocated_for_size - size){
875
                        allocated_for_size= byte_delta + (int64_t)size;
876
                        goto need_realloc;
877
                    }
878
                    ist->is_start=0;
879

    
880
                    memset(input_tmp, 0, byte_delta);
881
                    memcpy(input_tmp + byte_delta, buf, size);
882
                    buf= input_tmp;
883
                    size += byte_delta;
884
                    if(verbose > 2)
885
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
886
                }
887
            }else if(audio_sync_method>1){
888
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
889
                av_assert0(ost->audio_resample);
890
                if(verbose > 2)
891
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
892
//                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));
893
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
894
            }
895
        }
896
    }else
897
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
898
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
899

    
900
    if (ost->audio_resample) {
901
        buftmp = audio_buf;
902
        size_out = audio_resample(ost->resample,
903
                                  (short *)buftmp, (short *)buf,
904
                                  size / (dec->channels * isize));
905
        size_out = size_out * enc->channels * osize;
906
    } else {
907
        buftmp = buf;
908
        size_out = size;
909
    }
910

    
911
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
912
        const void *ibuf[6]= {buftmp};
913
        void *obuf[6]= {audio_buf};
914
        int istride[6]= {isize};
915
        int ostride[6]= {osize};
916
        int len= size_out/istride[0];
917
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
918
            printf("av_audio_convert() failed\n");
919
            if (exit_on_error)
920
                ffmpeg_exit(1);
921
            return;
922
        }
923
        buftmp = audio_buf;
924
        size_out = len*osize;
925
    }
926

    
927
    /* now encode as many frames as possible */
928
    if (enc->frame_size > 1) {
929
        /* output resampled raw samples */
930
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
931
            fprintf(stderr, "av_fifo_realloc2() failed\n");
932
            ffmpeg_exit(1);
933
        }
934
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
935

    
936
        frame_bytes = enc->frame_size * osize * enc->channels;
937

    
938
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
939
            AVPacket pkt;
940
            av_init_packet(&pkt);
941

    
942
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
943

    
944
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
945

    
946
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
947
                                       (short *)audio_buf);
948
            if (ret < 0) {
949
                fprintf(stderr, "Audio encoding failed\n");
950
                ffmpeg_exit(1);
951
            }
952
            audio_size += ret;
953
            pkt.stream_index= ost->index;
954
            pkt.data= audio_out;
955
            pkt.size= ret;
956
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
957
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
958
            pkt.flags |= AV_PKT_FLAG_KEY;
959
            write_frame(s, &pkt, enc, ost->bitstream_filters);
960

    
961
            ost->sync_opts += enc->frame_size;
962
        }
963
    } else {
964
        AVPacket pkt;
965
        av_init_packet(&pkt);
966

    
967
        ost->sync_opts += size_out / (osize * enc->channels);
968

    
969
        /* output a pcm frame */
970
        /* determine the size of the coded buffer */
971
        size_out /= osize;
972
        if (coded_bps)
973
            size_out = size_out*coded_bps/8;
974

    
975
        if(size_out > audio_out_size){
976
            fprintf(stderr, "Internal error, buffer size too small\n");
977
            ffmpeg_exit(1);
978
        }
979

    
980
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
981
        ret = avcodec_encode_audio(enc, audio_out, size_out,
982
                                   (short *)buftmp);
983
        if (ret < 0) {
984
            fprintf(stderr, "Audio encoding failed\n");
985
            ffmpeg_exit(1);
986
        }
987
        audio_size += ret;
988
        pkt.stream_index= ost->index;
989
        pkt.data= audio_out;
990
        pkt.size= ret;
991
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
992
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
993
        pkt.flags |= AV_PKT_FLAG_KEY;
994
        write_frame(s, &pkt, enc, ost->bitstream_filters);
995
    }
996
}
997

    
998
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
999
{
1000
    AVCodecContext *dec;
1001
    AVPicture *picture2;
1002
    AVPicture picture_tmp;
1003
    uint8_t *buf = 0;
1004

    
1005
    dec = ist->st->codec;
1006

    
1007
    /* deinterlace : must be done before any resize */
1008
    if (do_deinterlace) {
1009
        int size;
1010

    
1011
        /* create temporary picture */
1012
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1013
        buf = av_malloc(size);
1014
        if (!buf)
1015
            return;
1016

    
1017
        picture2 = &picture_tmp;
1018
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1019

    
1020
        if(avpicture_deinterlace(picture2, picture,
1021
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1022
            /* if error, do not deinterlace */
1023
            fprintf(stderr, "Deinterlacing failed\n");
1024
            av_free(buf);
1025
            buf = NULL;
1026
            picture2 = picture;
1027
        }
1028
    } else {
1029
        picture2 = picture;
1030
    }
1031

    
1032
    if (picture != picture2)
1033
        *picture = *picture2;
1034
    *bufp = buf;
1035
}
1036

    
1037
/* we begin to correct av delay at this threshold */
1038
#define AV_DELAY_MAX 0.100
1039

    
1040
static void do_subtitle_out(AVFormatContext *s,
1041
                            AVOutputStream *ost,
1042
                            AVInputStream *ist,
1043
                            AVSubtitle *sub,
1044
                            int64_t pts)
1045
{
1046
    static uint8_t *subtitle_out = NULL;
1047
    int subtitle_out_max_size = 1024 * 1024;
1048
    int subtitle_out_size, nb, i;
1049
    AVCodecContext *enc;
1050
    AVPacket pkt;
1051

    
1052
    if (pts == AV_NOPTS_VALUE) {
1053
        fprintf(stderr, "Subtitle packets must have a pts\n");
1054
        if (exit_on_error)
1055
            ffmpeg_exit(1);
1056
        return;
1057
    }
1058

    
1059
    enc = ost->st->codec;
1060

    
1061
    if (!subtitle_out) {
1062
        subtitle_out = av_malloc(subtitle_out_max_size);
1063
    }
1064

    
1065
    /* Note: DVB subtitle need one packet to draw them and one other
1066
       packet to clear them */
1067
    /* XXX: signal it in the codec context ? */
1068
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1069
        nb = 2;
1070
    else
1071
        nb = 1;
1072

    
1073
    for(i = 0; i < nb; i++) {
1074
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1075
        // start_display_time is required to be 0
1076
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1077
        sub->end_display_time -= sub->start_display_time;
1078
        sub->start_display_time = 0;
1079
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1080
                                                    subtitle_out_max_size, sub);
1081
        if (subtitle_out_size < 0) {
1082
            fprintf(stderr, "Subtitle encoding failed\n");
1083
            ffmpeg_exit(1);
1084
        }
1085

    
1086
        av_init_packet(&pkt);
1087
        pkt.stream_index = ost->index;
1088
        pkt.data = subtitle_out;
1089
        pkt.size = subtitle_out_size;
1090
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1091
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1092
            /* XXX: the pts correction is handled here. Maybe handling
1093
               it in the codec would be better */
1094
            if (i == 0)
1095
                pkt.pts += 90 * sub->start_display_time;
1096
            else
1097
                pkt.pts += 90 * sub->end_display_time;
1098
        }
1099
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1100
    }
1101
}
1102

    
1103
static int bit_buffer_size= 1024*256;
1104
static uint8_t *bit_buffer= NULL;
1105

    
1106
static void do_video_out(AVFormatContext *s,
1107
                         AVOutputStream *ost,
1108
                         AVInputStream *ist,
1109
                         AVFrame *in_picture,
1110
                         int *frame_size)
1111
{
1112
    int nb_frames, i, ret;
1113
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1114
    AVCodecContext *enc, *dec;
1115
    double sync_ipts;
1116

    
1117
    enc = ost->st->codec;
1118
    dec = ist->st->codec;
1119

    
1120
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1121

    
1122
    /* by default, we output a single frame */
1123
    nb_frames = 1;
1124

    
1125
    *frame_size = 0;
1126

    
1127
    if(video_sync_method){
1128
        double vdelta = sync_ipts - ost->sync_opts;
1129
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1130
        if (vdelta < -1.1)
1131
            nb_frames = 0;
1132
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1133
            if(vdelta<=-0.6){
1134
                nb_frames=0;
1135
            }else if(vdelta>0.6)
1136
                ost->sync_opts= lrintf(sync_ipts);
1137
        }else if (vdelta > 1.1)
1138
            nb_frames = lrintf(vdelta);
1139
//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);
1140
        if (nb_frames == 0){
1141
            ++nb_frames_drop;
1142
            if (verbose>2)
1143
                fprintf(stderr, "*** drop!\n");
1144
        }else if (nb_frames > 1) {
1145
            nb_frames_dup += nb_frames - 1;
1146
            if (verbose>2)
1147
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1148
        }
1149
    }else
1150
        ost->sync_opts= lrintf(sync_ipts);
1151

    
1152
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1153
    if (nb_frames <= 0)
1154
        return;
1155

    
1156
    formatted_picture = in_picture;
1157
    final_picture = formatted_picture;
1158
    padding_src = formatted_picture;
1159
    resampling_dst = &ost->pict_tmp;
1160

    
1161
    if (   ost->resample_height != ist->st->codec->height
1162
        || ost->resample_width  != ist->st->codec->width
1163
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1164

    
1165
        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));
1166
        if(!ost->video_resample)
1167
            ffmpeg_exit(1);
1168
    }
1169

    
1170
#if !CONFIG_AVFILTER
1171
    if (ost->video_resample) {
1172
        padding_src = NULL;
1173
        final_picture = &ost->pict_tmp;
1174
        if(  ost->resample_height != ist->st->codec->height
1175
          || ost->resample_width  != ist->st->codec->width
1176
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1177

    
1178
            /* initialize a new scaler context */
1179
            sws_freeContext(ost->img_resample_ctx);
1180
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1181
            ost->img_resample_ctx = sws_getContext(
1182
                ist->st->codec->width,
1183
                ist->st->codec->height,
1184
                ist->st->codec->pix_fmt,
1185
                ost->st->codec->width,
1186
                ost->st->codec->height,
1187
                ost->st->codec->pix_fmt,
1188
                sws_flags, NULL, NULL, NULL);
1189
            if (ost->img_resample_ctx == NULL) {
1190
                fprintf(stderr, "Cannot get resampling context\n");
1191
                ffmpeg_exit(1);
1192
            }
1193
        }
1194
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1195
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1196
    }
1197
#endif
1198

    
1199
    /* duplicates frame if needed */
1200
    for(i=0;i<nb_frames;i++) {
1201
        AVPacket pkt;
1202
        av_init_packet(&pkt);
1203
        pkt.stream_index= ost->index;
1204

    
1205
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1206
            /* raw pictures are written as AVPicture structure to
1207
               avoid any copies. We support temorarily the older
1208
               method. */
1209
            AVFrame* old_frame = enc->coded_frame;
1210
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1211
            pkt.data= (uint8_t *)final_picture;
1212
            pkt.size=  sizeof(AVPicture);
1213
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1214
            pkt.flags |= AV_PKT_FLAG_KEY;
1215

    
1216
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1217
            enc->coded_frame = old_frame;
1218
        } else {
1219
            AVFrame big_picture;
1220

    
1221
            big_picture= *final_picture;
1222
            /* better than nothing: use input picture interlaced
1223
               settings */
1224
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1225
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1226
                if(top_field_first == -1)
1227
                    big_picture.top_field_first = in_picture->top_field_first;
1228
                else
1229
                    big_picture.top_field_first = top_field_first;
1230
            }
1231

    
1232
            /* handles sameq here. This is not correct because it may
1233
               not be a global option */
1234
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1235
            if(!me_threshold)
1236
                big_picture.pict_type = 0;
1237
//            big_picture.pts = AV_NOPTS_VALUE;
1238
            big_picture.pts= ost->sync_opts;
1239
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1240
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1241
            if (ost->forced_kf_index < ost->forced_kf_count &&
1242
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1243
                big_picture.pict_type = FF_I_TYPE;
1244
                ost->forced_kf_index++;
1245
            }
1246
            ret = avcodec_encode_video(enc,
1247
                                       bit_buffer, bit_buffer_size,
1248
                                       &big_picture);
1249
            if (ret < 0) {
1250
                fprintf(stderr, "Video encoding failed\n");
1251
                ffmpeg_exit(1);
1252
            }
1253

    
1254
            if(ret>0){
1255
                pkt.data= bit_buffer;
1256
                pkt.size= ret;
1257
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1258
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1259
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1260
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1261
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1262

    
1263
                if(enc->coded_frame->key_frame)
1264
                    pkt.flags |= AV_PKT_FLAG_KEY;
1265
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1266
                *frame_size = ret;
1267
                video_size += ret;
1268
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1269
                //        enc->frame_number-1, ret, enc->pict_type);
1270
                /* if two pass, output log */
1271
                if (ost->logfile && enc->stats_out) {
1272
                    fprintf(ost->logfile, "%s", enc->stats_out);
1273
                }
1274
            }
1275
        }
1276
        ost->sync_opts++;
1277
        ost->frame_number++;
1278
    }
1279
}
1280

    
1281
static double psnr(double d){
1282
    return -10.0*log(d)/log(10.0);
1283
}
1284

    
1285
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1286
                           int frame_size)
1287
{
1288
    AVCodecContext *enc;
1289
    int frame_number;
1290
    double ti1, bitrate, avg_bitrate;
1291

    
1292
    /* this is executed just the first time do_video_stats is called */
1293
    if (!vstats_file) {
1294
        vstats_file = fopen(vstats_filename, "w");
1295
        if (!vstats_file) {
1296
            perror("fopen");
1297
            ffmpeg_exit(1);
1298
        }
1299
    }
1300

    
1301
    enc = ost->st->codec;
1302
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1303
        frame_number = ost->frame_number;
1304
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1305
        if (enc->flags&CODEC_FLAG_PSNR)
1306
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1307

    
1308
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1309
        /* compute pts value */
1310
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1311
        if (ti1 < 0.01)
1312
            ti1 = 0.01;
1313

    
1314
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1315
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1316
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1317
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1318
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1319
    }
1320
}
1321

    
1322
static void print_report(AVFormatContext **output_files,
1323
                         AVOutputStream **ost_table, int nb_ostreams,
1324
                         int is_last_report)
1325
{
1326
    char buf[1024];
1327
    AVOutputStream *ost;
1328
    AVFormatContext *oc;
1329
    int64_t total_size;
1330
    AVCodecContext *enc;
1331
    int frame_number, vid, i;
1332
    double bitrate, ti1, pts;
1333
    static int64_t last_time = -1;
1334
    static int qp_histogram[52];
1335

    
1336
    if (!is_last_report) {
1337
        int64_t cur_time;
1338
        /* display the report every 0.5 seconds */
1339
        cur_time = av_gettime();
1340
        if (last_time == -1) {
1341
            last_time = cur_time;
1342
            return;
1343
        }
1344
        if ((cur_time - last_time) < 500000)
1345
            return;
1346
        last_time = cur_time;
1347
    }
1348

    
1349

    
1350
    oc = output_files[0];
1351

    
1352
    total_size = avio_size(oc->pb);
1353
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1354
        total_size= avio_tell(oc->pb);
1355

    
1356
    buf[0] = '\0';
1357
    ti1 = 1e10;
1358
    vid = 0;
1359
    for(i=0;i<nb_ostreams;i++) {
1360
        ost = ost_table[i];
1361
        enc = ost->st->codec;
1362
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1363
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1364
                     !ost->st->stream_copy ?
1365
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1366
        }
1367
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1368
            float t = (av_gettime()-timer_start) / 1000000.0;
1369

    
1370
            frame_number = ost->frame_number;
1371
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1372
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1373
                     !ost->st->stream_copy ?
1374
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1375
            if(is_last_report)
1376
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1377
            if(qp_hist){
1378
                int j;
1379
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1380
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1381
                    qp_histogram[qp]++;
1382
                for(j=0; j<32; j++)
1383
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1384
            }
1385
            if (enc->flags&CODEC_FLAG_PSNR){
1386
                int j;
1387
                double error, error_sum=0;
1388
                double scale, scale_sum=0;
1389
                char type[3]= {'Y','U','V'};
1390
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1391
                for(j=0; j<3; j++){
1392
                    if(is_last_report){
1393
                        error= enc->error[j];
1394
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1395
                    }else{
1396
                        error= enc->coded_frame->error[j];
1397
                        scale= enc->width*enc->height*255.0*255.0;
1398
                    }
1399
                    if(j) scale/=4;
1400
                    error_sum += error;
1401
                    scale_sum += scale;
1402
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1403
                }
1404
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1405
            }
1406
            vid = 1;
1407
        }
1408
        /* compute min output value */
1409
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1410
        if ((pts < ti1) && (pts > 0))
1411
            ti1 = pts;
1412
    }
1413
    if (ti1 < 0.01)
1414
        ti1 = 0.01;
1415

    
1416
    if (verbose || is_last_report) {
1417
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1418

    
1419
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1420
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1421
            (double)total_size / 1024, ti1, bitrate);
1422

    
1423
        if (nb_frames_dup || nb_frames_drop)
1424
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1425
                  nb_frames_dup, nb_frames_drop);
1426

    
1427
        if (verbose >= 0)
1428
            fprintf(stderr, "%s    \r", buf);
1429

    
1430
        fflush(stderr);
1431
    }
1432

    
1433
    if (is_last_report && verbose >= 0){
1434
        int64_t raw= audio_size + video_size + extra_size;
1435
        fprintf(stderr, "\n");
1436
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1437
                video_size/1024.0,
1438
                audio_size/1024.0,
1439
                extra_size/1024.0,
1440
                100.0*(total_size - raw)/raw
1441
        );
1442
    }
1443
}
1444

    
1445
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1446
static int output_packet(AVInputStream *ist, int ist_index,
1447
                         AVOutputStream **ost_table, int nb_ostreams,
1448
                         const AVPacket *pkt)
1449
{
1450
    AVFormatContext *os;
1451
    AVOutputStream *ost;
1452
    int ret, i;
1453
    int got_picture;
1454
    AVFrame picture;
1455
    void *buffer_to_free;
1456
    static unsigned int samples_size= 0;
1457
    AVSubtitle subtitle, *subtitle_to_free;
1458
    int64_t pkt_pts = AV_NOPTS_VALUE;
1459
#if CONFIG_AVFILTER
1460
    int frame_available;
1461
#endif
1462

    
1463
    AVPacket avpkt;
1464
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1465

    
1466
    if(ist->next_pts == AV_NOPTS_VALUE)
1467
        ist->next_pts= ist->pts;
1468

    
1469
    if (pkt == NULL) {
1470
        /* EOF handling */
1471
        av_init_packet(&avpkt);
1472
        avpkt.data = NULL;
1473
        avpkt.size = 0;
1474
        goto handle_eof;
1475
    } else {
1476
        avpkt = *pkt;
1477
    }
1478

    
1479
    if(pkt->dts != AV_NOPTS_VALUE)
1480
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1481
    if(pkt->pts != AV_NOPTS_VALUE)
1482
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1483

    
1484
    //while we have more to decode or while the decoder did output something on EOF
1485
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1486
        uint8_t *data_buf, *decoded_data_buf;
1487
        int data_size, decoded_data_size;
1488
    handle_eof:
1489
        ist->pts= ist->next_pts;
1490

    
1491
        if(avpkt.size && avpkt.size != pkt->size &&
1492
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1493
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1494
            ist->showed_multi_packet_warning=1;
1495
        }
1496

    
1497
        /* decode the packet if needed */
1498
        decoded_data_buf = NULL; /* fail safe */
1499
        decoded_data_size= 0;
1500
        data_buf  = avpkt.data;
1501
        data_size = avpkt.size;
1502
        subtitle_to_free = NULL;
1503
        if (ist->decoding_needed) {
1504
            switch(ist->st->codec->codec_type) {
1505
            case AVMEDIA_TYPE_AUDIO:{
1506
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1507
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1508
                    av_free(samples);
1509
                    samples= av_malloc(samples_size);
1510
                }
1511
                decoded_data_size= samples_size;
1512
                    /* XXX: could avoid copy if PCM 16 bits with same
1513
                       endianness as CPU */
1514
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1515
                                            &avpkt);
1516
                if (ret < 0)
1517
                    goto fail_decode;
1518
                avpkt.data += ret;
1519
                avpkt.size -= ret;
1520
                data_size   = ret;
1521
                /* Some bug in mpeg audio decoder gives */
1522
                /* decoded_data_size < 0, it seems they are overflows */
1523
                if (decoded_data_size <= 0) {
1524
                    /* no audio frame */
1525
                    continue;
1526
                }
1527
                decoded_data_buf = (uint8_t *)samples;
1528
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1529
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1530
                break;}
1531
            case AVMEDIA_TYPE_VIDEO:
1532
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1533
                    /* XXX: allocate picture correctly */
1534
                    avcodec_get_frame_defaults(&picture);
1535
                    avpkt.pts = pkt_pts;
1536
                    avpkt.dts = ist->pts;
1537
                    pkt_pts = AV_NOPTS_VALUE;
1538

    
1539
                    ret = avcodec_decode_video2(ist->st->codec,
1540
                                                &picture, &got_picture, &avpkt);
1541
                    ist->st->quality= picture.quality;
1542
                    if (ret < 0)
1543
                        goto fail_decode;
1544
                    if (!got_picture) {
1545
                        /* no picture yet */
1546
                        goto discard_packet;
1547
                    }
1548
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1549
                    if (ist->st->codec->time_base.num != 0) {
1550
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1551
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1552
                                          ist->st->codec->time_base.num * ticks) /
1553
                            ist->st->codec->time_base.den;
1554
                    }
1555
                    avpkt.size = 0;
1556
                    break;
1557
            case AVMEDIA_TYPE_SUBTITLE:
1558
                ret = avcodec_decode_subtitle2(ist->st->codec,
1559
                                               &subtitle, &got_picture, &avpkt);
1560
                if (ret < 0)
1561
                    goto fail_decode;
1562
                if (!got_picture) {
1563
                    goto discard_packet;
1564
                }
1565
                subtitle_to_free = &subtitle;
1566
                avpkt.size = 0;
1567
                break;
1568
            default:
1569
                goto fail_decode;
1570
            }
1571
        } else {
1572
            switch(ist->st->codec->codec_type) {
1573
            case AVMEDIA_TYPE_AUDIO:
1574
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1575
                    ist->st->codec->sample_rate;
1576
                break;
1577
            case AVMEDIA_TYPE_VIDEO:
1578
                if (ist->st->codec->time_base.num != 0) {
1579
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1580
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1581
                                      ist->st->codec->time_base.num * ticks) /
1582
                        ist->st->codec->time_base.den;
1583
                }
1584
                break;
1585
            }
1586
            ret = avpkt.size;
1587
            avpkt.size = 0;
1588
        }
1589

    
1590
        buffer_to_free = NULL;
1591
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1592
            pre_process_video_frame(ist, (AVPicture *)&picture,
1593
                                    &buffer_to_free);
1594
        }
1595

    
1596
#if CONFIG_AVFILTER
1597
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1598
            AVRational sar;
1599
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1600
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1601
            // add it to be filtered
1602
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1603
                                     ist->pts,
1604
                                     sar);
1605
        }
1606
#endif
1607

    
1608
        // preprocess audio (volume)
1609
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1610
            if (audio_volume != 256) {
1611
                short *volp;
1612
                volp = samples;
1613
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1614
                    int v = ((*volp) * audio_volume + 128) >> 8;
1615
                    if (v < -32768) v = -32768;
1616
                    if (v >  32767) v = 32767;
1617
                    *volp++ = v;
1618
                }
1619
            }
1620
        }
1621

    
1622
        /* frame rate emulation */
1623
        if (rate_emu) {
1624
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1625
            int64_t now = av_gettime() - ist->start;
1626
            if (pts > now)
1627
                usleep(pts - now);
1628
        }
1629
#if CONFIG_AVFILTER
1630
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1631
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1632
#endif
1633
        /* if output time reached then transcode raw format,
1634
           encode packets and output them */
1635
        if (start_time == 0 || ist->pts >= start_time)
1636
#if CONFIG_AVFILTER
1637
        while (frame_available) {
1638
            AVRational ist_pts_tb;
1639
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1640
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1641
            if (ist->picref)
1642
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1643
#endif
1644
            for(i=0;i<nb_ostreams;i++) {
1645
                int frame_size;
1646

    
1647
                ost = ost_table[i];
1648
                if (ost->source_index == ist_index) {
1649
                    os = output_files[ost->file_index];
1650

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

    
1654
                    if (ost->encoding_needed) {
1655
                        av_assert0(ist->decoding_needed);
1656
                        switch(ost->st->codec->codec_type) {
1657
                        case AVMEDIA_TYPE_AUDIO:
1658
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1659
                            break;
1660
                        case AVMEDIA_TYPE_VIDEO:
1661
#if CONFIG_AVFILTER
1662
                            if (ist->picref->video)
1663
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1664
#endif
1665
                            do_video_out(os, ost, ist, &picture, &frame_size);
1666
                            if (vstats_filename && frame_size)
1667
                                do_video_stats(os, ost, frame_size);
1668
                            break;
1669
                        case AVMEDIA_TYPE_SUBTITLE:
1670
                            do_subtitle_out(os, ost, ist, &subtitle,
1671
                                            pkt->pts);
1672
                            break;
1673
                        default:
1674
                            abort();
1675
                        }
1676
                    } else {
1677
                        AVFrame avframe; //FIXME/XXX remove this
1678
                        AVPacket opkt;
1679
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1680

    
1681
                        av_init_packet(&opkt);
1682

    
1683
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1684
                            continue;
1685

    
1686
                        /* no reencoding needed : output the packet directly */
1687
                        /* force the input stream PTS */
1688

    
1689
                        avcodec_get_frame_defaults(&avframe);
1690
                        ost->st->codec->coded_frame= &avframe;
1691
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1692

    
1693
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1694
                            audio_size += data_size;
1695
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1696
                            video_size += data_size;
1697
                            ost->sync_opts++;
1698
                        }
1699

    
1700
                        opkt.stream_index= ost->index;
1701
                        if(pkt->pts != AV_NOPTS_VALUE)
1702
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1703
                        else
1704
                            opkt.pts= AV_NOPTS_VALUE;
1705

    
1706
                        if (pkt->dts == AV_NOPTS_VALUE)
1707
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1708
                        else
1709
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1710
                        opkt.dts -= ost_tb_start_time;
1711

    
1712
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1713
                        opkt.flags= pkt->flags;
1714

    
1715
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1716
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1717
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1718
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1719
                           ) {
1720
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1721
                                opkt.destruct= av_destruct_packet;
1722
                        } else {
1723
                            opkt.data = data_buf;
1724
                            opkt.size = data_size;
1725
                        }
1726

    
1727
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1728
                        ost->st->codec->frame_number++;
1729
                        ost->frame_number++;
1730
                        av_free_packet(&opkt);
1731
                    }
1732
                }
1733
            }
1734

    
1735
#if CONFIG_AVFILTER
1736
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1737
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1738
            if(ist->picref)
1739
                avfilter_unref_buffer(ist->picref);
1740
        }
1741
#endif
1742
        av_free(buffer_to_free);
1743
        /* XXX: allocate the subtitles in the codec ? */
1744
        if (subtitle_to_free) {
1745
            avsubtitle_free(subtitle_to_free);
1746
            subtitle_to_free = NULL;
1747
        }
1748
    }
1749
 discard_packet:
1750
    if (pkt == NULL) {
1751
        /* EOF handling */
1752

    
1753
        for(i=0;i<nb_ostreams;i++) {
1754
            ost = ost_table[i];
1755
            if (ost->source_index == ist_index) {
1756
                AVCodecContext *enc= ost->st->codec;
1757
                os = output_files[ost->file_index];
1758

    
1759
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1760
                    continue;
1761
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1762
                    continue;
1763

    
1764
                if (ost->encoding_needed) {
1765
                    for(;;) {
1766
                        AVPacket pkt;
1767
                        int fifo_bytes;
1768
                        av_init_packet(&pkt);
1769
                        pkt.stream_index= ost->index;
1770

    
1771
                        switch(ost->st->codec->codec_type) {
1772
                        case AVMEDIA_TYPE_AUDIO:
1773
                            fifo_bytes = av_fifo_size(ost->fifo);
1774
                            ret = 0;
1775
                            /* encode any samples remaining in fifo */
1776
                            if (fifo_bytes > 0) {
1777
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1778
                                int fs_tmp = enc->frame_size;
1779

    
1780
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1781
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1782
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1783
                                } else { /* pad */
1784
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1785
                                    if (allocated_audio_buf_size < frame_bytes)
1786
                                        ffmpeg_exit(1);
1787
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1788
                                }
1789

    
1790
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1791
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1792
                                                          ost->st->time_base.num, enc->sample_rate);
1793
                                enc->frame_size = fs_tmp;
1794
                            }
1795
                            if(ret <= 0) {
1796
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1797
                            }
1798
                            if (ret < 0) {
1799
                                fprintf(stderr, "Audio encoding failed\n");
1800
                                ffmpeg_exit(1);
1801
                            }
1802
                            audio_size += ret;
1803
                            pkt.flags |= AV_PKT_FLAG_KEY;
1804
                            break;
1805
                        case AVMEDIA_TYPE_VIDEO:
1806
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1807
                            if (ret < 0) {
1808
                                fprintf(stderr, "Video encoding failed\n");
1809
                                ffmpeg_exit(1);
1810
                            }
1811
                            video_size += ret;
1812
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1813
                                pkt.flags |= AV_PKT_FLAG_KEY;
1814
                            if (ost->logfile && enc->stats_out) {
1815
                                fprintf(ost->logfile, "%s", enc->stats_out);
1816
                            }
1817
                            break;
1818
                        default:
1819
                            ret=-1;
1820
                        }
1821

    
1822
                        if(ret<=0)
1823
                            break;
1824
                        pkt.data= bit_buffer;
1825
                        pkt.size= ret;
1826
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1827
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1828
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1829
                    }
1830
                }
1831
            }
1832
        }
1833
    }
1834

    
1835
    return 0;
1836
 fail_decode:
1837
    return -1;
1838
}
1839

    
1840
static void print_sdp(AVFormatContext **avc, int n)
1841
{
1842
    char sdp[2048];
1843

    
1844
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1845
    printf("SDP:\n%s\n", sdp);
1846
    fflush(stdout);
1847
}
1848

    
1849
static int copy_chapters(int infile, int outfile)
1850
{
1851
    AVFormatContext *is = input_files[infile];
1852
    AVFormatContext *os = output_files[outfile];
1853
    int i;
1854

    
1855
    for (i = 0; i < is->nb_chapters; i++) {
1856
        AVChapter *in_ch = is->chapters[i], *out_ch;
1857
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1858
                                      AV_TIME_BASE_Q, in_ch->time_base);
1859
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1860
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1861

    
1862

    
1863
        if (in_ch->end < ts_off)
1864
            continue;
1865
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1866
            break;
1867

    
1868
        out_ch = av_mallocz(sizeof(AVChapter));
1869
        if (!out_ch)
1870
            return AVERROR(ENOMEM);
1871

    
1872
        out_ch->id        = in_ch->id;
1873
        out_ch->time_base = in_ch->time_base;
1874
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1875
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1876

    
1877
        if (metadata_chapters_autocopy)
1878
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1879

    
1880
        os->nb_chapters++;
1881
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1882
        if (!os->chapters)
1883
            return AVERROR(ENOMEM);
1884
        os->chapters[os->nb_chapters - 1] = out_ch;
1885
    }
1886
    return 0;
1887
}
1888

    
1889
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1890
                                    AVCodecContext *avctx)
1891
{
1892
    char *p;
1893
    int n = 1, i;
1894
    int64_t t;
1895

    
1896
    for (p = kf; *p; p++)
1897
        if (*p == ',')
1898
            n++;
1899
    ost->forced_kf_count = n;
1900
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1901
    if (!ost->forced_kf_pts) {
1902
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1903
        ffmpeg_exit(1);
1904
    }
1905
    for (i = 0; i < n; i++) {
1906
        p = i ? strchr(p, ',') + 1 : kf;
1907
        t = parse_time_or_die("force_key_frames", p, 1);
1908
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1909
    }
1910
}
1911

    
1912
/*
1913
 * The following code is the main loop of the file converter
1914
 */
1915
static int transcode(AVFormatContext **output_files,
1916
                     int nb_output_files,
1917
                     AVFormatContext **input_files,
1918
                     int nb_input_files,
1919
                     AVStreamMap *stream_maps, int nb_stream_maps)
1920
{
1921
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1922
    AVFormatContext *is, *os;
1923
    AVCodecContext *codec, *icodec;
1924
    AVOutputStream *ost, **ost_table = NULL;
1925
    AVInputStream *ist, **ist_table = NULL;
1926
    AVInputFile *file_table;
1927
    char error[1024];
1928
    int key;
1929
    int want_sdp = 1;
1930
    uint8_t no_packet[MAX_FILES]={0};
1931
    int no_packet_count=0;
1932

    
1933
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1934
    if (!file_table)
1935
        goto fail;
1936

    
1937
    /* input stream init */
1938
    j = 0;
1939
    for(i=0;i<nb_input_files;i++) {
1940
        is = input_files[i];
1941
        file_table[i].ist_index = j;
1942
        file_table[i].nb_streams = is->nb_streams;
1943
        j += is->nb_streams;
1944
    }
1945
    nb_istreams = j;
1946

    
1947
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1948
    if (!ist_table)
1949
        goto fail;
1950

    
1951
    for(i=0;i<nb_istreams;i++) {
1952
        ist = av_mallocz(sizeof(AVInputStream));
1953
        if (!ist)
1954
            goto fail;
1955
        ist_table[i] = ist;
1956
    }
1957
    j = 0;
1958
    for(i=0;i<nb_input_files;i++) {
1959
        is = input_files[i];
1960
        for(k=0;k<is->nb_streams;k++) {
1961
            ist = ist_table[j++];
1962
            ist->st = is->streams[k];
1963
            ist->file_index = i;
1964
            ist->index = k;
1965
            ist->discard = 1; /* the stream is discarded by default
1966
                                 (changed later) */
1967

    
1968
            if (rate_emu) {
1969
                ist->start = av_gettime();
1970
            }
1971
        }
1972
    }
1973

    
1974
    /* output stream init */
1975
    nb_ostreams = 0;
1976
    for(i=0;i<nb_output_files;i++) {
1977
        os = output_files[i];
1978
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1979
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1980
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1981
            ret = AVERROR(EINVAL);
1982
            goto fail;
1983
        }
1984
        nb_ostreams += os->nb_streams;
1985
    }
1986
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1987
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1988
        ret = AVERROR(EINVAL);
1989
        goto fail;
1990
    }
1991

    
1992
    /* Sanity check the mapping args -- do the input files & streams exist? */
1993
    for(i=0;i<nb_stream_maps;i++) {
1994
        int fi = stream_maps[i].file_index;
1995
        int si = stream_maps[i].stream_index;
1996

    
1997
        if (fi < 0 || fi > nb_input_files - 1 ||
1998
            si < 0 || si > file_table[fi].nb_streams - 1) {
1999
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2000
            ret = AVERROR(EINVAL);
2001
            goto fail;
2002
        }
2003
        fi = stream_maps[i].sync_file_index;
2004
        si = stream_maps[i].sync_stream_index;
2005
        if (fi < 0 || fi > nb_input_files - 1 ||
2006
            si < 0 || si > file_table[fi].nb_streams - 1) {
2007
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2008
            ret = AVERROR(EINVAL);
2009
            goto fail;
2010
        }
2011
    }
2012

    
2013
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2014
    if (!ost_table)
2015
        goto fail;
2016
    n = 0;
2017
    for(k=0;k<nb_output_files;k++) {
2018
        os = output_files[k];
2019
        for(i=0;i<os->nb_streams;i++,n++) {
2020
            int found;
2021
            ost = ost_table[n] = output_streams_for_file[k][i];
2022
            ost->st = os->streams[i];
2023
            if (nb_stream_maps > 0) {
2024
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2025
                    stream_maps[n].stream_index;
2026

    
2027
                /* Sanity check that the stream types match */
2028
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2029
                    int i= ost->file_index;
2030
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2031
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2032
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2033
                        ost->file_index, ost->index);
2034
                    ffmpeg_exit(1);
2035
                }
2036

    
2037
            } else {
2038
                int best_nb_frames=-1;
2039
                /* get corresponding input stream index : we select the first one with the right type */
2040
                found = 0;
2041
                for(j=0;j<nb_istreams;j++) {
2042
                    int skip=0;
2043
                    ist = ist_table[j];
2044
                    if(opt_programid){
2045
                        int pi,si;
2046
                        AVFormatContext *f= input_files[ ist->file_index ];
2047
                        skip=1;
2048
                        for(pi=0; pi<f->nb_programs; pi++){
2049
                            AVProgram *p= f->programs[pi];
2050
                            if(p->id == opt_programid)
2051
                                for(si=0; si<p->nb_stream_indexes; si++){
2052
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2053
                                        skip=0;
2054
                                }
2055
                        }
2056
                    }
2057
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2058
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2059
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2060
                            best_nb_frames= ist->st->codec_info_nb_frames;
2061
                            ost->source_index = j;
2062
                            found = 1;
2063
                        }
2064
                    }
2065
                }
2066

    
2067
                if (!found) {
2068
                    if(! opt_programid) {
2069
                        /* try again and reuse existing stream */
2070
                        for(j=0;j<nb_istreams;j++) {
2071
                            ist = ist_table[j];
2072
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2073
                                && ist->st->discard != AVDISCARD_ALL) {
2074
                                ost->source_index = j;
2075
                                found = 1;
2076
                            }
2077
                        }
2078
                    }
2079
                    if (!found) {
2080
                        int i= ost->file_index;
2081
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2082
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2083
                                ost->file_index, ost->index);
2084
                        ffmpeg_exit(1);
2085
                    }
2086
                }
2087
            }
2088
            ist = ist_table[ost->source_index];
2089
            ist->discard = 0;
2090
            ost->sync_ist = (nb_stream_maps > 0) ?
2091
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2092
                         stream_maps[n].sync_stream_index] : ist;
2093
        }
2094
    }
2095

    
2096
    /* for each output stream, we compute the right encoding parameters */
2097
    for(i=0;i<nb_ostreams;i++) {
2098
        ost = ost_table[i];
2099
        os = output_files[ost->file_index];
2100
        ist = ist_table[ost->source_index];
2101

    
2102
        codec = ost->st->codec;
2103
        icodec = ist->st->codec;
2104

    
2105
        if (metadata_streams_autocopy)
2106
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2107
                             AV_METADATA_DONT_OVERWRITE);
2108

    
2109
        ost->st->disposition = ist->st->disposition;
2110
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2111
        codec->chroma_sample_location = icodec->chroma_sample_location;
2112

    
2113
        if (ost->st->stream_copy) {
2114
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2115

    
2116
            if (extra_size > INT_MAX)
2117
                goto fail;
2118

    
2119
            /* if stream_copy is selected, no need to decode or encode */
2120
            codec->codec_id = icodec->codec_id;
2121
            codec->codec_type = icodec->codec_type;
2122

    
2123
            if(!codec->codec_tag){
2124
                if(   !os->oformat->codec_tag
2125
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2126
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2127
                    codec->codec_tag = icodec->codec_tag;
2128
            }
2129

    
2130
            codec->bit_rate = icodec->bit_rate;
2131
            codec->rc_max_rate    = icodec->rc_max_rate;
2132
            codec->rc_buffer_size = icodec->rc_buffer_size;
2133
            codec->extradata= av_mallocz(extra_size);
2134
            if (!codec->extradata)
2135
                goto fail;
2136
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2137
            codec->extradata_size= icodec->extradata_size;
2138
            if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2139
                codec->time_base = icodec->time_base;
2140
                codec->time_base.num *= icodec->ticks_per_frame;
2141
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2142
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2143
            }else
2144
                codec->time_base = ist->st->time_base;
2145
            switch(codec->codec_type) {
2146
            case AVMEDIA_TYPE_AUDIO:
2147
                if(audio_volume != 256) {
2148
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2149
                    ffmpeg_exit(1);
2150
                }
2151
                codec->channel_layout = icodec->channel_layout;
2152
                codec->sample_rate = icodec->sample_rate;
2153
                codec->channels = icodec->channels;
2154
                codec->frame_size = icodec->frame_size;
2155
                codec->block_align= icodec->block_align;
2156
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2157
                    codec->block_align= 0;
2158
                if(codec->codec_id == CODEC_ID_AC3)
2159
                    codec->block_align= 0;
2160
                break;
2161
            case AVMEDIA_TYPE_VIDEO:
2162
                codec->pix_fmt = icodec->pix_fmt;
2163
                codec->width = icodec->width;
2164
                codec->height = icodec->height;
2165
                codec->has_b_frames = icodec->has_b_frames;
2166
                break;
2167
            case AVMEDIA_TYPE_SUBTITLE:
2168
                codec->width = icodec->width;
2169
                codec->height = icodec->height;
2170
                break;
2171
            default:
2172
                abort();
2173
            }
2174
        } else {
2175
            switch(codec->codec_type) {
2176
            case AVMEDIA_TYPE_AUDIO:
2177
                ost->fifo= av_fifo_alloc(1024);
2178
                if(!ost->fifo)
2179
                    goto fail;
2180
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2181
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2182
                icodec->request_channels = codec->channels;
2183
                ist->decoding_needed = 1;
2184
                ost->encoding_needed = 1;
2185
                ost->resample_sample_fmt  = icodec->sample_fmt;
2186
                ost->resample_sample_rate = icodec->sample_rate;
2187
                ost->resample_channels    = icodec->channels;
2188
                break;
2189
            case AVMEDIA_TYPE_VIDEO:
2190
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2191
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2192
                    ffmpeg_exit(1);
2193
                }
2194
                ost->video_resample = (codec->width != icodec->width   ||
2195
                                       codec->height != icodec->height ||
2196
                        (codec->pix_fmt != icodec->pix_fmt));
2197
                if (ost->video_resample) {
2198
#if !CONFIG_AVFILTER
2199
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2200
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2201
                                         codec->width, codec->height)) {
2202
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2203
                        ffmpeg_exit(1);
2204
                    }
2205
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2206
                    ost->img_resample_ctx = sws_getContext(
2207
                        icodec->width,
2208
                        icodec->height,
2209
                            icodec->pix_fmt,
2210
                            codec->width,
2211
                            codec->height,
2212
                            codec->pix_fmt,
2213
                            sws_flags, NULL, NULL, NULL);
2214
                    if (ost->img_resample_ctx == NULL) {
2215
                        fprintf(stderr, "Cannot get resampling context\n");
2216
                        ffmpeg_exit(1);
2217
                    }
2218

    
2219
                    ost->original_height = icodec->height;
2220
                    ost->original_width  = icodec->width;
2221
#endif
2222
                    codec->bits_per_raw_sample= 0;
2223
                }
2224
                ost->resample_height = icodec->height;
2225
                ost->resample_width  = icodec->width;
2226
                ost->resample_pix_fmt= icodec->pix_fmt;
2227
                ost->encoding_needed = 1;
2228
                ist->decoding_needed = 1;
2229

    
2230
#if CONFIG_AVFILTER
2231
                if (configure_filters(ist, ost)) {
2232
                    fprintf(stderr, "Error opening filters!\n");
2233
                    exit(1);
2234
                }
2235
#endif
2236
                break;
2237
            case AVMEDIA_TYPE_SUBTITLE:
2238
                ost->encoding_needed = 1;
2239
                ist->decoding_needed = 1;
2240
                break;
2241
            default:
2242
                abort();
2243
                break;
2244
            }
2245
            /* two pass mode */
2246
            if (ost->encoding_needed &&
2247
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2248
                char logfilename[1024];
2249
                FILE *f;
2250

    
2251
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2252
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2253
                         i);
2254
                if (codec->flags & CODEC_FLAG_PASS1) {
2255
                    f = fopen(logfilename, "wb");
2256
                    if (!f) {
2257
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2258
                        ffmpeg_exit(1);
2259
                    }
2260
                    ost->logfile = f;
2261
                } else {
2262
                    char  *logbuffer;
2263
                    size_t logbuffer_size;
2264
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2265
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2266
                        ffmpeg_exit(1);
2267
                    }
2268
                    codec->stats_in = logbuffer;
2269
                }
2270
            }
2271
        }
2272
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2273
            int size= codec->width * codec->height;
2274
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2275
        }
2276
    }
2277

    
2278
    if (!bit_buffer)
2279
        bit_buffer = av_malloc(bit_buffer_size);
2280
    if (!bit_buffer) {
2281
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2282
                bit_buffer_size);
2283
        ret = AVERROR(ENOMEM);
2284
        goto fail;
2285
    }
2286

    
2287
    /* open each encoder */
2288
    for(i=0;i<nb_ostreams;i++) {
2289
        ost = ost_table[i];
2290
        if (ost->encoding_needed) {
2291
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2292
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2293
            if (!codec)
2294
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2295
            if (!codec) {
2296
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2297
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2298
                ret = AVERROR(EINVAL);
2299
                goto dump_format;
2300
            }
2301
            if (dec->subtitle_header) {
2302
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2303
                if (!ost->st->codec->subtitle_header) {
2304
                    ret = AVERROR(ENOMEM);
2305
                    goto dump_format;
2306
                }
2307
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2308
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2309
            }
2310
            if (avcodec_open(ost->st->codec, codec) < 0) {
2311
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2312
                        ost->file_index, ost->index);
2313
                ret = AVERROR(EINVAL);
2314
                goto dump_format;
2315
            }
2316
            extra_size += ost->st->codec->extradata_size;
2317
        }
2318
    }
2319

    
2320
    /* open each decoder */
2321
    for(i=0;i<nb_istreams;i++) {
2322
        ist = ist_table[i];
2323
        if (ist->decoding_needed) {
2324
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2325
            if (!codec)
2326
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2327
            if (!codec) {
2328
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2329
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2330
                ret = AVERROR(EINVAL);
2331
                goto dump_format;
2332
            }
2333
            if (avcodec_open(ist->st->codec, codec) < 0) {
2334
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2335
                        ist->file_index, ist->index);
2336
                ret = AVERROR(EINVAL);
2337
                goto dump_format;
2338
            }
2339
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2340
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2341
        }
2342
    }
2343

    
2344
    /* init pts */
2345
    for(i=0;i<nb_istreams;i++) {
2346
        AVStream *st;
2347
        ist = ist_table[i];
2348
        st= ist->st;
2349
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2350
        ist->next_pts = AV_NOPTS_VALUE;
2351
        init_pts_correction(&ist->pts_ctx);
2352
        ist->is_start = 1;
2353
    }
2354

    
2355
    /* set meta data information from input file if required */
2356
    for (i=0;i<nb_meta_data_maps;i++) {
2357
        AVFormatContext *files[2];
2358
        AVMetadata      **meta[2];
2359
        int j;
2360

    
2361
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2362
        if ((index) < 0 || (index) >= (nb_elems)) {\
2363
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2364
                     (desc), (index));\
2365
            ret = AVERROR(EINVAL);\
2366
            goto dump_format;\
2367
        }
2368

    
2369
        int out_file_index = meta_data_maps[i][0].file;
2370
        int in_file_index = meta_data_maps[i][1].file;
2371
        if (in_file_index < 0 || out_file_index < 0)
2372
            continue;
2373
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2374
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2375

    
2376
        files[0] = output_files[out_file_index];
2377
        files[1] = input_files[in_file_index];
2378

    
2379
        for (j = 0; j < 2; j++) {
2380
            AVMetaDataMap *map = &meta_data_maps[i][j];
2381

    
2382
            switch (map->type) {
2383
            case 'g':
2384
                meta[j] = &files[j]->metadata;
2385
                break;
2386
            case 's':
2387
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2388
                meta[j] = &files[j]->streams[map->index]->metadata;
2389
                break;
2390
            case 'c':
2391
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2392
                meta[j] = &files[j]->chapters[map->index]->metadata;
2393
                break;
2394
            case 'p':
2395
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2396
                meta[j] = &files[j]->programs[map->index]->metadata;
2397
                break;
2398
            }
2399
        }
2400

    
2401
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2402
    }
2403

    
2404
    /* copy global metadata by default */
2405
    if (metadata_global_autocopy) {
2406

    
2407
        for (i = 0; i < nb_output_files; i++)
2408
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2409
                             AV_METADATA_DONT_OVERWRITE);
2410
    }
2411

    
2412
    /* copy chapters according to chapter maps */
2413
    for (i = 0; i < nb_chapter_maps; i++) {
2414
        int infile  = chapter_maps[i].in_file;
2415
        int outfile = chapter_maps[i].out_file;
2416

    
2417
        if (infile < 0 || outfile < 0)
2418
            continue;
2419
        if (infile >= nb_input_files) {
2420
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2421
            ret = AVERROR(EINVAL);
2422
            goto dump_format;
2423
        }
2424
        if (outfile >= nb_output_files) {
2425
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2426
            ret = AVERROR(EINVAL);
2427
            goto dump_format;
2428
        }
2429
        copy_chapters(infile, outfile);
2430
    }
2431

    
2432
    /* copy chapters from the first input file that has them*/
2433
    if (!nb_chapter_maps)
2434
        for (i = 0; i < nb_input_files; i++) {
2435
            if (!input_files[i]->nb_chapters)
2436
                continue;
2437

    
2438
            for (j = 0; j < nb_output_files; j++)
2439
                if ((ret = copy_chapters(i, j)) < 0)
2440
                    goto dump_format;
2441
            break;
2442
        }
2443

    
2444
    /* open files and write file headers */
2445
    for(i=0;i<nb_output_files;i++) {
2446
        os = output_files[i];
2447
        if (av_write_header(os) < 0) {
2448
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2449
            ret = AVERROR(EINVAL);
2450
            goto dump_format;
2451
        }
2452
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2453
            want_sdp = 0;
2454
        }
2455
    }
2456

    
2457
 dump_format:
2458
    /* dump the file output parameters - cannot be done before in case
2459
       of stream copy */
2460
    for(i=0;i<nb_output_files;i++) {
2461
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2462
    }
2463

    
2464
    /* dump the stream mapping */
2465
    if (verbose >= 0) {
2466
        fprintf(stderr, "Stream mapping:\n");
2467
        for(i=0;i<nb_ostreams;i++) {
2468
            ost = ost_table[i];
2469
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2470
                    ist_table[ost->source_index]->file_index,
2471
                    ist_table[ost->source_index]->index,
2472
                    ost->file_index,
2473
                    ost->index);
2474
            if (ost->sync_ist != ist_table[ost->source_index])
2475
                fprintf(stderr, " [sync #%d.%d]",
2476
                        ost->sync_ist->file_index,
2477
                        ost->sync_ist->index);
2478
            fprintf(stderr, "\n");
2479
        }
2480
    }
2481

    
2482
    if (ret) {
2483
        fprintf(stderr, "%s\n", error);
2484
        goto fail;
2485
    }
2486

    
2487
    if (want_sdp) {
2488
        print_sdp(output_files, nb_output_files);
2489
    }
2490

    
2491
    if (!using_stdin && verbose >= 0) {
2492
        fprintf(stderr, "Press [q] to stop encoding\n");
2493
        url_set_interrupt_cb(decode_interrupt_cb);
2494
    }
2495
    term_init();
2496

    
2497
    timer_start = av_gettime();
2498

    
2499
    for(; received_sigterm == 0;) {
2500
        int file_index, ist_index;
2501
        AVPacket pkt;
2502
        double ipts_min;
2503
        double opts_min;
2504

    
2505
    redo:
2506
        ipts_min= 1e100;
2507
        opts_min= 1e100;
2508
        /* if 'q' pressed, exits */
2509
        if (!using_stdin) {
2510
            if (q_pressed)
2511
                break;
2512
            /* read_key() returns 0 on EOF */
2513
            key = read_key();
2514
            if (key == 'q')
2515
                break;
2516
        }
2517

    
2518
        /* select the stream that we must read now by looking at the
2519
           smallest output pts */
2520
        file_index = -1;
2521
        for(i=0;i<nb_ostreams;i++) {
2522
            double ipts, opts;
2523
            ost = ost_table[i];
2524
            os = output_files[ost->file_index];
2525
            ist = ist_table[ost->source_index];
2526
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2527
                continue;
2528
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2529
            ipts = (double)ist->pts;
2530
            if (!file_table[ist->file_index].eof_reached){
2531
                if(ipts < ipts_min) {
2532
                    ipts_min = ipts;
2533
                    if(input_sync ) file_index = ist->file_index;
2534
                }
2535
                if(opts < opts_min) {
2536
                    opts_min = opts;
2537
                    if(!input_sync) file_index = ist->file_index;
2538
                }
2539
            }
2540
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2541
                file_index= -1;
2542
                break;
2543
            }
2544
        }
2545
        /* if none, if is finished */
2546
        if (file_index < 0) {
2547
            if(no_packet_count){
2548
                no_packet_count=0;
2549
                memset(no_packet, 0, sizeof(no_packet));
2550
                usleep(10000);
2551
                continue;
2552
            }
2553
            break;
2554
        }
2555

    
2556
        /* finish if limit size exhausted */
2557
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2558
            break;
2559

    
2560
        /* read a frame from it and output it in the fifo */
2561
        is = input_files[file_index];
2562
        ret= av_read_frame(is, &pkt);
2563
        if(ret == AVERROR(EAGAIN)){
2564
            no_packet[file_index]=1;
2565
            no_packet_count++;
2566
            continue;
2567
        }
2568
        if (ret < 0) {
2569
            file_table[file_index].eof_reached = 1;
2570
            if (opt_shortest)
2571
                break;
2572
            else
2573
                continue;
2574
        }
2575

    
2576
        no_packet_count=0;
2577
        memset(no_packet, 0, sizeof(no_packet));
2578

    
2579
        if (do_pkt_dump) {
2580
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2581
                             is->streams[pkt.stream_index]);
2582
        }
2583
        /* the following test is needed in case new streams appear
2584
           dynamically in stream : we ignore them */
2585
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2586
            goto discard_packet;
2587
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2588
        ist = ist_table[ist_index];
2589
        if (ist->discard)
2590
            goto discard_packet;
2591

    
2592
        if (pkt.dts != AV_NOPTS_VALUE)
2593
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2594
        if (pkt.pts != AV_NOPTS_VALUE)
2595
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2596

    
2597
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2598
            && input_files_ts_scale[file_index][pkt.stream_index]){
2599
            if(pkt.pts != AV_NOPTS_VALUE)
2600
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2601
            if(pkt.dts != AV_NOPTS_VALUE)
2602
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2603
        }
2604

    
2605
//        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);
2606
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2607
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2608
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2609
            int64_t delta= pkt_dts - ist->next_pts;
2610
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2611
                input_files_ts_offset[ist->file_index]-= delta;
2612
                if (verbose > 2)
2613
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2614
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2615
                if(pkt.pts != AV_NOPTS_VALUE)
2616
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2617
            }
2618
        }
2619

    
2620
        /* finish if recording time exhausted */
2621
        if (recording_time != INT64_MAX &&
2622
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2623
            ist->is_past_recording_time = 1;
2624
            goto discard_packet;
2625
        }
2626

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

    
2630
            if (verbose >= 0)
2631
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2632
                        ist->file_index, ist->index);
2633
            if (exit_on_error)
2634
                ffmpeg_exit(1);
2635
            av_free_packet(&pkt);
2636
            goto redo;
2637
        }
2638

    
2639
    discard_packet:
2640
        av_free_packet(&pkt);
2641

    
2642
        /* dump report by using the output first video and audio streams */
2643
        print_report(output_files, ost_table, nb_ostreams, 0);
2644
    }
2645

    
2646
    /* at the end of stream, we must flush the decoder buffers */
2647
    for(i=0;i<nb_istreams;i++) {
2648
        ist = ist_table[i];
2649
        if (ist->decoding_needed) {
2650
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2651
        }
2652
    }
2653

    
2654
    term_exit();
2655

    
2656
    /* write the trailer if needed and close file */
2657
    for(i=0;i<nb_output_files;i++) {
2658
        os = output_files[i];
2659
        av_write_trailer(os);
2660
    }
2661

    
2662
    /* dump report by using the first video and audio streams */
2663
    print_report(output_files, ost_table, nb_ostreams, 1);
2664

    
2665
    /* close each encoder */
2666
    for(i=0;i<nb_ostreams;i++) {
2667
        ost = ost_table[i];
2668
        if (ost->encoding_needed) {
2669
            av_freep(&ost->st->codec->stats_in);
2670
            avcodec_close(ost->st->codec);
2671
        }
2672
    }
2673

    
2674
    /* close each decoder */
2675
    for(i=0;i<nb_istreams;i++) {
2676
        ist = ist_table[i];
2677
        if (ist->decoding_needed) {
2678
            avcodec_close(ist->st->codec);
2679
        }
2680
    }
2681
#if CONFIG_AVFILTER
2682
    avfilter_graph_free(&graph);
2683
#endif
2684

    
2685
    /* finished ! */
2686
    ret = 0;
2687

    
2688
 fail:
2689
    av_freep(&bit_buffer);
2690
    av_free(file_table);
2691

    
2692
    if (ist_table) {
2693
        for(i=0;i<nb_istreams;i++) {
2694
            ist = ist_table[i];
2695
            av_free(ist);
2696
        }
2697
        av_free(ist_table);
2698
    }
2699
    if (ost_table) {
2700
        for(i=0;i<nb_ostreams;i++) {
2701
            ost = ost_table[i];
2702
            if (ost) {
2703
                if (ost->st->stream_copy)
2704
                    av_freep(&ost->st->codec->extradata);
2705
                if (ost->logfile) {
2706
                    fclose(ost->logfile);
2707
                    ost->logfile = NULL;
2708
                }
2709
                av_fifo_free(ost->fifo); /* works even if fifo is not
2710
                                             initialized but set to zero */
2711
                av_freep(&ost->st->codec->subtitle_header);
2712
                av_free(ost->pict_tmp.data[0]);
2713
                av_free(ost->forced_kf_pts);
2714
                if (ost->video_resample)
2715
                    sws_freeContext(ost->img_resample_ctx);
2716
                if (ost->resample)
2717
                    audio_resample_close(ost->resample);
2718
                if (ost->reformat_ctx)
2719
                    av_audio_convert_free(ost->reformat_ctx);
2720
                av_free(ost);
2721
            }
2722
        }
2723
        av_free(ost_table);
2724
    }
2725
    return ret;
2726
}
2727

    
2728
static void opt_format(const char *arg)
2729
{
2730
    last_asked_format = arg;
2731
}
2732

    
2733
static void opt_video_rc_override_string(const char *arg)
2734
{
2735
    video_rc_override_string = arg;
2736
}
2737

    
2738
static int opt_me_threshold(const char *opt, const char *arg)
2739
{
2740
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2741
    return 0;
2742
}
2743

    
2744
static int opt_verbose(const char *opt, const char *arg)
2745
{
2746
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2747
    return 0;
2748
}
2749

    
2750
static int opt_frame_rate(const char *opt, const char *arg)
2751
{
2752
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2753
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2754
        ffmpeg_exit(1);
2755
    }
2756
    return 0;
2757
}
2758

    
2759
static int opt_bitrate(const char *opt, const char *arg)
2760
{
2761
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2762

    
2763
    opt_default(opt, arg);
2764

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

    
2768
    return 0;
2769
}
2770

    
2771
static int opt_frame_crop(const char *opt, const char *arg)
2772
{
2773
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2774
    return AVERROR(EINVAL);
2775
}
2776

    
2777
static void opt_frame_size(const char *arg)
2778
{
2779
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2780
        fprintf(stderr, "Incorrect frame size\n");
2781
        ffmpeg_exit(1);
2782
    }
2783
}
2784

    
2785
static int opt_pad(const char *opt, const char *arg) {
2786
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2787
    return -1;
2788
}
2789

    
2790
static void opt_frame_pix_fmt(const char *arg)
2791
{
2792
    if (strcmp(arg, "list")) {
2793
        frame_pix_fmt = av_get_pix_fmt(arg);
2794
        if (frame_pix_fmt == PIX_FMT_NONE) {
2795
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2796
            ffmpeg_exit(1);
2797
        }
2798
    } else {
2799
        show_pix_fmts();
2800
        ffmpeg_exit(0);
2801
    }
2802
}
2803

    
2804
static void opt_frame_aspect_ratio(const char *arg)
2805
{
2806
    int x = 0, y = 0;
2807
    double ar = 0;
2808
    const char *p;
2809
    char *end;
2810

    
2811
    p = strchr(arg, ':');
2812
    if (p) {
2813
        x = strtol(arg, &end, 10);
2814
        if (end == p)
2815
            y = strtol(end+1, &end, 10);
2816
        if (x > 0 && y > 0)
2817
            ar = (double)x / (double)y;
2818
    } else
2819
        ar = strtod(arg, NULL);
2820

    
2821
    if (!ar) {
2822
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2823
        ffmpeg_exit(1);
2824
    }
2825
    frame_aspect_ratio = ar;
2826
}
2827

    
2828
static int opt_metadata(const char *opt, const char *arg)
2829
{
2830
    char *mid= strchr(arg, '=');
2831

    
2832
    if(!mid){
2833
        fprintf(stderr, "Missing =\n");
2834
        ffmpeg_exit(1);
2835
    }
2836
    *mid++= 0;
2837

    
2838
    av_metadata_set2(&metadata, arg, mid, 0);
2839

    
2840
    return 0;
2841
}
2842

    
2843
static void opt_qscale(const char *arg)
2844
{
2845
    video_qscale = atof(arg);
2846
    if (video_qscale <= 0 ||
2847
        video_qscale > 255) {
2848
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2849
        ffmpeg_exit(1);
2850
    }
2851
}
2852

    
2853
static void opt_top_field_first(const char *arg)
2854
{
2855
    top_field_first= atoi(arg);
2856
}
2857

    
2858
static int opt_thread_count(const char *opt, const char *arg)
2859
{
2860
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2861
#if !HAVE_THREADS
2862
    if (verbose >= 0)
2863
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2864
#endif
2865
    return 0;
2866
}
2867

    
2868
static void opt_audio_sample_fmt(const char *arg)
2869
{
2870
    if (strcmp(arg, "list")) {
2871
        audio_sample_fmt = av_get_sample_fmt(arg);
2872
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2873
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2874
            ffmpeg_exit(1);
2875
        }
2876
    } else {
2877
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2878
        ffmpeg_exit(0);
2879
    }
2880
}
2881

    
2882
static int opt_audio_rate(const char *opt, const char *arg)
2883
{
2884
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2885
    return 0;
2886
}
2887

    
2888
static int opt_audio_channels(const char *opt, const char *arg)
2889
{
2890
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2891
    return 0;
2892
}
2893

    
2894
static void opt_video_channel(const char *arg)
2895
{
2896
    video_channel = strtol(arg, NULL, 0);
2897
}
2898

    
2899
static void opt_video_standard(const char *arg)
2900
{
2901
    video_standard = av_strdup(arg);
2902
}
2903

    
2904
static void opt_codec(int *pstream_copy, char **pcodec_name,
2905
                      int codec_type, const char *arg)
2906
{
2907
    av_freep(pcodec_name);
2908
    if (!strcmp(arg, "copy")) {
2909
        *pstream_copy = 1;
2910
    } else {
2911
        *pcodec_name = av_strdup(arg);
2912
    }
2913
}
2914

    
2915
static void opt_audio_codec(const char *arg)
2916
{
2917
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2918
}
2919

    
2920
static void opt_video_codec(const char *arg)
2921
{
2922
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2923
}
2924

    
2925
static void opt_subtitle_codec(const char *arg)
2926
{
2927
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2928
}
2929

    
2930
static int opt_codec_tag(const char *opt, const char *arg)
2931
{
2932
    char *tail;
2933
    uint32_t *codec_tag;
2934

    
2935
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2936
                !strcmp(opt, "vtag") ? &video_codec_tag :
2937
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2938
    if (!codec_tag)
2939
        return -1;
2940

    
2941
    *codec_tag = strtol(arg, &tail, 0);
2942
    if (!tail || *tail)
2943
        *codec_tag = AV_RL32(arg);
2944

    
2945
    return 0;
2946
}
2947

    
2948
static void opt_map(const char *arg)
2949
{
2950
    AVStreamMap *m;
2951
    char *p;
2952

    
2953
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2954
    m = &stream_maps[nb_stream_maps-1];
2955

    
2956
    m->file_index = strtol(arg, &p, 0);
2957
    if (*p)
2958
        p++;
2959

    
2960
    m->stream_index = strtol(p, &p, 0);
2961
    if (*p) {
2962
        p++;
2963
        m->sync_file_index = strtol(p, &p, 0);
2964
        if (*p)
2965
            p++;
2966
        m->sync_stream_index = strtol(p, &p, 0);
2967
    } else {
2968
        m->sync_file_index = m->file_index;
2969
        m->sync_stream_index = m->stream_index;
2970
    }
2971
}
2972

    
2973
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2974
{
2975
    *endptr = arg;
2976
    if (*arg == ',') {
2977
        *type = *(++arg);
2978
        switch (*arg) {
2979
        case 'g':
2980
            break;
2981
        case 's':
2982
        case 'c':
2983
        case 'p':
2984
            *index = strtol(++arg, endptr, 0);
2985
            break;
2986
        default:
2987
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2988
            ffmpeg_exit(1);
2989
        }
2990
    } else
2991
        *type = 'g';
2992
}
2993

    
2994
static void opt_map_metadata(const char *arg)
2995
{
2996
    AVMetaDataMap *m, *m1;
2997
    char *p;
2998

    
2999
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3000
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3001

    
3002
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3003
    m->file = strtol(arg, &p, 0);
3004
    parse_meta_type(p, &m->type, &m->index, &p);
3005
    if (*p)
3006
        p++;
3007

    
3008
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3009
    m1->file = strtol(p, &p, 0);
3010
    parse_meta_type(p, &m1->type, &m1->index, &p);
3011

    
3012
    if (m->type == 'g' || m1->type == 'g')
3013
        metadata_global_autocopy = 0;
3014
    if (m->type == 's' || m1->type == 's')
3015
        metadata_streams_autocopy = 0;
3016
    if (m->type == 'c' || m1->type == 'c')
3017
        metadata_chapters_autocopy = 0;
3018
}
3019

    
3020
static void opt_map_meta_data(const char *arg)
3021
{
3022
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3023
                    "Use -map_metadata instead.\n");
3024
    opt_map_metadata(arg);
3025
}
3026

    
3027
static void opt_map_chapters(const char *arg)
3028
{
3029
    AVChapterMap *c;
3030
    char *p;
3031

    
3032
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3033
                              nb_chapter_maps + 1);
3034
    c = &chapter_maps[nb_chapter_maps - 1];
3035
    c->out_file = strtol(arg, &p, 0);
3036
    if (*p)
3037
        p++;
3038

    
3039
    c->in_file = strtol(p, &p, 0);
3040
}
3041

    
3042
static void opt_input_ts_scale(const char *arg)
3043
{
3044
    unsigned int stream;
3045
    double scale;
3046
    char *p;
3047

    
3048
    stream = strtol(arg, &p, 0);
3049
    if (*p)
3050
        p++;
3051
    scale= strtod(p, &p);
3052

    
3053
    if(stream >= MAX_STREAMS)
3054
        ffmpeg_exit(1);
3055

    
3056
    input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3057
    input_files_ts_scale[nb_input_files][stream]= scale;
3058
}
3059

    
3060
static int opt_recording_time(const char *opt, const char *arg)
3061
{
3062
    recording_time = parse_time_or_die(opt, arg, 1);
3063
    return 0;
3064
}
3065

    
3066
static int opt_start_time(const char *opt, const char *arg)
3067
{
3068
    start_time = parse_time_or_die(opt, arg, 1);
3069
    return 0;
3070
}
3071

    
3072
static int opt_recording_timestamp(const char *opt, const char *arg)
3073
{
3074
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3075
    return 0;
3076
}
3077

    
3078
static int opt_input_ts_offset(const char *opt, const char *arg)
3079
{
3080
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3081
    return 0;
3082
}
3083

    
3084
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3085
{
3086
    const char *codec_string = encoder ? "encoder" : "decoder";
3087
    AVCodec *codec;
3088

    
3089
    if(!name)
3090
        return CODEC_ID_NONE;
3091
    codec = encoder ?
3092
        avcodec_find_encoder_by_name(name) :
3093
        avcodec_find_decoder_by_name(name);
3094
    if(!codec) {
3095
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3096
        ffmpeg_exit(1);
3097
    }
3098
    if(codec->type != type) {
3099
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3100
        ffmpeg_exit(1);
3101
    }
3102
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3103
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3104
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3105
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3106
                codec_string, codec->name);
3107
        codec = encoder ?
3108
            avcodec_find_encoder(codec->id) :
3109
            avcodec_find_decoder(codec->id);
3110
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3111
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3112
                    codec_string, codec->name);
3113
        ffmpeg_exit(1);
3114
    }
3115
    return codec->id;
3116
}
3117

    
3118
static void opt_input_file(const char *filename)
3119
{
3120
    AVFormatContext *ic;
3121
    AVFormatParameters params, *ap = &params;
3122
    AVInputFormat *file_iformat = NULL;
3123
    int err, i, ret, rfps, rfps_base;
3124
    int64_t timestamp;
3125

    
3126
    if (last_asked_format) {
3127
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3128
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3129
            ffmpeg_exit(1);
3130
        }
3131
        last_asked_format = NULL;
3132
    }
3133

    
3134
    if (!strcmp(filename, "-"))
3135
        filename = "pipe:";
3136

    
3137
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3138
                    !strcmp(filename, "/dev/stdin");
3139

    
3140
    /* get default parameters from command line */
3141
    ic = avformat_alloc_context();
3142
    if (!ic) {
3143
        print_error(filename, AVERROR(ENOMEM));
3144
        ffmpeg_exit(1);
3145
    }
3146

    
3147
    memset(ap, 0, sizeof(*ap));
3148
    ap->prealloced_context = 1;
3149
    ap->sample_rate = audio_sample_rate;
3150
    ap->channels = audio_channels;
3151
    ap->time_base.den = frame_rate.num;
3152
    ap->time_base.num = frame_rate.den;
3153
    ap->width = frame_width;
3154
    ap->height = frame_height;
3155
    ap->pix_fmt = frame_pix_fmt;
3156
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3157
    ap->channel = video_channel;
3158
    ap->standard = video_standard;
3159

    
3160
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3161

    
3162
    ic->video_codec_id   =
3163
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3164
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3165
    ic->audio_codec_id   =
3166
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3167
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3168
    ic->subtitle_codec_id=
3169
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3170
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3171
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3172

    
3173
    /* open the input file with generic libav function */
3174
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3175
    if (err < 0) {
3176
        print_error(filename, err);
3177
        ffmpeg_exit(1);
3178
    }
3179
    if(opt_programid) {
3180
        int i, j;
3181
        int found=0;
3182
        for(i=0; i<ic->nb_streams; i++){
3183
            ic->streams[i]->discard= AVDISCARD_ALL;
3184
        }
3185
        for(i=0; i<ic->nb_programs; i++){
3186
            AVProgram *p= ic->programs[i];
3187
            if(p->id != opt_programid){
3188
                p->discard = AVDISCARD_ALL;
3189
            }else{
3190
                found=1;
3191
                for(j=0; j<p->nb_stream_indexes; j++){
3192
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3193
                }
3194
            }
3195
        }
3196
        if(!found){
3197
            fprintf(stderr, "Specified program id not found\n");
3198
            ffmpeg_exit(1);
3199
        }
3200
        opt_programid=0;
3201
    }
3202

    
3203
    ic->loop_input = loop_input;
3204

    
3205
    /* If not enough info to get the stream parameters, we decode the
3206
       first frames to get it. (used in mpeg case for example) */
3207
    ret = av_find_stream_info(ic);
3208
    if (ret < 0 && verbose >= 0) {
3209
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3210
        av_close_input_file(ic);
3211
        ffmpeg_exit(1);
3212
    }
3213

    
3214
    timestamp = start_time;
3215
    /* add the stream start time */
3216
    if (ic->start_time != AV_NOPTS_VALUE)
3217
        timestamp += ic->start_time;
3218

    
3219
    /* if seeking requested, we execute it */
3220
    if (start_time != 0) {
3221
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3222
        if (ret < 0) {
3223
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3224
                    filename, (double)timestamp / AV_TIME_BASE);
3225
        }
3226
        /* reset seek info */
3227
        start_time = 0;
3228
    }
3229

    
3230
    /* update the current parameters so that they match the one of the input stream */
3231
    for(i=0;i<ic->nb_streams;i++) {
3232
        AVStream *st = ic->streams[i];
3233
        AVCodecContext *dec = st->codec;
3234
        dec->thread_count = thread_count;
3235
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3236
        switch (dec->codec_type) {
3237
        case AVMEDIA_TYPE_AUDIO:
3238
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3239
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3240
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3241
            channel_layout    = dec->channel_layout;
3242
            audio_channels    = dec->channels;
3243
            audio_sample_rate = dec->sample_rate;
3244
            audio_sample_fmt  = dec->sample_fmt;
3245
            if(audio_disable)
3246
                st->discard= AVDISCARD_ALL;
3247
            /* Note that av_find_stream_info can add more streams, and we
3248
             * currently have no chance of setting up lowres decoding
3249
             * early enough for them. */
3250
            if (dec->lowres)
3251
                audio_sample_rate >>= dec->lowres;
3252
            break;
3253
        case AVMEDIA_TYPE_VIDEO:
3254
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3255
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3256
            frame_height = dec->height;
3257
            frame_width  = dec->width;
3258
            if(ic->streams[i]->sample_aspect_ratio.num)
3259
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3260
            else
3261
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3262
            frame_aspect_ratio *= (float) dec->width / dec->height;
3263
            frame_pix_fmt = dec->pix_fmt;
3264
            rfps      = ic->streams[i]->r_frame_rate.num;
3265
            rfps_base = ic->streams[i]->r_frame_rate.den;
3266
            if (dec->lowres) {
3267
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3268
                frame_height >>= dec->lowres;
3269
                frame_width  >>= dec->lowres;
3270
                dec->height = frame_height;
3271
                dec->width  = frame_width;
3272
            }
3273
            if(me_threshold)
3274
                dec->debug |= FF_DEBUG_MV;
3275

    
3276
            if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3277

    
3278
                if (verbose >= 0)
3279
                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3280
                            i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3281

    
3282
                    (float)rfps / rfps_base, rfps, rfps_base);
3283
            }
3284
            /* update the current frame rate to match the stream frame rate */
3285
            frame_rate.num = rfps;
3286
            frame_rate.den = rfps_base;
3287

    
3288
            if(video_disable)
3289
                st->discard= AVDISCARD_ALL;
3290
            else if(video_discard)
3291
                st->discard= video_discard;
3292
            break;
3293
        case AVMEDIA_TYPE_DATA:
3294
            break;
3295
        case AVMEDIA_TYPE_SUBTITLE:
3296
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3297
            if(subtitle_disable)
3298
                st->discard = AVDISCARD_ALL;
3299
            break;
3300
        case AVMEDIA_TYPE_ATTACHMENT:
3301
        case AVMEDIA_TYPE_UNKNOWN:
3302
            break;
3303
        default:
3304
            abort();
3305
        }
3306
    }
3307

    
3308
    input_files[nb_input_files] = ic;
3309
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3310
    /* dump the file content */
3311
    if (verbose >= 0)
3312
        av_dump_format(ic, nb_input_files, filename, 0);
3313

    
3314
    nb_input_files++;
3315

    
3316
    video_channel = 0;
3317

    
3318
    av_freep(&video_codec_name);
3319
    av_freep(&audio_codec_name);
3320
    av_freep(&subtitle_codec_name);
3321
}
3322

    
3323
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3324
                                         int *has_subtitle_ptr)
3325
{
3326
    int has_video, has_audio, has_subtitle, i, j;
3327
    AVFormatContext *ic;
3328

    
3329
    has_video = 0;
3330
    has_audio = 0;
3331
    has_subtitle = 0;
3332
    for(j=0;j<nb_input_files;j++) {
3333
        ic = input_files[j];
3334
        for(i=0;i<ic->nb_streams;i++) {
3335
            AVCodecContext *enc = ic->streams[i]->codec;
3336
            switch(enc->codec_type) {
3337
            case AVMEDIA_TYPE_AUDIO:
3338
                has_audio = 1;
3339
                break;
3340
            case AVMEDIA_TYPE_VIDEO:
3341
                has_video = 1;
3342
                break;
3343
            case AVMEDIA_TYPE_SUBTITLE:
3344
                has_subtitle = 1;
3345
                break;
3346
            case AVMEDIA_TYPE_DATA:
3347
            case AVMEDIA_TYPE_ATTACHMENT:
3348
            case AVMEDIA_TYPE_UNKNOWN:
3349
                break;
3350
            default:
3351
                abort();
3352
            }
3353
        }
3354
    }
3355
    *has_video_ptr = has_video;
3356
    *has_audio_ptr = has_audio;
3357
    *has_subtitle_ptr = has_subtitle;
3358
}
3359

    
3360
static void new_video_stream(AVFormatContext *oc, int file_idx)
3361
{
3362
    AVStream *st;
3363
    AVOutputStream *ost;
3364
    AVCodecContext *video_enc;
3365
    enum CodecID codec_id = CODEC_ID_NONE;
3366
    AVCodec *codec= NULL;
3367

    
3368
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3369
    if (!st) {
3370
        fprintf(stderr, "Could not alloc stream\n");
3371
        ffmpeg_exit(1);
3372
    }
3373
    ost = new_output_stream(oc, file_idx);
3374

    
3375
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3376
    if(!video_stream_copy){
3377
        if (video_codec_name) {
3378
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3379
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3380
            codec = avcodec_find_encoder_by_name(video_codec_name);
3381
            output_codecs[nb_output_codecs-1] = codec;
3382
        } else {
3383
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3384
            codec = avcodec_find_encoder(codec_id);
3385
        }
3386
    }
3387

    
3388
    avcodec_get_context_defaults3(st->codec, codec);
3389
    ost->bitstream_filters = video_bitstream_filters;
3390
    video_bitstream_filters= NULL;
3391

    
3392
    st->codec->thread_count= thread_count;
3393

    
3394
    video_enc = st->codec;
3395

    
3396
    if(video_codec_tag)
3397
        video_enc->codec_tag= video_codec_tag;
3398

    
3399
    if(   (video_global_header&1)
3400
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3401
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3402
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3403
    }
3404
    if(video_global_header&2){
3405
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3406
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3407
    }
3408

    
3409
    if (video_stream_copy) {
3410
        st->stream_copy = 1;
3411
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3412
        video_enc->sample_aspect_ratio =
3413
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3414
    } else {
3415
        const char *p;
3416
        int i;
3417
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3418

    
3419
        video_enc->codec_id = codec_id;
3420
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3421

    
3422
        if (codec && codec->supported_framerates && !force_fps)
3423
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3424
        video_enc->time_base.den = fps.num;
3425
        video_enc->time_base.num = fps.den;
3426

    
3427
        video_enc->width = frame_width;
3428
        video_enc->height = frame_height;
3429
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3430
        video_enc->pix_fmt = frame_pix_fmt;
3431
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3432

    
3433
        choose_pixel_fmt(st, codec);
3434

    
3435
        if (intra_only)
3436
            video_enc->gop_size = 0;
3437
        if (video_qscale || same_quality) {
3438
            video_enc->flags |= CODEC_FLAG_QSCALE;
3439
            video_enc->global_quality=
3440
                st->quality = FF_QP2LAMBDA * video_qscale;
3441
        }
3442

    
3443
        if(intra_matrix)
3444
            video_enc->intra_matrix = intra_matrix;
3445
        if(inter_matrix)
3446
            video_enc->inter_matrix = inter_matrix;
3447

    
3448
        p= video_rc_override_string;
3449
        for(i=0; p; i++){
3450
            int start, end, q;
3451
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3452
            if(e!=3){
3453
                fprintf(stderr, "error parsing rc_override\n");
3454
                ffmpeg_exit(1);
3455
            }
3456
            video_enc->rc_override=
3457
                av_realloc(video_enc->rc_override,
3458
                           sizeof(RcOverride)*(i+1));
3459
            video_enc->rc_override[i].start_frame= start;
3460
            video_enc->rc_override[i].end_frame  = end;
3461
            if(q>0){
3462
                video_enc->rc_override[i].qscale= q;
3463
                video_enc->rc_override[i].quality_factor= 1.0;
3464
            }
3465
            else{
3466
                video_enc->rc_override[i].qscale= 0;
3467
                video_enc->rc_override[i].quality_factor= -q/100.0;
3468
            }
3469
            p= strchr(p, '/');
3470
            if(p) p++;
3471
        }
3472
        video_enc->rc_override_count=i;
3473
        if (!video_enc->rc_initial_buffer_occupancy)
3474
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3475
        video_enc->me_threshold= me_threshold;
3476
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3477

    
3478
        if (do_psnr)
3479
            video_enc->flags|= CODEC_FLAG_PSNR;
3480

    
3481
        /* two pass mode */
3482
        if (do_pass) {
3483
            if (do_pass == 1) {
3484
                video_enc->flags |= CODEC_FLAG_PASS1;
3485
            } else {
3486
                video_enc->flags |= CODEC_FLAG_PASS2;
3487
            }
3488
        }
3489

    
3490
        if (forced_key_frames)
3491
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3492
    }
3493
    if (video_language) {
3494
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3495
        av_freep(&video_language);
3496
    }
3497

    
3498
    /* reset some key parameters */
3499
    video_disable = 0;
3500
    av_freep(&video_codec_name);
3501
    av_freep(&forced_key_frames);
3502
    video_stream_copy = 0;
3503
    frame_pix_fmt = PIX_FMT_NONE;
3504
}
3505

    
3506
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3507
{
3508
    AVStream *st;
3509
    AVOutputStream *ost;
3510
    AVCodec *codec= NULL;
3511
    AVCodecContext *audio_enc;
3512
    enum CodecID codec_id = CODEC_ID_NONE;
3513

    
3514
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3515
    if (!st) {
3516
        fprintf(stderr, "Could not alloc stream\n");
3517
        ffmpeg_exit(1);
3518
    }
3519
    ost = new_output_stream(oc, file_idx);
3520

    
3521
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3522
    if(!audio_stream_copy){
3523
        if (audio_codec_name) {
3524
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3525
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3526
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3527
            output_codecs[nb_output_codecs-1] = codec;
3528
        } else {
3529
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3530
            codec = avcodec_find_encoder(codec_id);
3531
        }
3532
    }
3533

    
3534
    avcodec_get_context_defaults3(st->codec, codec);
3535

    
3536
    ost->bitstream_filters = audio_bitstream_filters;
3537
    audio_bitstream_filters= NULL;
3538

    
3539
    st->codec->thread_count= thread_count;
3540

    
3541
    audio_enc = st->codec;
3542
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3543

    
3544
    if(audio_codec_tag)
3545
        audio_enc->codec_tag= audio_codec_tag;
3546

    
3547
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3548
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3549
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3550
    }
3551
    if (audio_stream_copy) {
3552
        st->stream_copy = 1;
3553
        audio_enc->channels = audio_channels;
3554
        audio_enc->sample_rate = audio_sample_rate;
3555
    } else {
3556
        audio_enc->codec_id = codec_id;
3557
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3558

    
3559
        if (audio_qscale > QSCALE_NONE) {
3560
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3561
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3562
        }
3563
        audio_enc->channels = audio_channels;
3564
        audio_enc->sample_fmt = audio_sample_fmt;
3565
        audio_enc->sample_rate = audio_sample_rate;
3566
        audio_enc->channel_layout = channel_layout;
3567
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3568
            audio_enc->channel_layout = 0;
3569
        choose_sample_fmt(st, codec);
3570
        choose_sample_rate(st, codec);
3571
    }
3572
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3573
    if (audio_language) {
3574
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3575
        av_freep(&audio_language);
3576
    }
3577

    
3578
    /* reset some key parameters */
3579
    audio_disable = 0;
3580
    av_freep(&audio_codec_name);
3581
    audio_stream_copy = 0;
3582
}
3583

    
3584
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3585
{
3586
    AVStream *st;
3587
    AVOutputStream *ost;
3588
    AVCodec *codec=NULL;
3589
    AVCodecContext *subtitle_enc;
3590
    enum CodecID codec_id = CODEC_ID_NONE;
3591

    
3592
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3593
    if (!st) {
3594
        fprintf(stderr, "Could not alloc stream\n");
3595
        ffmpeg_exit(1);
3596
    }
3597
    ost = new_output_stream(oc, file_idx);
3598
    subtitle_enc = st->codec;
3599
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3600
    if(!subtitle_stream_copy){
3601
        if (subtitle_codec_name) {
3602
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3603
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3604
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3605
        } else {
3606
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3607
            codec = avcodec_find_encoder(codec_id);
3608
        }
3609
    }
3610
    avcodec_get_context_defaults3(st->codec, codec);
3611

    
3612
    ost->bitstream_filters = subtitle_bitstream_filters;
3613
    subtitle_bitstream_filters= NULL;
3614

    
3615
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3616

    
3617
    if(subtitle_codec_tag)
3618
        subtitle_enc->codec_tag= subtitle_codec_tag;
3619

    
3620
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3621
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3622
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3623
    }
3624
    if (subtitle_stream_copy) {
3625
        st->stream_copy = 1;
3626
    } else {
3627
        subtitle_enc->codec_id = codec_id;
3628
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3629
    }
3630

    
3631
    if (subtitle_language) {
3632
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3633
        av_freep(&subtitle_language);
3634
    }
3635

    
3636
    subtitle_disable = 0;
3637
    av_freep(&subtitle_codec_name);
3638
    subtitle_stream_copy = 0;
3639
}
3640

    
3641
static int opt_new_stream(const char *opt, const char *arg)
3642
{
3643
    AVFormatContext *oc;
3644
    int file_idx = nb_output_files - 1;
3645
    if (nb_output_files <= 0) {
3646
        fprintf(stderr, "At least one output file must be specified\n");
3647
        ffmpeg_exit(1);
3648
    }
3649
    oc = output_files[file_idx];
3650

    
3651
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3652
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3653
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3654
    else av_assert0(0);
3655
    return 0;
3656
}
3657

    
3658
/* arg format is "output-stream-index:streamid-value". */
3659
static int opt_streamid(const char *opt, const char *arg)
3660
{
3661
    int idx;
3662
    char *p;
3663
    char idx_str[16];
3664

    
3665
    strncpy(idx_str, arg, sizeof(idx_str));
3666
    idx_str[sizeof(idx_str)-1] = '\0';
3667
    p = strchr(idx_str, ':');
3668
    if (!p) {
3669
        fprintf(stderr,
3670
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3671
                arg, opt);
3672
        ffmpeg_exit(1);
3673
    }
3674
    *p++ = '\0';
3675
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3676
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3677
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3678
    return 0;
3679
}
3680

    
3681
static void opt_output_file(const char *filename)
3682
{
3683
    AVFormatContext *oc;
3684
    int err, use_video, use_audio, use_subtitle;
3685
    int input_has_video, input_has_audio, input_has_subtitle;
3686
    AVFormatParameters params, *ap = &params;
3687
    AVOutputFormat *file_oformat;
3688

    
3689
    if (!strcmp(filename, "-"))
3690
        filename = "pipe:";
3691

    
3692
    oc = avformat_alloc_context();
3693
    if (!oc) {
3694
        print_error(filename, AVERROR(ENOMEM));
3695
        ffmpeg_exit(1);
3696
    }
3697

    
3698
    if (last_asked_format) {
3699
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3700
        if (!file_oformat) {
3701
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3702
            ffmpeg_exit(1);
3703
        }
3704
        last_asked_format = NULL;
3705
    } else {
3706
        file_oformat = av_guess_format(NULL, filename, NULL);
3707
        if (!file_oformat) {
3708
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3709
                    filename);
3710
            ffmpeg_exit(1);
3711
        }
3712
    }
3713

    
3714
    oc->oformat = file_oformat;
3715
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3716

    
3717
    if (!strcmp(file_oformat->name, "ffm") &&
3718
        av_strstart(filename, "http:", NULL)) {
3719
        /* special case for files sent to ffserver: we get the stream
3720
           parameters from ffserver */
3721
        int err = read_ffserver_streams(oc, filename);
3722
        if (err < 0) {
3723
            print_error(filename, err);
3724
            ffmpeg_exit(1);
3725
        }
3726
    } else {
3727
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3728
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3729
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3730

    
3731
        /* disable if no corresponding type found and at least one
3732
           input file */
3733
        if (nb_input_files > 0) {
3734
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3735
                                         &input_has_subtitle);
3736
            if (!input_has_video)
3737
                use_video = 0;
3738
            if (!input_has_audio)
3739
                use_audio = 0;
3740
            if (!input_has_subtitle)
3741
                use_subtitle = 0;
3742
        }
3743

    
3744
        /* manual disable */
3745
        if (audio_disable)    use_audio    = 0;
3746
        if (video_disable)    use_video    = 0;
3747
        if (subtitle_disable) use_subtitle = 0;
3748

    
3749
        if (use_video)    new_video_stream(oc, nb_output_files);
3750
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3751
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3752

    
3753
        oc->timestamp = recording_timestamp;
3754

    
3755
        av_metadata_copy(&oc->metadata, metadata, 0);
3756
        av_metadata_free(&metadata);
3757
    }
3758

    
3759
    output_files[nb_output_files++] = oc;
3760

    
3761
    /* check filename in case of an image number is expected */
3762
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3763
        if (!av_filename_number_test(oc->filename)) {
3764
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3765
            ffmpeg_exit(1);
3766
        }
3767
    }
3768

    
3769
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3770
        /* test if it already exists to avoid loosing precious files */
3771
        if (!file_overwrite &&
3772
            (strchr(filename, ':') == NULL ||
3773
             filename[1] == ':' ||
3774
             av_strstart(filename, "file:", NULL))) {
3775
            if (url_exist(filename)) {
3776
                if (!using_stdin) {
3777
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3778
                    fflush(stderr);
3779
                    if (!read_yesno()) {
3780
                        fprintf(stderr, "Not overwriting - exiting\n");
3781
                        ffmpeg_exit(1);
3782
                    }
3783
                }
3784
                else {
3785
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3786
                    ffmpeg_exit(1);
3787
                }
3788
            }
3789
        }
3790

    
3791
        /* open the file */
3792
        if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3793
            print_error(filename, err);
3794
            ffmpeg_exit(1);
3795
        }
3796
    }
3797

    
3798
    memset(ap, 0, sizeof(*ap));
3799
    if (av_set_parameters(oc, ap) < 0) {
3800
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3801
                oc->filename);
3802
        ffmpeg_exit(1);
3803
    }
3804

    
3805
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3806
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3807
    oc->loop_output = loop_output;
3808
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3809

    
3810
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3811

    
3812
    av_freep(&forced_key_frames);
3813
}
3814

    
3815
/* same option as mencoder */
3816
static void opt_pass(const char *pass_str)
3817
{
3818
    int pass;
3819
    pass = atoi(pass_str);
3820
    if (pass != 1 && pass != 2) {
3821
        fprintf(stderr, "pass number can be only 1 or 2\n");
3822
        ffmpeg_exit(1);
3823
    }
3824
    do_pass = pass;
3825
}
3826

    
3827
static int64_t getutime(void)
3828
{
3829
#if HAVE_GETRUSAGE
3830
    struct rusage rusage;
3831

    
3832
    getrusage(RUSAGE_SELF, &rusage);
3833
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3834
#elif HAVE_GETPROCESSTIMES
3835
    HANDLE proc;
3836
    FILETIME c, e, k, u;
3837
    proc = GetCurrentProcess();
3838
    GetProcessTimes(proc, &c, &e, &k, &u);
3839
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3840
#else
3841
    return av_gettime();
3842
#endif
3843
}
3844

    
3845
static int64_t getmaxrss(void)
3846
{
3847
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3848
    struct rusage rusage;
3849
    getrusage(RUSAGE_SELF, &rusage);
3850
    return (int64_t)rusage.ru_maxrss * 1024;
3851
#elif HAVE_GETPROCESSMEMORYINFO
3852
    HANDLE proc;
3853
    PROCESS_MEMORY_COUNTERS memcounters;
3854
    proc = GetCurrentProcess();
3855
    memcounters.cb = sizeof(memcounters);
3856
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3857
    return memcounters.PeakPagefileUsage;
3858
#else
3859
    return 0;
3860
#endif
3861
}
3862

    
3863
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3864
{
3865
    int i;
3866
    const char *p = str;
3867
    for(i = 0;; i++) {
3868
        dest[i] = atoi(p);
3869
        if(i == 63)
3870
            break;
3871
        p = strchr(p, ',');
3872
        if(!p) {
3873
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3874
            ffmpeg_exit(1);
3875
        }
3876
        p++;
3877
    }
3878
}
3879

    
3880
static void opt_inter_matrix(const char *arg)
3881
{
3882
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3883
    parse_matrix_coeffs(inter_matrix, arg);
3884
}
3885

    
3886
static void opt_intra_matrix(const char *arg)
3887
{
3888
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3889
    parse_matrix_coeffs(intra_matrix, arg);
3890
}
3891

    
3892
static void show_usage(void)
3893
{
3894
    printf("Hyper fast Audio and Video encoder\n");
3895
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3896
    printf("\n");
3897
}
3898

    
3899
static void show_help(void)
3900
{
3901
    AVCodec *c;
3902
    AVOutputFormat *oformat = NULL;
3903

    
3904
    av_log_set_callback(log_callback_help);
3905
    show_usage();
3906
    show_help_options(options, "Main options:\n",
3907
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3908
    show_help_options(options, "\nAdvanced options:\n",
3909
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3910
                      OPT_EXPERT);
3911
    show_help_options(options, "\nVideo options:\n",
3912
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3913
                      OPT_VIDEO);
3914
    show_help_options(options, "\nAdvanced Video options:\n",
3915
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3916
                      OPT_VIDEO | OPT_EXPERT);
3917
    show_help_options(options, "\nAudio options:\n",
3918
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3919
                      OPT_AUDIO);
3920
    show_help_options(options, "\nAdvanced Audio options:\n",
3921
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3922
                      OPT_AUDIO | OPT_EXPERT);
3923
    show_help_options(options, "\nSubtitle options:\n",
3924
                      OPT_SUBTITLE | OPT_GRAB,
3925
                      OPT_SUBTITLE);
3926
    show_help_options(options, "\nAudio/Video grab options:\n",
3927
                      OPT_GRAB,
3928
                      OPT_GRAB);
3929
    printf("\n");
3930
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3931
    printf("\n");
3932

    
3933
    /* individual codec options */
3934
    c = NULL;
3935
    while ((c = av_codec_next(c))) {
3936
        if (c->priv_class) {
3937
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3938
            printf("\n");
3939
        }
3940
    }
3941

    
3942
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3943
    printf("\n");
3944

    
3945
    /* individual muxer options */
3946
    while ((oformat = av_oformat_next(oformat))) {
3947
        if (oformat->priv_class) {
3948
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3949
            printf("\n");
3950
        }
3951
    }
3952

    
3953
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3954
}
3955

    
3956
static void opt_target(const char *arg)
3957
{
3958
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3959
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3960

    
3961
    if(!strncmp(arg, "pal-", 4)) {
3962
        norm = PAL;
3963
        arg += 4;
3964
    } else if(!strncmp(arg, "ntsc-", 5)) {
3965
        norm = NTSC;
3966
        arg += 5;
3967
    } else if(!strncmp(arg, "film-", 5)) {
3968
        norm = FILM;
3969
        arg += 5;
3970
    } else {
3971
        int fr;
3972
        /* Calculate FR via float to avoid int overflow */
3973
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3974
        if(fr == 25000) {
3975
            norm = PAL;
3976
        } else if((fr == 29970) || (fr == 23976)) {
3977
            norm = NTSC;
3978
        } else {
3979
            /* Try to determine PAL/NTSC by peeking in the input files */
3980
            if(nb_input_files) {
3981
                int i, j;
3982
                for(j = 0; j < nb_input_files; j++) {
3983
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3984
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3985
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3986
                            continue;
3987
                        fr = c->time_base.den * 1000 / c->time_base.num;
3988
                        if(fr == 25000) {
3989
                            norm = PAL;
3990
                            break;
3991
                        } else if((fr == 29970) || (fr == 23976)) {
3992
                            norm = NTSC;
3993
                            break;
3994
                        }
3995
                    }
3996
                    if(norm != UNKNOWN)
3997
                        break;
3998
                }
3999
            }
4000
        }
4001
        if(verbose && norm != UNKNOWN)
4002
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4003
    }
4004

    
4005
    if(norm == UNKNOWN) {
4006
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4007
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4008
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4009
        ffmpeg_exit(1);
4010
    }
4011

    
4012
    if(!strcmp(arg, "vcd")) {
4013

    
4014
        opt_video_codec("mpeg1video");
4015
        opt_audio_codec("mp2");
4016
        opt_format("vcd");
4017

    
4018
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4019
        opt_frame_rate(NULL, frame_rates[norm]);
4020
        opt_default("g", norm == PAL ? "15" : "18");
4021

    
4022
        opt_default("b", "1150000");
4023
        opt_default("maxrate", "1150000");
4024
        opt_default("minrate", "1150000");
4025
        opt_default("bufsize", "327680"); // 40*1024*8;
4026

    
4027
        opt_default("ab", "224000");
4028
        audio_sample_rate = 44100;
4029
        audio_channels = 2;
4030

    
4031
        opt_default("packetsize", "2324");
4032
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4033

    
4034
        /* We have to offset the PTS, so that it is consistent with the SCR.
4035
           SCR starts at 36000, but the first two packs contain only padding
4036
           and the first pack from the other stream, respectively, may also have
4037
           been written before.
4038
           So the real data starts at SCR 36000+3*1200. */
4039
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4040
    } else if(!strcmp(arg, "svcd")) {
4041

    
4042
        opt_video_codec("mpeg2video");
4043
        opt_audio_codec("mp2");
4044
        opt_format("svcd");
4045

    
4046
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4047
        opt_frame_rate(NULL, frame_rates[norm]);
4048
        opt_default("g", norm == PAL ? "15" : "18");
4049

    
4050
        opt_default("b", "2040000");
4051
        opt_default("maxrate", "2516000");
4052
        opt_default("minrate", "0"); //1145000;
4053
        opt_default("bufsize", "1835008"); //224*1024*8;
4054
        opt_default("flags", "+scan_offset");
4055

    
4056

    
4057
        opt_default("ab", "224000");
4058
        audio_sample_rate = 44100;
4059

    
4060
        opt_default("packetsize", "2324");
4061

    
4062
    } else if(!strcmp(arg, "dvd")) {
4063

    
4064
        opt_video_codec("mpeg2video");
4065
        opt_audio_codec("ac3");
4066
        opt_format("dvd");
4067

    
4068
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4069
        opt_frame_rate(NULL, frame_rates[norm]);
4070
        opt_default("g", norm == PAL ? "15" : "18");
4071

    
4072
        opt_default("b", "6000000");
4073
        opt_default("maxrate", "9000000");
4074
        opt_default("minrate", "0"); //1500000;
4075
        opt_default("bufsize", "1835008"); //224*1024*8;
4076

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

    
4080
        opt_default("ab", "448000");
4081
        audio_sample_rate = 48000;
4082

    
4083
    } else if(!strncmp(arg, "dv", 2)) {
4084

    
4085
        opt_format("dv");
4086

    
4087
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4088
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4089
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4090
        opt_frame_rate(NULL, frame_rates[norm]);
4091

    
4092
        audio_sample_rate = 48000;
4093
        audio_channels = 2;
4094

    
4095
    } else {
4096
        fprintf(stderr, "Unknown target: %s\n", arg);
4097
        ffmpeg_exit(1);
4098
    }
4099
}
4100

    
4101
static void opt_vstats_file (const char *arg)
4102
{
4103
    av_free (vstats_filename);
4104
    vstats_filename=av_strdup (arg);
4105
}
4106

    
4107
static void opt_vstats (void)
4108
{
4109
    char filename[40];
4110
    time_t today2 = time(NULL);
4111
    struct tm *today = localtime(&today2);
4112

    
4113
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4114
             today->tm_sec);
4115
    opt_vstats_file(filename);
4116
}
4117

    
4118
static int opt_bsf(const char *opt, const char *arg)
4119
{
4120
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4121
    AVBitStreamFilterContext **bsfp;
4122

    
4123
    if(!bsfc){
4124
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4125
        ffmpeg_exit(1);
4126
    }
4127

    
4128
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4129
          *opt == 'a' ? &audio_bitstream_filters :
4130
                        &subtitle_bitstream_filters;
4131
    while(*bsfp)
4132
        bsfp= &(*bsfp)->next;
4133

    
4134
    *bsfp= bsfc;
4135

    
4136
    return 0;
4137
}
4138

    
4139
static int opt_preset(const char *opt, const char *arg)
4140
{
4141
    FILE *f=NULL;
4142
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4143
    char *codec_name = *opt == 'v' ? video_codec_name :
4144
                       *opt == 'a' ? audio_codec_name :
4145
                                     subtitle_codec_name;
4146

    
4147
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4148
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4149
        ffmpeg_exit(1);
4150
    }
4151

    
4152
    while(!feof(f)){
4153
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4154
        if(line[0] == '#' && !e)
4155
            continue;
4156
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4157
        if(e){
4158
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4159
            ffmpeg_exit(1);
4160
        }
4161
        if(!strcmp(tmp, "acodec")){
4162
            opt_audio_codec(tmp2);
4163
        }else if(!strcmp(tmp, "vcodec")){
4164
            opt_video_codec(tmp2);
4165
        }else if(!strcmp(tmp, "scodec")){
4166
            opt_subtitle_codec(tmp2);
4167
        }else if(opt_default(tmp, tmp2) < 0){
4168
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4169
            ffmpeg_exit(1);
4170
        }
4171
    }
4172

    
4173
    fclose(f);
4174

    
4175
    return 0;
4176
}
4177

    
4178
static const OptionDef options[] = {
4179
    /* main options */
4180
#include "cmdutils_common_opts.h"
4181
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4182
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4183
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4184
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4185
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4186
      "outfile[,metadata]:infile[,metadata]" },
4187
    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4188
      "outfile[,metadata]:infile[,metadata]" },
4189
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4190
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4191
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4192
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4193
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4194
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4195
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4196
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4197
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4198
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4199
      "add timings for benchmarking" },
4200
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4201
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4202
      "dump each input packet" },
4203
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4204
      "when dumping packets, also dump the payload" },
4205
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4206
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4207
    { "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)", "" },
4208
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4209
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4210
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4211
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4212
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4213
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4214
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4215
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4216
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4217
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4218
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4219
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4220
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4221
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4222

    
4223
    /* video options */
4224
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4225
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4226
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4227
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4228
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4229
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4230
    { "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" },
4231
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4232
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4233
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4234
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4235
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4236
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4237
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4238
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4239
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4240
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4241
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4242
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4243
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4244
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4245
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4246
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4247
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4248
      "use same video quality as source (implies VBR)" },
4249
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4250
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4251
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4252
      "deinterlace pictures" },
4253
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4254
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4255
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4256
#if CONFIG_AVFILTER
4257
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4258
#endif
4259
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4260
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4261
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4262
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4263
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4264
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4265
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4266
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4267
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4268
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4269
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4270

    
4271
    /* audio options */
4272
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4273
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4274
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4275
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4276
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4277
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4278
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4279
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4280
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4281
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4282
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4283
    { "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" },
4284

    
4285
    /* subtitle options */
4286
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4287
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4288
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4289
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4290
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4291

    
4292
    /* grab options */
4293
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4294
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4295
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4296

    
4297
    /* muxer options */
4298
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4299
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4300

    
4301
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4302
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4303
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4304

    
4305
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4306
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4307
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4308
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4309

    
4310
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4311
    { NULL, },
4312
};
4313

    
4314
int main(int argc, char **argv)
4315
{
4316
    int64_t ti;
4317

    
4318
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4319

    
4320
    avcodec_register_all();
4321
#if CONFIG_AVDEVICE
4322
    avdevice_register_all();
4323
#endif
4324
#if CONFIG_AVFILTER
4325
    avfilter_register_all();
4326
#endif
4327
    av_register_all();
4328

    
4329
#if HAVE_ISATTY
4330
    if(isatty(STDIN_FILENO))
4331
        url_set_interrupt_cb(decode_interrupt_cb);
4332
#endif
4333

    
4334
    init_opts();
4335

    
4336
    show_banner();
4337

    
4338
    /* parse options */
4339
    parse_options(argc, argv, options, opt_output_file);
4340

    
4341
    if(nb_output_files <= 0 && nb_input_files == 0) {
4342
        show_usage();
4343
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4344
        ffmpeg_exit(1);
4345
    }
4346

    
4347
    /* file converter / grab */
4348
    if (nb_output_files <= 0) {
4349
        fprintf(stderr, "At least one output file must be specified\n");
4350
        ffmpeg_exit(1);
4351
    }
4352

    
4353
    if (nb_input_files == 0) {
4354
        fprintf(stderr, "At least one input file must be specified\n");
4355
        ffmpeg_exit(1);
4356
    }
4357

    
4358
    ti = getutime();
4359
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4360
                  stream_maps, nb_stream_maps) < 0)
4361
        ffmpeg_exit(1);
4362
    ti = getutime() - ti;
4363
    if (do_benchmark) {
4364
        int maxrss = getmaxrss() / 1024;
4365
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4366
    }
4367

    
4368
    return ffmpeg_exit(0);
4369
}