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