path: root/ffmpeg.c (plain)
blob: bbce98e036f235ebf95f2fc916599f427bb97356

1	/*
2	* Copyright (c) 2000-2003 Fabrice Bellard
3	*
4	* This file is part of FFmpeg.
5	*
6	* FFmpeg is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public
8	* License as published by the Free Software Foundation; either
9	* version 2.1 of the License, or (at your option) any later version.
10	*
11	* FFmpeg is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.
15	*
16	* You should have received a copy of the GNU Lesser General Public
17	* License along with FFmpeg; if not, write to the Free Software
18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19	*/
20
21	/**
22	* @file
23	* multimedia converter based on the FFmpeg libraries
24	*/
25
26	#include "config.h"
27	#include <ctype.h>
28	#include <string.h>
29	#include <math.h>
30	#include <stdlib.h>
31	#include <errno.h>
32	#include <limits.h>
33	#if HAVE_ISATTY
34	#if HAVE_IO_H
35	#include <io.h>
36	#endif
37	#if HAVE_UNISTD_H
38	#include <unistd.h>
39	#endif
40	#endif
41	#include "libavformat/avformat.h"
42	#include "libavdevice/avdevice.h"
43	#include "libswscale/swscale.h"
44	#include "libswresample/swresample.h"
45	#include "libavutil/opt.h"
46	#include "libavutil/channel_layout.h"
47	#include "libavutil/parseutils.h"
48	#include "libavutil/samplefmt.h"
49	#include "libavutil/fifo.h"
50	#include "libavutil/intreadwrite.h"
51	#include "libavutil/dict.h"
52	#include "libavutil/mathematics.h"
53	#include "libavutil/pixdesc.h"
54	#include "libavutil/avstring.h"
55	#include "libavutil/libm.h"
56	#include "libavutil/imgutils.h"
57	#include "libavutil/timestamp.h"
58	#include "libavutil/bprint.h"
59	#include "libavutil/time.h"
60	#include "libavformat/os_support.h"
61
62	#include "libavformat/ffm.h" // not public API
63
64	# include "libavfilter/avcodec.h"
65	# include "libavfilter/avfilter.h"
66	# include "libavfilter/buffersrc.h"
67	# include "libavfilter/buffersink.h"
68
69	#if HAVE_SYS_RESOURCE_H
70	#include <sys/time.h>
71	#include <sys/types.h>
72	#include <sys/resource.h>
73	#elif HAVE_GETPROCESSTIMES
74	#include <windows.h>
75	#endif
76	#if HAVE_GETPROCESSMEMORYINFO
77	#include <windows.h>
78	#include <psapi.h>
79	#endif
80
81	#if HAVE_SYS_SELECT_H
82	#include <sys/select.h>
83	#endif
84
85	#if HAVE_TERMIOS_H
86	#include <fcntl.h>
87	#include <sys/ioctl.h>
88	#include <sys/time.h>
89	#include <termios.h>
90	#elif HAVE_KBHIT
91	#include <conio.h>
92	#endif
93
94	#if HAVE_PTHREADS
95	#include <pthread.h>
96	#endif
97
98	#include <time.h>
99
100	#include "ffmpeg.h"
101	#include "cmdutils.h"
102
103	#include "libavutil/avassert.h"
104
105	const char program_name[] = "ffmpeg";
106	const int program_birth_year = 2000;
107
108	static FILE *vstats_file;
109
110	const char *const forced_keyframes_const_names[] = {
111	"n",
112	"n_forced",
113	"prev_forced_n",
114	"prev_forced_t",
115	"t",
116	NULL
117	};
118
119	static void do_video_stats(OutputStream *ost, int frame_size);
120	static int64_t getutime(void);
121	static int64_t getmaxrss(void);
122
123	static int run_as_daemon = 0;
124	static int64_t video_size = 0;
125	static int64_t audio_size = 0;
126	static int64_t subtitle_size = 0;
127	static int64_t extra_size = 0;
128	static int nb_frames_dup = 0;
129	static int nb_frames_drop = 0;
130	static int64_t decode_error_stat[2];
131
132	static int current_time;
133	AVIOContext *progress_avio = NULL;
134
135	static uint8_t *subtitle_out;
136
137	#if HAVE_PTHREADS
138	/* signal to input threads that they should exit; set by the main thread */
139	static int transcoding_finished;
140	#endif
141
142	#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
143
144	InputStream **input_streams = NULL;
145	int nb_input_streams = 0;
146	InputFile **input_files = NULL;
147	int nb_input_files = 0;
148
149	OutputStream **output_streams = NULL;
150	int nb_output_streams = 0;
151	OutputFile **output_files = NULL;
152	int nb_output_files = 0;
153
154	FilterGraph **filtergraphs;
155	int nb_filtergraphs;
156
157	#if HAVE_TERMIOS_H
158
159	/* init terminal so that we can grab keys */
160	static struct termios oldtty;
161	static int restore_tty;
162	#endif
163
164	static void free_input_threads(void);
165
166
167	/* sub2video hack:
168	Convert subtitles to video with alpha to insert them in filter graphs.
169	This is a temporary solution until libavfilter gets real subtitles support.
170	*/
171
172	static int sub2video_get_blank_frame(InputStream *ist)
173	{
174	int ret;
175	AVFrame *frame = ist->sub2video.frame;
176
177	av_frame_unref(frame);
178	ist->sub2video.frame->width = ist->sub2video.w;
179	ist->sub2video.frame->height = ist->sub2video.h;
180	ist->sub2video.frame->format = AV_PIX_FMT_RGB32;
181	if ((ret = av_frame_get_buffer(frame, 32)) < 0)
182	return ret;
183	memset(frame->data[0], 0, frame->height * frame->linesize[0]);
184	return 0;
185	}
186
187	static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
188	AVSubtitleRect *r)
189	{
190	uint32_t *pal, *dst2;
191	uint8_t *src, *src2;
192	int x, y;
193
194	if (r->type != SUBTITLE_BITMAP) {
195	av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
196	return;
197	}
198	if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
199	av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle overflowing\n");
200	return;
201	}
202
203	dst += r->y * dst_linesize + r->x * 4;
204	src = r->pict.data[0];
205	pal = (uint32_t *)r->pict.data[1];
206	for (y = 0; y < r->h; y++) {
207	dst2 = (uint32_t *)dst;
208	src2 = src;
209	for (x = 0; x < r->w; x++)
210	*(dst2++) = pal[*(src2++)];
211	dst += dst_linesize;
212	src += r->pict.linesize[0];
213	}
214	}
215
216	static void sub2video_push_ref(InputStream *ist, int64_t pts)
217	{
218	AVFrame *frame = ist->sub2video.frame;
219	int i;
220
221	av_assert1(frame->data[0]);
222	ist->sub2video.last_pts = frame->pts = pts;
223	for (i = 0; i < ist->nb_filters; i++)
224	av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
225	AV_BUFFERSRC_FLAG_KEEP_REF |
226	AV_BUFFERSRC_FLAG_PUSH);
227	}
228
229	static void sub2video_update(InputStream *ist, AVSubtitle *sub)
230	{
231	int w = ist->sub2video.w, h = ist->sub2video.h;
232	AVFrame *frame = ist->sub2video.frame;
233	int8_t *dst;
234	int dst_linesize;
235	int num_rects, i;
236	int64_t pts, end_pts;
237
238	if (!frame)
239	return;
240	if (sub) {
241	pts = av_rescale_q(sub->pts + sub->start_display_time * 1000,
242	AV_TIME_BASE_Q, ist->st->time_base);
243	end_pts = av_rescale_q(sub->pts + sub->end_display_time * 1000,
244	AV_TIME_BASE_Q, ist->st->time_base);
245	num_rects = sub->num_rects;
246	} else {
247	pts = ist->sub2video.end_pts;
248	end_pts = INT64_MAX;
249	num_rects = 0;
250	}
251	if (sub2video_get_blank_frame(ist) < 0) {
252	av_log(ist->st->codec, AV_LOG_ERROR,
253	"Impossible to get a blank canvas.\n");
254	return;
255	}
256	dst = frame->data [0];
257	dst_linesize = frame->linesize[0];
258	for (i = 0; i < num_rects; i++)
259	sub2video_copy_rect(dst, dst_linesize, w, h, sub->rects[i]);
260	sub2video_push_ref(ist, pts);
261	ist->sub2video.end_pts = end_pts;
262	}
263
264	static void sub2video_heartbeat(InputStream *ist, int64_t pts)
265	{
266	InputFile *infile = input_files[ist->file_index];
267	int i, j, nb_reqs;
268	int64_t pts2;
269
270	/* When a frame is read from a file, examine all sub2video streams in
271	the same file and send the sub2video frame again. Otherwise, decoded
272	video frames could be accumulating in the filter graph while a filter
273	(possibly overlay) is desperately waiting for a subtitle frame. */
274	for (i = 0; i < infile->nb_streams; i++) {
275	InputStream *ist2 = input_streams[infile->ist_index + i];
276	if (!ist2->sub2video.frame)
277	continue;
278	/* subtitles seem to be usually muxed ahead of other streams;
279	if not, substracting a larger time here is necessary */
280	pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
281	/* do not send the heartbeat frame if the subtitle is already ahead */
282	if (pts2 <= ist2->sub2video.last_pts)
283	continue;
284	if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])
285	sub2video_update(ist2, NULL);
286	for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
287	nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
288	if (nb_reqs)
289	sub2video_push_ref(ist2, pts2);
290	}
291	}
292
293	static void sub2video_flush(InputStream *ist)
294	{
295	int i;
296
297	for (i = 0; i < ist->nb_filters; i++)
298	av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
299	}
300
301	/* end of sub2video hack */
302
303	void term_exit(void)
304	{
305	av_log(NULL, AV_LOG_QUIET, "%s", "");
306	#if HAVE_TERMIOS_H
307	if(restore_tty)
308	tcsetattr (0, TCSANOW, &oldtty);
309	#endif
310	}
311
312	static volatile int received_sigterm = 0;
313	static volatile int received_nb_signals = 0;
314
315	static void
316	sigterm_handler(int sig)
317	{
318	received_sigterm = sig;
319	received_nb_signals++;
320	term_exit();
321	if(received_nb_signals > 3)
322	exit_program(123);
323	}
324
325	void term_init(void)
326	{
327	#if HAVE_TERMIOS_H
328	if(!run_as_daemon){
329	struct termios tty;
330	int istty = 1;
331	#if HAVE_ISATTY
332	istty = isatty(0) && isatty(2);
333	#endif
334	if (istty && tcgetattr (0, &tty) == 0) {
335	oldtty = tty;
336	restore_tty = 1;
337
338	tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
339	|INLCR|IGNCR|ICRNL|IXON);
340	tty.c_oflag |= OPOST;
341	tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
342	tty.c_cflag &= ~(CSIZE|PARENB);
343	tty.c_cflag |= CS8;
344	tty.c_cc[VMIN] = 1;
345	tty.c_cc[VTIME] = 0;
346
347	tcsetattr (0, TCSANOW, &tty);
348	}
349	signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
350	}
351	#endif
352	avformat_network_deinit();
353
354	signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
355	signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
356	#ifdef SIGXCPU
357	signal(SIGXCPU, sigterm_handler);
358	#endif
359	}
360
361	/* read a key without blocking */
362	static int read_key(void)
363	{
364	unsigned char ch;
365	#if HAVE_TERMIOS_H
366	int n = 1;
367	struct timeval tv;
368	fd_set rfds;
369
370	FD_ZERO(&rfds);
371	FD_SET(0, &rfds);
372	tv.tv_sec = 0;
373	tv.tv_usec = 0;
374	n = select(1, &rfds, NULL, NULL, &tv);
375	if (n > 0) {
376	n = read(0, &ch, 1);
377	if (n == 1)
378	return ch;
379
380	return n;
381	}
382	#elif HAVE_KBHIT
383	# if HAVE_PEEKNAMEDPIPE
384	static int is_pipe;
385	static HANDLE input_handle;
386	DWORD dw, nchars;
387	if(!input_handle){
388	input_handle = GetStdHandle(STD_INPUT_HANDLE);
389	is_pipe = !GetConsoleMode(input_handle, &dw);
390	}
391
392	if (stdin->_cnt > 0) {
393	read(0, &ch, 1);
394	return ch;
395	}
396	if (is_pipe) {
397	/* When running under a GUI, you will end here. */
398	if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
399	// input pipe may have been closed by the program that ran ffmpeg
400	return -1;
401	}
402	//Read it
403	if(nchars != 0) {
404	read(0, &ch, 1);
405	return ch;
406	}else{
407	return -1;
408	}
409	}
410	# endif
411	if(kbhit())
412	return(getch());
413	#endif
414	return -1;
415	}
416
417	static int decode_interrupt_cb(void *ctx)
418	{
419	return received_nb_signals > 1;
420	}
421
422	const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
423
424	static void ffmpeg_cleanup(int ret)
425	{
426	int i, j;
427
428	if (do_benchmark) {
429	int maxrss = getmaxrss() / 1024;
430	printf("bench: maxrss=%ikB\n", maxrss);
431	}
432
433	for (i = 0; i < nb_filtergraphs; i++) {
434	avfilter_graph_free(&filtergraphs[i]->graph);
435	for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
436	av_freep(&filtergraphs[i]->inputs[j]->name);
437	av_freep(&filtergraphs[i]->inputs[j]);
438	}
439	av_freep(&filtergraphs[i]->inputs);
440	for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
441	av_freep(&filtergraphs[i]->outputs[j]->name);
442	av_freep(&filtergraphs[i]->outputs[j]);
443	}
444	av_freep(&filtergraphs[i]->outputs);
445	av_freep(&filtergraphs[i]->graph_desc);
446	av_freep(&filtergraphs[i]);
447	}
448	av_freep(&filtergraphs);
449
450	av_freep(&subtitle_out);
451
452	/* close files */
453	for (i = 0; i < nb_output_files; i++) {
454	AVFormatContext *s = output_files[i]->ctx;
455	if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb)
456	avio_close(s->pb);
457	avformat_free_context(s);
458	av_dict_free(&output_files[i]->opts);
459	av_freep(&output_files[i]);
460	}
461	for (i = 0; i < nb_output_streams; i++) {
462	AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
463	while (bsfc) {
464	AVBitStreamFilterContext *next = bsfc->next;
465	av_bitstream_filter_close(bsfc);
466	bsfc = next;
467	}
468	output_streams[i]->bitstream_filters = NULL;
469	avcodec_free_frame(&output_streams[i]->filtered_frame);
470
471	av_freep(&output_streams[i]->forced_keyframes);
472	av_expr_free(output_streams[i]->forced_keyframes_pexpr);
473	av_freep(&output_streams[i]->avfilter);
474	av_freep(&output_streams[i]->logfile_prefix);
475	av_freep(&output_streams[i]);
476	}
477	#if HAVE_PTHREADS
478	free_input_threads();
479	#endif
480	for (i = 0; i < nb_input_files; i++) {
481	avformat_close_input(&input_files[i]->ctx);
482	av_freep(&input_files[i]);
483	}
484	for (i = 0; i < nb_input_streams; i++) {
485	av_frame_free(&input_streams[i]->decoded_frame);
486	av_frame_free(&input_streams[i]->filter_frame);
487	av_dict_free(&input_streams[i]->opts);
488	avsubtitle_free(&input_streams[i]->prev_sub.subtitle);
489	av_frame_free(&input_streams[i]->sub2video.frame);
490	av_freep(&input_streams[i]->filters);
491	av_freep(&input_streams[i]);
492	}
493
494	if (vstats_file)
495	fclose(vstats_file);
496	av_free(vstats_filename);
497
498	av_freep(&input_streams);
499	av_freep(&input_files);
500	av_freep(&output_streams);
501	av_freep(&output_files);
502
503	uninit_opts();
504
505	avformat_network_deinit();
506
507	if (received_sigterm) {
508	av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
509	(int) received_sigterm);
510	}
511	term_exit();
512	}
513
514	void assert_avoptions(AVDictionary *m)
515	{
516	AVDictionaryEntry *t;
517	if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
518	av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
519	exit_program(1);
520	}
521	}
522
523	static void abort_codec_experimental(AVCodec *c, int encoder)
524	{
525	exit_program(1);
526	}
527
528	static void update_benchmark(const char *fmt, ...)
529	{
530	if (do_benchmark_all) {
531	int64_t t = getutime();
532	va_list va;
533	char buf[1024];
534
535	if (fmt) {
536	va_start(va, fmt);
537	vsnprintf(buf, sizeof(buf), fmt, va);
538	va_end(va);
539	printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
540	}
541	current_time = t;
542	}
543	}
544
545	static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
546	{
547	AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
548	AVCodecContext *avctx = ost->st->codec;
549	int ret;
550
551	if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
552	(avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
553	pkt->pts = pkt->dts = AV_NOPTS_VALUE;
554
555	/*
556	* Audio encoders may split the packets -- #frames in != #packets out.
557	* But there is no reordering, so we can limit the number of output packets
558	* by simply dropping them here.
559	* Counting encoded video frames needs to be done separately because of
560	* reordering, see do_video_out()
561	*/
562	if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
563	if (ost->frame_number >= ost->max_frames) {
564	av_free_packet(pkt);
565	return;
566	}
567	ost->frame_number++;
568	}
569
570	while (bsfc) {
571	AVPacket new_pkt = *pkt;
572	int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
573	&new_pkt.data, &new_pkt.size,
574	pkt->data, pkt->size,
575	pkt->flags & AV_PKT_FLAG_KEY);
576	if(a == 0 && new_pkt.data != pkt->data && new_pkt.destruct) {
577	uint8_t *t = av_malloc(new_pkt.size + FF_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
578	if(t) {
579	memcpy(t, new_pkt.data, new_pkt.size);
580	memset(t + new_pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
581	new_pkt.data = t;
582	new_pkt.buf = NULL;
583	a = 1;
584	} else
585	a = AVERROR(ENOMEM);
586	}
587	if (a > 0) {
588	av_free_packet(pkt);
589	new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
590	av_buffer_default_free, NULL, 0);
591	if (!new_pkt.buf)
592	exit_program(1);
593	} else if (a < 0) {
594	av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
595	bsfc->filter->name, pkt->stream_index,
596	avctx->codec ? avctx->codec->name : "copy");
597	print_error("", a);
598	if (exit_on_error)
599	exit_program(1);
600	}
601	*pkt = new_pkt;
602
603	bsfc = bsfc->next;
604	}
605
606	if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
607	(avctx->codec_type == AVMEDIA_TYPE_AUDIO || avctx->codec_type == AVMEDIA_TYPE_VIDEO) &&
608	pkt->dts != AV_NOPTS_VALUE &&
609	ost->last_mux_dts != AV_NOPTS_VALUE) {
610	int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
611	if (pkt->dts < max) {
612	int loglevel = max - pkt->dts > 2 || avctx->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
613	av_log(s, loglevel, "Non-monotonous DTS in output stream "
614	"%d:%d; previous: %"PRId64", current: %"PRId64"; ",
615	ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
616	if (exit_on_error) {
617	av_log(NULL, AV_LOG_FATAL, "aborting.\n");
618	exit_program(1);
619	}
620	av_log(s, loglevel, "changing to %"PRId64". This may result "
621	"in incorrect timestamps in the output file.\n",
622	max);
623	if(pkt->pts >= pkt->dts)
624	pkt->pts = FFMAX(pkt->pts, max);
625	pkt->dts = max;
626	}
627	}
628	ost->last_mux_dts = pkt->dts;
629
630	pkt->stream_index = ost->index;
631
632	if (debug_ts) {
633	av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
634	"pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
635	av_get_media_type_string(ost->st->codec->codec_type),
636	av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
637	av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
638	pkt->size
639	);
640	}
641
642	ret = av_interleaved_write_frame(s, pkt);
643	if (ret < 0) {
644	print_error("av_interleaved_write_frame()", ret);
645	exit_program(1);
646	}
647	}
648
649	static void close_output_stream(OutputStream *ost)
650	{
651	OutputFile *of = output_files[ost->file_index];
652
653	ost->finished = 1;
654	if (of->shortest) {
655	int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, AV_TIME_BASE_Q);
656	of->recording_time = FFMIN(of->recording_time, end);
657	}
658	}
659
660	static int check_recording_time(OutputStream *ost)
661	{
662	OutputFile *of = output_files[ost->file_index];
663
664	if (of->recording_time != INT64_MAX &&
665	av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
666	AV_TIME_BASE_Q) >= 0) {
667	close_output_stream(ost);
668	return 0;
669	}
670	return 1;
671	}
672
673	static void do_audio_out(AVFormatContext *s, OutputStream *ost,
674	AVFrame *frame)
675	{
676	AVCodecContext *enc = ost->st->codec;
677	AVPacket pkt;
678	int got_packet = 0;
679
680	av_init_packet(&pkt);
681	pkt.data = NULL;
682	pkt.size = 0;
683
684	if (!check_recording_time(ost))
685	return;
686
687	if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
688	frame->pts = ost->sync_opts;
689	ost->sync_opts = frame->pts + frame->nb_samples;
690
691	av_assert0(pkt.size || !pkt.data);
692	update_benchmark(NULL);
693	if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
694	av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
695	exit_program(1);
696	}
697	update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
698
699	if (got_packet) {
700	if (pkt.pts != AV_NOPTS_VALUE)
701	pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
702	if (pkt.dts != AV_NOPTS_VALUE)
703	pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
704	if (pkt.duration > 0)
705	pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
706
707	if (debug_ts) {
708	av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
709	"pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
710	av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
711	av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
712	}
713
714	audio_size += pkt.size;
715	write_frame(s, &pkt, ost);
716
717	av_free_packet(&pkt);
718	}
719	}
720
721	static void do_subtitle_out(AVFormatContext *s,
722	OutputStream *ost,
723	InputStream *ist,
724	AVSubtitle *sub)
725	{
726	int subtitle_out_max_size = 1024 * 1024;
727	int subtitle_out_size, nb, i;
728	AVCodecContext *enc;
729	AVPacket pkt;
730	int64_t pts;
731
732	if (sub->pts == AV_NOPTS_VALUE) {
733	av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
734	if (exit_on_error)
735	exit_program(1);
736	return;
737	}
738
739	enc = ost->st->codec;
740
741	if (!subtitle_out) {
742	subtitle_out = av_malloc(subtitle_out_max_size);
743	}
744
745	/* Note: DVB subtitle need one packet to draw them and one other
746	packet to clear them */
747	/* XXX: signal it in the codec context ? */
748	if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
749	nb = 2;
750	else
751	nb = 1;
752
753	/* shift timestamp to honor -ss and make check_recording_time() work with -t */
754	pts = sub->pts;
755	if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
756	pts -= output_files[ost->file_index]->start_time;
757	for (i = 0; i < nb; i++) {
758	ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
759	if (!check_recording_time(ost))
760	return;
761
762	sub->pts = pts;
763	// start_display_time is required to be 0
764	sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
765	sub->end_display_time -= sub->start_display_time;
766	sub->start_display_time = 0;
767	if (i == 1)
768	sub->num_rects = 0;
769	subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
770	subtitle_out_max_size, sub);
771	if (subtitle_out_size < 0) {
772	av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
773	exit_program(1);
774	}
775
776	av_init_packet(&pkt);
777	pkt.data = subtitle_out;
778	pkt.size = subtitle_out_size;
779	pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
780	pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
781	if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
782	/* XXX: the pts correction is handled here. Maybe handling
783	it in the codec would be better */
784	if (i == 0)
785	pkt.pts += 90 * sub->start_display_time;
786	else
787	pkt.pts += 90 * sub->end_display_time;
788	}
789	subtitle_size += pkt.size;
790	write_frame(s, &pkt, ost);
791	}
792	}
793
794	static void do_video_out(AVFormatContext *s,
795	OutputStream *ost,
796	AVFrame *in_picture)
797	{
798	int ret, format_video_sync;
799	AVPacket pkt;
800	AVCodecContext *enc = ost->st->codec;
801	int nb_frames, i;
802	double sync_ipts, delta;
803	double duration = 0;
804	int frame_size = 0;
805	InputStream *ist = NULL;
806
807	if (ost->source_index >= 0)
808	ist = input_streams[ost->source_index];
809
810	if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
811	duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
812
813	sync_ipts = in_picture->pts;
814	delta = sync_ipts - ost->sync_opts + duration;
815
816	/* by default, we output a single frame */
817	nb_frames = 1;
818
819	format_video_sync = video_sync_method;
820	if (format_video_sync == VSYNC_AUTO)
821	format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
822
823	switch (format_video_sync) {
824	case VSYNC_CFR:
825	// FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
826	if (delta < -1.1)
827	nb_frames = 0;
828	else if (delta > 1.1)
829	nb_frames = lrintf(delta);
830	break;
831	case VSYNC_VFR:
832	if (delta <= -0.6)
833	nb_frames = 0;
834	else if (delta > 0.6)
835	ost->sync_opts = lrint(sync_ipts);
836	break;
837	case VSYNC_DROP:
838	case VSYNC_PASSTHROUGH:
839	ost->sync_opts = lrint(sync_ipts);
840	break;
841	default:
842	av_assert0(0);
843	}
844
845	nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
846	if (nb_frames == 0) {
847	nb_frames_drop++;
848	av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
849	return;
850	} else if (nb_frames > 1) {
851	if (nb_frames > dts_error_threshold * 30) {
852	av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
853	nb_frames_drop++;
854	return;
855	}
856	nb_frames_dup += nb_frames - 1;
857	av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
858	}
859
860	/* duplicates frame if needed */
861	for (i = 0; i < nb_frames; i++) {
862	av_init_packet(&pkt);
863	pkt.data = NULL;
864	pkt.size = 0;
865
866	in_picture->pts = ost->sync_opts;
867
868	#if 1
869	if (!check_recording_time(ost))
870	#else
871	if (ost->frame_number >= ost->max_frames)
872	#endif
873	return;
874
875	if (s->oformat->flags & AVFMT_RAWPICTURE &&
876	enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
877	/* raw pictures are written as AVPicture structure to
878	avoid any copies. We support temporarily the older
879	method. */
880	enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
881	enc->coded_frame->top_field_first = in_picture->top_field_first;
882	if (enc->coded_frame->interlaced_frame)
883	enc->field_order = enc->coded_frame->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
884	else
885	enc->field_order = AV_FIELD_PROGRESSIVE;
886	pkt.data = (uint8_t *)in_picture;
887	pkt.size = sizeof(AVPicture);
888	pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
889	pkt.flags |= AV_PKT_FLAG_KEY;
890
891	video_size += pkt.size;
892	write_frame(s, &pkt, ost);
893	} else {
894	int got_packet, forced_keyframe = 0;
895	double pts_time;
896
897	if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME) &&
898	ost->top_field_first >= 0)
899	in_picture->top_field_first = !!ost->top_field_first;
900
901	if (in_picture->interlaced_frame) {
902	if (enc->codec->id == AV_CODEC_ID_MJPEG)
903	enc->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
904	else
905	enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
906	} else
907	enc->field_order = AV_FIELD_PROGRESSIVE;
908
909	in_picture->quality = ost->st->codec->global_quality;
910	if (!enc->me_threshold)
911	in_picture->pict_type = 0;
912
913	pts_time = in_picture->pts != AV_NOPTS_VALUE ?
914	in_picture->pts * av_q2d(enc->time_base) : NAN;
915	if (ost->forced_kf_index < ost->forced_kf_count &&
916	in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
917	ost->forced_kf_index++;
918	forced_keyframe = 1;
919	} else if (ost->forced_keyframes_pexpr) {
920	double res;
921	ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
922	res = av_expr_eval(ost->forced_keyframes_pexpr,
923	ost->forced_keyframes_expr_const_values, NULL);
924	av_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
925	ost->forced_keyframes_expr_const_values[FKF_N],
926	ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
927	ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
928	ost->forced_keyframes_expr_const_values[FKF_T],
929	ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
930	res);
931	if (res) {
932	forced_keyframe = 1;
933	ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
934	ost->forced_keyframes_expr_const_values[FKF_N];
935	ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
936	ost->forced_keyframes_expr_const_values[FKF_T];
937	ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
938	}
939
940	ost->forced_keyframes_expr_const_values[FKF_N] += 1;
941	}
942	if (forced_keyframe) {
943	in_picture->pict_type = AV_PICTURE_TYPE_I;
944	av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
945	}
946
947	update_benchmark(NULL);
948	ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
949	update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
950	if (ret < 0) {
951	av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
952	exit_program(1);
953	}
954
955	if (got_packet) {
956	if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
957	pkt.pts = ost->sync_opts;
958
959	if (pkt.pts != AV_NOPTS_VALUE)
960	pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
961	if (pkt.dts != AV_NOPTS_VALUE)
962	pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
963
964	if (debug_ts) {
965	av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
966	"pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
967	av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
968	av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
969	}
970
971	frame_size = pkt.size;
972	video_size += pkt.size;
973	write_frame(s, &pkt, ost);
974	av_free_packet(&pkt);
975
976	/* if two pass, output log */
977	if (ost->logfile && enc->stats_out) {
978	fprintf(ost->logfile, "%s", enc->stats_out);
979	}
980	}
981	}
982	ost->sync_opts++;
983	/*
984	* For video, number of frames in == number of packets out.
985	* But there may be reordering, so we can't throw away frames on encoder
986	* flush, we need to limit them here, before they go into encoder.
987	*/
988	ost->frame_number++;
989
990	if (vstats_filename && frame_size)
991	do_video_stats(ost, frame_size);
992	}
993	}
994
995	static double psnr(double d)
996	{
997	return -10.0 * log(d) / log(10.0);
998	}
999
1000	static void do_video_stats(OutputStream *ost, int frame_size)
1001	{
1002	AVCodecContext *enc;
1003	int frame_number;
1004	double ti1, bitrate, avg_bitrate;
1005
1006	/* this is executed just the first time do_video_stats is called */
1007	if (!vstats_file) {
1008	vstats_file = fopen(vstats_filename, "w");
1009	if (!vstats_file) {
1010	perror("fopen");
1011	exit_program(1);
1012	}
1013	}
1014
1015	enc = ost->st->codec;
1016	if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1017	frame_number = ost->st->nb_frames;
1018	fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1019	if (enc->flags&CODEC_FLAG_PSNR)
1020	fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1021
1022	fprintf(vstats_file,"f_size= %6d ", frame_size);
1023	/* compute pts value */
1024	ti1 = ost->st->pts.val * av_q2d(enc->time_base);
1025	if (ti1 < 0.01)
1026	ti1 = 0.01;
1027
1028	bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1029	avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1030	fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1031	(double)video_size / 1024, ti1, bitrate, avg_bitrate);
1032	fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1033	}
1034	}
1035
1036	/**
1037	* Get and encode new output from any of the filtergraphs, without causing
1038	* activity.
1039	*
1040	* @return 0 for success, <0 for severe errors
1041	*/
1042	static int reap_filters(void)
1043	{
1044	AVFrame *filtered_frame = NULL;
1045	int i;
1046	int64_t frame_pts;
1047
1048	/* Reap all buffers present in the buffer sinks */
1049	for (i = 0; i < nb_output_streams; i++) {
1050	OutputStream *ost = output_streams[i];
1051	OutputFile *of = output_files[ost->file_index];
1052	int ret = 0;
1053
1054	if (!ost->filter)
1055	continue;
1056
1057	if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
1058	return AVERROR(ENOMEM);
1059	} else
1060	avcodec_get_frame_defaults(ost->filtered_frame);
1061	filtered_frame = ost->filtered_frame;
1062
1063	while (1) {
1064	ret = av_buffersink_get_frame_flags(ost->filter->filter, filtered_frame,
1065	AV_BUFFERSINK_FLAG_NO_REQUEST);
1066	if (ret < 0) {
1067	if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1068	av_log(NULL, AV_LOG_WARNING,
1069	"Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1070	}
1071	break;
1072	}
1073	frame_pts = AV_NOPTS_VALUE;
1074	if (filtered_frame->pts != AV_NOPTS_VALUE) {
1075	int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1076	filtered_frame->pts = frame_pts = av_rescale_q(filtered_frame->pts,
1077	ost->filter->filter->inputs[0]->time_base,
1078	ost->st->codec->time_base) -
1079	av_rescale_q(start_time,
1080	AV_TIME_BASE_Q,
1081	ost->st->codec->time_base);
1082	}
1083	//if (ost->source_index >= 0)
1084	// *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1085
1086
1087	switch (ost->filter->filter->inputs[0]->type) {
1088	case AVMEDIA_TYPE_VIDEO:
1089	filtered_frame->pts = frame_pts;
1090	if (!ost->frame_aspect_ratio.num)
1091	ost->st->codec->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1092
1093	do_video_out(of->ctx, ost, filtered_frame);
1094	break;
1095	case AVMEDIA_TYPE_AUDIO:
1096	filtered_frame->pts = frame_pts;
1097	if (!(ost->st->codec->codec->capabilities & CODEC_CAP_PARAM_CHANGE) &&
1098	ost->st->codec->channels != av_frame_get_channels(filtered_frame)) {
1099	av_log(NULL, AV_LOG_ERROR,
1100	"Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1101	break;
1102	}
1103	do_audio_out(of->ctx, ost, filtered_frame);
1104	break;
1105	default:
1106	// TODO support subtitle filters
1107	av_assert0(0);
1108	}
1109
1110	av_frame_unref(filtered_frame);
1111	}
1112	}
1113
1114	return 0;
1115	}
1116
1117	static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1118	{
1119	char buf[1024];
1120	AVBPrint buf_script;
1121	OutputStream *ost;
1122	AVFormatContext *oc;
1123	int64_t total_size;
1124	AVCodecContext *enc;
1125	int frame_number, vid, i;
1126	double bitrate;
1127	int64_t pts = INT64_MIN;
1128	static int64_t last_time = -1;
1129	static int qp_histogram[52];
1130	int hours, mins, secs, us;
1131
1132	if (!print_stats && !is_last_report && !progress_avio)
1133	return;
1134
1135	if (!is_last_report) {
1136	if (last_time == -1) {
1137	last_time = cur_time;
1138	return;
1139	}
1140	if ((cur_time - last_time) < 500000)
1141	return;
1142	last_time = cur_time;
1143	}
1144
1145
1146	oc = output_files[0]->ctx;
1147
1148	total_size = avio_size(oc->pb);
1149	if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1150	total_size = avio_tell(oc->pb);
1151
1152	buf[0] = '\0';
1153	vid = 0;
1154	av_bprint_init(&buf_script, 0, 1);
1155	for (i = 0; i < nb_output_streams; i++) {
1156	float q = -1;
1157	ost = output_streams[i];
1158	enc = ost->st->codec;
1159	if (!ost->stream_copy && enc->coded_frame)
1160	q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1161	if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1162	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1163	av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1164	ost->file_index, ost->index, q);
1165	}
1166	if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1167	float fps, t = (cur_time-timer_start) / 1000000.0;
1168
1169	frame_number = ost->frame_number;
1170	fps = t > 1 ? frame_number / t : 0;
1171	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1172	frame_number, fps < 9.95, fps, q);
1173	av_bprintf(&buf_script, "frame=%d\n", frame_number);
1174	av_bprintf(&buf_script, "fps=%.1f\n", fps);
1175	av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1176	ost->file_index, ost->index, q);
1177	if (is_last_report)
1178	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1179	if (qp_hist) {
1180	int j;
1181	int qp = lrintf(q);
1182	if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1183	qp_histogram[qp]++;
1184	for (j = 0; j < 32; j++)
1185	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
1186	}
1187	if ((enc->flags&CODEC_FLAG_PSNR) && (enc->coded_frame || is_last_report)) {
1188	int j;
1189	double error, error_sum = 0;
1190	double scale, scale_sum = 0;
1191	double p;
1192	char type[3] = { 'Y','U','V' };
1193	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1194	for (j = 0; j < 3; j++) {
1195	if (is_last_report) {
1196	error = enc->error[j];
1197	scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1198	} else {
1199	error = enc->coded_frame->error[j];
1200	scale = enc->width * enc->height * 255.0 * 255.0;
1201	}
1202	if (j)
1203	scale /= 4;
1204	error_sum += error;
1205	scale_sum += scale;
1206	p = psnr(error / scale);
1207	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
1208	av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1209	ost->file_index, ost->index, type[j] | 32, p);
1210	}
1211	p = psnr(error_sum / scale_sum);
1212	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1213	av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1214	ost->file_index, ost->index, p);
1215	}
1216	vid = 1;
1217	}
1218	/* compute min output value */
1219	if ((is_last_report || !ost->finished) && ost->st->pts.val != AV_NOPTS_VALUE)
1220	pts = FFMAX(pts, av_rescale_q(ost->st->pts.val,
1221	ost->st->time_base, AV_TIME_BASE_Q));
1222	}
1223
1224	secs = pts / AV_TIME_BASE;
1225	us = pts % AV_TIME_BASE;
1226	mins = secs / 60;
1227	secs %= 60;
1228	hours = mins / 60;
1229	mins %= 60;
1230
1231	bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1232
1233	if (total_size < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1234	"size=N/A time=");
1235	else snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1236	"size=%8.0fkB time=", total_size / 1024.0);
1237	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1238	"%02d:%02d:%02d.%02d ", hours, mins, secs,
1239	(100 * us) / AV_TIME_BASE);
1240	if (bitrate < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1241	"bitrate=N/A");
1242	else snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1243	"bitrate=%6.1fkbits/s", bitrate);
1244	if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1245	else av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1246	av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1247	av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
1248	hours, mins, secs, us);
1249
1250	if (nb_frames_dup || nb_frames_drop)
1251	snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1252	nb_frames_dup, nb_frames_drop);
1253	av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1254	av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1255
1256	if (print_stats || is_last_report) {
1257	if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1258	fprintf(stderr, "%s \r", buf);
1259	} else
1260	av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1261
1262	fflush(stderr);
1263	}
1264
1265	if (progress_avio) {
1266	av_bprintf(&buf_script, "progress=%s\n",
1267	is_last_report ? "end" : "continue");
1268	avio_write(progress_avio, buf_script.str,
1269	FFMIN(buf_script.len, buf_script.size - 1));
1270	avio_flush(progress_avio);
1271	av_bprint_finalize(&buf_script, NULL);
1272	if (is_last_report) {
1273	avio_close(progress_avio);
1274	progress_avio = NULL;
1275	}
1276	}
1277
1278	if (is_last_report) {
1279	int64_t raw= audio_size + video_size + subtitle_size + extra_size;
1280	av_log(NULL, AV_LOG_INFO, "\n");
1281	av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%%\n",
1282	video_size / 1024.0,
1283	audio_size / 1024.0,
1284	subtitle_size / 1024.0,
1285	extra_size / 1024.0,
1286	100.0 * (total_size - raw) / raw
1287	);
1288	if(video_size + audio_size + subtitle_size + extra_size == 0){
1289	av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1290	}
1291	}
1292	}
1293
1294	static void flush_encoders(void)
1295	{
1296	int i, ret;
1297
1298	for (i = 0; i < nb_output_streams; i++) {
1299	OutputStream *ost = output_streams[i];
1300	AVCodecContext *enc = ost->st->codec;
1301	AVFormatContext *os = output_files[ost->file_index]->ctx;
1302	int stop_encoding = 0;
1303
1304	if (!ost->encoding_needed)
1305	continue;
1306
1307	if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1308	continue;
1309	if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
1310	continue;
1311
1312	for (;;) {
1313	int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
1314	const char *desc;
1315	int64_t *size;
1316
1317	switch (ost->st->codec->codec_type) {
1318	case AVMEDIA_TYPE_AUDIO:
1319	encode = avcodec_encode_audio2;
1320	desc = "Audio";
1321	size = &audio_size;
1322	break;
1323	case AVMEDIA_TYPE_VIDEO:
1324	encode = avcodec_encode_video2;
1325	desc = "Video";
1326	size = &video_size;
1327	break;
1328	default:
1329	stop_encoding = 1;
1330	}
1331
1332	if (encode) {
1333	AVPacket pkt;
1334	int got_packet;
1335	av_init_packet(&pkt);
1336	pkt.data = NULL;
1337	pkt.size = 0;
1338
1339	update_benchmark(NULL);
1340	ret = encode(enc, &pkt, NULL, &got_packet);
1341	update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
1342	if (ret < 0) {
1343	av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
1344	exit_program(1);
1345	}
1346	*size += pkt.size;
1347	if (ost->logfile && enc->stats_out) {
1348	fprintf(ost->logfile, "%s", enc->stats_out);
1349	}
1350	if (!got_packet) {
1351	stop_encoding = 1;
1352	break;
1353	}
1354	if (pkt.pts != AV_NOPTS_VALUE)
1355	pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1356	if (pkt.dts != AV_NOPTS_VALUE)
1357	pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1358	if (pkt.duration > 0)
1359	pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1360	write_frame(os, &pkt, ost);
1361	if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1362	do_video_stats(ost, pkt.size);
1363	}
1364	}
1365
1366	if (stop_encoding)
1367	break;
1368	}
1369	}
1370	}
1371
1372	/*
1373	* Check whether a packet from ist should be written into ost at this time
1374	*/
1375	static int check_output_constraints(InputStream *ist, OutputStream *ost)
1376	{
1377	OutputFile *of = output_files[ost->file_index];
1378	int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
1379
1380	if (ost->source_index != ist_index)
1381	return 0;
1382
1383	if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1384	return 0;
1385
1386	return 1;
1387	}
1388
1389	static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1390	{
1391	OutputFile *of = output_files[ost->file_index];
1392	InputFile *f = input_files [ist->file_index];
1393	int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1394	int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1395	int64_t ist_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ist->st->time_base);
1396	AVPicture pict;
1397	AVPacket opkt;
1398
1399	av_init_packet(&opkt);
1400
1401	if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1402	!ost->copy_initial_nonkeyframes)
1403	return;
1404
1405	if (pkt->pts == AV_NOPTS_VALUE) {
1406	if (!ost->frame_number && ist->pts < start_time &&
1407	!ost->copy_prior_start)
1408	return;
1409	} else {
1410	if (!ost->frame_number && pkt->pts < ist_tb_start_time &&
1411	!ost->copy_prior_start)
1412	return;
1413	}
1414
1415	if (of->recording_time != INT64_MAX &&
1416	ist->pts >= of->recording_time + start_time) {
1417	close_output_stream(ost);
1418	return;
1419	}
1420
1421	if (f->recording_time != INT64_MAX) {
1422	start_time = f->ctx->start_time;
1423	if (f->start_time != AV_NOPTS_VALUE)
1424	start_time += f->start_time;
1425	if (ist->pts >= f->recording_time + start_time) {
1426	close_output_stream(ost);
1427	return;
1428	}
1429	}
1430
1431	/* force the input stream PTS */
1432	if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1433	audio_size += pkt->size;
1434	else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1435	video_size += pkt->size;
1436	ost->sync_opts++;
1437	} else if (ost->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1438	subtitle_size += pkt->size;
1439	}
1440
1441	if (pkt->pts != AV_NOPTS_VALUE)
1442	opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1443	else
1444	opkt.pts = AV_NOPTS_VALUE;
1445
1446	if (pkt->dts == AV_NOPTS_VALUE)
1447	opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
1448	else
1449	opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1450	opkt.dts -= ost_tb_start_time;
1451
1452	if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1453	int duration = av_get_audio_frame_duration(ist->st->codec, pkt->size);
1454	if(!duration)
1455	duration = ist->st->codec->frame_size;
1456	opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
1457	(AVRational){1, ist->st->codec->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
1458	ost->st->time_base) - ost_tb_start_time;
1459	}
1460
1461	opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1462	opkt.flags = pkt->flags;
1463
1464	// FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1465	if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
1466	&& ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
1467	&& ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
1468	&& ost->st->codec->codec_id != AV_CODEC_ID_VC1
1469	) {
1470	if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY)) {
1471	opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1472	if (!opkt.buf)
1473	exit_program(1);
1474	}
1475	} else {
1476	opkt.data = pkt->data;
1477	opkt.size = pkt->size;
1478	}
1479
1480	if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
1481	/* store AVPicture in AVPacket, as expected by the output format */
1482	avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1483	opkt.data = (uint8_t *)&pict;
1484	opkt.size = sizeof(AVPicture);
1485	opkt.flags |= AV_PKT_FLAG_KEY;
1486	}
1487
1488	write_frame(of->ctx, &opkt, ost);
1489	ost->st->codec->frame_number++;
1490	}
1491
1492	int guess_input_channel_layout(InputStream *ist)
1493	{
1494	AVCodecContext *dec = ist->st->codec;
1495
1496	if (!dec->channel_layout) {
1497	char layout_name[256];
1498
1499	if (dec->channels > ist->guess_layout_max)
1500	return 0;
1501	dec->channel_layout = av_get_default_channel_layout(dec->channels);
1502	if (!dec->channel_layout)
1503	return 0;
1504	av_get_channel_layout_string(layout_name, sizeof(layout_name),
1505	dec->channels, dec->channel_layout);
1506	av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1507	"#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1508	}
1509	return 1;
1510	}
1511
1512	static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1513	{
1514	AVFrame *decoded_frame, *f;
1515	AVCodecContext *avctx = ist->st->codec;
1516	int i, ret, err = 0, resample_changed;
1517	AVRational decoded_frame_tb;
1518
1519	if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1520	return AVERROR(ENOMEM);
1521	if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1522	return AVERROR(ENOMEM);
1523	decoded_frame = ist->decoded_frame;
1524
1525	update_benchmark(NULL);
1526	ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1527	update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
1528
1529	if (ret >= 0 && avctx->sample_rate <= 0) {
1530	av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
1531	ret = AVERROR_INVALIDDATA;
1532	}
1533
1534	if (*got_output || ret<0 || pkt->size)
1535	decode_error_stat[ret<0] ++;
1536
1537	if (!*got_output || ret < 0) {
1538	if (!pkt->size) {
1539	for (i = 0; i < ist->nb_filters; i++)
1540	#if 1
1541	av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
1542	#else
1543	av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
1544	#endif
1545	}
1546	return ret;
1547	}
1548
1549	#if 1
1550	/* increment next_dts to use for the case where the input stream does not
1551	have timestamps or there are multiple frames in the packet */
1552	ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1553	avctx->sample_rate;
1554	ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1555	avctx->sample_rate;
1556	#endif
1557
1558	resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
1559	ist->resample_channels != avctx->channels ||
1560	ist->resample_channel_layout != decoded_frame->channel_layout ||
1561	ist->resample_sample_rate != decoded_frame->sample_rate;
1562	if (resample_changed) {
1563	char layout1[64], layout2[64];
1564
1565	if (!guess_input_channel_layout(ist)) {
1566	av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1567	"layout for Input Stream #%d.%d\n", ist->file_index,
1568	ist->st->index);
1569	exit_program(1);
1570	}
1571	decoded_frame->channel_layout = avctx->channel_layout;
1572
1573	av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1574	ist->resample_channel_layout);
1575	av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1576	decoded_frame->channel_layout);
1577
1578	av_log(NULL, AV_LOG_INFO,
1579	"Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
1580	ist->file_index, ist->st->index,
1581	ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
1582	ist->resample_channels, layout1,
1583	decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1584	avctx->channels, layout2);
1585
1586	ist->resample_sample_fmt = decoded_frame->format;
1587	ist->resample_sample_rate = decoded_frame->sample_rate;
1588	ist->resample_channel_layout = decoded_frame->channel_layout;
1589	ist->resample_channels = avctx->channels;
1590
1591	for (i = 0; i < nb_filtergraphs; i++)
1592	if (ist_in_filtergraph(filtergraphs[i], ist)) {
1593	FilterGraph *fg = filtergraphs[i];
1594	int j;
1595	if (configure_filtergraph(fg) < 0) {
1596	av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1597	exit_program(1);
1598	}
1599	for (j = 0; j < fg->nb_outputs; j++) {
1600	OutputStream *ost = fg->outputs[j]->ost;
1601	if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
1602	!(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
1603	av_buffersink_set_frame_size(ost->filter->filter,
1604	ost->st->codec->frame_size);
1605	}
1606	}
1607	}
1608
1609	/* if the decoder provides a pts, use it instead of the last packet pts.
1610	the decoder could be delaying output by a packet or more. */
1611	if (decoded_frame->pts != AV_NOPTS_VALUE) {
1612	ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
1613	decoded_frame_tb = avctx->time_base;
1614	} else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
1615	decoded_frame->pts = decoded_frame->pkt_pts;
1616	pkt->pts = AV_NOPTS_VALUE;
1617	decoded_frame_tb = ist->st->time_base;
1618	} else if (pkt->pts != AV_NOPTS_VALUE) {
1619	decoded_frame->pts = pkt->pts;
1620	pkt->pts = AV_NOPTS_VALUE;
1621	decoded_frame_tb = ist->st->time_base;
1622	}else {
1623	decoded_frame->pts = ist->dts;
1624	decoded_frame_tb = AV_TIME_BASE_Q;
1625	}
1626	if (decoded_frame->pts != AV_NOPTS_VALUE)
1627	decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
1628	(AVRational){1, ist->st->codec->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
1629	(AVRational){1, ist->st->codec->sample_rate});
1630	for (i = 0; i < ist->nb_filters; i++) {
1631	if (i < ist->nb_filters - 1) {
1632	f = ist->filter_frame;
1633	err = av_frame_ref(f, decoded_frame);
1634	if (err < 0)
1635	break;
1636	} else
1637	f = decoded_frame;
1638	err = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f,
1639	AV_BUFFERSRC_FLAG_PUSH);
1640	if (err == AVERROR_EOF)
1641	err = 0; /* ignore */
1642	if (err < 0)
1643	break;
1644	}
1645	decoded_frame->pts = AV_NOPTS_VALUE;
1646
1647	av_frame_unref(ist->filter_frame);
1648	av_frame_unref(decoded_frame);
1649	return err < 0 ? err : ret;
1650	}
1651
1652	static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
1653	{
1654	AVFrame *decoded_frame, *f;
1655	int i, ret = 0, err = 0, resample_changed;
1656	int64_t best_effort_timestamp;
1657	AVRational *frame_sample_aspect;
1658
1659	if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1660	return AVERROR(ENOMEM);
1661	if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1662	return AVERROR(ENOMEM);
1663	decoded_frame = ist->decoded_frame;
1664	pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
1665
1666	update_benchmark(NULL);
1667	ret = avcodec_decode_video2(ist->st->codec,
1668	decoded_frame, got_output, pkt);
1669	update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
1670
1671	if (*got_output || ret<0 || pkt->size)
1672	decode_error_stat[ret<0] ++;
1673
1674	if (!*got_output || ret < 0) {
1675	if (!pkt->size) {
1676	for (i = 0; i < ist->nb_filters; i++)
1677	#if 1
1678	av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
1679	#else
1680	av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
1681	#endif
1682	}
1683	return ret;
1684	}
1685
1686	if(ist->top_field_first>=0)
1687	decoded_frame->top_field_first = ist->top_field_first;
1688
1689	best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
1690	if(best_effort_timestamp != AV_NOPTS_VALUE)
1691	ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
1692
1693	if (debug_ts) {
1694	av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
1695	"frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d \n",
1696	ist->st->index, av_ts2str(decoded_frame->pts),
1697	av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
1698	best_effort_timestamp,
1699	av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
1700	decoded_frame->key_frame, decoded_frame->pict_type);
1701	}
1702
1703	pkt->size = 0;
1704
1705	if (ist->st->sample_aspect_ratio.num)
1706	decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1707
1708	resample_changed = ist->resample_width != decoded_frame->width ||
1709	ist->resample_height != decoded_frame->height ||
1710	ist->resample_pix_fmt != decoded_frame->format;
1711	if (resample_changed) {
1712	av_log(NULL, AV_LOG_INFO,
1713	"Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1714	ist->file_index, ist->st->index,
1715	ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
1716	decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1717
1718	ist->resample_width = decoded_frame->width;
1719	ist->resample_height = decoded_frame->height;
1720	ist->resample_pix_fmt = decoded_frame->format;
1721
1722	for (i = 0; i < nb_filtergraphs; i++) {
1723	if (ist_in_filtergraph(filtergraphs[i], ist) && ist->reinit_filters &&
1724	configure_filtergraph(filtergraphs[i]) < 0) {
1725	av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1726	exit_program(1);
1727	}
1728	}
1729	}
1730
1731	frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
1732	for (i = 0; i < ist->nb_filters; i++) {
1733	if (!frame_sample_aspect->num)
1734	*frame_sample_aspect = ist->st->sample_aspect_ratio;
1735
1736	if (i < ist->nb_filters - 1) {
1737	f = ist->filter_frame;
1738	err = av_frame_ref(f, decoded_frame);
1739	if (err < 0)
1740	break;
1741	} else
1742	f = decoded_frame;
1743	ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f, AV_BUFFERSRC_FLAG_PUSH);
1744	if (ret == AVERROR_EOF) {
1745	ret = 0; /* ignore */
1746	} else if (ret < 0) {
1747	av_log(NULL, AV_LOG_FATAL,
1748	"Failed to inject frame into filter network: %s\n", av_err2str(ret));
1749	exit_program(1);
1750	}
1751	}
1752
1753	av_frame_unref(ist->filter_frame);
1754	av_frame_unref(decoded_frame);
1755	return err < 0 ? err : ret;
1756	}
1757
1758	static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1759	{
1760	AVSubtitle subtitle;
1761	int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1762	&subtitle, got_output, pkt);
1763
1764	if (*got_output || ret<0 || pkt->size)
1765	decode_error_stat[ret<0] ++;
1766
1767	if (ret < 0 || !*got_output) {
1768	if (!pkt->size)
1769	sub2video_flush(ist);
1770	return ret;
1771	}
1772
1773	if (ist->fix_sub_duration) {
1774	if (ist->prev_sub.got_output) {
1775	int end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
1776	1000, AV_TIME_BASE);
1777	if (end < ist->prev_sub.subtitle.end_display_time) {
1778	av_log(ist->st->codec, AV_LOG_DEBUG,
1779	"Subtitle duration reduced from %d to %d\n",
1780	ist->prev_sub.subtitle.end_display_time, end);
1781	ist->prev_sub.subtitle.end_display_time = end;
1782	}
1783	}
1784	FFSWAP(int, *got_output, ist->prev_sub.got_output);
1785	FFSWAP(int, ret, ist->prev_sub.ret);
1786	FFSWAP(AVSubtitle, subtitle, ist->prev_sub.subtitle);
1787	}
1788
1789	sub2video_update(ist, &subtitle);
1790
1791	if (!*got_output || !subtitle.num_rects)
1792	return ret;
1793
1794	for (i = 0; i < nb_output_streams; i++) {
1795	OutputStream *ost = output_streams[i];
1796
1797	if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1798	continue;
1799
1800	do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle);
1801	}
1802
1803	avsubtitle_free(&subtitle);
1804	return ret;
1805	}
1806
1807	/* pkt = NULL means EOF (needed to flush decoder buffers) */
1808	static int output_packet(InputStream *ist, const AVPacket *pkt)
1809	{
1810	int ret = 0, i;
1811	int got_output = 0;
1812
1813	AVPacket avpkt;
1814	if (!ist->saw_first_ts) {
1815	ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1816	ist->pts = 0;
1817	if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
1818	ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1819	ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
1820	}
1821	ist->saw_first_ts = 1;
1822	}
1823
1824	if (ist->next_dts == AV_NOPTS_VALUE)
1825	ist->next_dts = ist->dts;
1826	if (ist->next_pts == AV_NOPTS_VALUE)
1827	ist->next_pts = ist->pts;
1828
1829	if (pkt == NULL) {
1830	/* EOF handling */
1831	av_init_packet(&avpkt);
1832	avpkt.data = NULL;
1833	avpkt.size = 0;
1834	goto handle_eof;
1835	} else {
1836	avpkt = *pkt;
1837	}
1838
1839	if (pkt->dts != AV_NOPTS_VALUE) {
1840	ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1841	if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
1842	ist->next_pts = ist->pts = ist->dts;
1843	}
1844
1845	// while we have more to decode or while the decoder did output something on EOF
1846	while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1847	int duration;
1848	handle_eof:
1849
1850	ist->pts = ist->next_pts;
1851	ist->dts = ist->next_dts;
1852
1853	if (avpkt.size && avpkt.size != pkt->size) {
1854	av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1855	"Multiple frames in a packet from stream %d\n", pkt->stream_index);
1856	ist->showed_multi_packet_warning = 1;
1857	}
1858
1859	switch (ist->st->codec->codec_type) {
1860	case AVMEDIA_TYPE_AUDIO:
1861	ret = decode_audio (ist, &avpkt, &got_output);
1862	break;
1863	case AVMEDIA_TYPE_VIDEO:
1864	ret = decode_video (ist, &avpkt, &got_output);
1865	if (avpkt.duration) {
1866	duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
1867	} else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
1868	int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1869	duration = ((int64_t)AV_TIME_BASE *
1870	ist->st->codec->time_base.num * ticks) /
1871	ist->st->codec->time_base.den;
1872	} else
1873	duration = 0;
1874
1875	if(ist->dts != AV_NOPTS_VALUE && duration) {
1876	ist->next_dts += duration;
1877	}else
1878	ist->next_dts = AV_NOPTS_VALUE;
1879
1880	if (got_output)
1881	ist->next_pts += duration; //FIXME the duration is not correct in some cases
1882	break;
1883	case AVMEDIA_TYPE_SUBTITLE:
1884	ret = transcode_subtitles(ist, &avpkt, &got_output);
1885	break;
1886	default:
1887	return -1;
1888	}
1889
1890	if (ret < 0)
1891	return ret;
1892
1893	avpkt.dts=
1894	avpkt.pts= AV_NOPTS_VALUE;
1895
1896	// touch data and size only if not EOF
1897	if (pkt) {
1898	if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1899	ret = avpkt.size;
1900	avpkt.data += ret;
1901	avpkt.size -= ret;
1902	}
1903	if (!got_output) {
1904	continue;
1905	}
1906	}
1907
1908	/* handle stream copy */
1909	if (!ist->decoding_needed) {
1910	ist->dts = ist->next_dts;
1911	switch (ist->st->codec->codec_type) {
1912	case AVMEDIA_TYPE_AUDIO:
1913	ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1914	ist->st->codec->sample_rate;
1915	break;
1916	case AVMEDIA_TYPE_VIDEO:
1917	if (ist->framerate.num) {
1918	// TODO: Remove work-around for c99-to-c89 issue 7
1919	AVRational time_base_q = AV_TIME_BASE_Q;
1920	int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
1921	ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
1922	} else if (pkt->duration) {
1923	ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1924	} else if(ist->st->codec->time_base.num != 0) {
1925	int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
1926	ist->next_dts += ((int64_t)AV_TIME_BASE *
1927	ist->st->codec->time_base.num * ticks) /
1928	ist->st->codec->time_base.den;
1929	}
1930	break;
1931	}
1932	ist->pts = ist->dts;
1933	ist->next_pts = ist->next_dts;
1934	}
1935	for (i = 0; pkt && i < nb_output_streams; i++) {
1936	OutputStream *ost = output_streams[i];
1937
1938	if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1939	continue;
1940
1941	do_streamcopy(ist, ost, pkt);
1942	}
1943
1944	return 0;
1945	}
1946
1947	static void print_sdp(void)
1948	{
1949	char sdp[16384];
1950	int i;
1951	AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
1952
1953	if (!avc)
1954	exit_program(1);
1955	for (i = 0; i < nb_output_files; i++)
1956	avc[i] = output_files[i]->ctx;
1957
1958	av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
1959	printf("SDP:\n%s\n", sdp);
1960	fflush(stdout);
1961	av_freep(&avc);
1962	}
1963
1964	static int init_input_stream(int ist_index, char *error, int error_len)
1965	{
1966	int ret;
1967	InputStream *ist = input_streams[ist_index];
1968
1969	if (ist->decoding_needed) {
1970	AVCodec *codec = ist->dec;
1971	if (!codec) {
1972	snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
1973	avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1974	return AVERROR(EINVAL);
1975	}
1976
1977	av_opt_set_int(ist->st->codec, "refcounted_frames", 1, 0);
1978
1979	if (!av_dict_get(ist->opts, "threads", NULL, 0))
1980	av_dict_set(&ist->opts, "threads", "auto", 0);
1981	if ((ret = avcodec_open2(ist->st->codec, codec, &ist->opts)) < 0) {
1982	char errbuf[128];
1983	if (ret == AVERROR_EXPERIMENTAL)
1984	abort_codec_experimental(codec, 0);
1985
1986	av_strerror(ret, errbuf, sizeof(errbuf));
1987
1988	snprintf(error, error_len,
1989	"Error while opening decoder for input stream "
1990	"#%d:%d : %s",
1991	ist->file_index, ist->st->index, errbuf);
1992	return ret;
1993	}
1994	assert_avoptions(ist->opts);
1995	}
1996
1997	ist->next_pts = AV_NOPTS_VALUE;
1998	ist->next_dts = AV_NOPTS_VALUE;
1999	ist->is_start = 1;
2000
2001	return 0;
2002	}
2003
2004	static InputStream *get_input_stream(OutputStream *ost)
2005	{
2006	if (ost->source_index >= 0)
2007	return input_streams[ost->source_index];
2008	return NULL;
2009	}
2010
2011	static int compare_int64(const void *a, const void *b)
2012	{
2013	int64_t va = *(int64_t *)a, vb = *(int64_t *)b;
2014	return va < vb ? -1 : va > vb ? +1 : 0;
2015	}
2016
2017	static void parse_forced_key_frames(char *kf, OutputStream *ost,
2018	AVCodecContext *avctx)
2019	{
2020	char *p;
2021	int n = 1, i, size, index = 0;
2022	int64_t t, *pts;
2023
2024	for (p = kf; *p; p++)
2025	if (*p == ',')
2026	n++;
2027	size = n;
2028	pts = av_malloc(sizeof(*pts) * size);
2029	if (!pts) {
2030	av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2031	exit_program(1);
2032	}
2033
2034	p = kf;
2035	for (i = 0; i < n; i++) {
2036	char *next = strchr(p, ',');
2037
2038	if (next)
2039	*next++ = 0;
2040
2041	if (!memcmp(p, "chapters", 8)) {
2042
2043	AVFormatContext *avf = output_files[ost->file_index]->ctx;
2044	int j;
2045
2046	if (avf->nb_chapters > INT_MAX - size ||
2047	!(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
2048	sizeof(*pts)))) {
2049	av_log(NULL, AV_LOG_FATAL,
2050	"Could not allocate forced key frames array.\n");
2051	exit_program(1);
2052	}
2053	t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
2054	t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2055
2056	for (j = 0; j < avf->nb_chapters; j++) {
2057	AVChapter *c = avf->chapters[j];
2058	av_assert1(index < size);
2059	pts[index++] = av_rescale_q(c->start, c->time_base,
2060	avctx->time_base) + t;
2061	}
2062
2063	} else {
2064
2065	t = parse_time_or_die("force_key_frames", p, 1);
2066	av_assert1(index < size);
2067	pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2068
2069	}
2070
2071	p = next;
2072	}
2073
2074	av_assert0(index == size);
2075	qsort(pts, size, sizeof(*pts), compare_int64);
2076	ost->forced_kf_count = size;
2077	ost->forced_kf_pts = pts;
2078	}
2079
2080	static void report_new_stream(int input_index, AVPacket *pkt)
2081	{
2082	InputFile *file = input_files[input_index];
2083	AVStream *st = file->ctx->streams[pkt->stream_index];
2084
2085	if (pkt->stream_index < file->nb_streams_warn)
2086	return;
2087	av_log(file->ctx, AV_LOG_WARNING,
2088	"New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
2089	av_get_media_type_string(st->codec->codec_type),
2090	input_index, pkt->stream_index,
2091	pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
2092	file->nb_streams_warn = pkt->stream_index + 1;
2093	}
2094
2095	static int transcode_init(void)
2096	{
2097	int ret = 0, i, j, k;
2098	AVFormatContext *oc;
2099	AVCodecContext *codec;
2100	OutputStream *ost;
2101	InputStream *ist;
2102	char error[1024];
2103	int want_sdp = 1;
2104
2105	for (i = 0; i < nb_filtergraphs; i++) {
2106	FilterGraph *fg = filtergraphs[i];
2107	for (j = 0; j < fg->nb_outputs; j++) {
2108	OutputFilter *ofilter = fg->outputs[j];
2109	if (!ofilter->ost || ofilter->ost->source_index >= 0)
2110	continue;
2111	if (fg->nb_inputs != 1)
2112	continue;
2113	for (k = nb_input_streams-1; k >= 0 ; k--)
2114	if (fg->inputs[0]->ist == input_streams[k])
2115	break;
2116	ofilter->ost->source_index = k;
2117	}
2118	}
2119
2120	/* init framerate emulation */
2121	for (i = 0; i < nb_input_files; i++) {
2122	InputFile *ifile = input_files[i];
2123	if (ifile->rate_emu)
2124	for (j = 0; j < ifile->nb_streams; j++)
2125	input_streams[j + ifile->ist_index]->start = av_gettime();
2126	}
2127
2128	/* output stream init */
2129	for (i = 0; i < nb_output_files; i++) {
2130	oc = output_files[i]->ctx;
2131	if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2132	av_dump_format(oc, i, oc->filename, 1);
2133	av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2134	return AVERROR(EINVAL);
2135	}
2136	}
2137
2138	/* init complex filtergraphs */
2139	for (i = 0; i < nb_filtergraphs; i++)
2140	if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2141	return ret;
2142
2143	/* for each output stream, we compute the right encoding parameters */
2144	for (i = 0; i < nb_output_streams; i++) {
2145	AVCodecContext *icodec = NULL;
2146	ost = output_streams[i];
2147	oc = output_files[ost->file_index]->ctx;
2148	ist = get_input_stream(ost);
2149
2150	if (ost->attachment_filename)
2151	continue;
2152
2153	codec = ost->st->codec;
2154
2155	if (ist) {
2156	icodec = ist->st->codec;
2157
2158	ost->st->disposition = ist->st->disposition;
2159	codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2160	codec->chroma_sample_location = icodec->chroma_sample_location;
2161	} else {
2162	for (j=0; j<oc->nb_streams; j++) {
2163	AVStream *st = oc->streams[j];
2164	if (st != ost->st && st->codec->codec_type == codec->codec_type)
2165	break;
2166	}
2167	if (j == oc->nb_streams)
2168	if (codec->codec_type == AVMEDIA_TYPE_AUDIO || codec->codec_type == AVMEDIA_TYPE_VIDEO)
2169	ost->st->disposition = AV_DISPOSITION_DEFAULT;
2170	}
2171
2172	if (ost->stream_copy) {
2173	AVRational sar;
2174	uint64_t extra_size;
2175
2176	av_assert0(ist && !ost->filter);
2177
2178	extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2179
2180	if (extra_size > INT_MAX) {
2181	return AVERROR(EINVAL);
2182	}
2183
2184	/* if stream_copy is selected, no need to decode or encode */
2185	codec->codec_id = icodec->codec_id;
2186	codec->codec_type = icodec->codec_type;
2187
2188	if (!codec->codec_tag) {
2189	unsigned int codec_tag;
2190	if (!oc->oformat->codec_tag ||
2191	av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2192	!av_codec_get_tag2(oc->oformat->codec_tag, icodec->codec_id, &codec_tag))
2193	codec->codec_tag = icodec->codec_tag;
2194	}
2195
2196	codec->bit_rate = icodec->bit_rate;
2197	codec->rc_max_rate = icodec->rc_max_rate;
2198	codec->rc_buffer_size = icodec->rc_buffer_size;
2199	codec->field_order = icodec->field_order;
2200	codec->extradata = av_mallocz(extra_size);
2201	if (!codec->extradata) {
2202	return AVERROR(ENOMEM);
2203	}
2204	memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2205	codec->extradata_size= icodec->extradata_size;
2206	codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
2207
2208	codec->time_base = ist->st->time_base;
2209	/*
2210	* Avi is a special case here because it supports variable fps but
2211	* having the fps and timebase differe significantly adds quite some
2212	* overhead
2213	*/
2214	if(!strcmp(oc->oformat->name, "avi")) {
2215	if ( copy_tb<0 && av_q2d(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2216	&& 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
2217	&& 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(icodec->time_base)
2218	&& av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(icodec->time_base) < 1.0/500
2219	|| copy_tb==2){
2220	codec->time_base.num = ist->st->r_frame_rate.den;
2221	codec->time_base.den = 2*ist->st->r_frame_rate.num;
2222	codec->ticks_per_frame = 2;
2223	} else if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2224	&& av_q2d(ist->st->time_base) < 1.0/500
2225	|| copy_tb==0){
2226	codec->time_base = icodec->time_base;
2227	codec->time_base.num *= icodec->ticks_per_frame;
2228	codec->time_base.den *= 2;
2229	codec->ticks_per_frame = 2;
2230	}
2231	} else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2232	&& strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2233	&& strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2234	&& strcmp(oc->oformat->name, "f4v")
2235	) {
2236	if( copy_tb<0 && icodec->time_base.den
2237	&& av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2238	&& av_q2d(ist->st->time_base) < 1.0/500
2239	|| copy_tb==0){
2240	codec->time_base = icodec->time_base;
2241	codec->time_base.num *= icodec->ticks_per_frame;
2242	}
2243	}
2244	if ( codec->codec_tag == AV_RL32("tmcd")
2245	&& icodec->time_base.num < icodec->time_base.den
2246	&& icodec->time_base.num > 0
2247	&& 121LL*icodec->time_base.num > icodec->time_base.den) {
2248	codec->time_base = icodec->time_base;
2249	}
2250
2251	if (ist && !ost->frame_rate.num)
2252	ost->frame_rate = ist->framerate;
2253	if(ost->frame_rate.num)
2254	codec->time_base = av_inv_q(ost->frame_rate);
2255
2256	av_reduce(&codec->time_base.num, &codec->time_base.den,
2257	codec->time_base.num, codec->time_base.den, INT_MAX);
2258
2259	switch (codec->codec_type) {
2260	case AVMEDIA_TYPE_AUDIO:
2261	if (audio_volume != 256) {
2262	av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2263	exit_program(1);
2264	}
2265	codec->channel_layout = icodec->channel_layout;
2266	codec->sample_rate = icodec->sample_rate;
2267	codec->channels = icodec->channels;
2268	codec->frame_size = icodec->frame_size;
2269	codec->audio_service_type = icodec->audio_service_type;
2270	codec->block_align = icodec->block_align;
2271	if((codec->block_align == 1 || codec->block_align == 1152 || codec->block_align == 576) && codec->codec_id == AV_CODEC_ID_MP3)
2272	codec->block_align= 0;
2273	if(codec->codec_id == AV_CODEC_ID_AC3)
2274	codec->block_align= 0;
2275	break;
2276	case AVMEDIA_TYPE_VIDEO:
2277	codec->pix_fmt = icodec->pix_fmt;
2278	codec->width = icodec->width;
2279	codec->height = icodec->height;
2280	codec->has_b_frames = icodec->has_b_frames;
2281	if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
2282	sar =
2283	av_mul_q(ost->frame_aspect_ratio,
2284	(AVRational){ codec->height, codec->width });
2285	av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
2286	"with stream copy may produce invalid files\n");
2287	}
2288	else if (ist->st->sample_aspect_ratio.num)
2289	sar = ist->st->sample_aspect_ratio;
2290	else
2291	sar = icodec->sample_aspect_ratio;
2292	ost->st->sample_aspect_ratio = codec->sample_aspect_ratio = sar;
2293	ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2294	break;
2295	case AVMEDIA_TYPE_SUBTITLE:
2296	codec->width = icodec->width;
2297	codec->height = icodec->height;
2298	break;
2299	case AVMEDIA_TYPE_DATA:
2300	case AVMEDIA_TYPE_ATTACHMENT:
2301	break;
2302	default:
2303	abort();
2304	}
2305	} else {
2306	if (!ost->enc)
2307	ost->enc = avcodec_find_encoder(codec->codec_id);
2308	if (!ost->enc) {
2309	/* should only happen when a default codec is not present. */
2310	snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2311	avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2312	ret = AVERROR(EINVAL);
2313	goto dump_format;
2314	}
2315
2316	if (ist)
2317	ist->decoding_needed++;
2318	ost->encoding_needed = 1;
2319
2320	if (!ost->filter &&
2321	(codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2322	codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
2323	FilterGraph *fg;
2324	fg = init_simple_filtergraph(ist, ost);
2325	if (configure_filtergraph(fg)) {
2326	av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2327	exit_program(1);
2328	}
2329	}
2330
2331	if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2332	if (ost->filter && !ost->frame_rate.num)
2333	ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
2334	if (ist && !ost->frame_rate.num)
2335	ost->frame_rate = ist->framerate;
2336	if (ist && !ost->frame_rate.num)
2337	ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2338	// ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
2339	if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2340	int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2341	ost->frame_rate = ost->enc->supported_framerates[idx];
2342	}
2343	}
2344
2345	switch (codec->codec_type) {
2346	case AVMEDIA_TYPE_AUDIO:
2347	codec->sample_fmt = ost->filter->filter->inputs[0]->format;
2348	codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
2349	codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
2350	codec->channels = avfilter_link_get_channels(ost->filter->filter->inputs[0]);
2351	codec->time_base = (AVRational){ 1, codec->sample_rate };
2352	break;
2353	case AVMEDIA_TYPE_VIDEO:
2354	codec->time_base = av_inv_q(ost->frame_rate);
2355	if (ost->filter && !(codec->time_base.num && codec->time_base.den))
2356	codec->time_base = ost->filter->filter->inputs[0]->time_base;
2357	if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
2358	&& (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2359	av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
2360	"Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
2361	}
2362	for (j = 0; j < ost->forced_kf_count; j++)
2363	ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2364	AV_TIME_BASE_Q,
2365	codec->time_base);
2366
2367	codec->width = ost->filter->filter->inputs[0]->w;
2368	codec->height = ost->filter->filter->inputs[0]->h;
2369	codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
2370	ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
2371	av_mul_q(ost->frame_aspect_ratio, (AVRational){ codec->height, codec->width }) :
2372	ost->filter->filter->inputs[0]->sample_aspect_ratio;
2373	if (!strncmp(ost->enc->name, "libx264", 7) &&
2374	codec->pix_fmt == AV_PIX_FMT_NONE &&
2375	ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
2376	av_log(NULL, AV_LOG_WARNING,
2377	"No pixel format specified, %s for H.264 encoding chosen.\n"
2378	"Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
2379	av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
2380	if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
2381	codec->pix_fmt == AV_PIX_FMT_NONE &&
2382	ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
2383	av_log(NULL, AV_LOG_WARNING,
2384	"No pixel format specified, %s for MPEG-2 encoding chosen.\n"
2385	"Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
2386	av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
2387	codec->pix_fmt = ost->filter->filter->inputs[0]->format;
2388
2389	if (!icodec ||
2390	codec->width != icodec->width ||
2391	codec->height != icodec->height ||
2392	codec->pix_fmt != icodec->pix_fmt) {
2393	codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2394	}
2395
2396	if (ost->forced_keyframes) {
2397	if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
2398	ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
2399	forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
2400	if (ret < 0) {
2401	av_log(NULL, AV_LOG_ERROR,
2402	"Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
2403	return ret;
2404	}
2405	ost->forced_keyframes_expr_const_values[FKF_N] = 0;
2406	ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
2407	ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
2408	ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
2409	} else {
2410	parse_forced_key_frames(ost->forced_keyframes, ost, ost->st->codec);
2411	}
2412	}
2413	break;
2414	case AVMEDIA_TYPE_SUBTITLE:
2415	codec->time_base = (AVRational){1, 1000};
2416	if (!codec->width) {
2417	codec->width = input_streams[ost->source_index]->st->codec->width;
2418	codec->height = input_streams[ost->source_index]->st->codec->height;
2419	}
2420	break;
2421	default:
2422	abort();
2423	break;
2424	}
2425	/* two pass mode */
2426	if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
2427	char logfilename[1024];
2428	FILE *f;
2429
2430	snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2431	ost->logfile_prefix ? ost->logfile_prefix :
2432	DEFAULT_PASS_LOGFILENAME_PREFIX,
2433	i);
2434	if (!strcmp(ost->enc->name, "libx264")) {
2435	av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2436	} else {
2437	if (codec->flags & CODEC_FLAG_PASS2) {
2438	char *logbuffer;
2439	size_t logbuffer_size;
2440	if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2441	av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2442	logfilename);
2443	exit_program(1);
2444	}
2445	codec->stats_in = logbuffer;
2446	}
2447	if (codec->flags & CODEC_FLAG_PASS1) {
2448	f = fopen(logfilename, "wb");
2449	if (!f) {
2450	av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2451	logfilename, strerror(errno));
2452	exit_program(1);
2453	}
2454	ost->logfile = f;
2455	}
2456	}
2457	}
2458	}
2459	}
2460
2461	/* open each encoder */
2462	for (i = 0; i < nb_output_streams; i++) {
2463	ost = output_streams[i];
2464	if (ost->encoding_needed) {
2465	AVCodec *codec = ost->enc;
2466	AVCodecContext *dec = NULL;
2467
2468	if ((ist = get_input_stream(ost)))
2469	dec = ist->st->codec;
2470	if (dec && dec->subtitle_header) {
2471	/* ASS code assumes this buffer is null terminated so add extra byte. */
2472	ost->st->codec->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
2473	if (!ost->st->codec->subtitle_header) {
2474	ret = AVERROR(ENOMEM);
2475	goto dump_format;
2476	}
2477	memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2478	ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2479	}
2480	if (!av_dict_get(ost->opts, "threads", NULL, 0))
2481	av_dict_set(&ost->opts, "threads", "auto", 0);
2482	if ((ret = avcodec_open2(ost->st->codec, codec, &ost->opts)) < 0) {
2483	if (ret == AVERROR_EXPERIMENTAL)
2484	abort_codec_experimental(codec, 1);
2485	snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2486	ost->file_index, ost->index);
2487	goto dump_format;
2488	}
2489	if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2490	!(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2491	av_buffersink_set_frame_size(ost->filter->filter,
2492	ost->st->codec->frame_size);
2493	assert_avoptions(ost->opts);
2494	if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2495	av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2496	" It takes bits/s as argument, not kbits/s\n");
2497	extra_size += ost->st->codec->extradata_size;
2498
2499	if (ost->st->codec->me_threshold)
2500	input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
2501	} else {
2502	av_opt_set_dict(ost->st->codec, &ost->opts);
2503	}
2504	}
2505
2506	/* init input streams */
2507	for (i = 0; i < nb_input_streams; i++)
2508	if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
2509	for (i = 0; i < nb_output_streams; i++) {
2510	ost = output_streams[i];
2511	avcodec_close(ost->st->codec);
2512	}
2513	goto dump_format;
2514	}
2515
2516	/* discard unused programs */
2517	for (i = 0; i < nb_input_files; i++) {
2518	InputFile *ifile = input_files[i];
2519	for (j = 0; j < ifile->ctx->nb_programs; j++) {
2520	AVProgram *p = ifile->ctx->programs[j];
2521	int discard = AVDISCARD_ALL;
2522
2523	for (k = 0; k < p->nb_stream_indexes; k++)
2524	if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
2525	discard = AVDISCARD_DEFAULT;
2526	break;
2527	}
2528	p->discard = discard;
2529	}
2530	}
2531
2532	/* open files and write file headers */
2533	for (i = 0; i < nb_output_files; i++) {
2534	oc = output_files[i]->ctx;
2535	oc->interrupt_callback = int_cb;
2536	if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
2537	char errbuf[128];
2538	av_strerror(ret, errbuf, sizeof(errbuf));
2539	snprintf(error, sizeof(error),
2540	"Could not write header for output file #%d "
2541	"(incorrect codec parameters ?): %s",
2542	i, errbuf);
2543	ret = AVERROR(EINVAL);
2544	goto dump_format;
2545	}
2546	// assert_avoptions(output_files[i]->opts);
2547	if (strcmp(oc->oformat->name, "rtp")) {
2548	want_sdp = 0;
2549	}
2550	}
2551
2552	dump_format:
2553	/* dump the file output parameters - cannot be done before in case
2554	of stream copy */
2555	for (i = 0; i < nb_output_files; i++) {
2556	av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
2557	}
2558
2559	/* dump the stream mapping */
2560	av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2561	for (i = 0; i < nb_input_streams; i++) {
2562	ist = input_streams[i];
2563
2564	for (j = 0; j < ist->nb_filters; j++) {
2565	if (ist->filters[j]->graph->graph_desc) {
2566	av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
2567	ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
2568	ist->filters[j]->name);
2569	if (nb_filtergraphs > 1)
2570	av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
2571	av_log(NULL, AV_LOG_INFO, "\n");
2572	}
2573	}
2574	}
2575
2576	for (i = 0; i < nb_output_streams; i++) {
2577	ost = output_streams[i];
2578
2579	if (ost->attachment_filename) {
2580	/* an attached file */
2581	av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2582	ost->attachment_filename, ost->file_index, ost->index);
2583	continue;
2584	}
2585
2586	if (ost->filter && ost->filter->graph->graph_desc) {
2587	/* output from a complex graph */
2588	av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
2589	if (nb_filtergraphs > 1)
2590	av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
2591
2592	av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
2593	ost->index, ost->enc ? ost->enc->name : "?");
2594	continue;
2595	}
2596
2597	av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2598	input_streams[ost->source_index]->file_index,
2599	input_streams[ost->source_index]->st->index,
2600	ost->file_index,
2601	ost->index);
2602	if (ost->sync_ist != input_streams[ost->source_index])
2603	av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2604	ost->sync_ist->file_index,
2605	ost->sync_ist->st->index);
2606	if (ost->stream_copy)
2607	av_log(NULL, AV_LOG_INFO, " (copy)");
2608	else
2609	av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2610	input_streams[ost->source_index]->dec->name : "?",
2611	ost->enc ? ost->enc->name : "?");
2612	av_log(NULL, AV_LOG_INFO, "\n");
2613	}
2614
2615	if (ret) {
2616	av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2617	return ret;
2618	}
2619
2620	if (want_sdp) {
2621	print_sdp();
2622	}
2623
2624	return 0;
2625	}
2626
2627	/* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
2628	static int need_output(void)
2629	{
2630	int i;
2631
2632	for (i = 0; i < nb_output_streams; i++) {
2633	OutputStream *ost = output_streams[i];
2634	OutputFile *of = output_files[ost->file_index];
2635	AVFormatContext *os = output_files[ost->file_index]->ctx;
2636
2637	if (ost->finished ||
2638	(os->pb && avio_tell(os->pb) >= of->limit_filesize))
2639	continue;
2640	if (ost->frame_number >= ost->max_frames) {
2641	int j;
2642	for (j = 0; j < of->ctx->nb_streams; j++)
2643	close_output_stream(output_streams[of->ost_index + j]);
2644	continue;
2645	}
2646
2647	return 1;
2648	}
2649
2650	return 0;
2651	}
2652
2653	/**
2654	* Select the output stream to process.
2655	*
2656	* @return selected output stream, or NULL if none available
2657	*/
2658	static OutputStream *choose_output(void)
2659	{
2660	int i;
2661	int64_t opts_min = INT64_MAX;
2662	OutputStream *ost_min = NULL;
2663
2664	for (i = 0; i < nb_output_streams; i++) {
2665	OutputStream *ost = output_streams[i];
2666	int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
2667	AV_TIME_BASE_Q);
2668	if (!ost->unavailable && !ost->finished && opts < opts_min) {
2669	opts_min = opts;
2670	ost_min = ost;
2671	}
2672	}
2673	return ost_min;
2674	}
2675
2676	static int check_keyboard_interaction(int64_t cur_time)
2677	{
2678	int i, ret, key;
2679	static int64_t last_time;
2680	if (received_nb_signals)
2681	return AVERROR_EXIT;
2682	/* read_key() returns 0 on EOF */
2683	if(cur_time - last_time >= 100000 && !run_as_daemon){
2684	key = read_key();
2685	last_time = cur_time;
2686	}else
2687	key = -1;
2688	if (key == 'q')
2689	return AVERROR_EXIT;
2690	if (key == '+') av_log_set_level(av_log_get_level()+10);
2691	if (key == '-') av_log_set_level(av_log_get_level()-10);
2692	if (key == 's') qp_hist ^= 1;
2693	if (key == 'h'){
2694	if (do_hex_dump){
2695	do_hex_dump = do_pkt_dump = 0;
2696	} else if(do_pkt_dump){
2697	do_hex_dump = 1;
2698	} else
2699	do_pkt_dump = 1;
2700	av_log_set_level(AV_LOG_DEBUG);
2701	}
2702	if (key == 'c' || key == 'C'){
2703	char buf[4096], target[64], command[256], arg[256] = {0};
2704	double time;
2705	int k, n = 0;
2706	fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
2707	i = 0;
2708	while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2709	if (k > 0)
2710	buf[i++] = k;
2711	buf[i] = 0;
2712	if (k > 0 &&
2713	(n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2714	av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2715	target, time, command, arg);
2716	for (i = 0; i < nb_filtergraphs; i++) {
2717	FilterGraph *fg = filtergraphs[i];
2718	if (fg->graph) {
2719	if (time < 0) {
2720	ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
2721	key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2722	fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
2723	} else if (key == 'c') {
2724	fprintf(stderr, "Queing commands only on filters supporting the specific command is unsupported\n");
2725	ret = AVERROR_PATCHWELCOME;
2726	} else {
2727	ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
2728	}
2729	}
2730	}
2731	} else {
2732	av_log(NULL, AV_LOG_ERROR,
2733	"Parse error, at least 3 arguments were expected, "
2734	"only %d given in string '%s'\n", n, buf);
2735	}
2736	}
2737	if (key == 'd' || key == 'D'){
2738	int debug=0;
2739	if(key == 'D') {
2740	debug = input_streams[0]->st->codec->debug<<1;
2741	if(!debug) debug = 1;
2742	while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2743	debug += debug;
2744	}else
2745	if(scanf("%d", &debug)!=1)
2746	fprintf(stderr,"error parsing debug value\n");
2747	for(i=0;i<nb_input_streams;i++) {
2748	input_streams[i]->st->codec->debug = debug;
2749	}
2750	for(i=0;i<nb_output_streams;i++) {
2751	OutputStream *ost = output_streams[i];
2752	ost->st->codec->debug = debug;
2753	}
2754	if(debug) av_log_set_level(AV_LOG_DEBUG);
2755	fprintf(stderr,"debug=%d\n", debug);
2756	}
2757	if (key == '?'){
2758	fprintf(stderr, "key function\n"
2759	"? show this help\n"
2760	"+ increase verbosity\n"
2761	"- decrease verbosity\n"
2762	"c Send command to first matching filter supporting it\n"
2763	"C Send/Que command to all matching filters\n"
2764	"D cycle through available debug modes\n"
2765	"h dump packets/hex press to cycle through the 3 states\n"
2766	"q quit\n"
2767	"s Show QP histogram\n"
2768	);
2769	}
2770	return 0;
2771	}
2772
2773	#if HAVE_PTHREADS
2774	static void *input_thread(void *arg)
2775	{
2776	InputFile *f = arg;
2777	int ret = 0;
2778
2779	while (!transcoding_finished && ret >= 0) {
2780	AVPacket pkt;
2781	ret = av_read_frame(f->ctx, &pkt);
2782
2783	if (ret == AVERROR(EAGAIN)) {
2784	av_usleep(10000);
2785	ret = 0;
2786	continue;
2787	} else if (ret < 0)
2788	break;
2789
2790	pthread_mutex_lock(&f->fifo_lock);
2791	while (!av_fifo_space(f->fifo))
2792	pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2793
2794	av_dup_packet(&pkt);
2795	av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2796
2797	pthread_mutex_unlock(&f->fifo_lock);
2798	}
2799
2800	f->finished = 1;
2801	return NULL;
2802	}
2803
2804	static void free_input_threads(void)
2805	{
2806	int i;
2807
2808	if (nb_input_files == 1)
2809	return;
2810
2811	transcoding_finished = 1;
2812
2813	for (i = 0; i < nb_input_files; i++) {
2814	InputFile *f = input_files[i];
2815	AVPacket pkt;
2816
2817	if (!f->fifo || f->joined)
2818	continue;
2819
2820	pthread_mutex_lock(&f->fifo_lock);
2821	while (av_fifo_size(f->fifo)) {
2822	av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2823	av_free_packet(&pkt);
2824	}
2825	pthread_cond_signal(&f->fifo_cond);
2826	pthread_mutex_unlock(&f->fifo_lock);
2827
2828	pthread_join(f->thread, NULL);
2829	f->joined = 1;
2830
2831	while (av_fifo_size(f->fifo)) {
2832	av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2833	av_free_packet(&pkt);
2834	}
2835	av_fifo_free(f->fifo);
2836	}
2837	}
2838
2839	static int init_input_threads(void)
2840	{
2841	int i, ret;
2842
2843	if (nb_input_files == 1)
2844	return 0;
2845
2846	for (i = 0; i < nb_input_files; i++) {
2847	InputFile *f = input_files[i];
2848
2849	if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2850	return AVERROR(ENOMEM);
2851
2852	pthread_mutex_init(&f->fifo_lock, NULL);
2853	pthread_cond_init (&f->fifo_cond, NULL);
2854
2855	if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2856	return AVERROR(ret);
2857	}
2858	return 0;
2859	}
2860
2861	static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2862	{
2863	int ret = 0;
2864
2865	pthread_mutex_lock(&f->fifo_lock);
2866
2867	if (av_fifo_size(f->fifo)) {
2868	av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2869	pthread_cond_signal(&f->fifo_cond);
2870	} else {
2871	if (f->finished)
2872	ret = AVERROR_EOF;
2873	else
2874	ret = AVERROR(EAGAIN);
2875	}
2876
2877	pthread_mutex_unlock(&f->fifo_lock);
2878
2879	return ret;
2880	}
2881	#endif
2882
2883	static int get_input_packet(InputFile *f, AVPacket *pkt)
2884	{
2885	if (f->rate_emu) {
2886	int i;
2887	for (i = 0; i < f->nb_streams; i++) {
2888	InputStream *ist = input_streams[f->ist_index + i];
2889	int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2890	int64_t now = av_gettime() - ist->start;
2891	if (pts > now)
2892	return AVERROR(EAGAIN);
2893	}
2894	}
2895
2896	#if HAVE_PTHREADS
2897	if (nb_input_files > 1)
2898	return get_input_packet_mt(f, pkt);
2899	#endif
2900	return av_read_frame(f->ctx, pkt);
2901	}
2902
2903	static int got_eagain(void)
2904	{
2905	int i;
2906	for (i = 0; i < nb_output_streams; i++)
2907	if (output_streams[i]->unavailable)
2908	return 1;
2909	return 0;
2910	}
2911
2912	static void reset_eagain(void)
2913	{
2914	int i;
2915	for (i = 0; i < nb_input_files; i++)
2916	input_files[i]->eagain = 0;
2917	for (i = 0; i < nb_output_streams; i++)
2918	output_streams[i]->unavailable = 0;
2919	}
2920
2921	/*
2922	* Return
2923	* - 0 -- one packet was read and processed
2924	* - AVERROR(EAGAIN) -- no packets were available for selected file,
2925	* this function should be called again
2926	* - AVERROR_EOF -- this function should not be called again
2927	*/
2928	static int process_input(int file_index)
2929	{
2930	InputFile *ifile = input_files[file_index];
2931	AVFormatContext *is;
2932	InputStream *ist;
2933	AVPacket pkt;
2934	int ret, i, j;
2935
2936	is = ifile->ctx;
2937	ret = get_input_packet(ifile, &pkt);
2938
2939	if (ret == AVERROR(EAGAIN)) {
2940	ifile->eagain = 1;
2941	return ret;
2942	}
2943	if (ret < 0) {
2944	if (ret != AVERROR_EOF) {
2945	print_error(is->filename, ret);
2946	if (exit_on_error)
2947	exit_program(1);
2948	}
2949	ifile->eof_reached = 1;
2950
2951	for (i = 0; i < ifile->nb_streams; i++) {
2952	ist = input_streams[ifile->ist_index + i];
2953	if (ist->decoding_needed)
2954	output_packet(ist, NULL);
2955
2956	/* mark all outputs that don't go through lavfi as finished */
2957	for (j = 0; j < nb_output_streams; j++) {
2958	OutputStream *ost = output_streams[j];
2959
2960	if (ost->source_index == ifile->ist_index + i &&
2961	(ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
2962	close_output_stream(ost);
2963	}
2964	}
2965
2966	return AVERROR(EAGAIN);
2967	}
2968
2969	reset_eagain();
2970
2971	if (do_pkt_dump) {
2972	av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2973	is->streams[pkt.stream_index]);
2974	}
2975	/* the following test is needed in case new streams appear
2976	dynamically in stream : we ignore them */
2977	if (pkt.stream_index >= ifile->nb_streams) {
2978	report_new_stream(file_index, &pkt);
2979	goto discard_packet;
2980	}
2981
2982	ist = input_streams[ifile->ist_index + pkt.stream_index];
2983	if (ist->discard)
2984	goto discard_packet;
2985
2986	if (debug_ts) {
2987	av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
2988	"next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
2989	ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->st->codec->codec_type),
2990	av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
2991	av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
2992	av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
2993	av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
2994	av_ts2str(input_files[ist->file_index]->ts_offset),
2995	av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
2996	}
2997
2998	if(!ist->wrap_correction_done && is->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
2999	int64_t stime, stime2;
3000	// Correcting starttime based on the enabled streams
3001	// FIXME this ideally should be done before the first use of starttime but we do not know which are the enabled streams at that point.
3002	// so we instead do it here as part of discontinuity handling
3003	if ( ist->next_dts == AV_NOPTS_VALUE
3004	&& ifile->ts_offset == -is->start_time
3005	&& (is->iformat->flags & AVFMT_TS_DISCONT)) {
3006	int64_t new_start_time = INT64_MAX;
3007	for (i=0; i<is->nb_streams; i++) {
3008	AVStream *st = is->streams[i];
3009	if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
3010	continue;
3011	new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
3012	}
3013	if (new_start_time > is->start_time) {
3014	av_log(is, AV_LOG_VERBOSE, "Correcting start time by %"PRId64"\n", new_start_time - is->start_time);
3015	ifile->ts_offset = -new_start_time;
3016	}
3017	}
3018
3019	stime = av_rescale_q(is->start_time, AV_TIME_BASE_Q, ist->st->time_base);
3020	stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
3021	ist->wrap_correction_done = 1;
3022
3023	if(stime2 > stime && pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3024	pkt.dts -= 1ULL<<ist->st->pts_wrap_bits;
3025	ist->wrap_correction_done = 0;
3026	}
3027	if(stime2 > stime && pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3028	pkt.pts -= 1ULL<<ist->st->pts_wrap_bits;
3029	ist->wrap_correction_done = 0;
3030	}
3031	}
3032
3033	if (pkt.dts != AV_NOPTS_VALUE)
3034	pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3035	if (pkt.pts != AV_NOPTS_VALUE)
3036	pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3037
3038	if (pkt.pts != AV_NOPTS_VALUE)
3039	pkt.pts *= ist->ts_scale;
3040	if (pkt.dts != AV_NOPTS_VALUE)
3041	pkt.dts *= ist->ts_scale;
3042
3043	if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts == AV_NOPTS_VALUE && !copy_ts
3044	&& (is->iformat->flags & AVFMT_TS_DISCONT) && ifile->last_ts != AV_NOPTS_VALUE) {
3045	int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3046	int64_t delta = pkt_dts - ifile->last_ts;
3047	if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3048	(delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3049	ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)){
3050	ifile->ts_offset -= delta;
3051	av_log(NULL, AV_LOG_DEBUG,
3052	"Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3053	delta, ifile->ts_offset);
3054	pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3055	if (pkt.pts != AV_NOPTS_VALUE)
3056	pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3057	}
3058	}
3059
3060	if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
3061	!copy_ts) {
3062	int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3063	int64_t delta = pkt_dts - ist->next_dts;
3064	if (is->iformat->flags & AVFMT_TS_DISCONT) {
3065	if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3066	(delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3067	ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3068	pkt_dts + AV_TIME_BASE/10 < ist->pts){
3069	ifile->ts_offset -= delta;
3070	av_log(NULL, AV_LOG_DEBUG,
3071	"timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3072	delta, ifile->ts_offset);
3073	pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3074	if (pkt.pts != AV_NOPTS_VALUE)
3075	pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3076	}
3077	} else {
3078	if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3079	(delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
3080	) {
3081	av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3082	pkt.dts = AV_NOPTS_VALUE;
3083	}
3084	if (pkt.pts != AV_NOPTS_VALUE){
3085	int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3086	delta = pkt_pts - ist->next_dts;
3087	if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3088	(delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
3089	) {
3090	av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3091	pkt.pts = AV_NOPTS_VALUE;
3092	}
3093	}
3094	}
3095	}
3096
3097	if (pkt.dts != AV_NOPTS_VALUE)
3098	ifile->last_ts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3099
3100	if (debug_ts) {
3101	av_log(NULL, AV_LOG_INFO, "demuxer+ffmpeg -> ist_index:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
3102	ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->st->codec->codec_type),
3103	av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3104	av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3105	av_ts2str(input_files[ist->file_index]->ts_offset),
3106	av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3107	}
3108
3109	sub2video_heartbeat(ist, pkt.pts);
3110
3111	ret = output_packet(ist, &pkt);
3112	if (ret < 0) {
3113	char buf[128];
3114	av_strerror(ret, buf, sizeof(buf));
3115	av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
3116	ist->file_index, ist->st->index, buf);
3117	if (exit_on_error)
3118	exit_program(1);
3119	}
3120
3121	discard_packet:
3122	av_free_packet(&pkt);
3123
3124	return 0;
3125	}
3126
3127	/**
3128	* Perform a step of transcoding for the specified filter graph.
3129	*
3130	* @param[in] graph filter graph to consider
3131	* @param[out] best_ist input stream where a frame would allow to continue
3132	* @return 0 for success, <0 for error
3133	*/
3134	static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
3135	{
3136	int i, ret;
3137	int nb_requests, nb_requests_max = 0;
3138	InputFilter *ifilter;
3139	InputStream *ist;
3140
3141	*best_ist = NULL;
3142	ret = avfilter_graph_request_oldest(graph->graph);
3143	if (ret >= 0)
3144	return reap_filters();
3145
3146	if (ret == AVERROR_EOF) {
3147	ret = reap_filters();
3148	for (i = 0; i < graph->nb_outputs; i++)
3149	close_output_stream(graph->outputs[i]->ost);
3150	return ret;
3151	}
3152	if (ret != AVERROR(EAGAIN))
3153	return ret;
3154
3155	for (i = 0; i < graph->nb_inputs; i++) {
3156	ifilter = graph->inputs[i];
3157	ist = ifilter->ist;
3158	if (input_files[ist->file_index]->eagain ||
3159	input_files[ist->file_index]->eof_reached)
3160	continue;
3161	nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter);
3162	if (nb_requests > nb_requests_max) {
3163	nb_requests_max = nb_requests;
3164	*best_ist = ist;
3165	}
3166	}
3167
3168	if (!*best_ist)
3169	for (i = 0; i < graph->nb_outputs; i++)
3170	graph->outputs[i]->ost->unavailable = 1;
3171
3172	return 0;
3173	}
3174
3175	/**
3176	* Run a single step of transcoding.
3177	*
3178	* @return 0 for success, <0 for error
3179	*/
3180	static int transcode_step(void)
3181	{
3182	OutputStream *ost;
3183	InputStream *ist;
3184	int ret;
3185
3186	ost = choose_output();
3187	if (!ost) {
3188	if (got_eagain()) {
3189	reset_eagain();
3190	av_usleep(10000);
3191	return 0;
3192	}
3193	av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
3194	return AVERROR_EOF;
3195	}
3196
3197	if (ost->filter) {
3198	if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
3199	return ret;
3200	if (!ist)
3201	return 0;
3202	} else {
3203	av_assert0(ost->source_index >= 0);
3204	ist = input_streams[ost->source_index];
3205	}
3206
3207	ret = process_input(ist->file_index);
3208	if (ret == AVERROR(EAGAIN)) {
3209	if (input_files[ist->file_index]->eagain)
3210	ost->unavailable = 1;
3211	return 0;
3212	}
3213	if (ret < 0)
3214	return ret == AVERROR_EOF ? 0 : ret;
3215
3216	return reap_filters();
3217	}
3218
3219	/*
3220	* The following code is the main loop of the file converter
3221	*/
3222	static int transcode(void)
3223	{
3224	int ret, i;
3225	AVFormatContext *os;
3226	OutputStream *ost;
3227	InputStream *ist;
3228	int64_t timer_start;
3229
3230	ret = transcode_init();
3231	if (ret < 0)
3232	goto fail;
3233
3234	if (stdin_interaction) {
3235	av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3236	}
3237
3238	timer_start = av_gettime();
3239
3240	#if HAVE_PTHREADS
3241	if ((ret = init_input_threads()) < 0)
3242	goto fail;
3243	#endif
3244
3245	while (!received_sigterm) {
3246	int64_t cur_time= av_gettime();
3247
3248	/* if 'q' pressed, exits */
3249	if (stdin_interaction)
3250	if (check_keyboard_interaction(cur_time) < 0)
3251	break;
3252
3253	/* check if there's any stream where output is still needed */
3254	if (!need_output()) {
3255	av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
3256	break;
3257	}
3258
3259	ret = transcode_step();
3260	if (ret < 0) {
3261	if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
3262	continue;
3263
3264	av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
3265	break;
3266	}
3267
3268	/* dump report by using the output first video and audio streams */
3269	print_report(0, timer_start, cur_time);
3270	}
3271	#if HAVE_PTHREADS
3272	free_input_threads();
3273	#endif
3274
3275	/* at the end of stream, we must flush the decoder buffers */
3276	for (i = 0; i < nb_input_streams; i++) {
3277	ist = input_streams[i];
3278	if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3279	output_packet(ist, NULL);
3280	}
3281	}
3282	flush_encoders();
3283
3284	term_exit();
3285
3286	/* write the trailer if needed and close file */
3287	for (i = 0; i < nb_output_files; i++) {
3288	os = output_files[i]->ctx;
3289	av_write_trailer(os);
3290	}
3291
3292	/* dump report by using the first video and audio streams */
3293	print_report(1, timer_start, av_gettime());
3294
3295	/* close each encoder */
3296	for (i = 0; i < nb_output_streams; i++) {
3297	ost = output_streams[i];
3298	if (ost->encoding_needed) {
3299	av_freep(&ost->st->codec->stats_in);
3300	avcodec_close(ost->st->codec);
3301	}
3302	}
3303
3304	/* close each decoder */
3305	for (i = 0; i < nb_input_streams; i++) {
3306	ist = input_streams[i];
3307	if (ist->decoding_needed) {
3308	avcodec_close(ist->st->codec);
3309	}
3310	}
3311
3312	/* finished ! */
3313	ret = 0;
3314
3315	fail:
3316	#if HAVE_PTHREADS
3317	free_input_threads();
3318	#endif
3319
3320	if (output_streams) {
3321	for (i = 0; i < nb_output_streams; i++) {
3322	ost = output_streams[i];
3323	if (ost) {
3324	if (ost->stream_copy)
3325	av_freep(&ost->st->codec->extradata);
3326	if (ost->logfile) {
3327	fclose(ost->logfile);
3328	ost->logfile = NULL;
3329	}
3330	av_freep(&ost->st->codec->subtitle_header);
3331	av_freep(&ost->forced_kf_pts);
3332	av_freep(&ost->apad);
3333	av_dict_free(&ost->opts);
3334	av_dict_free(&ost->swr_opts);
3335	av_dict_free(&ost->resample_opts);
3336	}
3337	}
3338	}
3339	return ret;
3340	}
3341
3342
3343	static int64_t getutime(void)
3344	{
3345	#if HAVE_GETRUSAGE
3346	struct rusage rusage;
3347
3348	getrusage(RUSAGE_SELF, &rusage);
3349	return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3350	#elif HAVE_GETPROCESSTIMES
3351	HANDLE proc;
3352	FILETIME c, e, k, u;
3353	proc = GetCurrentProcess();
3354	GetProcessTimes(proc, &c, &e, &k, &u);
3355	return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3356	#else
3357	return av_gettime();
3358	#endif
3359	}
3360
3361	static int64_t getmaxrss(void)
3362	{
3363	#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3364	struct rusage rusage;
3365	getrusage(RUSAGE_SELF, &rusage);
3366	return (int64_t)rusage.ru_maxrss * 1024;
3367	#elif HAVE_GETPROCESSMEMORYINFO
3368	HANDLE proc;
3369	PROCESS_MEMORY_COUNTERS memcounters;
3370	proc = GetCurrentProcess();
3371	memcounters.cb = sizeof(memcounters);
3372	GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3373	return memcounters.PeakPagefileUsage;
3374	#else
3375	return 0;
3376	#endif
3377	}
3378
3379	static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
3380	{
3381	}
3382
3383	int main(int argc, char **argv)
3384	{
3385	int ret;
3386	int64_t ti;
3387
3388	register_exit(ffmpeg_cleanup);
3389
3390	setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
3391
3392	av_log_set_flags(AV_LOG_SKIP_REPEATED);
3393	parse_loglevel(argc, argv, options);
3394
3395	if(argc>1 && !strcmp(argv[1], "-d")){
3396	run_as_daemon=1;
3397	av_log_set_callback(log_callback_null);
3398	argc--;
3399	argv++;
3400	}
3401
3402	avcodec_register_all();
3403	#if CONFIG_AVDEVICE
3404	avdevice_register_all();
3405	#endif
3406	avfilter_register_all();
3407	av_register_all();
3408	avformat_network_init();
3409
3410	show_banner(argc, argv, options);
3411
3412	term_init();
3413
3414	/* parse options and open all input/output files */
3415	ret = ffmpeg_parse_options(argc, argv);
3416	if (ret < 0)
3417	exit_program(1);
3418
3419	if (nb_output_files <= 0 && nb_input_files == 0) {
3420	show_usage();
3421	av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3422	exit_program(1);
3423	}
3424
3425	/* file converter / grab */
3426	if (nb_output_files <= 0) {
3427	av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
3428	exit_program(1);
3429	}
3430
3431	// if (nb_input_files == 0) {
3432	// av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
3433	// exit_program(1);
3434	// }
3435
3436	current_time = ti = getutime();
3437	if (transcode() < 0)
3438	exit_program(1);
3439	ti = getutime() - ti;
3440	if (do_benchmark) {
3441	printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3442	}
3443	av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
3444	decode_error_stat[0], decode_error_stat[1]);
3445	if ((decode_error_stat[0] + decode_error_stat[1]) * max_error_rate < decode_error_stat[1])
3446	exit_program(69);
3447
3448	exit_program(received_nb_signals ? 255 : 0);
3449	return 0;
3450	}
3451