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