avconv: factor out initializing input streams.
[libav.git] / avconv.c
CommitLineData
6291d7e4
AK
1/*
2 * avconv main
3 * Copyright (c) 2000-2011 The libav developers.
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#include "config.h"
23#include <ctype.h>
24#include <string.h>
25#include <math.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <signal.h>
29#include <limits.h>
30#include <unistd.h>
31#include "libavformat/avformat.h"
32#include "libavdevice/avdevice.h"
33#include "libswscale/swscale.h"
34#include "libavutil/opt.h"
35#include "libavcodec/audioconvert.h"
36#include "libavutil/audioconvert.h"
37#include "libavutil/parseutils.h"
38#include "libavutil/samplefmt.h"
39#include "libavutil/colorspace.h"
40#include "libavutil/fifo.h"
41#include "libavutil/intreadwrite.h"
42#include "libavutil/dict.h"
43#include "libavutil/mathematics.h"
44#include "libavutil/pixdesc.h"
45#include "libavutil/avstring.h"
46#include "libavutil/libm.h"
47#include "libavformat/os_support.h"
48
49#if CONFIG_AVFILTER
50# include "libavfilter/avfilter.h"
51# include "libavfilter/avfiltergraph.h"
52# include "libavfilter/vsrc_buffer.h"
53#endif
54
55#if HAVE_SYS_RESOURCE_H
56#include <sys/types.h>
57#include <sys/time.h>
58#include <sys/resource.h>
59#elif HAVE_GETPROCESSTIMES
60#include <windows.h>
61#endif
62#if HAVE_GETPROCESSMEMORYINFO
63#include <windows.h>
64#include <psapi.h>
65#endif
66
67#if HAVE_SYS_SELECT_H
68#include <sys/select.h>
69#endif
70
71#include <time.h>
72
73#include "cmdutils.h"
74
75#include "libavutil/avassert.h"
76
77const char program_name[] = "avconv";
78const int program_birth_year = 2000;
79
80/* select an input stream for an output stream */
81typedef struct StreamMap {
8d2e4a7e 82 int disabled; /** 1 is this mapping is disabled by a negative map */
6291d7e4
AK
83 int file_index;
84 int stream_index;
85 int sync_file_index;
86 int sync_stream_index;
87} StreamMap;
88
89/**
90 * select an input file for an output file
91 */
92typedef struct MetadataMap {
93 int file; //< file index
94 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
95 int index; //< stream/chapter/program number
96} MetadataMap;
97
6291d7e4
AK
98static const OptionDef options[];
99
6291d7e4 100static const char *last_asked_format = NULL;
09af7fb3 101static AVDictionary *ts_scale;
6291d7e4 102
6291d7e4
AK
103static StreamMap *stream_maps = NULL;
104static int nb_stream_maps;
105
92f1940e
AK
106static AVDictionary *codec_names;
107
6291d7e4
AK
108/* first item specifies output metadata, second is input */
109static MetadataMap (*meta_data_maps)[2] = NULL;
110static int nb_meta_data_maps;
111static int metadata_global_autocopy = 1;
112static int metadata_streams_autocopy = 1;
113static int metadata_chapters_autocopy = 1;
114
b9aac90b 115static int chapters_input_file = INT_MAX;
6291d7e4
AK
116
117/* indexed by output file stream index */
118static int *streamid_map = NULL;
119static int nb_streamid_map = 0;
120
121static int frame_width = 0;
122static int frame_height = 0;
123static float frame_aspect_ratio = 0;
124static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
125static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
126static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
127static AVRational frame_rate;
128static float video_qscale = 0;
129static uint16_t *intra_matrix = NULL;
130static uint16_t *inter_matrix = NULL;
131static const char *video_rc_override_string=NULL;
132static int video_disable = 0;
133static int video_discard = 0;
6291d7e4
AK
134static unsigned int video_codec_tag = 0;
135static char *video_language = NULL;
f4ad238c 136static int same_quant = 0;
6291d7e4
AK
137static int do_deinterlace = 0;
138static int top_field_first = -1;
139static int me_threshold = 0;
140static int intra_dc_precision = 8;
6291d7e4
AK
141static int qp_hist = 0;
142#if CONFIG_AVFILTER
143static char *vfilters = NULL;
144#endif
145
6291d7e4
AK
146static int audio_sample_rate = 0;
147#define QSCALE_NONE -99999
148static float audio_qscale = QSCALE_NONE;
149static int audio_disable = 0;
150static int audio_channels = 0;
6291d7e4
AK
151static unsigned int audio_codec_tag = 0;
152static char *audio_language = NULL;
153
154static int subtitle_disable = 0;
6291d7e4
AK
155static char *subtitle_language = NULL;
156static unsigned int subtitle_codec_tag = 0;
157
158static int data_disable = 0;
6291d7e4
AK
159static unsigned int data_codec_tag = 0;
160
161static float mux_preload= 0.5;
162static float mux_max_delay= 0.7;
163
164static int64_t recording_time = INT64_MAX;
165static int64_t start_time = 0;
166static int64_t input_ts_offset = 0;
167static int file_overwrite = 0;
168static AVDictionary *metadata;
169static int do_benchmark = 0;
170static int do_hex_dump = 0;
171static int do_pkt_dump = 0;
172static int do_psnr = 0;
173static int do_pass = 0;
174static char *pass_logfilename_prefix = NULL;
6291d7e4
AK
175static int video_sync_method= -1;
176static int audio_sync_method= 0;
177static float audio_drift_threshold= 0.1;
178static int copy_ts= 0;
179static int copy_tb;
180static int opt_shortest = 0;
181static char *vstats_filename;
182static FILE *vstats_file;
183static int opt_programid = 0;
184static int copy_initial_nonkeyframes = 0;
185
186static int rate_emu = 0;
187
188static int audio_volume = 256;
189
190static int exit_on_error = 0;
191static int using_stdin = 0;
192static int verbose = 1;
193static int thread_count= 1;
194static int64_t video_size = 0;
195static int64_t audio_size = 0;
196static int64_t extra_size = 0;
197static int nb_frames_dup = 0;
198static int nb_frames_drop = 0;
199static int input_sync;
200static uint64_t limit_filesize = 0;
201static int force_fps = 0;
202static char *forced_key_frames = NULL;
203
204static float dts_delta_threshold = 10;
205
6291d7e4
AK
206static uint8_t *audio_buf;
207static uint8_t *audio_out;
208static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
209
210static short *samples;
211
212static AVBitStreamFilterContext *video_bitstream_filters=NULL;
213static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
214static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
215
216#define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
217
6494c001
AK
218typedef struct InputStream {
219 int file_index;
220 AVStream *st;
221 int discard; /* true if stream data should be discarded */
222 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
223 AVCodec *dec;
224
225 int64_t start; /* time when read started */
226 int64_t next_pts; /* synthetic pts for cases where pkt.pts
227 is not defined */
228 int64_t pts; /* current pts */
229 PtsCorrectionContext pts_ctx;
230 double ts_scale;
231 int is_start; /* is 1 at the start and after a discontinuity */
232 int showed_multi_packet_warning;
233 AVDictionary *opts;
234} InputStream;
235
236typedef struct InputFile {
237 AVFormatContext *ctx;
238 int eof_reached; /* true if eof reached */
239 int ist_index; /* index of first stream in ist_table */
240 int buffer_size; /* current total buffer size */
241 int64_t ts_offset;
242} InputFile;
6291d7e4
AK
243
244typedef struct OutputStream {
245 int file_index; /* file index */
246 int index; /* stream index in the output file */
247 int source_index; /* InputStream index */
248 AVStream *st; /* stream in the output file */
249 int encoding_needed; /* true if encoding needed for this stream */
250 int frame_number;
251 /* input pts and corresponding output pts
252 for A/V sync */
253 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
254 struct InputStream *sync_ist; /* input stream to sync against */
255 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
256 AVBitStreamFilterContext *bitstream_filters;
257 AVCodec *enc;
258
259 /* video only */
260 int video_resample;
261 AVFrame pict_tmp; /* temporary image for resampling */
262 struct SwsContext *img_resample_ctx; /* for image resampling */
263 int resample_height;
264 int resample_width;
265 int resample_pix_fmt;
266 AVRational frame_rate;
267
268 float frame_aspect_ratio;
269
270 /* forced key frames */
271 int64_t *forced_kf_pts;
272 int forced_kf_count;
273 int forced_kf_index;
274
275 /* audio only */
276 int audio_resample;
277 ReSampleContext *resample; /* for audio resampling */
278 int resample_sample_fmt;
279 int resample_channels;
280 int resample_sample_rate;
281 int reformat_pair;
282 AVAudioConvert *reformat_ctx;
283 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
284 FILE *logfile;
285
286#if CONFIG_AVFILTER
287 AVFilterContext *output_video_filter;
288 AVFilterContext *input_video_filter;
289 AVFilterBufferRef *picref;
290 char *avfilter;
291 AVFilterGraph *graph;
292#endif
293
294 int sws_flags;
295 AVDictionary *opts;
ef44a607 296 int is_past_recording_time;
6291d7e4
AK
297} OutputStream;
298
6291d7e4 299
af70aa45
AK
300typedef struct OutputFile {
301 AVFormatContext *ctx;
302 AVDictionary *opts;
4288e031 303 int ost_index; /* index of the first stream in output_streams */
ef44a607 304 int64_t recording_time; /* desired length of the resulting file in microseconds */
ea065176 305 int64_t start_time; /* start time in microseconds */
af70aa45
AK
306} OutputFile;
307
6291d7e4
AK
308static InputStream *input_streams = NULL;
309static int nb_input_streams = 0;
310static InputFile *input_files = NULL;
311static int nb_input_files = 0;
312
4288e031
AK
313static OutputStream *output_streams = NULL;
314static int nb_output_streams = 0;
af70aa45
AK
315static OutputFile *output_files = NULL;
316static int nb_output_files = 0;
317
6291d7e4
AK
318#if CONFIG_AVFILTER
319
320static int configure_video_filters(InputStream *ist, OutputStream *ost)
321{
322 AVFilterContext *last_filter, *filter;
323 /** filter graph containing all filters including input & output */
324 AVCodecContext *codec = ost->st->codec;
325 AVCodecContext *icodec = ist->st->codec;
326 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
327 AVRational sample_aspect_ratio;
328 char args[255];
329 int ret;
330
331 ost->graph = avfilter_graph_alloc();
332
333 if (ist->st->sample_aspect_ratio.num){
334 sample_aspect_ratio = ist->st->sample_aspect_ratio;
335 }else
336 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
337
338 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
339 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
340 sample_aspect_ratio.num, sample_aspect_ratio.den);
341
342 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
343 "src", args, NULL, ost->graph);
344 if (ret < 0)
345 return ret;
346 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
347 "out", NULL, &ffsink_ctx, ost->graph);
348 if (ret < 0)
349 return ret;
350 last_filter = ost->input_video_filter;
351
352 if (codec->width != icodec->width || codec->height != icodec->height) {
353 snprintf(args, 255, "%d:%d:flags=0x%X",
354 codec->width,
355 codec->height,
356 ost->sws_flags);
357 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
358 NULL, args, NULL, ost->graph)) < 0)
359 return ret;
360 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
361 return ret;
362 last_filter = filter;
363 }
364
365 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
366 ost->graph->scale_sws_opts = av_strdup(args);
367
368 if (ost->avfilter) {
369 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
370 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
371
372 outputs->name = av_strdup("in");
373 outputs->filter_ctx = last_filter;
374 outputs->pad_idx = 0;
375 outputs->next = NULL;
376
377 inputs->name = av_strdup("out");
378 inputs->filter_ctx = ost->output_video_filter;
379 inputs->pad_idx = 0;
380 inputs->next = NULL;
381
382 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
383 return ret;
384 av_freep(&ost->avfilter);
385 } else {
386 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
387 return ret;
388 }
389
390 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
391 return ret;
392
393 codec->width = ost->output_video_filter->inputs[0]->w;
394 codec->height = ost->output_video_filter->inputs[0]->h;
395 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
396 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
397 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
398 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
399
400 return 0;
401}
402#endif /* CONFIG_AVFILTER */
403
404static void term_exit(void)
405{
406 av_log(NULL, AV_LOG_QUIET, "");
407}
408
409static volatile int received_sigterm = 0;
410static volatile int received_nb_signals = 0;
411
412static void
413sigterm_handler(int sig)
414{
415 received_sigterm = sig;
416 received_nb_signals++;
417 term_exit();
418}
419
420static void term_init(void)
421{
422 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
423 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
424#ifdef SIGXCPU
425 signal(SIGXCPU, sigterm_handler);
426#endif
427}
428
429static int decode_interrupt_cb(void)
430{
431 return received_nb_signals > 1;
432}
433
434static int exit_program(int ret)
435{
436 int i;
437
438 /* close files */
439 for(i=0;i<nb_output_files;i++) {
af70aa45 440 AVFormatContext *s = output_files[i].ctx;
6291d7e4
AK
441 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
442 avio_close(s->pb);
443 avformat_free_context(s);
af70aa45 444 av_dict_free(&output_files[i].opts);
6291d7e4
AK
445 }
446 for(i=0;i<nb_input_files;i++) {
447 av_close_input_file(input_files[i].ctx);
448 }
449 for (i = 0; i < nb_input_streams; i++)
450 av_dict_free(&input_streams[i].opts);
451
452 av_free(intra_matrix);
453 av_free(inter_matrix);
454
455 if (vstats_file)
456 fclose(vstats_file);
457 av_free(vstats_filename);
458
6291d7e4
AK
459 av_free(meta_data_maps);
460
461 av_freep(&input_streams);
462 av_freep(&input_files);
4288e031 463 av_freep(&output_streams);
af70aa45 464 av_freep(&output_files);
6291d7e4 465
6291d7e4
AK
466 uninit_opts();
467 av_free(audio_buf);
468 av_free(audio_out);
469 allocated_audio_buf_size= allocated_audio_out_size= 0;
470 av_free(samples);
471
472#if CONFIG_AVFILTER
473 avfilter_uninit();
474#endif
475
476 if (received_sigterm) {
477 fprintf(stderr,
478 "Received signal %d: terminating.\n",
479 (int) received_sigterm);
480 exit (255);
481 }
482
483 exit(ret); /* not all OS-es handle main() return value */
484 return ret;
485}
486
487static void assert_avoptions(AVDictionary *m)
488{
489 AVDictionaryEntry *t;
490 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
491 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
492 exit_program(1);
493 }
494}
495
496static void assert_codec_experimental(AVCodecContext *c, int encoder)
497{
498 const char *codec_string = encoder ? "encoder" : "decoder";
499 AVCodec *codec;
500 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
501 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
502 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
503 "results.\nAdd '-strict experimental' if you want to use it.\n",
504 codec_string, c->codec->name);
505 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
506 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
507 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
508 codec_string, codec->name);
509 exit_program(1);
510 }
511}
512
513/* similar to ff_dynarray_add() and av_fast_realloc() */
514static void *grow_array(void *array, int elem_size, int *size, int new_size)
515{
516 if (new_size >= INT_MAX / elem_size) {
517 fprintf(stderr, "Array too big.\n");
518 exit_program(1);
519 }
520 if (*size < new_size) {
521 uint8_t *tmp = av_realloc(array, new_size*elem_size);
522 if (!tmp) {
523 fprintf(stderr, "Could not alloc buffer.\n");
524 exit_program(1);
525 }
526 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
527 *size = new_size;
528 return tmp;
529 }
530 return array;
531}
532
533static void choose_sample_fmt(AVStream *st, AVCodec *codec)
534{
535 if(codec && codec->sample_fmts){
536 const enum AVSampleFormat *p= codec->sample_fmts;
537 for(; *p!=-1; p++){
538 if(*p == st->codec->sample_fmt)
539 break;
540 }
541 if (*p == -1) {
542 av_log(NULL, AV_LOG_WARNING,
543 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
544 av_get_sample_fmt_name(st->codec->sample_fmt),
545 codec->name,
546 av_get_sample_fmt_name(codec->sample_fmts[0]));
547 st->codec->sample_fmt = codec->sample_fmts[0];
548 }
549 }
550}
551
552/**
553 * Update the requested input sample format based on the output sample format.
554 * This is currently only used to request float output from decoders which
555 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
556 * Ideally this will be removed in the future when decoders do not do format
557 * conversion and only output in their native format.
558 */
559static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
560 AVCodecContext *enc)
561{
562 /* if sample formats match or a decoder sample format has already been
563 requested, just return */
564 if (enc->sample_fmt == dec->sample_fmt ||
565 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
566 return;
567
568 /* if decoder supports more than one output format */
569 if (dec_codec && dec_codec->sample_fmts &&
570 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
571 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
572 const enum AVSampleFormat *p;
573 int min_dec = -1, min_inc = -1;
574
575 /* find a matching sample format in the encoder */
576 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
577 if (*p == enc->sample_fmt) {
578 dec->request_sample_fmt = *p;
579 return;
580 } else if (*p > enc->sample_fmt) {
581 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
582 } else
583 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
584 }
585
586 /* if none match, provide the one that matches quality closest */
587 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
588 enc->sample_fmt - min_dec;
589 }
590}
591
592static void choose_sample_rate(AVStream *st, AVCodec *codec)
593{
594 if(codec && codec->supported_samplerates){
595 const int *p= codec->supported_samplerates;
596 int best=0;
597 int best_dist=INT_MAX;
598 for(; *p; p++){
599 int dist= abs(st->codec->sample_rate - *p);
600 if(dist < best_dist){
601 best_dist= dist;
602 best= *p;
603 }
604 }
605 if(best_dist){
606 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
607 }
608 st->codec->sample_rate= best;
609 }
610}
611
612static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
613{
614 if(codec && codec->pix_fmts){
615 const enum PixelFormat *p= codec->pix_fmts;
616 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
617 if(st->codec->codec_id==CODEC_ID_MJPEG){
618 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
619 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
620 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};
621 }
622 }
623 for(; *p!=-1; p++){
624 if(*p == st->codec->pix_fmt)
625 break;
626 }
627 if (*p == -1) {
628 if(st->codec->pix_fmt != PIX_FMT_NONE)
629 av_log(NULL, AV_LOG_WARNING,
630 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
631 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
632 codec->name,
633 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
634 st->codec->pix_fmt = codec->pix_fmts[0];
635 }
636 }
637}
638
6291d7e4
AK
639static double
640get_sync_ipts(const OutputStream *ost)
641{
642 const InputStream *ist = ost->sync_ist;
ea065176
AK
643 OutputFile *of = &output_files[ost->file_index];
644 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
6291d7e4
AK
645}
646
647static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
648 int ret;
649
650 while(bsfc){
651 AVPacket new_pkt= *pkt;
652 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
653 &new_pkt.data, &new_pkt.size,
654 pkt->data, pkt->size,
655 pkt->flags & AV_PKT_FLAG_KEY);
656 if(a>0){
657 av_free_packet(pkt);
658 new_pkt.destruct= av_destruct_packet;
659 } else if(a<0){
660 fprintf(stderr, "%s failed for stream %d, codec %s",
661 bsfc->filter->name, pkt->stream_index,
662 avctx->codec ? avctx->codec->name : "copy");
663 print_error("", a);
664 if (exit_on_error)
665 exit_program(1);
666 }
667 *pkt= new_pkt;
668
669 bsfc= bsfc->next;
670 }
671
672 ret= av_interleaved_write_frame(s, pkt);
673 if(ret < 0){
674 print_error("av_interleaved_write_frame()", ret);
675 exit_program(1);
676 }
677}
678
6291d7e4
AK
679static void do_audio_out(AVFormatContext *s,
680 OutputStream *ost,
681 InputStream *ist,
682 unsigned char *buf, int size)
683{
684 uint8_t *buftmp;
685 int64_t audio_out_size, audio_buf_size;
686 int64_t allocated_for_size= size;
687
688 int size_out, frame_bytes, ret, resample_changed;
689 AVCodecContext *enc= ost->st->codec;
690 AVCodecContext *dec= ist->st->codec;
691 int osize = av_get_bytes_per_sample(enc->sample_fmt);
692 int isize = av_get_bytes_per_sample(dec->sample_fmt);
693 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
694
695need_realloc:
696 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
697 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
698 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
699 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
700 audio_buf_size*= osize*enc->channels;
701
702 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
703 if(coded_bps > 8*osize)
704 audio_out_size= audio_out_size * coded_bps / (8*osize);
705 audio_out_size += FF_MIN_BUFFER_SIZE;
706
707 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
708 fprintf(stderr, "Buffer sizes too large\n");
709 exit_program(1);
710 }
711
712 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
713 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
714 if (!audio_buf || !audio_out){
715 fprintf(stderr, "Out of memory in do_audio_out\n");
716 exit_program(1);
717 }
718
719 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
720 ost->audio_resample = 1;
721
722 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
723 ost->resample_channels != dec->channels ||
724 ost->resample_sample_rate != dec->sample_rate;
725
726 if ((ost->audio_resample && !ost->resample) || resample_changed) {
727 if (resample_changed) {
728 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",
729 ist->file_index, ist->st->index,
730 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
731 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
732 ost->resample_sample_fmt = dec->sample_fmt;
733 ost->resample_channels = dec->channels;
734 ost->resample_sample_rate = dec->sample_rate;
735 if (ost->resample)
736 audio_resample_close(ost->resample);
737 }
738 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
739 if (audio_sync_method <= 1 &&
740 ost->resample_sample_fmt == enc->sample_fmt &&
741 ost->resample_channels == enc->channels &&
742 ost->resample_sample_rate == enc->sample_rate) {
743 ost->resample = NULL;
744 ost->audio_resample = 0;
745 } else if (ost->audio_resample) {
746 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
747 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
748 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
749 enc->sample_rate, dec->sample_rate,
750 enc->sample_fmt, dec->sample_fmt,
751 16, 10, 0, 0.8);
752 if (!ost->resample) {
753 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
754 dec->channels, dec->sample_rate,
755 enc->channels, enc->sample_rate);
756 exit_program(1);
757 }
758 }
759 }
760
761#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
762 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
763 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
764 if (ost->reformat_ctx)
765 av_audio_convert_free(ost->reformat_ctx);
766 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
767 dec->sample_fmt, 1, NULL, 0);
768 if (!ost->reformat_ctx) {
769 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
770 av_get_sample_fmt_name(dec->sample_fmt),
771 av_get_sample_fmt_name(enc->sample_fmt));
772 exit_program(1);
773 }
774 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
775 }
776
777 if(audio_sync_method){
778 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
779 - av_fifo_size(ost->fifo)/(enc->channels * 2);
780 double idelta= delta*dec->sample_rate / enc->sample_rate;
781 int byte_delta= ((int)idelta)*2*dec->channels;
782
783 //FIXME resample delay
784 if(fabs(delta) > 50){
785 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
786 if(byte_delta < 0){
787 byte_delta= FFMAX(byte_delta, -size);
788 size += byte_delta;
789 buf -= byte_delta;
790 if(verbose > 2)
791 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
792 if(!size)
793 return;
794 ist->is_start=0;
795 }else{
796 static uint8_t *input_tmp= NULL;
797 input_tmp= av_realloc(input_tmp, byte_delta + size);
798
799 if(byte_delta > allocated_for_size - size){
800 allocated_for_size= byte_delta + (int64_t)size;
801 goto need_realloc;
802 }
803 ist->is_start=0;
804
805 memset(input_tmp, 0, byte_delta);
806 memcpy(input_tmp + byte_delta, buf, size);
807 buf= input_tmp;
808 size += byte_delta;
809 if(verbose > 2)
810 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
811 }
812 }else if(audio_sync_method>1){
813 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
814 av_assert0(ost->audio_resample);
815 if(verbose > 2)
816 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
817// 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));
818 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
819 }
820 }
821 }else
822 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
823 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
824
825 if (ost->audio_resample) {
826 buftmp = audio_buf;
827 size_out = audio_resample(ost->resample,
828 (short *)buftmp, (short *)buf,
829 size / (dec->channels * isize));
830 size_out = size_out * enc->channels * osize;
831 } else {
832 buftmp = buf;
833 size_out = size;
834 }
835
836 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
837 const void *ibuf[6]= {buftmp};
838 void *obuf[6]= {audio_buf};
839 int istride[6]= {isize};
840 int ostride[6]= {osize};
841 int len= size_out/istride[0];
842 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
843 printf("av_audio_convert() failed\n");
844 if (exit_on_error)
845 exit_program(1);
846 return;
847 }
848 buftmp = audio_buf;
849 size_out = len*osize;
850 }
851
852 /* now encode as many frames as possible */
853 if (enc->frame_size > 1) {
854 /* output resampled raw samples */
855 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
856 fprintf(stderr, "av_fifo_realloc2() failed\n");
857 exit_program(1);
858 }
859 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
860
861 frame_bytes = enc->frame_size * osize * enc->channels;
862
863 while (av_fifo_size(ost->fifo) >= frame_bytes) {
864 AVPacket pkt;
865 av_init_packet(&pkt);
866
867 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
868
869 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
870
871 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
872 (short *)audio_buf);
873 if (ret < 0) {
874 fprintf(stderr, "Audio encoding failed\n");
875 exit_program(1);
876 }
877 audio_size += ret;
878 pkt.stream_index= ost->index;
879 pkt.data= audio_out;
880 pkt.size= ret;
881 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
882 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
883 pkt.flags |= AV_PKT_FLAG_KEY;
884 write_frame(s, &pkt, enc, ost->bitstream_filters);
885
886 ost->sync_opts += enc->frame_size;
887 }
888 } else {
889 AVPacket pkt;
890 av_init_packet(&pkt);
891
892 ost->sync_opts += size_out / (osize * enc->channels);
893
894 /* output a pcm frame */
895 /* determine the size of the coded buffer */
896 size_out /= osize;
897 if (coded_bps)
898 size_out = size_out*coded_bps/8;
899
900 if(size_out > audio_out_size){
901 fprintf(stderr, "Internal error, buffer size too small\n");
902 exit_program(1);
903 }
904
905 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
906 ret = avcodec_encode_audio(enc, audio_out, size_out,
907 (short *)buftmp);
908 if (ret < 0) {
909 fprintf(stderr, "Audio encoding failed\n");
910 exit_program(1);
911 }
912 audio_size += ret;
913 pkt.stream_index= ost->index;
914 pkt.data= audio_out;
915 pkt.size= ret;
916 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
917 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
918 pkt.flags |= AV_PKT_FLAG_KEY;
919 write_frame(s, &pkt, enc, ost->bitstream_filters);
920 }
921}
922
923static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
924{
925 AVCodecContext *dec;
926 AVPicture *picture2;
927 AVPicture picture_tmp;
928 uint8_t *buf = 0;
929
930 dec = ist->st->codec;
931
932 /* deinterlace : must be done before any resize */
933 if (do_deinterlace) {
934 int size;
935
936 /* create temporary picture */
937 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
938 buf = av_malloc(size);
939 if (!buf)
940 return;
941
942 picture2 = &picture_tmp;
943 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
944
945 if(avpicture_deinterlace(picture2, picture,
946 dec->pix_fmt, dec->width, dec->height) < 0) {
947 /* if error, do not deinterlace */
948 fprintf(stderr, "Deinterlacing failed\n");
949 av_free(buf);
950 buf = NULL;
951 picture2 = picture;
952 }
953 } else {
954 picture2 = picture;
955 }
956
957 if (picture != picture2)
958 *picture = *picture2;
959 *bufp = buf;
960}
961
6291d7e4
AK
962static void do_subtitle_out(AVFormatContext *s,
963 OutputStream *ost,
964 InputStream *ist,
965 AVSubtitle *sub,
966 int64_t pts)
967{
968 static uint8_t *subtitle_out = NULL;
969 int subtitle_out_max_size = 1024 * 1024;
970 int subtitle_out_size, nb, i;
971 AVCodecContext *enc;
972 AVPacket pkt;
973
974 if (pts == AV_NOPTS_VALUE) {
975 fprintf(stderr, "Subtitle packets must have a pts\n");
976 if (exit_on_error)
977 exit_program(1);
978 return;
979 }
980
981 enc = ost->st->codec;
982
983 if (!subtitle_out) {
984 subtitle_out = av_malloc(subtitle_out_max_size);
985 }
986
987 /* Note: DVB subtitle need one packet to draw them and one other
988 packet to clear them */
989 /* XXX: signal it in the codec context ? */
990 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
991 nb = 2;
992 else
993 nb = 1;
994
995 for(i = 0; i < nb; i++) {
996 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
997 // start_display_time is required to be 0
998 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
999 sub->end_display_time -= sub->start_display_time;
1000 sub->start_display_time = 0;
1001 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1002 subtitle_out_max_size, sub);
1003 if (subtitle_out_size < 0) {
1004 fprintf(stderr, "Subtitle encoding failed\n");
1005 exit_program(1);
1006 }
1007
1008 av_init_packet(&pkt);
1009 pkt.stream_index = ost->index;
1010 pkt.data = subtitle_out;
1011 pkt.size = subtitle_out_size;
1012 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1013 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1014 /* XXX: the pts correction is handled here. Maybe handling
1015 it in the codec would be better */
1016 if (i == 0)
1017 pkt.pts += 90 * sub->start_display_time;
1018 else
1019 pkt.pts += 90 * sub->end_display_time;
1020 }
1021 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1022 }
1023}
1024
1025static int bit_buffer_size= 1024*256;
1026static uint8_t *bit_buffer= NULL;
1027
87ef060c
AC
1028static void do_video_resample(OutputStream *ost,
1029 InputStream *ist,
1030 AVFrame *in_picture,
1031 AVFrame **out_picture)
6291d7e4 1032{
87ef060c
AC
1033 int resample_changed = 0;
1034 AVCodecContext *dec = ist->st->codec;
1035 *out_picture = in_picture;
6291d7e4
AK
1036
1037 resample_changed = ost->resample_width != dec->width ||
1038 ost->resample_height != dec->height ||
1039 ost->resample_pix_fmt != dec->pix_fmt;
1040
1041 if (resample_changed) {
1042 av_log(NULL, AV_LOG_INFO,
1043 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1044 ist->file_index, ist->st->index,
1045 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1046 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1047 if(!ost->video_resample)
5c59fa56 1048 ost->video_resample = 1;
6291d7e4
AK
1049 }
1050
1051#if !CONFIG_AVFILTER
1052 if (ost->video_resample) {
87ef060c 1053 *out_picture = &ost->pict_tmp;
6291d7e4
AK
1054 if (resample_changed) {
1055 /* initialize a new scaler context */
1056 sws_freeContext(ost->img_resample_ctx);
1057 ost->img_resample_ctx = sws_getContext(
1058 ist->st->codec->width,
1059 ist->st->codec->height,
1060 ist->st->codec->pix_fmt,
1061 ost->st->codec->width,
1062 ost->st->codec->height,
1063 ost->st->codec->pix_fmt,
1064 ost->sws_flags, NULL, NULL, NULL);
1065 if (ost->img_resample_ctx == NULL) {
1066 fprintf(stderr, "Cannot get resampling context\n");
1067 exit_program(1);
1068 }
1069 }
87ef060c
AC
1070 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1071 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
6291d7e4 1072 }
428c59d9
K
1073#else
1074 if (resample_changed) {
1075 avfilter_graph_free(&ost->graph);
1076 if (configure_video_filters(ist, ost)) {
1077 fprintf(stderr, "Error reinitialising filters!\n");
1078 exit_program(1);
1079 }
1080 }
6291d7e4 1081#endif
428c59d9
K
1082 if (resample_changed) {
1083 ost->resample_width = dec->width;
1084 ost->resample_height = dec->height;
1085 ost->resample_pix_fmt = dec->pix_fmt;
1086 }
87ef060c
AC
1087}
1088
1089
1090static void do_video_out(AVFormatContext *s,
1091 OutputStream *ost,
1092 InputStream *ist,
1093 AVFrame *in_picture,
1094 int *frame_size, float quality)
1095{
553735f5 1096 int nb_frames, i, ret, format_video_sync;
87ef060c
AC
1097 AVFrame *final_picture;
1098 AVCodecContext *enc, *dec;
1099 double sync_ipts;
1100
1101 enc = ost->st->codec;
1102 dec = ist->st->codec;
1103
1104 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1105
1106 /* by default, we output a single frame */
1107 nb_frames = 1;
1108
1109 *frame_size = 0;
1110
553735f5
AC
1111 format_video_sync = video_sync_method;
1112 if (format_video_sync < 0)
1113 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1114
1115 if (format_video_sync) {
87ef060c
AC
1116 double vdelta = sync_ipts - ost->sync_opts;
1117 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1118 if (vdelta < -1.1)
1119 nb_frames = 0;
553735f5 1120 else if (format_video_sync == 2) {
87ef060c
AC
1121 if(vdelta<=-0.6){
1122 nb_frames=0;
1123 }else if(vdelta>0.6)
1124 ost->sync_opts= lrintf(sync_ipts);
1125 }else if (vdelta > 1.1)
1126 nb_frames = lrintf(vdelta);
1127//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);
1128 if (nb_frames == 0){
1129 ++nb_frames_drop;
1130 if (verbose>2)
1131 fprintf(stderr, "*** drop!\n");
1132 }else if (nb_frames > 1) {
1133 nb_frames_dup += nb_frames - 1;
1134 if (verbose>2)
1135 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1136 }
1137 }else
1138 ost->sync_opts= lrintf(sync_ipts);
1139
1140 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1141 if (nb_frames <= 0)
1142 return;
1143
1144 do_video_resample(ost, ist, in_picture, &final_picture);
6291d7e4
AK
1145
1146 /* duplicates frame if needed */
1147 for(i=0;i<nb_frames;i++) {
1148 AVPacket pkt;
1149 av_init_packet(&pkt);
1150 pkt.stream_index= ost->index;
1151
1152 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1153 /* raw pictures are written as AVPicture structure to
1154 avoid any copies. We support temorarily the older
1155 method. */
1156 AVFrame* old_frame = enc->coded_frame;
1157 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1158 pkt.data= (uint8_t *)final_picture;
1159 pkt.size= sizeof(AVPicture);
1160 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1161 pkt.flags |= AV_PKT_FLAG_KEY;
1162
1163 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1164 enc->coded_frame = old_frame;
1165 } else {
1166 AVFrame big_picture;
1167
1168 big_picture= *final_picture;
1169 /* better than nothing: use input picture interlaced
1170 settings */
1171 big_picture.interlaced_frame = in_picture->interlaced_frame;
1172 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1173 if(top_field_first == -1)
1174 big_picture.top_field_first = in_picture->top_field_first;
1175 else
1176 big_picture.top_field_first = top_field_first;
1177 }
1178
f4ad238c 1179 /* handles same_quant here. This is not correct because it may
6291d7e4
AK
1180 not be a global option */
1181 big_picture.quality = quality;
1182 if(!me_threshold)
1183 big_picture.pict_type = 0;
1184// big_picture.pts = AV_NOPTS_VALUE;
1185 big_picture.pts= ost->sync_opts;
1186// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1187//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1188 if (ost->forced_kf_index < ost->forced_kf_count &&
1189 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1190 big_picture.pict_type = AV_PICTURE_TYPE_I;
1191 ost->forced_kf_index++;
1192 }
1193 ret = avcodec_encode_video(enc,
1194 bit_buffer, bit_buffer_size,
1195 &big_picture);
1196 if (ret < 0) {
1197 fprintf(stderr, "Video encoding failed\n");
1198 exit_program(1);
1199 }
1200
1201 if(ret>0){
1202 pkt.data= bit_buffer;
1203 pkt.size= ret;
1204 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1205 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1206/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1207 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1208 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1209
1210 if(enc->coded_frame->key_frame)
1211 pkt.flags |= AV_PKT_FLAG_KEY;
1212 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1213 *frame_size = ret;
1214 video_size += ret;
1215 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1216 // enc->frame_number-1, ret, enc->pict_type);
1217 /* if two pass, output log */
1218 if (ost->logfile && enc->stats_out) {
1219 fprintf(ost->logfile, "%s", enc->stats_out);
1220 }
1221 }
1222 }
1223 ost->sync_opts++;
1224 ost->frame_number++;
1225 }
1226}
1227
1228static double psnr(double d){
1229 return -10.0*log(d)/log(10.0);
1230}
1231
1232static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1233 int frame_size)
1234{
1235 AVCodecContext *enc;
1236 int frame_number;
1237 double ti1, bitrate, avg_bitrate;
1238
1239 /* this is executed just the first time do_video_stats is called */
1240 if (!vstats_file) {
1241 vstats_file = fopen(vstats_filename, "w");
1242 if (!vstats_file) {
1243 perror("fopen");
1244 exit_program(1);
1245 }
1246 }
1247
1248 enc = ost->st->codec;
1249 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1250 frame_number = ost->frame_number;
1251 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1252 if (enc->flags&CODEC_FLAG_PSNR)
1253 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1254
1255 fprintf(vstats_file,"f_size= %6d ", frame_size);
1256 /* compute pts value */
1257 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1258 if (ti1 < 0.01)
1259 ti1 = 0.01;
1260
1261 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1262 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1263 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1264 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1265 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1266 }
1267}
1268
af70aa45 1269static void print_report(OutputFile *output_files,
4288e031 1270 OutputStream *ost_table, int nb_ostreams,
c5ad2c2c 1271 int is_last_report, int64_t timer_start)
6291d7e4
AK
1272{
1273 char buf[1024];
1274 OutputStream *ost;
1275 AVFormatContext *oc;
1276 int64_t total_size;
1277 AVCodecContext *enc;
1278 int frame_number, vid, i;
1279 double bitrate, ti1, pts;
1280 static int64_t last_time = -1;
1281 static int qp_histogram[52];
1282
1283 if (!is_last_report) {
1284 int64_t cur_time;
1285 /* display the report every 0.5 seconds */
1286 cur_time = av_gettime();
1287 if (last_time == -1) {
1288 last_time = cur_time;
1289 return;
1290 }
1291 if ((cur_time - last_time) < 500000)
1292 return;
1293 last_time = cur_time;
1294 }
1295
1296
af70aa45 1297 oc = output_files[0].ctx;
6291d7e4
AK
1298
1299 total_size = avio_size(oc->pb);
1300 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1301 total_size= avio_tell(oc->pb);
1302
1303 buf[0] = '\0';
1304 ti1 = 1e10;
1305 vid = 0;
1306 for(i=0;i<nb_ostreams;i++) {
1307 float q = -1;
4288e031 1308 ost = &ost_table[i];
6291d7e4
AK
1309 enc = ost->st->codec;
1310 if (!ost->st->stream_copy && enc->coded_frame)
1311 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1312 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1313 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1314 }
1315 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1316 float t = (av_gettime()-timer_start) / 1000000.0;
1317
1318 frame_number = ost->frame_number;
1319 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1320 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1321 if(is_last_report)
1322 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1323 if(qp_hist){
1324 int j;
1325 int qp = lrintf(q);
1326 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1327 qp_histogram[qp]++;
1328 for(j=0; j<32; j++)
1329 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1330 }
1331 if (enc->flags&CODEC_FLAG_PSNR){
1332 int j;
1333 double error, error_sum=0;
1334 double scale, scale_sum=0;
1335 char type[3]= {'Y','U','V'};
1336 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1337 for(j=0; j<3; j++){
1338 if(is_last_report){
1339 error= enc->error[j];
1340 scale= enc->width*enc->height*255.0*255.0*frame_number;
1341 }else{
1342 error= enc->coded_frame->error[j];
1343 scale= enc->width*enc->height*255.0*255.0;
1344 }
1345 if(j) scale/=4;
1346 error_sum += error;
1347 scale_sum += scale;
1348 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1349 }
1350 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1351 }
1352 vid = 1;
1353 }
1354 /* compute min output value */
1355 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1356 if ((pts < ti1) && (pts > 0))
1357 ti1 = pts;
1358 }
1359 if (ti1 < 0.01)
1360 ti1 = 0.01;
1361
1362 if (verbose > 0 || is_last_report) {
1363 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1364
1365 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1366 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1367 (double)total_size / 1024, ti1, bitrate);
1368
1369 if (nb_frames_dup || nb_frames_drop)
1370 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1371 nb_frames_dup, nb_frames_drop);
1372
1373 if (verbose >= 0)
1374 fprintf(stderr, "%s \r", buf);
1375
1376 fflush(stderr);
1377 }
1378
1379 if (is_last_report && verbose >= 0){
1380 int64_t raw= audio_size + video_size + extra_size;
1381 fprintf(stderr, "\n");
1382 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1383 video_size/1024.0,
1384 audio_size/1024.0,
1385 extra_size/1024.0,
1386 100.0*(total_size - raw)/raw
1387 );
1388 }
1389}
1390
1391static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1392{
1393 int fill_char = 0x00;
1394 if (sample_fmt == AV_SAMPLE_FMT_U8)
1395 fill_char = 0x80;
1396 memset(buf, fill_char, size);
1397}
1398
1399/* pkt = NULL means EOF (needed to flush decoder buffers) */
1400static int output_packet(InputStream *ist, int ist_index,
4288e031 1401 OutputStream *ost_table, int nb_ostreams,
6291d7e4
AK
1402 const AVPacket *pkt)
1403{
1404 AVFormatContext *os;
1405 OutputStream *ost;
1406 int ret, i;
1407 int got_output;
1408 AVFrame picture;
1409 void *buffer_to_free = NULL;
1410 static unsigned int samples_size= 0;
1411 AVSubtitle subtitle, *subtitle_to_free;
1412 int64_t pkt_pts = AV_NOPTS_VALUE;
1413#if CONFIG_AVFILTER
1414 int frame_available;
1415#endif
1416 float quality;
1417
1418 AVPacket avpkt;
1419 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1420
1421 if(ist->next_pts == AV_NOPTS_VALUE)
1422 ist->next_pts= ist->pts;
1423
1424 if (pkt == NULL) {
1425 /* EOF handling */
1426 av_init_packet(&avpkt);
1427 avpkt.data = NULL;
1428 avpkt.size = 0;
1429 goto handle_eof;
1430 } else {
1431 avpkt = *pkt;
1432 }
1433
1434 if(pkt->dts != AV_NOPTS_VALUE)
1435 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1436 if(pkt->pts != AV_NOPTS_VALUE)
1437 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1438
1439 //while we have more to decode or while the decoder did output something on EOF
1440 while (avpkt.size > 0 || (!pkt && got_output)) {
1441 uint8_t *data_buf, *decoded_data_buf;
1442 int data_size, decoded_data_size;
1443 handle_eof:
1444 ist->pts= ist->next_pts;
1445
1446 if(avpkt.size && avpkt.size != pkt->size &&
1447 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1448 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1449 ist->showed_multi_packet_warning=1;
1450 }
1451
1452 /* decode the packet if needed */
1453 decoded_data_buf = NULL; /* fail safe */
1454 decoded_data_size= 0;
1455 data_buf = avpkt.data;
1456 data_size = avpkt.size;
1457 subtitle_to_free = NULL;
1458 if (ist->decoding_needed) {
1459 switch(ist->st->codec->codec_type) {
1460 case AVMEDIA_TYPE_AUDIO:{
1461 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1462 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1463 av_free(samples);
1464 samples= av_malloc(samples_size);
1465 }
1466 decoded_data_size= samples_size;
1467 /* XXX: could avoid copy if PCM 16 bits with same
1468 endianness as CPU */
1469 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1470 &avpkt);
1471 if (ret < 0)
1472 return ret;
1473 avpkt.data += ret;
1474 avpkt.size -= ret;
1475 data_size = ret;
1476 got_output = decoded_data_size > 0;
1477 /* Some bug in mpeg audio decoder gives */
1478 /* decoded_data_size < 0, it seems they are overflows */
1479 if (!got_output) {
1480 /* no audio frame */
1481 continue;
1482 }
1483 decoded_data_buf = (uint8_t *)samples;
1484 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1485 (ist->st->codec->sample_rate * ist->st->codec->channels);
1486 break;}
1487 case AVMEDIA_TYPE_VIDEO:
1488 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1489 /* XXX: allocate picture correctly */
1490 avcodec_get_frame_defaults(&picture);
1491 avpkt.pts = pkt_pts;
1492 avpkt.dts = ist->pts;
1493 pkt_pts = AV_NOPTS_VALUE;
1494
1495 ret = avcodec_decode_video2(ist->st->codec,
1496 &picture, &got_output, &avpkt);
f4ad238c 1497 quality = same_quant ? picture.quality : 0;
6291d7e4
AK
1498 if (ret < 0)
1499 return ret;
1500 if (!got_output) {
1501 /* no picture yet */
1502 goto discard_packet;
1503 }
1504 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1505 if (ist->st->codec->time_base.num != 0) {
1506 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1507 ist->next_pts += ((int64_t)AV_TIME_BASE *
1508 ist->st->codec->time_base.num * ticks) /
1509 ist->st->codec->time_base.den;
1510 }
1511 avpkt.size = 0;
1512 buffer_to_free = NULL;
1513 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1514 break;
1515 case AVMEDIA_TYPE_SUBTITLE:
1516 ret = avcodec_decode_subtitle2(ist->st->codec,
1517 &subtitle, &got_output, &avpkt);
1518 if (ret < 0)
1519 return ret;
1520 if (!got_output) {
1521 goto discard_packet;
1522 }
1523 subtitle_to_free = &subtitle;
1524 avpkt.size = 0;
1525 break;
1526 default:
1527 return -1;
1528 }
1529 } else {
1530 switch(ist->st->codec->codec_type) {
1531 case AVMEDIA_TYPE_AUDIO:
1532 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1533 ist->st->codec->sample_rate;
1534 break;
1535 case AVMEDIA_TYPE_VIDEO:
1536 if (ist->st->codec->time_base.num != 0) {
1537 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1538 ist->next_pts += ((int64_t)AV_TIME_BASE *
1539 ist->st->codec->time_base.num * ticks) /
1540 ist->st->codec->time_base.den;
1541 }
1542 break;
1543 }
1544 ret = avpkt.size;
1545 avpkt.size = 0;
1546 }
1547
6291d7e4
AK
1548 // preprocess audio (volume)
1549 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1550 if (audio_volume != 256) {
1551 short *volp;
1552 volp = samples;
1553 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1554 int v = ((*volp) * audio_volume + 128) >> 8;
1555 if (v < -32768) v = -32768;
1556 if (v > 32767) v = 32767;
1557 *volp++ = v;
1558 }
1559 }
1560 }
1561
1562 /* frame rate emulation */
1563 if (rate_emu) {
1564 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1565 int64_t now = av_gettime() - ist->start;
1566 if (pts > now)
1567 usleep(pts - now);
1568 }
1569 /* if output time reached then transcode raw format,
1570 encode packets and output them */
ea065176 1571 for (i = 0; i < nb_ostreams; i++) {
45f86128
AK
1572 OutputFile *of = &output_files[ost_table[i].file_index];
1573 int frame_size;
6291d7e4 1574
45f86128
AK
1575 ost = &ost_table[i];
1576 if (ost->source_index != ist_index)
1577 continue;
f1176d41 1578
45f86128
AK
1579 if (of->start_time && ist->pts < of->start_time)
1580 continue;
ea065176 1581
45f86128
AK
1582 if (of->recording_time != INT64_MAX &&
1583 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1584 (AVRational){1, 1000000}) >= 0) {
1585 ost->is_past_recording_time = 1;
1586 continue;
1587 }
ef44a607 1588
6291d7e4 1589#if CONFIG_AVFILTER
45f86128
AK
1590 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1591 ost->input_video_filter) {
1592 AVRational sar;
1593 if (ist->st->sample_aspect_ratio.num)
1594 sar = ist->st->sample_aspect_ratio;
1595 else
1596 sar = ist->st->codec->sample_aspect_ratio;
1597 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1598 }
1599 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1600 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1601 while (frame_available) {
1602 AVRational ist_pts_tb;
1603 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1604 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1605 if (ost->picref)
1606 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
6291d7e4 1607#endif
45f86128
AK
1608 os = output_files[ost->file_index].ctx;
1609
1610 /* set the input output pts pairs */
1611 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1612
1613 if (ost->encoding_needed) {
1614 av_assert0(ist->decoding_needed);
1615 switch(ost->st->codec->codec_type) {
1616 case AVMEDIA_TYPE_AUDIO:
1617 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1618 break;
1619 case AVMEDIA_TYPE_VIDEO:
6291d7e4 1620#if CONFIG_AVFILTER
45f86128
AK
1621 if (ost->picref->video && !ost->frame_aspect_ratio)
1622 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
6291d7e4 1623#endif
45f86128
AK
1624 do_video_out(os, ost, ist, &picture, &frame_size,
1625 same_quant ? quality : ost->st->codec->global_quality);
1626 if (vstats_filename && frame_size)
1627 do_video_stats(os, ost, frame_size);
1628 break;
1629 case AVMEDIA_TYPE_SUBTITLE:
1630 do_subtitle_out(os, ost, ist, &subtitle,
1631 pkt->pts);
1632 break;
1633 default:
1634 abort();
1635 }
1636 } else {
1637 AVFrame avframe; //FIXME/XXX remove this
1638 AVPacket opkt;
1639 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
6291d7e4 1640
45f86128 1641 av_init_packet(&opkt);
6291d7e4 1642
45f86128 1643 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
6291d7e4 1644#if !CONFIG_AVFILTER
45f86128 1645 continue;
6291d7e4 1646#else
45f86128 1647 goto cont;
6291d7e4
AK
1648#endif
1649
45f86128
AK
1650 /* no reencoding needed : output the packet directly */
1651 /* force the input stream PTS */
1652
1653 avcodec_get_frame_defaults(&avframe);
1654 ost->st->codec->coded_frame= &avframe;
1655 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1656
1657 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1658 audio_size += data_size;
1659 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1660 video_size += data_size;
1661 ost->sync_opts++;
6291d7e4 1662 }
45f86128
AK
1663
1664 opkt.stream_index= ost->index;
1665 if(pkt->pts != AV_NOPTS_VALUE)
1666 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1667 else
1668 opkt.pts= AV_NOPTS_VALUE;
1669
1670 if (pkt->dts == AV_NOPTS_VALUE)
1671 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1672 else
1673 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1674 opkt.dts -= ost_tb_start_time;
1675
1676 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1677 opkt.flags= pkt->flags;
1678
1679 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1680 if( ost->st->codec->codec_id != CODEC_ID_H264
1681 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1682 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1683 ) {
1684 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1685 opkt.destruct= av_destruct_packet;
1686 } else {
1687 opkt.data = data_buf;
1688 opkt.size = data_size;
1689 }
1690
1691 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1692 ost->st->codec->frame_number++;
1693 ost->frame_number++;
1694 av_free_packet(&opkt);
6291d7e4 1695 }
45f86128
AK
1696#if CONFIG_AVFILTER
1697 cont:
1698 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1699 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1700 if (ost->picref)
1701 avfilter_unref_buffer(ost->picref);
1702 }
6291d7e4 1703#endif
6291d7e4
AK
1704 }
1705
1706 av_free(buffer_to_free);
1707 /* XXX: allocate the subtitles in the codec ? */
1708 if (subtitle_to_free) {
1709 avsubtitle_free(subtitle_to_free);
1710 subtitle_to_free = NULL;
1711 }
1712 }
1713 discard_packet:
1714 if (pkt == NULL) {
1715 /* EOF handling */
1716
1717 for(i=0;i<nb_ostreams;i++) {
4288e031 1718 ost = &ost_table[i];
6291d7e4
AK
1719 if (ost->source_index == ist_index) {
1720 AVCodecContext *enc= ost->st->codec;
af70aa45 1721 os = output_files[ost->file_index].ctx;
6291d7e4
AK
1722
1723 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1724 continue;
1725 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1726 continue;
1727
1728 if (ost->encoding_needed) {
1729 for(;;) {
1730 AVPacket pkt;
1731 int fifo_bytes;
1732 av_init_packet(&pkt);
1733 pkt.stream_index= ost->index;
1734
1735 switch(ost->st->codec->codec_type) {
1736 case AVMEDIA_TYPE_AUDIO:
1737 fifo_bytes = av_fifo_size(ost->fifo);
1738 ret = 0;
1739 /* encode any samples remaining in fifo */
1740 if (fifo_bytes > 0) {
1741 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1742 int fs_tmp = enc->frame_size;
1743
1744 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1745 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1746 enc->frame_size = fifo_bytes / (osize * enc->channels);
1747 } else { /* pad */
1748 int frame_bytes = enc->frame_size*osize*enc->channels;
1749 if (allocated_audio_buf_size < frame_bytes)
1750 exit_program(1);
1751 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1752 }
1753
1754 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1755 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1756 ost->st->time_base.num, enc->sample_rate);
1757 enc->frame_size = fs_tmp;
1758 }
1759 if(ret <= 0) {
1760 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1761 }
1762 if (ret < 0) {
1763 fprintf(stderr, "Audio encoding failed\n");
1764 exit_program(1);
1765 }
1766 audio_size += ret;
1767 pkt.flags |= AV_PKT_FLAG_KEY;
1768 break;
1769 case AVMEDIA_TYPE_VIDEO:
1770 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1771 if (ret < 0) {
1772 fprintf(stderr, "Video encoding failed\n");
1773 exit_program(1);
1774 }
1775 video_size += ret;
1776 if(enc->coded_frame && enc->coded_frame->key_frame)
1777 pkt.flags |= AV_PKT_FLAG_KEY;
1778 if (ost->logfile && enc->stats_out) {
1779 fprintf(ost->logfile, "%s", enc->stats_out);
1780 }
1781 break;
1782 default:
1783 ret=-1;
1784 }
1785
1786 if(ret<=0)
1787 break;
1788 pkt.data= bit_buffer;
1789 pkt.size= ret;
1790 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1791 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1792 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1793 }
1794 }
1795 }
1796 }
1797 }
1798
1799 return 0;
1800}
1801
af70aa45 1802static void print_sdp(OutputFile *output_files, int n)
6291d7e4
AK
1803{
1804 char sdp[2048];
af70aa45
AK
1805 int i;
1806 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1807
1808 if (!avc)
1809 exit_program(1);
1810 for (i = 0; i < n; i++)
1811 avc[i] = output_files[i].ctx;
6291d7e4
AK
1812
1813 av_sdp_create(avc, n, sdp, sizeof(sdp));
1814 printf("SDP:\n%s\n", sdp);
1815 fflush(stdout);
af70aa45 1816 av_freep(&avc);
6291d7e4
AK
1817}
1818
630902a1
AK
1819static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1820 char *error, int error_len)
1821{
1822 int i;
1823 InputStream *ist = &input_streams[ist_index];
1824 if (ist->decoding_needed) {
1825 AVCodec *codec = ist->dec;
1826 if (!codec)
1827 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1828 if (!codec) {
1829 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
1830 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1831 return AVERROR(EINVAL);
1832 }
1833
1834 /* update requested sample format for the decoder based on the
1835 corresponding encoder sample format */
1836 for (i = 0; i < nb_output_streams; i++) {
1837 OutputStream *ost = &output_streams[i];
1838 if (ost->source_index == ist_index) {
1839 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1840 break;
1841 }
1842 }
1843
1844 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1845 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
1846 ist->file_index, ist->st->index);
1847 return AVERROR(EINVAL);
1848 }
1849 assert_codec_experimental(ist->st->codec, 0);
1850 assert_avoptions(ist->opts);
1851 }
1852
1853 ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1854 ist->next_pts = AV_NOPTS_VALUE;
1855 init_pts_correction(&ist->pts_ctx);
1856 ist->is_start = 1;
1857
1858 return 0;
1859}
1860
6291d7e4
AK
1861/*
1862 * The following code is the main loop of the file converter
1863 */
af70aa45 1864static int transcode(OutputFile *output_files,
6291d7e4
AK
1865 int nb_output_files,
1866 InputFile *input_files,
3d4f0dab 1867 int nb_input_files)
6291d7e4 1868{
630902a1 1869 int ret = 0, i;
6291d7e4
AK
1870 AVFormatContext *is, *os;
1871 AVCodecContext *codec, *icodec;
4288e031 1872 OutputStream *ost;
6291d7e4
AK
1873 InputStream *ist;
1874 char error[1024];
1875 int want_sdp = 1;
b0c9e8e0 1876 uint8_t *no_packet;
6291d7e4 1877 int no_packet_count=0;
c5ad2c2c 1878 int64_t timer_start;
6291d7e4 1879
b0c9e8e0
AK
1880 if (!(no_packet = av_mallocz(nb_input_files)))
1881 exit_program(1);
1882
6291d7e4
AK
1883 if (rate_emu)
1884 for (i = 0; i < nb_input_streams; i++)
1885 input_streams[i].start = av_gettime();
1886
1887 /* output stream init */
6291d7e4 1888 for(i=0;i<nb_output_files;i++) {
af70aa45 1889 os = output_files[i].ctx;
6291d7e4 1890 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
af70aa45 1891 av_dump_format(os, i, os->filename, 1);
6291d7e4
AK
1892 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1893 ret = AVERROR(EINVAL);
1894 goto fail;
1895 }
6291d7e4
AK
1896 }
1897
1898 /* for each output stream, we compute the right encoding parameters */
4288e031
AK
1899 for (i = 0; i < nb_output_streams; i++) {
1900 ost = &output_streams[i];
af70aa45 1901 os = output_files[ost->file_index].ctx;
6291d7e4
AK
1902 ist = &input_streams[ost->source_index];
1903
1904 codec = ost->st->codec;
1905 icodec = ist->st->codec;
1906
6291d7e4
AK
1907 ost->st->disposition = ist->st->disposition;
1908 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1909 codec->chroma_sample_location = icodec->chroma_sample_location;
1910
1911 if (ost->st->stream_copy) {
1912 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1913
1914 if (extra_size > INT_MAX)
1915 goto fail;
1916
1917 /* if stream_copy is selected, no need to decode or encode */
1918 codec->codec_id = icodec->codec_id;
1919 codec->codec_type = icodec->codec_type;
1920
1921 if(!codec->codec_tag){
1922 if( !os->oformat->codec_tag
1923 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1924 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1925 codec->codec_tag = icodec->codec_tag;
1926 }
1927
1928 codec->bit_rate = icodec->bit_rate;
1929 codec->rc_max_rate = icodec->rc_max_rate;
1930 codec->rc_buffer_size = icodec->rc_buffer_size;
1931 codec->extradata= av_mallocz(extra_size);
1932 if (!codec->extradata)
1933 goto fail;
1934 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1935 codec->extradata_size= icodec->extradata_size;
1936 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){
1937 codec->time_base = icodec->time_base;
1938 codec->time_base.num *= icodec->ticks_per_frame;
1939 av_reduce(&codec->time_base.num, &codec->time_base.den,
1940 codec->time_base.num, codec->time_base.den, INT_MAX);
1941 }else
1942 codec->time_base = ist->st->time_base;
1943 switch(codec->codec_type) {
1944 case AVMEDIA_TYPE_AUDIO:
1945 if(audio_volume != 256) {
1946 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1947 exit_program(1);
1948 }
1949 codec->channel_layout = icodec->channel_layout;
1950 codec->sample_rate = icodec->sample_rate;
1951 codec->channels = icodec->channels;
1952 codec->frame_size = icodec->frame_size;
1953 codec->audio_service_type = icodec->audio_service_type;
1954 codec->block_align= icodec->block_align;
1955 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1956 codec->block_align= 0;
1957 if(codec->codec_id == CODEC_ID_AC3)
1958 codec->block_align= 0;
1959 break;
1960 case AVMEDIA_TYPE_VIDEO:
1961 codec->pix_fmt = icodec->pix_fmt;
1962 codec->width = icodec->width;
1963 codec->height = icodec->height;
1964 codec->has_b_frames = icodec->has_b_frames;
1965 if (!codec->sample_aspect_ratio.num) {
1966 codec->sample_aspect_ratio =
1967 ost->st->sample_aspect_ratio =
1968 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1969 ist->st->codec->sample_aspect_ratio.num ?
1970 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1971 }
1972 break;
1973 case AVMEDIA_TYPE_SUBTITLE:
1974 codec->width = icodec->width;
1975 codec->height = icodec->height;
1976 break;
1977 case AVMEDIA_TYPE_DATA:
1978 break;
1979 default:
1980 abort();
1981 }
1982 } else {
1983 if (!ost->enc)
1984 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1985 switch(codec->codec_type) {
1986 case AVMEDIA_TYPE_AUDIO:
1987 ost->fifo= av_fifo_alloc(1024);
1988 if(!ost->fifo)
1989 goto fail;
1990 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
1991 if (!codec->sample_rate) {
1992 codec->sample_rate = icodec->sample_rate;
1993 if (icodec->lowres)
1994 codec->sample_rate >>= icodec->lowres;
1995 }
1996 choose_sample_rate(ost->st, ost->enc);
1997 codec->time_base = (AVRational){1, codec->sample_rate};
1998 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
1999 codec->sample_fmt = icodec->sample_fmt;
2000 choose_sample_fmt(ost->st, ost->enc);
2001 if (!codec->channels)
2002 codec->channels = icodec->channels;
2003 codec->channel_layout = icodec->channel_layout;
2004 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2005 codec->channel_layout = 0;
2006 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2007 icodec->request_channels = codec->channels;
2008 ist->decoding_needed = 1;
2009 ost->encoding_needed = 1;
2010 ost->resample_sample_fmt = icodec->sample_fmt;
2011 ost->resample_sample_rate = icodec->sample_rate;
2012 ost->resample_channels = icodec->channels;
2013 break;
2014 case AVMEDIA_TYPE_VIDEO:
2015 if (codec->pix_fmt == PIX_FMT_NONE)
2016 codec->pix_fmt = icodec->pix_fmt;
2017 choose_pixel_fmt(ost->st, ost->enc);
2018
2019 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2020 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2021 exit_program(1);
2022 }
2023
2024 if (!codec->width || !codec->height) {
2025 codec->width = icodec->width;
2026 codec->height = icodec->height;
2027 }
2028
2029 ost->video_resample = codec->width != icodec->width ||
2030 codec->height != icodec->height ||
2031 codec->pix_fmt != icodec->pix_fmt;
2032 if (ost->video_resample) {
2033#if !CONFIG_AVFILTER
2034 avcodec_get_frame_defaults(&ost->pict_tmp);
2035 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2036 codec->width, codec->height)) {
2037 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2038 exit_program(1);
2039 }
2040 ost->img_resample_ctx = sws_getContext(
2041 icodec->width,
2042 icodec->height,
2043 icodec->pix_fmt,
2044 codec->width,
2045 codec->height,
2046 codec->pix_fmt,
2047 ost->sws_flags, NULL, NULL, NULL);
2048 if (ost->img_resample_ctx == NULL) {
2049 fprintf(stderr, "Cannot get resampling context\n");
2050 exit_program(1);
2051 }
2052#endif
2053 codec->bits_per_raw_sample= 0;
2054 }
2055
2056 ost->resample_height = icodec->height;
2057 ost->resample_width = icodec->width;
2058 ost->resample_pix_fmt= icodec->pix_fmt;
2059 ost->encoding_needed = 1;
2060 ist->decoding_needed = 1;
2061
2062 if (!ost->frame_rate.num)
2063 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2064 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2065 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2066 ost->frame_rate = ost->enc->supported_framerates[idx];
2067 }
2068 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2069
2070#if CONFIG_AVFILTER
2071 if (configure_video_filters(ist, ost)) {
2072 fprintf(stderr, "Error opening filters!\n");
2073 exit(1);
2074 }
2075#endif
2076 break;
2077 case AVMEDIA_TYPE_SUBTITLE:
2078 ost->encoding_needed = 1;
2079 ist->decoding_needed = 1;
2080 break;
2081 default:
2082 abort();
2083 break;
2084 }
2085 /* two pass mode */
2086 if (ost->encoding_needed &&
2087 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2088 char logfilename[1024];
2089 FILE *f;
2090
2091 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2092 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2093 i);
2094 if (codec->flags & CODEC_FLAG_PASS1) {
2095 f = fopen(logfilename, "wb");
2096 if (!f) {
2097 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2098 exit_program(1);
2099 }
2100 ost->logfile = f;
2101 } else {
2102 char *logbuffer;
2103 size_t logbuffer_size;
2104 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2105 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2106 exit_program(1);
2107 }
2108 codec->stats_in = logbuffer;
2109 }
2110 }
2111 }
2112 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2113 int size= codec->width * codec->height;
2114 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2115 }
2116 }
2117
2118 if (!bit_buffer)
2119 bit_buffer = av_malloc(bit_buffer_size);
2120 if (!bit_buffer) {
2121 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2122 bit_buffer_size);
2123 ret = AVERROR(ENOMEM);
2124 goto fail;
2125 }
2126
2127 /* open each encoder */
4288e031
AK
2128 for (i = 0; i < nb_output_streams; i++) {
2129 ost = &output_streams[i];
6291d7e4
AK
2130 if (ost->encoding_needed) {
2131 AVCodec *codec = ost->enc;
2132 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2133 if (!codec) {
2134 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2135 ost->st->codec->codec_id, ost->file_index, ost->index);
2136 ret = AVERROR(EINVAL);
2137 goto dump_format;
2138 }
2139 if (dec->subtitle_header) {
2140 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2141 if (!ost->st->codec->subtitle_header) {
2142 ret = AVERROR(ENOMEM);
2143 goto dump_format;
2144 }
2145 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2146 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2147 }
2148 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2149 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2150 ost->file_index, ost->index);
2151 ret = AVERROR(EINVAL);
2152 goto dump_format;
2153 }
2154 assert_codec_experimental(ost->st->codec, 1);
2155 assert_avoptions(ost->opts);
2156 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2157 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2158 "It takes bits/s as argument, not kbits/s\n");
2159 extra_size += ost->st->codec->extradata_size;
2160 }
2161 }
2162
630902a1
AK
2163 /* init input streams */
2164 for (i = 0; i < nb_input_streams; i++)
2165 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error)) < 0))
2166 goto dump_format;
6291d7e4 2167
6291d7e4 2168 /* open files and write file headers */
af70aa45
AK
2169 for (i = 0; i < nb_output_files; i++) {
2170 os = output_files[i].ctx;
2171 if (avformat_write_header(os, &output_files[i].opts) < 0) {
6291d7e4
AK
2172 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2173 ret = AVERROR(EINVAL);
2174 goto dump_format;
2175 }
af70aa45
AK
2176 assert_avoptions(output_files[i].opts);
2177 if (strcmp(os->oformat->name, "rtp")) {
6291d7e4
AK
2178 want_sdp = 0;
2179 }
2180 }
2181
2182 dump_format:
2183 /* dump the file output parameters - cannot be done before in case
2184 of stream copy */
2185 for(i=0;i<nb_output_files;i++) {
af70aa45 2186 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
6291d7e4
AK
2187 }
2188
2189 /* dump the stream mapping */
2190 if (verbose >= 0) {
2191 fprintf(stderr, "Stream mapping:\n");
4288e031
AK
2192 for (i = 0; i < nb_output_streams;i ++) {
2193 ost = &output_streams[i];
6291d7e4
AK
2194 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2195 input_streams[ost->source_index].file_index,
2196 input_streams[ost->source_index].st->index,
2197 ost->file_index,
2198 ost->index);
2199 if (ost->sync_ist != &input_streams[ost->source_index])
2200 fprintf(stderr, " [sync #%d.%d]",
2201 ost->sync_ist->file_index,
2202 ost->sync_ist->st->index);
ad42126a
AK
2203 if (ost->st->stream_copy)
2204 fprintf(stderr, " (copy)");
6291d7e4
AK
2205 fprintf(stderr, "\n");
2206 }
2207 }
2208
2209 if (ret) {
2210 fprintf(stderr, "%s\n", error);
2211 goto fail;
2212 }
2213
2214 if (want_sdp) {
2215 print_sdp(output_files, nb_output_files);
2216 }
2217
2218 if (verbose >= 0)
2219 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2220 term_init();
2221
2222 timer_start = av_gettime();
2223
2224 for(; received_sigterm == 0;) {
2225 int file_index, ist_index;
2226 AVPacket pkt;
9be3c124 2227 int64_t ipts_min;
6291d7e4
AK
2228 double opts_min;
2229
2230 redo:
9be3c124 2231 ipts_min = INT64_MAX;
6291d7e4
AK
2232 opts_min= 1e100;
2233
2234 /* select the stream that we must read now by looking at the
2235 smallest output pts */
2236 file_index = -1;
4288e031 2237 for (i = 0; i < nb_output_streams; i++) {
9be3c124
AC
2238 int64_t ipts;
2239 double opts;
4288e031 2240 ost = &output_streams[i];
af70aa45 2241 os = output_files[ost->file_index].ctx;
6291d7e4 2242 ist = &input_streams[ost->source_index];
ef44a607 2243 if(ost->is_past_recording_time || no_packet[ist->file_index])
6291d7e4
AK
2244 continue;
2245 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
9be3c124 2246 ipts = ist->pts;
6291d7e4
AK
2247 if (!input_files[ist->file_index].eof_reached){
2248 if(ipts < ipts_min) {
2249 ipts_min = ipts;
2250 if(input_sync ) file_index = ist->file_index;
2251 }
2252 if(opts < opts_min) {
2253 opts_min = opts;
2254 if(!input_sync) file_index = ist->file_index;
2255 }
2256 }
2257 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2258 file_index= -1;
2259 break;
2260 }
2261 }
2262 /* if none, if is finished */
2263 if (file_index < 0) {
2264 if(no_packet_count){
2265 no_packet_count=0;
b0c9e8e0 2266 memset(no_packet, 0, nb_input_files);
6291d7e4
AK
2267 usleep(10000);
2268 continue;
2269 }
2270 break;
2271 }
2272
2273 /* finish if limit size exhausted */
af70aa45 2274 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0].ctx->pb))
6291d7e4
AK
2275 break;
2276
2277 /* read a frame from it and output it in the fifo */
2278 is = input_files[file_index].ctx;
2279 ret= av_read_frame(is, &pkt);
2280 if(ret == AVERROR(EAGAIN)){
2281 no_packet[file_index]=1;
2282 no_packet_count++;
2283 continue;
2284 }
2285 if (ret < 0) {
2286 input_files[file_index].eof_reached = 1;
2287 if (opt_shortest)
2288 break;
2289 else
2290 continue;
2291 }
2292
2293 no_packet_count=0;
b0c9e8e0 2294 memset(no_packet, 0, nb_input_files);
6291d7e4
AK
2295
2296 if (do_pkt_dump) {
2297 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2298 is->streams[pkt.stream_index]);
2299 }
2300 /* the following test is needed in case new streams appear
2301 dynamically in stream : we ignore them */
2302 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2303 goto discard_packet;
2304 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2305 ist = &input_streams[ist_index];
2306 if (ist->discard)
2307 goto discard_packet;
2308
2309 if (pkt.dts != AV_NOPTS_VALUE)
2310 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2311 if (pkt.pts != AV_NOPTS_VALUE)
2312 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2313
2314 if (ist->ts_scale) {
2315 if(pkt.pts != AV_NOPTS_VALUE)
2316 pkt.pts *= ist->ts_scale;
2317 if(pkt.dts != AV_NOPTS_VALUE)
2318 pkt.dts *= ist->ts_scale;
2319 }
2320
2321// fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2322 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2323 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2324 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2325 int64_t delta= pkt_dts - ist->next_pts;
2326 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2327 input_files[ist->file_index].ts_offset -= delta;
2328 if (verbose > 2)
2329 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2330 delta, input_files[ist->file_index].ts_offset);
2331 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2332 if(pkt.pts != AV_NOPTS_VALUE)
2333 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2334 }
2335 }
2336
6291d7e4 2337 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
4288e031 2338 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
6291d7e4
AK
2339
2340 if (verbose >= 0)
2341 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2342 ist->file_index, ist->st->index);
2343 if (exit_on_error)
2344 exit_program(1);
2345 av_free_packet(&pkt);
2346 goto redo;
2347 }
2348
2349 discard_packet:
2350 av_free_packet(&pkt);
2351
2352 /* dump report by using the output first video and audio streams */
c5ad2c2c 2353 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
6291d7e4
AK
2354 }
2355
2356 /* at the end of stream, we must flush the decoder buffers */
2357 for (i = 0; i < nb_input_streams; i++) {
2358 ist = &input_streams[i];
2359 if (ist->decoding_needed) {
4288e031 2360 output_packet(ist, i, output_streams, nb_output_streams, NULL);
6291d7e4
AK
2361 }
2362 }
2363
2364 term_exit();
2365
2366 /* write the trailer if needed and close file */
2367 for(i=0;i<nb_output_files;i++) {
af70aa45 2368 os = output_files[i].ctx;
6291d7e4
AK
2369 av_write_trailer(os);
2370 }
2371
2372 /* dump report by using the first video and audio streams */
c5ad2c2c 2373 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
6291d7e4
AK
2374
2375 /* close each encoder */
4288e031
AK
2376 for (i = 0; i < nb_output_streams; i++) {
2377 ost = &output_streams[i];
6291d7e4
AK
2378 if (ost->encoding_needed) {
2379 av_freep(&ost->st->codec->stats_in);
2380 avcodec_close(ost->st->codec);
2381 }
2382#if CONFIG_AVFILTER
2383 avfilter_graph_free(&ost->graph);
2384#endif
2385 }
2386
2387 /* close each decoder */
2388 for (i = 0; i < nb_input_streams; i++) {
2389 ist = &input_streams[i];
2390 if (ist->decoding_needed) {
2391 avcodec_close(ist->st->codec);
2392 }
2393 }
2394
2395 /* finished ! */
2396 ret = 0;
2397
2398 fail:
2399 av_freep(&bit_buffer);
b0c9e8e0 2400 av_freep(&no_packet);
6291d7e4 2401
4288e031
AK
2402 if (output_streams) {
2403 for (i = 0; i < nb_output_streams; i++) {
2404 ost = &output_streams[i];
6291d7e4
AK
2405 if (ost) {
2406 if (ost->st->stream_copy)
2407 av_freep(&ost->st->codec->extradata);
2408 if (ost->logfile) {
2409 fclose(ost->logfile);
2410 ost->logfile = NULL;
2411 }
2412 av_fifo_free(ost->fifo); /* works even if fifo is not
2413 initialized but set to zero */
2414 av_freep(&ost->st->codec->subtitle_header);
2415 av_free(ost->pict_tmp.data[0]);
2416 av_free(ost->forced_kf_pts);
2417 if (ost->video_resample)
2418 sws_freeContext(ost->img_resample_ctx);
2419 if (ost->resample)
2420 audio_resample_close(ost->resample);
2421 if (ost->reformat_ctx)
2422 av_audio_convert_free(ost->reformat_ctx);
2423 av_dict_free(&ost->opts);
6291d7e4
AK
2424 }
2425 }
6291d7e4
AK
2426 }
2427 return ret;
2428}
2429
2430static int opt_format(const char *opt, const char *arg)
2431{
2432 last_asked_format = arg;
2433 return 0;
2434}
2435
2436static int opt_video_rc_override_string(const char *opt, const char *arg)
2437{
2438 video_rc_override_string = arg;
2439 return 0;
2440}
2441
2442static int opt_me_threshold(const char *opt, const char *arg)
2443{
2444 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2445 return 0;
2446}
2447
2448static int opt_verbose(const char *opt, const char *arg)
2449{
2450 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2451 return 0;
2452}
2453
2454static int opt_frame_rate(const char *opt, const char *arg)
2455{
2456 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2457 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2458 exit_program(1);
2459 }
2460 return 0;
2461}
2462
2463static int opt_frame_crop(const char *opt, const char *arg)
2464{
2465 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2466 return AVERROR(EINVAL);
2467}
2468
2469static int opt_frame_size(const char *opt, const char *arg)
2470{
2471 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2472 fprintf(stderr, "Incorrect frame size\n");
2473 return AVERROR(EINVAL);
2474 }
2475 return 0;
2476}
2477
2478static int opt_pad(const char *opt, const char *arg) {
2479 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2480 return -1;
2481}
2482
2483static int opt_frame_pix_fmt(const char *opt, const char *arg)
2484{
2485 if (strcmp(arg, "list")) {
2486 frame_pix_fmt = av_get_pix_fmt(arg);
2487 if (frame_pix_fmt == PIX_FMT_NONE) {
2488 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2489 return AVERROR(EINVAL);
2490 }
2491 } else {
2492 show_pix_fmts();
2493 exit_program(0);
2494 }
2495 return 0;
2496}
2497
2498static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2499{
2500 int x = 0, y = 0;
2501 double ar = 0;
2502 const char *p;
2503 char *end;
2504
2505 p = strchr(arg, ':');
2506 if (p) {
2507 x = strtol(arg, &end, 10);
2508 if (end == p)
2509 y = strtol(end+1, &end, 10);
2510 if (x > 0 && y > 0)
2511 ar = (double)x / (double)y;
2512 } else
2513 ar = strtod(arg, NULL);
2514
2515 if (!ar) {
2516 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2517 return AVERROR(EINVAL);
2518 }
2519 frame_aspect_ratio = ar;
2520 return 0;
2521}
2522
2523static int opt_metadata(const char *opt, const char *arg)
2524{
2525 char *mid= strchr(arg, '=');
2526
2527 if(!mid){
2528 fprintf(stderr, "Missing =\n");
2529 exit_program(1);
2530 }
2531 *mid++= 0;
2532
2533 av_dict_set(&metadata, arg, mid, 0);
2534
2535 return 0;
2536}
2537
2538static int opt_qscale(const char *opt, const char *arg)
2539{
2540 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2541 if (video_qscale == 0) {
2542 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2543 return AVERROR(EINVAL);
2544 }
2545 return 0;
2546}
2547
2548static int opt_top_field_first(const char *opt, const char *arg)
2549{
2550 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2551 return 0;
2552}
2553
2554static int opt_thread_count(const char *opt, const char *arg)
2555{
2556 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2557#if !HAVE_THREADS
2558 if (verbose >= 0)
2559 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2560#endif
2561 return 0;
2562}
2563
2564static int opt_audio_sample_fmt(const char *opt, const char *arg)
2565{
2566 if (strcmp(arg, "list")) {
2567 audio_sample_fmt = av_get_sample_fmt(arg);
2568 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2569 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2570 return AVERROR(EINVAL);
2571 }
2572 } else {
2573 int i;
2574 char fmt_str[128];
2575 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2576 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2577 exit_program(0);
2578 }
2579 return 0;
2580}
2581
2582static int opt_audio_rate(const char *opt, const char *arg)
2583{
2584 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2585 return 0;
2586}
2587
2588static int opt_audio_channels(const char *opt, const char *arg)
2589{
2590 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2591 return 0;
2592}
2593
92f1940e 2594static int opt_codec(const char *opt, const char *arg)
6291d7e4 2595{
92f1940e 2596 return av_dict_set(&codec_names, opt, arg, 0);
6291d7e4
AK
2597}
2598
2599static int opt_audio_codec(const char *opt, const char *arg)
2600{
92f1940e 2601 return opt_codec("codec:a", arg);
6291d7e4
AK
2602}
2603
2604static int opt_video_codec(const char *opt, const char *arg)
2605{
92f1940e 2606 return opt_codec("codec:v", arg);
6291d7e4
AK
2607}
2608
2609static int opt_subtitle_codec(const char *opt, const char *arg)
2610{
92f1940e 2611 return opt_codec("codec:s", arg);
6291d7e4
AK
2612}
2613
2614static int opt_data_codec(const char *opt, const char *arg)
2615{
92f1940e 2616 return opt_codec("codec:d", arg);
6291d7e4
AK
2617}
2618
2619static int opt_codec_tag(const char *opt, const char *arg)
2620{
2621 char *tail;
2622 uint32_t *codec_tag;
2623
2624 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2625 !strcmp(opt, "vtag") ? &video_codec_tag :
2626 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2627 if (!codec_tag)
2628 return -1;
2629
2630 *codec_tag = strtol(arg, &tail, 0);
2631 if (!tail || *tail)
2632 *codec_tag = AV_RL32(arg);
2633
2634 return 0;
2635}
2636
2637static int opt_map(const char *opt, const char *arg)
2638{
8d2e4a7e
AK
2639 StreamMap *m = NULL;
2640 int i, negative = 0, file_idx;
2641 int sync_file_idx = -1, sync_stream_idx;
2642 char *p, *sync;
2643 char *map;
6291d7e4 2644
8d2e4a7e
AK
2645 if (*arg == '-') {
2646 negative = 1;
2647 arg++;
2648 }
2649 map = av_strdup(arg);
6291d7e4 2650
8d2e4a7e
AK
2651 /* parse sync stream first, just pick first matching stream */
2652 if (sync = strchr(map, ',')) {
2653 *sync = 0;
2654 sync_file_idx = strtol(sync + 1, &sync, 0);
2655 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2656 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2657 exit_program(1);
2658 }
2659 if (*sync)
2660 sync++;
2661 for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2662 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2663 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2664 sync_stream_idx = i;
2665 break;
2666 }
2667 if (i == input_files[sync_file_idx].ctx->nb_streams) {
2668 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2669 "match any streams.\n", arg);
2670 exit_program(1);
2671 }
2672 }
6291d7e4 2673
8d2e4a7e
AK
2674
2675 file_idx = strtol(map, &p, 0);
2676 if (file_idx >= nb_input_files || file_idx < 0) {
2677 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2678 exit_program(1);
6291d7e4 2679 }
8d2e4a7e
AK
2680 if (negative)
2681 /* disable some already defined maps */
2682 for (i = 0; i < nb_stream_maps; i++) {
2683 m = &stream_maps[i];
2684 if (check_stream_specifier(input_files[m->file_index].ctx,
2685 input_files[m->file_index].ctx->streams[m->stream_index],
2686 *p == ':' ? p + 1 : p) > 0)
2687 m->disabled = 1;
2688 }
2689 else
2690 for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2691 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2692 *p == ':' ? p + 1 : p) <= 0)
2693 continue;
2694 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2695 m = &stream_maps[nb_stream_maps - 1];
2696
2697 m->file_index = file_idx;
2698 m->stream_index = i;
2699
2700 if (sync_file_idx >= 0) {
2701 m->sync_file_index = sync_file_idx;
2702 m->sync_stream_index = sync_stream_idx;
2703 } else {
2704 m->sync_file_index = file_idx;
2705 m->sync_stream_index = i;
2706 }
2707 }
2708
2709 if (!m) {
2710 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2711 exit_program(1);
2712 }
2713
2714 av_freep(&map);
6291d7e4
AK
2715 return 0;
2716}
2717
e6e6060c 2718static void parse_meta_type(char *arg, char *type, int *index)
6291d7e4 2719{
e6e6060c 2720 if (*arg == ':') {
6291d7e4
AK
2721 *type = *(++arg);
2722 switch (*arg) {
2723 case 'g':
2724 break;
2725 case 's':
2726 case 'c':
2727 case 'p':
e6e6060c
AK
2728 if (*(++arg) == ':')
2729 *index = strtol(++arg, NULL, 0);
6291d7e4
AK
2730 break;
2731 default:
2732 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2733 exit_program(1);
2734 }
2735 } else
2736 *type = 'g';
2737}
2738
2739static int opt_map_metadata(const char *opt, const char *arg)
2740{
2741 MetadataMap *m, *m1;
2742 char *p;
2743
2744 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2745 &nb_meta_data_maps, nb_meta_data_maps + 1);
2746
e6e6060c 2747 m = &meta_data_maps[nb_meta_data_maps - 1][1];
6291d7e4 2748 m->file = strtol(arg, &p, 0);
e6e6060c 2749 parse_meta_type(p, &m->type, &m->index);
6291d7e4 2750
e6e6060c
AK
2751 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2752 if (p = strchr(opt, ':'))
2753 parse_meta_type(p, &m1->type, &m1->index);
2754 else
2755 m1->type = 'g';
6291d7e4
AK
2756
2757 if (m->type == 'g' || m1->type == 'g')
2758 metadata_global_autocopy = 0;
2759 if (m->type == 's' || m1->type == 's')
2760 metadata_streams_autocopy = 0;
2761 if (m->type == 'c' || m1->type == 'c')
2762 metadata_chapters_autocopy = 0;
2763
2764 return 0;
2765}
2766
6291d7e4
AK
2767static int opt_input_ts_scale(const char *opt, const char *arg)
2768{
09af7fb3 2769 return av_dict_set(&ts_scale, opt, arg, 0);
6291d7e4
AK
2770}
2771
2772static int opt_recording_time(const char *opt, const char *arg)
2773{
2774 recording_time = parse_time_or_die(opt, arg, 1);
2775 return 0;
2776}
2777
2778static int opt_start_time(const char *opt, const char *arg)
2779{
2780 start_time = parse_time_or_die(opt, arg, 1);
2781 return 0;
2782}
2783
6291d7e4
AK
2784static int opt_input_ts_offset(const char *opt, const char *arg)
2785{
2786 input_ts_offset = parse_time_or_die(opt, arg, 1);
2787 return 0;
2788}
2789
169f0647
AK
2790static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2791{
2792 const char *codec_string = encoder ? "encoder" : "decoder";
2793 AVCodec *codec;
2794
2795 if(!name)
2796 return CODEC_ID_NONE;
2797 codec = encoder ?
2798 avcodec_find_encoder_by_name(name) :
2799 avcodec_find_decoder_by_name(name);
2800 if(!codec) {
2801 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2802 exit_program(1);
2803 }
2804 if(codec->type != type) {
2805 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2806 exit_program(1);
2807 }
2808 return codec->id;
2809}
2810
2811static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2812{
2813 AVDictionaryEntry *e = NULL;
2814 char *codec_name = NULL;
2815 int ret;
2816
2817 while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2818 char *p = strchr(e->key, ':');
2819
2820 if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2821 codec_name = e->value;
2822 else if (ret < 0)
2823 exit_program(1);
2824 }
2825
2826 if (!codec_name) {
6cd9d0f7
AK
2827 if (s->oformat) {
2828 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2829 return avcodec_find_encoder(st->codec->codec_id);
2830 }
169f0647
AK
2831 } else if (!strcmp(codec_name, "copy"))
2832 st->stream_copy = 1;
2833 else {
2834 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2835 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2836 avcodec_find_decoder_by_name(codec_name);
2837 }
2838
2839 return NULL;
2840}
6291d7e4 2841
88867844
AK
2842/**
2843 * Add all the streams from the given input file to the global
2844 * list of input streams.
2845 */
2846static void add_input_streams(AVFormatContext *ic)
2847{
09af7fb3 2848 int i, rfps, rfps_base, ret;
88867844
AK
2849
2850 for (i = 0; i < ic->nb_streams; i++) {
2851 AVStream *st = ic->streams[i];
2852 AVCodecContext *dec = st->codec;
09af7fb3 2853 AVDictionaryEntry *e = NULL;
88867844 2854 InputStream *ist;
09af7fb3 2855 char *scale = NULL;
88867844
AK
2856
2857 dec->thread_count = thread_count;
2858
2859 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2860 ist = &input_streams[nb_input_streams - 1];
2861 ist->st = st;
2862 ist->file_index = nb_input_files;
2863 ist->discard = 1;
2864 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2865
09af7fb3
AK
2866 while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
2867 char *p = strchr(e->key, ':');
2868
2869 if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
2870 scale = e->value;
2871 else if (ret < 0)
2872 exit_program(1);
2873 }
2874 if (scale)
2875 ist->ts_scale = strtod(scale, NULL);
88867844
AK
2876
2877 ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
2878
2879 switch (dec->codec_type) {
2880 case AVMEDIA_TYPE_AUDIO:
2881 if(audio_disable)
2882 st->discard= AVDISCARD_ALL;
2883 break;
2884 case AVMEDIA_TYPE_VIDEO:
2885 rfps = ic->streams[i]->r_frame_rate.num;
2886 rfps_base = ic->streams[i]->r_frame_rate.den;
2887 if (dec->lowres) {
2888 dec->flags |= CODEC_FLAG_EMU_EDGE;
2889 dec->height >>= dec->lowres;
2890 dec->width >>= dec->lowres;
2891 }
2892 if(me_threshold)
2893 dec->debug |= FF_DEBUG_MV;
2894
2895 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2896
2897 if (verbose >= 0)
2898 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2899 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2900
2901 (float)rfps / rfps_base, rfps, rfps_base);
2902 }
2903
2904 if(video_disable)
2905 st->discard= AVDISCARD_ALL;
2906 else if(video_discard)
2907 st->discard= video_discard;
2908 break;
2909 case AVMEDIA_TYPE_DATA:
2910 break;
2911 case AVMEDIA_TYPE_SUBTITLE:
2912 if(subtitle_disable)
2913 st->discard = AVDISCARD_ALL;
2914 break;
2915 case AVMEDIA_TYPE_ATTACHMENT:
2916 case AVMEDIA_TYPE_UNKNOWN:
2917 break;
2918 default:
2919 abort();
2920 }
2921 }
2922}
2923
6291d7e4
AK
2924static int opt_input_file(const char *opt, const char *filename)
2925{
2926 AVFormatContext *ic;
2927 AVInputFormat *file_iformat = NULL;
88867844 2928 int err, i, ret;
6291d7e4
AK
2929 int64_t timestamp;
2930 uint8_t buf[128];
2931 AVDictionary **opts;
2932 int orig_nb_streams; // number of streams before avformat_find_stream_info
2933
2934 if (last_asked_format) {
2935 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2936 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2937 exit_program(1);
2938 }
2939 last_asked_format = NULL;
2940 }
2941
2942 if (!strcmp(filename, "-"))
2943 filename = "pipe:";
2944
2945 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2946 !strcmp(filename, "/dev/stdin");
2947
2948 /* get default parameters from command line */
2949 ic = avformat_alloc_context();
2950 if (!ic) {
2951 print_error(filename, AVERROR(ENOMEM));
2952 exit_program(1);
2953 }
2954 if (audio_sample_rate) {
2955 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2956 av_dict_set(&format_opts, "sample_rate", buf, 0);
2957 }
2958 if (audio_channels) {
2959 snprintf(buf, sizeof(buf), "%d", audio_channels);
2960 av_dict_set(&format_opts, "channels", buf, 0);
2961 }
2962 if (frame_rate.num) {
2963 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2964 av_dict_set(&format_opts, "framerate", buf, 0);
2965 }
2966 if (frame_width && frame_height) {
2967 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2968 av_dict_set(&format_opts, "video_size", buf, 0);
2969 }
2970 if (frame_pix_fmt != PIX_FMT_NONE)
2971 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2972
6291d7e4
AK
2973 ic->flags |= AVFMT_FLAG_NONBLOCK;
2974
2975 /* open the input file with generic libav function */
2976 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2977 if (err < 0) {
2978 print_error(filename, err);
2979 exit_program(1);
2980 }
2981 assert_avoptions(format_opts);
2982
2983 if(opt_programid) {
2984 int i, j;
2985 int found=0;
2986 for(i=0; i<ic->nb_streams; i++){
2987 ic->streams[i]->discard= AVDISCARD_ALL;
2988 }
2989 for(i=0; i<ic->nb_programs; i++){
2990 AVProgram *p= ic->programs[i];
2991 if(p->id != opt_programid){
2992 p->discard = AVDISCARD_ALL;
2993 }else{
2994 found=1;
2995 for(j=0; j<p->nb_stream_indexes; j++){
2996 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2997 }
2998 }
2999 }
3000 if(!found){
3001 fprintf(stderr, "Specified program id not found\n");
3002 exit_program(1);
3003 }
3004 opt_programid=0;
3005 }
3006
92f1940e
AK
3007 /* apply forced codec ids */
3008 for (i = 0; i < ic->nb_streams; i++)
3009 choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3010
6291d7e4
AK
3011 /* Set AVCodecContext options for avformat_find_stream_info */
3012 opts = setup_find_stream_info_opts(ic, codec_opts);
3013 orig_nb_streams = ic->nb_streams;
3014
3015 /* If not enough info to get the stream parameters, we decode the
3016 first frames to get it. (used in mpeg case for example) */
3017 ret = avformat_find_stream_info(ic, opts);
3018 if (ret < 0 && verbose >= 0) {
3019 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3020 av_close_input_file(ic);
3021 exit_program(1);
3022 }
3023
3024 timestamp = start_time;
3025 /* add the stream start time */
3026 if (ic->start_time != AV_NOPTS_VALUE)
3027 timestamp += ic->start_time;
3028
3029 /* if seeking requested, we execute it */
3030 if (start_time != 0) {
3031 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3032 if (ret < 0) {
3033 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3034 filename, (double)timestamp / AV_TIME_BASE);
3035 }
3036 /* reset seek info */
3037 start_time = 0;
3038 }
3039
3040 /* update the current parameters so that they match the one of the input stream */
88867844 3041 add_input_streams(ic);
6291d7e4
AK
3042
3043 /* dump the file content */
3044 if (verbose >= 0)
3045 av_dump_format(ic, nb_input_files, filename, 0);
3046
3047 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3048 input_files[nb_input_files - 1].ctx = ic;
3049 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3050 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3051
3052 frame_rate = (AVRational){0, 0};
3053 frame_pix_fmt = PIX_FMT_NONE;
3054 frame_height = 0;
3055 frame_width = 0;
3056 audio_sample_rate = 0;
3057 audio_channels = 0;
3058 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
09af7fb3 3059 av_dict_free(&ts_scale);
6291d7e4
AK
3060
3061 for (i = 0; i < orig_nb_streams; i++)
3062 av_dict_free(&opts[i]);
3063 av_freep(&opts);
92f1940e 3064 av_dict_free(&codec_names);
6291d7e4
AK
3065 uninit_opts();
3066 init_opts();
3067 return 0;
3068}
3069
f233cfed
AK
3070static void parse_forced_key_frames(char *kf, OutputStream *ost,
3071 AVCodecContext *avctx)
3072{
3073 char *p;
3074 int n = 1, i;
3075 int64_t t;
3076
3077 for (p = kf; *p; p++)
3078 if (*p == ',')
3079 n++;
3080 ost->forced_kf_count = n;
3081 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3082 if (!ost->forced_kf_pts) {
3083 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3084 exit_program(1);
3085 }
3086 for (i = 0; i < n; i++) {
3087 p = i ? strchr(p, ',') + 1 : kf;
3088 t = parse_time_or_die("force_key_frames", p, 1);
3089 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3090 }
3091}
3092
6cd9d0f7 3093static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
169f0647
AK
3094{
3095 OutputStream *ost;
3096 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3097 int idx = oc->nb_streams - 1;
3098
3099 if (!st) {
3100 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3101 exit_program(1);
3102 }
3103
4288e031
AK
3104 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3105 nb_output_streams + 1);
3106 ost = &output_streams[nb_output_streams - 1];
40fc2810 3107 ost->file_index = nb_output_files;
169f0647
AK
3108 ost->index = idx;
3109 ost->st = st;
3110 st->codec->codec_type = type;
3111 ost->enc = choose_codec(oc, st, type, codec_names);
3112 if (ost->enc) {
3113 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3114 }
3115
3116 avcodec_get_context_defaults3(st->codec, ost->enc);
3117 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3118
3119 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3120 return ost;
3121}
3122
6cd9d0f7 3123static OutputStream *new_video_stream(AVFormatContext *oc)
6291d7e4
AK
3124{
3125 AVStream *st;
3126 OutputStream *ost;
3127 AVCodecContext *video_enc;
6291d7e4 3128
6cd9d0f7 3129 ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
6291d7e4 3130 st = ost->st;
92f1940e 3131 if (!st->stream_copy) {
6291d7e4
AK
3132 ost->frame_aspect_ratio = frame_aspect_ratio;
3133 frame_aspect_ratio = 0;
3134#if CONFIG_AVFILTER
3135 ost->avfilter= vfilters;
3136 vfilters = NULL;
3137#endif
3138 }
3139
3140 ost->bitstream_filters = video_bitstream_filters;
3141 video_bitstream_filters= NULL;
3142
3143 st->codec->thread_count= thread_count;
3144
3145 video_enc = st->codec;
3146
3147 if(video_codec_tag)
3148 video_enc->codec_tag= video_codec_tag;
3149
3150 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3151 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3152 }
3153
92f1940e 3154 if (st->stream_copy) {
6291d7e4
AK
3155 video_enc->sample_aspect_ratio =
3156 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3157 } else {
3158 const char *p;
3159 int i;
3160
3161 if (frame_rate.num)
3162 ost->frame_rate = frame_rate;
6291d7e4
AK
3163
3164 video_enc->width = frame_width;
3165 video_enc->height = frame_height;
3166 video_enc->pix_fmt = frame_pix_fmt;
3167 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3168
f4ad238c 3169 if (video_qscale || same_quant) {
6291d7e4
AK
3170 video_enc->flags |= CODEC_FLAG_QSCALE;
3171 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3172 }
3173
3174 if(intra_matrix)
3175 video_enc->intra_matrix = intra_matrix;
3176 if(inter_matrix)
3177 video_enc->inter_matrix = inter_matrix;
3178
3179 p= video_rc_override_string;
3180 for(i=0; p; i++){
3181 int start, end, q;
3182 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3183 if(e!=3){
3184 fprintf(stderr, "error parsing rc_override\n");
3185 exit_program(1);
3186 }
3187 video_enc->rc_override=
3188 av_realloc(video_enc->rc_override,
3189 sizeof(RcOverride)*(i+1));
3190 video_enc->rc_override[i].start_frame= start;
3191 video_enc->rc_override[i].end_frame = end;
3192 if(q>0){
3193 video_enc->rc_override[i].qscale= q;
3194 video_enc->rc_override[i].quality_factor= 1.0;
3195 }
3196 else{
3197 video_enc->rc_override[i].qscale= 0;
3198 video_enc->rc_override[i].quality_factor= -q/100.0;
3199 }
3200 p= strchr(p, '/');
3201 if(p) p++;
3202 }
3203 video_enc->rc_override_count=i;
3204 if (!video_enc->rc_initial_buffer_occupancy)
3205 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3206 video_enc->me_threshold= me_threshold;
3207 video_enc->intra_dc_precision= intra_dc_precision - 8;
3208
3209 if (do_psnr)
3210 video_enc->flags|= CODEC_FLAG_PSNR;
3211
3212 /* two pass mode */
3213 if (do_pass) {
3214 if (do_pass == 1) {
3215 video_enc->flags |= CODEC_FLAG_PASS1;
3216 } else {
3217 video_enc->flags |= CODEC_FLAG_PASS2;
3218 }
3219 }
3220
3221 if (forced_key_frames)
3222 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3223 }
3224 if (video_language) {
3225 av_dict_set(&st->metadata, "language", video_language, 0);
3226 av_freep(&video_language);
3227 }
3228
3229 /* reset some key parameters */
3230 video_disable = 0;
6291d7e4 3231 av_freep(&forced_key_frames);
6291d7e4 3232 frame_pix_fmt = PIX_FMT_NONE;
3d4f0dab 3233 return ost;
6291d7e4
AK
3234}
3235
6cd9d0f7 3236static OutputStream *new_audio_stream(AVFormatContext *oc)
6291d7e4
AK
3237{
3238 AVStream *st;
3239 OutputStream *ost;
6291d7e4 3240 AVCodecContext *audio_enc;
6291d7e4 3241
6cd9d0f7 3242 ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
6291d7e4
AK
3243 st = ost->st;
3244
3245 ost->bitstream_filters = audio_bitstream_filters;
3246 audio_bitstream_filters= NULL;
3247
3248 st->codec->thread_count= thread_count;
3249
3250 audio_enc = st->codec;
3251 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3252
3253 if(audio_codec_tag)
3254 audio_enc->codec_tag= audio_codec_tag;
3255
3256 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3257 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3258 }
92f1940e 3259 if (!st->stream_copy) {
6291d7e4
AK
3260 if (audio_qscale > QSCALE_NONE) {
3261 audio_enc->flags |= CODEC_FLAG_QSCALE;
3262 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3263 }
3264 if (audio_channels)
3265 audio_enc->channels = audio_channels;
3266 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3267 audio_enc->sample_fmt = audio_sample_fmt;
3268 if (audio_sample_rate)
3269 audio_enc->sample_rate = audio_sample_rate;
3270 }
3271 if (audio_language) {
3272 av_dict_set(&st->metadata, "language", audio_language, 0);
3273 av_freep(&audio_language);
3274 }
3275
3276 /* reset some key parameters */
3277 audio_disable = 0;
3d4f0dab
AK
3278
3279 return ost;
6291d7e4
AK
3280}
3281
6cd9d0f7 3282static OutputStream *new_data_stream(AVFormatContext *oc)
6291d7e4
AK
3283{
3284 AVStream *st;
3285 OutputStream *ost;
3286 AVCodecContext *data_enc;
3287
6cd9d0f7 3288 ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
6291d7e4
AK
3289 st = ost->st;
3290 data_enc = st->codec;
92f1940e 3291 if (!st->stream_copy) {
6291d7e4
AK
3292 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3293 exit_program(1);
3294 }
3295
6291d7e4
AK
3296 if (data_codec_tag)
3297 data_enc->codec_tag= data_codec_tag;
3298
3299 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3300 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3301 }
6291d7e4
AK
3302
3303 data_disable = 0;
3d4f0dab 3304 return ost;
6291d7e4
AK
3305}
3306
6cd9d0f7 3307static OutputStream *new_subtitle_stream(AVFormatContext *oc)
6291d7e4
AK
3308{
3309 AVStream *st;
3310 OutputStream *ost;
6291d7e4 3311 AVCodecContext *subtitle_enc;
6291d7e4 3312
6cd9d0f7 3313 ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
6291d7e4
AK
3314 st = ost->st;
3315 subtitle_enc = st->codec;
3316
3317 ost->bitstream_filters = subtitle_bitstream_filters;
3318 subtitle_bitstream_filters= NULL;
3319
3320 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3321
3322 if(subtitle_codec_tag)
3323 subtitle_enc->codec_tag= subtitle_codec_tag;
3324
3325 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3326 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3327 }
6291d7e4
AK
3328
3329 if (subtitle_language) {
3330 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3331 av_freep(&subtitle_language);
3332 }
3333
3334 subtitle_disable = 0;
3d4f0dab 3335 return ost;
6291d7e4
AK
3336}
3337
3338/* arg format is "output-stream-index:streamid-value". */
3339static int opt_streamid(const char *opt, const char *arg)
3340{
3341 int idx;
3342 char *p;
3343 char idx_str[16];
3344
3345 av_strlcpy(idx_str, arg, sizeof(idx_str));
3346 p = strchr(idx_str, ':');
3347 if (!p) {
3348 fprintf(stderr,
3349 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3350 arg, opt);
3351 exit_program(1);
3352 }
3353 *p++ = '\0';
3354 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3355 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3356 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3357 return 0;
3358}
3359
86530f41
AK
3360static int copy_chapters(int infile, int outfile)
3361{
3362 AVFormatContext *is = input_files[infile].ctx;
af70aa45 3363 AVFormatContext *os = output_files[outfile].ctx;
86530f41
AK
3364 int i;
3365
3366 for (i = 0; i < is->nb_chapters; i++) {
3367 AVChapter *in_ch = is->chapters[i], *out_ch;
3368 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
3369 AV_TIME_BASE_Q, in_ch->time_base);
3370 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
3371 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3372
3373
3374 if (in_ch->end < ts_off)
3375 continue;
3376 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3377 break;
3378
3379 out_ch = av_mallocz(sizeof(AVChapter));
3380 if (!out_ch)
3381 return AVERROR(ENOMEM);
3382
3383 out_ch->id = in_ch->id;
3384 out_ch->time_base = in_ch->time_base;
3385 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3386 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3387
3388 if (metadata_chapters_autocopy)
3389 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3390
3391 os->nb_chapters++;
3392 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3393 if (!os->chapters)
3394 return AVERROR(ENOMEM);
3395 os->chapters[os->nb_chapters - 1] = out_ch;
3396 }
3397 return 0;
3398}
3399
169f0647
AK
3400static int read_avserver_streams(AVFormatContext *s, const char *filename)
3401{
3402 int i, err;
3403 AVFormatContext *ic = NULL;
169f0647
AK
3404
3405 err = avformat_open_input(&ic, filename, NULL, NULL);
3406 if (err < 0)
3407 return err;
3408 /* copy stream format */
3409 for(i=0;i<ic->nb_streams;i++) {
3410 AVStream *st;
3411 OutputStream *ost;
3412 AVCodec *codec;
3413
3414 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
6cd9d0f7 3415 ost = new_output_stream(s, codec->type);
169f0647
AK
3416 st = ost->st;
3417
3418 // FIXME: a more elegant solution is needed
3419 memcpy(st, ic->streams[i], sizeof(AVStream));
3420 st->info = NULL;
3421 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3422
3423 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3424 choose_sample_fmt(st, codec);
3425 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3426 choose_pixel_fmt(st, codec);
169f0647
AK
3427 }
3428
3429 av_close_input_file(ic);
3430 return 0;
3431}
3432
6291d7e4
AK
3433static void opt_output_file(const char *filename)
3434{
3435 AVFormatContext *oc;
3d4f0dab 3436 int i, err;
6291d7e4 3437 AVOutputFormat *file_oformat;
3d4f0dab
AK
3438 OutputStream *ost;
3439 InputStream *ist;
6291d7e4
AK
3440
3441 if (!strcmp(filename, "-"))
3442 filename = "pipe:";
3443
3444 oc = avformat_alloc_context();
3445 if (!oc) {
3446 print_error(filename, AVERROR(ENOMEM));
3447 exit_program(1);
3448 }
3449
3450 if (last_asked_format) {
3451 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3452 if (!file_oformat) {
3453 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3454 exit_program(1);
3455 }
3456 last_asked_format = NULL;
3457 } else {
3458 file_oformat = av_guess_format(NULL, filename, NULL);
3459 if (!file_oformat) {
3460 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3461 filename);
3462 exit_program(1);
3463 }
3464 }
3465
3466 oc->oformat = file_oformat;
3467 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3468
3469 if (!strcmp(file_oformat->name, "ffm") &&
3470 av_strstart(filename, "http:", NULL)) {
3471 /* special case for files sent to avserver: we get the stream
3472 parameters from avserver */
3473 int err = read_avserver_streams(oc, filename);
3474 if (err < 0) {
3475 print_error(filename, err);
3476 exit_program(1);
3477 }
3d4f0dab
AK
3478 } else if (!nb_stream_maps) {
3479 /* pick the "best" stream of each type */
3480#define NEW_STREAM(type, index)\
3481 if (index >= 0) {\
6cd9d0f7 3482 ost = new_ ## type ## _stream(oc);\
3d4f0dab
AK
3483 ost->source_index = index;\
3484 ost->sync_ist = &input_streams[index];\
3485 input_streams[index].discard = 0;\
3486 }
3487
3488 /* video: highest resolution */
3489 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3490 int area = 0, idx = -1;
3491 for (i = 0; i < nb_input_streams; i++) {
3492 ist = &input_streams[i];
3493 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3494 ist->st->codec->width * ist->st->codec->height > area) {
3495 area = ist->st->codec->width * ist->st->codec->height;
3496 idx = i;
3497 }
3498 }
3499 NEW_STREAM(video, idx);
3500 }
3501
3502 /* audio: most channels */
3503 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3504 int channels = 0, idx = -1;
3505 for (i = 0; i < nb_input_streams; i++) {
3506 ist = &input_streams[i];
3507 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3508 ist->st->codec->channels > channels) {
3509 channels = ist->st->codec->channels;
3510 idx = i;
3511 }
3512 }
3513 NEW_STREAM(audio, idx);
3514 }
3515
3516 /* subtitles: pick first */
3517 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3518 for (i = 0; i < nb_input_streams; i++)
3519 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3520 NEW_STREAM(subtitle, i);
3521 break;
3522 }
3523 }
3524 /* do something with data? */
6291d7e4 3525 } else {
3d4f0dab
AK
3526 for (i = 0; i < nb_stream_maps; i++) {
3527 StreamMap *map = &stream_maps[i];
3d4f0dab 3528
8d2e4a7e
AK
3529 if (map->disabled)
3530 continue;
3d4f0dab 3531
6cd9d0f7 3532 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3d4f0dab 3533 switch (ist->st->codec->codec_type) {
6cd9d0f7
AK
3534 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
3535 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
3536 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3537 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
3d4f0dab
AK
3538 default:
3539 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3540 map->file_index, map->stream_index);
3541 exit_program(1);
3542 }
3543
6cd9d0f7 3544 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3d4f0dab
AK
3545 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3546 map->sync_stream_index];
3547 ist->discard = 0;
3548 }
6291d7e4
AK
3549 }
3550
3d4f0dab
AK
3551 av_dict_copy(&oc->metadata, metadata, 0);
3552 av_dict_free(&metadata);
3553
af70aa45 3554
af70aa45
AK
3555 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3556 output_files[nb_output_files - 1].ctx = oc;
4288e031 3557 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
ef44a607 3558 output_files[nb_output_files - 1].recording_time = recording_time;
ea065176 3559 output_files[nb_output_files - 1].start_time = start_time;
af70aa45 3560 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
6291d7e4
AK
3561
3562 /* check filename in case of an image number is expected */
3563 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3564 if (!av_filename_number_test(oc->filename)) {
3565 print_error(oc->filename, AVERROR(EINVAL));
3566 exit_program(1);
3567 }
3568 }
3569
3570 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3571 /* test if it already exists to avoid loosing precious files */
3572 if (!file_overwrite &&
3573 (strchr(filename, ':') == NULL ||
3574 filename[1] == ':' ||
3575 av_strstart(filename, "file:", NULL))) {
3576 if (avio_check(filename, 0) == 0) {
3577 if (!using_stdin) {
3578 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3579 fflush(stderr);
3580 if (!read_yesno()) {
3581 fprintf(stderr, "Not overwriting - exiting\n");
3582 exit_program(1);
3583 }
3584 }
3585 else {
3586 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3587 exit_program(1);
3588 }
3589 }
3590 }
3591
3592 /* open the file */
3593 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3594 print_error(filename, err);
3595 exit_program(1);
3596 }
3597 }
3598
3599 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3600 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
6291d7e4
AK
3601 oc->flags |= AVFMT_FLAG_NONBLOCK;
3602
b9aac90b
AK
3603 /* copy chapters */
3604 if (chapters_input_file >= nb_input_files) {
3605 if (chapters_input_file == INT_MAX) {
3606 /* copy chapters from the first input file that has them*/
3607 chapters_input_file = -1;
3608 for (i = 0; i < nb_input_files; i++)
3609 if (input_files[i].ctx->nb_chapters) {
3610 chapters_input_file = i;
3611 break;
3612 }
3613 } else {
3614 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3615 chapters_input_file);
3616 exit_program(1);
3617 }
3618 }
3619 if (chapters_input_file >= 0)
3620 copy_chapters(chapters_input_file, nb_output_files - 1);
3621
e6e6060c
AK
3622 /* copy metadata */
3623 for (i = 0; i < nb_meta_data_maps; i++) {
3624 AVFormatContext *files[2];
3625 AVDictionary **meta[2];
3626 int j;
3627
3628#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3629 if ((index) < 0 || (index) >= (nb_elems)) {\
3630 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3631 (desc), (index));\
3632 exit_program(1);\
3633 }
3634
3635 int in_file_index = meta_data_maps[i][1].file;
3636 if (in_file_index < 0)
3637 continue;
3638 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3639
3640 files[0] = oc;
3641 files[1] = input_files[in_file_index].ctx;
3642
3643 for (j = 0; j < 2; j++) {
3644 MetadataMap *map = &meta_data_maps[i][j];
3645
3646 switch (map->type) {
3647 case 'g':
3648 meta[j] = &files[j]->metadata;
3649 break;
3650 case 's':
3651 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3652 meta[j] = &files[j]->streams[map->index]->metadata;
3653 break;
3654 case 'c':
3655 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3656 meta[j] = &files[j]->chapters[map->index]->metadata;
3657 break;
3658 case 'p':
3659 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3660 meta[j] = &files[j]->programs[map->index]->metadata;
3661 break;
3662 }
3663 }
3664
3665 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3666 }
3667
3668 /* copy global metadata by default */
5759cce7 3669 if (metadata_global_autocopy && nb_input_files)
e6e6060c
AK
3670 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3671 AV_DICT_DONT_OVERWRITE);
3672 if (metadata_streams_autocopy)
4288e031
AK
3673 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3674 InputStream *ist = &input_streams[output_streams[i].source_index];
3675 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
e6e6060c
AK
3676 }
3677
6291d7e4
AK
3678 frame_rate = (AVRational){0, 0};
3679 frame_width = 0;
3680 frame_height = 0;
3681 audio_sample_rate = 0;
3682 audio_channels = 0;
3683 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
b9aac90b 3684 chapters_input_file = INT_MAX;
ef44a607 3685 recording_time = INT64_MAX;
ea065176 3686 start_time = 0;
6291d7e4 3687
e6e6060c
AK
3688 av_freep(&meta_data_maps);
3689 nb_meta_data_maps = 0;
3690 metadata_global_autocopy = 1;
3691 metadata_streams_autocopy = 1;
3692 metadata_chapters_autocopy = 1;
3d4f0dab
AK
3693 av_freep(&stream_maps);
3694 nb_stream_maps = 0;
e922bbfa
AK
3695 av_freep(&streamid_map);
3696 nb_streamid_map = 0;
e6e6060c 3697
92f1940e
AK
3698 av_dict_free(&codec_names);
3699
6291d7e4
AK
3700 av_freep(&forced_key_frames);
3701 uninit_opts();
3702 init_opts();
3703}
3704
3705/* same option as mencoder */
3706static int opt_pass(const char *opt, const char *arg)
3707{
3708 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3709 return 0;
3710}
3711
3712static int64_t getutime(void)
3713{
3714#if HAVE_GETRUSAGE
3715 struct rusage rusage;
3716
3717 getrusage(RUSAGE_SELF, &rusage);
3718 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3719#elif HAVE_GETPROCESSTIMES
3720 HANDLE proc;
3721 FILETIME c, e, k, u;
3722 proc = GetCurrentProcess();
3723 GetProcessTimes(proc, &c, &e, &k, &u);
3724 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3725#else
3726 return av_gettime();
3727#endif
3728}
3729
3730static int64_t getmaxrss(void)
3731{
3732#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3733 struct rusage rusage;
3734 getrusage(RUSAGE_SELF, &rusage);
3735 return (int64_t)rusage.ru_maxrss * 1024;
3736#elif HAVE_GETPROCESSMEMORYINFO
3737 HANDLE proc;
3738 PROCESS_MEMORY_COUNTERS memcounters;
3739 proc = GetCurrentProcess();
3740 memcounters.cb = sizeof(memcounters);
3741 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3742 return memcounters.PeakPagefileUsage;
3743#else
3744 return 0;
3745#endif
3746}
3747
3748static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3749{
3750 int i;
3751 const char *p = str;
3752 for(i = 0;; i++) {
3753 dest[i] = atoi(p);
3754 if(i == 63)
3755 break;
3756 p = strchr(p, ',');
3757 if(!p) {
3758 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3759 exit_program(1);
3760 }
3761 p++;
3762 }
3763}
3764
3765static void opt_inter_matrix(const char *arg)
3766{
3767 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3768 parse_matrix_coeffs(inter_matrix, arg);
3769}
3770
3771static void opt_intra_matrix(const char *arg)
3772{
3773 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3774 parse_matrix_coeffs(intra_matrix, arg);
3775}
3776
3777static void show_usage(void)
3778{
3779 printf("Hyper fast Audio and Video encoder\n");
3780 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3781 printf("\n");
3782}
3783
3784static void show_help(void)
3785{
3786 AVCodec *c;
3787 AVOutputFormat *oformat = NULL;
3788 AVInputFormat *iformat = NULL;
3789
3790 av_log_set_callback(log_callback_help);
3791 show_usage();
3792 show_help_options(options, "Main options:\n",
3793 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3794 show_help_options(options, "\nAdvanced options:\n",
3795 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3796 OPT_EXPERT);
3797 show_help_options(options, "\nVideo options:\n",
3798 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3799 OPT_VIDEO);
3800 show_help_options(options, "\nAdvanced Video options:\n",
3801 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3802 OPT_VIDEO | OPT_EXPERT);
3803 show_help_options(options, "\nAudio options:\n",
3804 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3805 OPT_AUDIO);
3806 show_help_options(options, "\nAdvanced Audio options:\n",
3807 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3808 OPT_AUDIO | OPT_EXPERT);
3809 show_help_options(options, "\nSubtitle options:\n",
3810 OPT_SUBTITLE | OPT_GRAB,
3811 OPT_SUBTITLE);
3812 show_help_options(options, "\nAudio/Video grab options:\n",
3813 OPT_GRAB,
3814 OPT_GRAB);
3815 printf("\n");
3816 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3817 printf("\n");
3818
3819 /* individual codec options */
3820 c = NULL;
3821 while ((c = av_codec_next(c))) {
3822 if (c->priv_class) {
3823 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3824 printf("\n");
3825 }
3826 }
3827
3828 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3829 printf("\n");
3830
3831 /* individual muxer options */
3832 while ((oformat = av_oformat_next(oformat))) {
3833 if (oformat->priv_class) {
3834 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3835 printf("\n");
3836 }
3837 }
3838
3839 /* individual demuxer options */
3840 while ((iformat = av_iformat_next(iformat))) {
3841 if (iformat->priv_class) {
3842 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3843 printf("\n");
3844 }
3845 }
3846
3847 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3848}
3849
3850static int opt_target(const char *opt, const char *arg)
3851{
3852 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3853 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3854
3855 if(!strncmp(arg, "pal-", 4)) {
3856 norm = PAL;
3857 arg += 4;
3858 } else if(!strncmp(arg, "ntsc-", 5)) {
3859 norm = NTSC;
3860 arg += 5;
3861 } else if(!strncmp(arg, "film-", 5)) {
3862 norm = FILM;
3863 arg += 5;
3864 } else {
3865 int fr;
3866 /* Calculate FR via float to avoid int overflow */
3867 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3868 if(fr == 25000) {
3869 norm = PAL;
3870 } else if((fr == 29970) || (fr == 23976)) {
3871 norm = NTSC;
3872 } else {
3873 /* Try to determine PAL/NTSC by peeking in the input files */
3874 if(nb_input_files) {
3875 int i, j;
3876 for (j = 0; j < nb_input_files; j++) {
3877 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3878 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3879 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3880 continue;
3881 fr = c->time_base.den * 1000 / c->time_base.num;
3882 if(fr == 25000) {
3883 norm = PAL;
3884 break;
3885 } else if((fr == 29970) || (fr == 23976)) {
3886 norm = NTSC;
3887 break;
3888 }
3889 }
3890 if(norm != UNKNOWN)
3891 break;
3892 }
3893 }
3894 }
3895 if(verbose > 0 && norm != UNKNOWN)
3896 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3897 }
3898
3899 if(norm == UNKNOWN) {
3900 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3901 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3902 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3903 exit_program(1);
3904 }
3905
3906 if(!strcmp(arg, "vcd")) {
92f1940e
AK
3907 opt_codec("c:v", "mpeg1video");
3908 opt_codec("c:a", "mp2");
6291d7e4
AK
3909 opt_format("f", "vcd");
3910
3911 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3912 opt_frame_rate("r", frame_rates[norm]);
3913 opt_default("g", norm == PAL ? "15" : "18");
3914
3915 opt_default("b", "1150000");
3916 opt_default("maxrate", "1150000");
3917 opt_default("minrate", "1150000");
3918 opt_default("bufsize", "327680"); // 40*1024*8;
3919
64db1a82 3920 opt_default("b:a", "224000");
6291d7e4
AK
3921 audio_sample_rate = 44100;
3922 audio_channels = 2;
3923
3924 opt_default("packetsize", "2324");
3925 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3926
3927 /* We have to offset the PTS, so that it is consistent with the SCR.
3928 SCR starts at 36000, but the first two packs contain only padding
3929 and the first pack from the other stream, respectively, may also have
3930 been written before.
3931 So the real data starts at SCR 36000+3*1200. */
3932 mux_preload= (36000+3*1200) / 90000.0; //0.44
3933 } else if(!strcmp(arg, "svcd")) {
3934
92f1940e
AK
3935 opt_codec("c:v", "mpeg2video");
3936 opt_codec("c:a", "mp2");
6291d7e4
AK
3937 opt_format("f", "svcd");
3938
3939 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3940 opt_frame_rate("r", frame_rates[norm]);
3941 opt_default("g", norm == PAL ? "15" : "18");
3942
3943 opt_default("b", "2040000");
3944 opt_default("maxrate", "2516000");
3945 opt_default("minrate", "0"); //1145000;
3946 opt_default("bufsize", "1835008"); //224*1024*8;
3947 opt_default("flags", "+scan_offset");
3948
3949
64db1a82 3950 opt_default("b:a", "224000");
6291d7e4
AK
3951 audio_sample_rate = 44100;
3952
3953 opt_default("packetsize", "2324");
3954
3955 } else if(!strcmp(arg, "dvd")) {
3956
92f1940e
AK
3957 opt_codec("c:v", "mpeg2video");
3958 opt_codec("c:a", "ac3");
6291d7e4
AK
3959 opt_format("f", "dvd");
3960
3961 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3962 opt_frame_rate("r", frame_rates[norm]);
3963 opt_default("g", norm == PAL ? "15" : "18");
3964
3965 opt_default("b", "6000000");
3966 opt_default("maxrate", "9000000");
3967 opt_default("minrate", "0"); //1500000;
3968 opt_default("bufsize", "1835008"); //224*1024*8;
3969
3970 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3971 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3972
64db1a82 3973 opt_default("b:a", "448000");
6291d7e4
AK
3974 audio_sample_rate = 48000;
3975
3976 } else if(!strncmp(arg, "dv", 2)) {
3977
3978 opt_format("f", "dv");
3979
3980 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3981 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3982 norm == PAL ? "yuv420p" : "yuv411p");
3983 opt_frame_rate("r", frame_rates[norm]);
3984
3985 audio_sample_rate = 48000;
3986 audio_channels = 2;
3987
3988 } else {
3989 fprintf(stderr, "Unknown target: %s\n", arg);
3990 return AVERROR(EINVAL);
3991 }
3992 return 0;
3993}
3994
3995static int opt_vstats_file(const char *opt, const char *arg)
3996{
3997 av_free (vstats_filename);
3998 vstats_filename=av_strdup (arg);
3999 return 0;
4000}
4001
4002static int opt_vstats(const char *opt, const char *arg)
4003{
4004 char filename[40];