2001-07-22 17:37:44 +03:00
/*
2003-06-07 21:34:02 +03:00
* Copyright ( c ) 2000 - 2003 Fabrice Bellard
2001-07-22 17:37:44 +03:00
*
2006-10-07 18:30:46 +03:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-26 01:25:13 +03:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 18:30:46 +03:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 17:37:44 +03:00
*
2006-10-07 18:30:46 +03:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 17:37:44 +03:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-26 01:25:13 +03:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 17:37:44 +03:00
*
2002-05-26 01:25:13 +03:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 18:30:46 +03:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-13 00:43:26 +02:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 17:37:44 +03:00
*/
2007-06-10 17:34:56 +03:00
2011-12-22 12:23:22 +03:00
/**
* @ file
* multimedia converter based on the FFmpeg libraries
*/
2007-07-02 10:43:23 +03:00
# include "config.h"
# include <ctype.h>
# include <string.h>
# include <math.h>
# include <stdlib.h>
# include <errno.h>
2004-05-12 19:51:39 +03:00
# include <limits.h>
2012-06-22 23:34:02 +03:00
# if HAVE_ISATTY
2008-08-15 01:01:59 +03:00
# include <unistd.h>
2012-06-22 23:34:02 +03:00
# endif
2008-05-09 14:56:36 +03:00
# include "libavformat/avformat.h"
# include "libavdevice/avdevice.h"
# include "libswscale/swscale.h"
2012-05-19 13:05:02 +03:00
# include "libswresample/swresample.h"
2011-02-03 15:58:59 +02:00
# include "libavutil/opt.h"
2011-02-07 15:37:08 +02:00
# include "libavutil/audioconvert.h"
# include "libavutil/parseutils.h"
# include "libavutil/samplefmt.h"
2010-07-01 21:49:44 +03:00
# include "libavutil/colorspace.h"
2008-05-09 14:56:36 +03:00
# include "libavutil/fifo.h"
2010-11-01 00:48:44 +02:00
# include "libavutil/intreadwrite.h"
2011-05-22 13:46:29 +03:00
# include "libavutil/dict.h"
2011-06-04 14:58:23 +03:00
# include "libavutil/mathematics.h"
2010-01-30 21:10:26 +02:00
# include "libavutil/pixdesc.h"
2008-05-09 14:56:36 +03:00
# include "libavutil/avstring.h"
2010-03-09 17:10:23 +02:00
# include "libavutil/libm.h"
2011-12-26 05:35:54 +03:00
# include "libavutil/imgutils.h"
2012-01-20 19:06:26 +03:00
# include "libavutil/timestamp.h"
2012-05-17 20:31:35 +03:00
# include "libavutil/bprint.h"
2012-06-21 22:31:44 +03:00
# include "libavutil/time.h"
2008-05-09 14:56:36 +03:00
# include "libavformat/os_support.h"
2001-08-16 01:29:44 +03:00
2011-04-09 04:09:49 +03:00
# include "libavformat/ffm.h" // not public API
2011-05-01 15:47:05 +03:00
# include "libavfilter / avcodec.h"
2010-05-07 12:43:21 +03:00
# include "libavfilter / avfilter.h"
# include "libavfilter / avfiltergraph.h"
2011-12-26 05:35:54 +03:00
# include "libavfilter / buffersrc.h"
2012-05-19 13:05:02 +03:00
# include "libavfilter / buffersink.h"
2010-05-07 12:43:21 +03:00
2009-01-14 01:44:16 +02:00
# if HAVE_SYS_RESOURCE_H
2008-05-11 14:17:23 +03:00
# include <sys/types.h>
2008-05-08 03:44:42 +03:00
# include <sys/resource.h>
2009-01-14 01:44:16 +02:00
# elif HAVE_GETPROCESSTIMES
2007-07-13 19:11:36 +03:00
# include <windows.h>
# endif
2010-02-23 00:21:58 +02:00
# if HAVE_GETPROCESSMEMORYINFO
# include <windows.h>
# include <psapi.h>
# endif
2007-07-13 19:11:36 +03:00
2009-01-14 01:44:16 +02:00
# if HAVE_SYS_SELECT_H
2008-09-26 05:13:38 +03:00
# include <sys/select.h>
# endif
2011-03-30 21:58:13 +03:00
# if HAVE_TERMIOS_H
# include <fcntl.h>
# include <sys/ioctl.h>
# include <sys/time.h>
# include <termios.h>
# elif HAVE_KBHIT
2007-07-11 17:07:55 +03:00
# include <conio.h>
2001-08-14 00:43:02 +03:00
# endif
2012-06-10 22:34:15 +03:00
2012-06-02 08:26:41 +03:00
# if HAVE_PTHREADS
# include <pthread.h>
# endif
2002-05-26 01:25:13 +03:00
# include <time.h>
2001-07-22 17:37:44 +03:00
2012-08-09 01:26:38 +03:00
# include "ffmpeg.h"
2003-06-07 21:34:02 +03:00
# include "cmdutils.h"
2010-10-01 16:55:13 +03:00
# include "libavutil/avassert.h"
2004-09-22 20:50:53 +03:00
2011-04-23 16:19:17 +03:00
const char program_name [ ] = " ffmpeg " ;
2008-05-29 11:48:51 +03:00
const int program_birth_year = 2000 ;
2007-09-27 09:38:40 +03:00
2007-09-06 23:11:02 +03:00
static FILE * vstats_file ;
2002-10-10 20:09:01 +03:00
2012-08-09 01:26:38 +03:00
static void do_video_stats ( AVFormatContext * os , OutputStream * ost , int frame_size ) ;
static int64_t getutime ( void ) ;
2003-01-23 00:40:52 +02:00
2011-04-22 19:49:44 +03:00
static int run_as_daemon = 0 ;
2004-04-15 16:57:55 +03:00
static int64_t video_size = 0 ;
static int64_t audio_size = 0 ;
2012-06-17 20:50:36 +03:00
static int64_t subtitle_size = 0 ;
2004-04-15 16:57:55 +03:00
static int64_t extra_size = 0 ;
2004-06-12 01:03:16 +03:00
static int nb_frames_dup = 0 ;
static int nb_frames_drop = 0 ;
2003-08-29 23:51:10 +03:00
2012-04-11 20:26:09 +03:00
static int current_time ;
2012-08-09 01:26:38 +03:00
AVIOContext * progress_avio = NULL ;
2005-09-11 14:10:25 +03:00
2012-06-22 23:15:24 +03:00
static uint8_t * subtitle_out ;
2012-06-11 16:34:12 +03:00
# if HAVE_PTHREADS
2012-06-02 08:26:41 +03:00
/* signal to input threads that they should exit; set by the main thread */
static int transcoding_finished ;
# endif
2008-12-26 21:25:24 +02:00
# define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
2001-07-22 17:37:44 +03:00
2012-08-01 19:23:12 +03:00
InputStream * * input_streams = NULL ;
int nb_input_streams = 0 ;
InputFile * * input_files = NULL ;
int nb_input_files = 0 ;
2012-06-02 08:26:41 +03:00
2012-08-01 19:23:12 +03:00
OutputStream * * output_streams = NULL ;
int nb_output_streams = 0 ;
OutputFile * * output_files = NULL ;
int nb_output_files = 0 ;
2001-07-22 17:37:44 +03:00
2012-08-01 19:23:12 +03:00
FilterGraph * * filtergraphs ;
int nb_filtergraphs ;
2001-07-22 17:37:44 +03:00
2011-03-30 21:58:13 +03:00
# if HAVE_TERMIOS_H
/* init terminal so that we can grab keys */
static struct termios oldtty ;
2012-01-17 02:10:17 +03:00
static int restore_tty ;
2011-03-30 21:58:13 +03:00
# endif
2012-04-11 20:26:09 +03:00
2012-07-26 20:29:27 +03:00
/* sub2video hack:
Convert subtitles to video with alpha to insert them in filter graphs .
This is a temporary solution until libavfilter gets real subtitles support .
*/
static void sub2video_copy_rect ( uint8_t * dst , int dst_linesize , int w , int h ,
AVSubtitleRect * r )
{
uint32_t * pal , * dst2 ;
uint8_t * src , * src2 ;
int x , y ;
if ( r - > type ! = SUBTITLE_BITMAP ) {
av_log ( NULL , AV_LOG_WARNING , " sub2video: non-bitmap subtitle \n " ) ;
return ;
}
if ( r - > x < 0 | | r - > x + r - > w > w | | r - > y < 0 | | r - > y + r - > h > h ) {
av_log ( NULL , AV_LOG_WARNING , " sub2video: rectangle overflowing \n " ) ;
return ;
}
dst + = r - > y * dst_linesize + r - > x * 4 ;
src = r - > pict . data [ 0 ] ;
pal = ( uint32_t * ) r - > pict . data [ 1 ] ;
for ( y = 0 ; y < r - > h ; y + + ) {
dst2 = ( uint32_t * ) dst ;
src2 = src ;
for ( x = 0 ; x < r - > w ; x + + )
* ( dst2 + + ) = pal [ * ( src2 + + ) ] ;
dst + = dst_linesize ;
src + = r - > pict . linesize [ 0 ] ;
}
}
static void sub2video_push_ref ( InputStream * ist , int64_t pts )
{
AVFilterBufferRef * ref = ist - > sub2video . ref ;
int i ;
ist - > sub2video . last_pts = ref - > pts = pts ;
for ( i = 0 ; i < ist - > nb_filters ; i + + )
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter ,
avfilter_ref_buffer ( ref , ~ 0 ) ,
AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
AV_BUFFERSRC_FLAG_NO_COPY ) ;
}
static void sub2video_update ( InputStream * ist , AVSubtitle * sub , int64_t pts )
{
int w = ist - > sub2video . w , h = ist - > sub2video . h ;
AVFilterBufferRef * ref = ist - > sub2video . ref ;
int8_t * dst ;
int dst_linesize ;
int i ;
if ( ! ref )
return ;
dst = ref - > data [ 0 ] ;
dst_linesize = ref - > linesize [ 0 ] ;
memset ( dst , 0 , h * dst_linesize ) ;
for ( i = 0 ; i < sub - > num_rects ; i + + )
sub2video_copy_rect ( dst , dst_linesize , w , h , sub - > rects [ i ] ) ;
sub2video_push_ref ( ist , pts ) ;
}
static void sub2video_heartbeat ( InputStream * ist , int64_t pts )
{
InputFile * infile = input_files [ ist - > file_index ] ;
int i , j , nb_reqs ;
int64_t pts2 ;
/* When a frame is read from a file, examine all sub2video streams in
the same file and send the sub2video frame again . Otherwise , decoded
video frames could be accumulating in the filter graph while a filter
( possibly overlay ) is desperately waiting for a subtitle frame . */
for ( i = 0 ; i < infile - > nb_streams ; i + + ) {
InputStream * ist2 = input_streams [ infile - > ist_index + i ] ;
if ( ! ist2 - > sub2video . ref )
continue ;
/* subtitles seem to be usually muxed ahead of other streams;
if not , substracting a larger time here is necessary */
pts2 = av_rescale_q ( pts , ist - > st - > time_base , ist2 - > st - > time_base ) - 1 ;
/* do not send the heartbeat frame if the subtitle is already ahead */
if ( pts2 < = ist2 - > sub2video . last_pts )
continue ;
for ( j = 0 , nb_reqs = 0 ; j < ist2 - > nb_filters ; j + + )
nb_reqs + = av_buffersrc_get_nb_failed_requests ( ist2 - > filters [ j ] - > filter ) ;
if ( nb_reqs )
sub2video_push_ref ( ist2 , pts2 ) ;
}
}
static void sub2video_flush ( InputStream * ist )
{
int i ;
for ( i = 0 ; i < ist - > nb_filters ; i + + )
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter , NULL , 0 ) ;
}
/* end of sub2video hack */
2012-08-09 01:26:38 +03:00
void term_exit ( void )
2011-09-05 03:04:27 +03:00
{
2012-08-09 01:26:38 +03:00
av_log ( NULL , AV_LOG_QUIET , " %s " , " " ) ;
# if HAVE_TERMIOS_H
if ( restore_tty )
tcsetattr ( 0 , TCSANOW , & oldtty ) ;
# endif
2011-07-27 21:56:59 +03:00
}
2011-09-05 03:04:27 +03:00
2011-07-27 21:56:59 +03:00
static volatile int received_sigterm = 0 ;
2012-08-09 05:12:50 +03:00
static volatile int received_nb_signals = 0 ;
2011-09-05 03:04:27 +03:00
2012-08-09 05:12:50 +03:00
static void
sigterm_handler ( int sig )
2011-07-27 21:56:59 +03:00
{
received_sigterm = sig ;
received_nb_signals + + ;
term_exit ( ) ;
2012-08-09 01:26:38 +03:00
if ( received_nb_signals > 3 )
exit ( 123 ) ;
2011-09-05 03:04:27 +03:00
}
2012-08-09 01:26:38 +03:00
void term_init ( void )
2010-05-07 12:43:21 +03:00
{
2012-08-09 01:26:38 +03:00
# if HAVE_TERMIOS_H
if ( ! run_as_daemon ) {
struct termios tty ;
int istty = 1 ;
# if HAVE_ISATTY
istty = isatty ( 0 ) & & isatty ( 2 ) ;
# endif
if ( istty & & tcgetattr ( 0 , & tty ) = = 0 ) {
oldtty = tty ;
restore_tty = 1 ;
atexit ( term_exit ) ;
tty . c_iflag & = ~ ( IGNBRK | BRKINT | PARMRK | ISTRIP
| INLCR | IGNCR | ICRNL | IXON ) ;
tty . c_oflag | = OPOST ;
tty . c_lflag & = ~ ( ECHO | ECHONL | ICANON | IEXTEN ) ;
tty . c_cflag & = ~ ( CSIZE | PARENB ) ;
tty . c_cflag | = CS8 ;
tty . c_cc [ VMIN ] = 1 ;
tty . c_cc [ VTIME ] = 0 ;
tcsetattr ( 0 , TCSANOW , & tty ) ;
2012-04-17 05:01:17 +03:00
}
2012-08-09 01:26:38 +03:00
signal ( SIGQUIT , sigterm_handler ) ; /* Quit (POSIX). */
2012-04-17 05:01:17 +03:00
}
2012-08-09 01:26:38 +03:00
# endif
avformat_network_deinit ( ) ;
2011-12-29 23:28:29 +03:00
signal ( SIGINT , sigterm_handler ) ; /* Interrupt (ANSI). */
2011-07-27 21:56:59 +03:00
signal ( SIGTERM , sigterm_handler ) ; /* Termination (ANSI). */
# ifdef SIGXCPU
signal ( SIGXCPU , sigterm_handler ) ;
# endif
2012-04-17 05:01:17 +03:00
}
2012-08-09 01:26:38 +03:00
/* read a key without blocking */
static int read_key ( void )
2012-03-23 17:46:30 +03:00
{
2012-08-09 01:26:38 +03:00
unsigned char ch ;
# if HAVE_TERMIOS_H
int n = 1 ;
struct timeval tv ;
fd_set rfds ;
2012-04-27 07:56:56 +03:00
2012-08-09 01:26:38 +03:00
FD_ZERO ( & rfds ) ;
FD_SET ( 0 , & rfds ) ;
tv . tv_sec = 0 ;
tv . tv_usec = 0 ;
n = select ( 1 , & rfds , NULL , NULL , & tv ) ;
if ( n > 0 ) {
n = read ( 0 , & ch , 1 ) ;
if ( n = = 1 )
return ch ;
return n ;
}
# elif HAVE_KBHIT
# if HAVE_PEEKNAMEDPIPE
static int is_pipe ;
static HANDLE input_handle ;
DWORD dw , nchars ;
if ( ! input_handle ) {
input_handle = GetStdHandle ( STD_INPUT_HANDLE ) ;
is_pipe = ! GetConsoleMode ( input_handle , & dw ) ;
}
2012-05-10 03:14:44 +03:00
2012-08-09 01:26:38 +03:00
if ( stdin - > _cnt > 0 ) {
read ( 0 , & ch , 1 ) ;
return ch ;
}
if ( is_pipe ) {
/* When running under a GUI, you will end here. */
if ( ! PeekNamedPipe ( input_handle , NULL , 0 , NULL , & nchars , NULL ) )
return - 1 ;
//Read it
if ( nchars ! = 0 ) {
read ( 0 , & ch , 1 ) ;
return ch ;
} else {
return - 1 ;
2012-05-05 19:22:46 +03:00
}
2012-08-09 01:26:38 +03:00
}
# endif
if ( kbhit ( ) )
return ( getch ( ) ) ;
# endif
return - 1 ;
2012-03-23 17:46:30 +03:00
}
2011-11-07 00:22:04 +03:00
static int decode_interrupt_cb ( void * ctx )
2011-07-27 21:56:59 +03:00
{
return received_nb_signals > 1 ;
2012-05-05 19:22:46 +03:00
}
2012-08-01 19:23:12 +03:00
const AVIOInterruptCB int_cb = { decode_interrupt_cb , NULL } ;
2012-05-05 19:22:46 +03:00
2012-08-09 01:26:38 +03:00
void av_noreturn exit_program ( int ret )
2011-07-27 21:56:59 +03:00
{
2012-03-29 09:51:17 +03:00
int i , j ;
2012-05-05 19:22:46 +03:00
2012-03-29 09:51:17 +03:00
for ( i = 0 ; i < nb_filtergraphs ; i + + ) {
avfilter_graph_free ( & filtergraphs [ i ] - > graph ) ;
2012-05-26 14:31:54 +03:00
for ( j = 0 ; j < filtergraphs [ i ] - > nb_inputs ; j + + ) {
av_freep ( & filtergraphs [ i ] - > inputs [ j ] - > name ) ;
2012-03-29 09:51:17 +03:00
av_freep ( & filtergraphs [ i ] - > inputs [ j ] ) ;
2012-05-26 14:31:54 +03:00
}
2012-03-29 09:51:17 +03:00
av_freep ( & filtergraphs [ i ] - > inputs ) ;
2012-05-26 14:31:54 +03:00
for ( j = 0 ; j < filtergraphs [ i ] - > nb_outputs ; j + + ) {
av_freep ( & filtergraphs [ i ] - > outputs [ j ] - > name ) ;
2012-03-29 09:51:17 +03:00
av_freep ( & filtergraphs [ i ] - > outputs [ j ] ) ;
2012-05-26 14:31:54 +03:00
}
2012-03-29 09:51:17 +03:00
av_freep ( & filtergraphs [ i ] - > outputs ) ;
av_freep ( & filtergraphs [ i ] ) ;
}
av_freep ( & filtergraphs ) ;
2012-05-05 19:22:46 +03:00
2012-08-09 01:26:38 +03:00
av_freep ( & subtitle_out ) ;
2012-05-05 19:22:46 +03:00
2011-07-27 21:56:59 +03:00
/* close files */
2011-12-29 23:28:29 +03:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 16:28:30 +03:00
AVFormatContext * s = output_files [ i ] - > ctx ;
2011-07-27 21:56:59 +03:00
if ( ! ( s - > oformat - > flags & AVFMT_NOFILE ) & & s - > pb )
avio_close ( s - > pb ) ;
avformat_free_context ( s ) ;
2012-04-15 16:28:30 +03:00
av_dict_free ( & output_files [ i ] - > opts ) ;
av_freep ( & output_files [ i ] ) ;
2011-07-27 21:56:59 +03:00
}
2012-01-01 19:56:28 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
AVBitStreamFilterContext * bsfc = output_streams [ i ] - > bitstream_filters ;
2012-01-01 19:56:28 +03:00
while ( bsfc ) {
AVBitStreamFilterContext * next = bsfc - > next ;
av_bitstream_filter_close ( bsfc ) ;
bsfc = next ;
}
2012-04-15 16:28:30 +03:00
output_streams [ i ] - > bitstream_filters = NULL ;
2012-03-29 09:51:17 +03:00
2012-06-22 15:36:27 +03:00
av_freep ( & output_streams [ i ] - > forced_keyframes ) ;
2012-08-09 01:26:38 +03:00
av_freep ( & output_streams [ i ] - > avfilter ) ;
2012-08-09 05:12:50 +03:00
av_freep ( & output_streams [ i ] - > filtered_frame ) ;
2012-04-15 16:28:30 +03:00
av_freep ( & output_streams [ i ] ) ;
2012-01-01 19:56:28 +03:00
}
2011-12-29 23:28:29 +03:00
for ( i = 0 ; i < nb_input_files ; i + + ) {
2012-04-15 16:28:30 +03:00
avformat_close_input ( & input_files [ i ] - > ctx ) ;
av_freep ( & input_files [ i ] ) ;
2011-07-27 21:56:59 +03:00
}
2011-12-05 19:49:38 +03:00
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
av_freep ( & input_streams [ i ] - > decoded_frame ) ;
av_dict_free ( & input_streams [ i ] - > opts ) ;
2012-05-30 08:32:43 +03:00
free_buffer_pool ( & input_streams [ i ] - > buffer_pool ) ;
2012-08-09 01:26:38 +03:00
avfilter_unref_bufferp ( & input_streams [ i ] - > sub2video . ref ) ;
2012-03-29 09:51:17 +03:00
av_freep ( & input_streams [ i ] - > filters ) ;
2012-04-15 16:28:30 +03:00
av_freep ( & input_streams [ i ] ) ;
2011-12-05 19:49:38 +03:00
}
2012-03-29 09:51:17 +03:00
2011-07-27 21:56:59 +03:00
if ( vstats_file )
fclose ( vstats_file ) ;
av_free ( vstats_filename ) ;
2012-03-29 09:51:17 +03:00
2011-07-27 21:56:59 +03:00
av_freep ( & input_streams ) ;
av_freep ( & input_files ) ;
2011-08-17 11:21:37 +03:00
av_freep ( & output_streams ) ;
2011-08-17 10:56:08 +03:00
av_freep ( & output_files ) ;
2012-05-26 13:47:47 +03:00
2011-07-27 21:56:59 +03:00
uninit_opts ( ) ;
2012-03-29 09:51:17 +03:00
2011-07-27 21:56:59 +03:00
avfilter_uninit ( ) ;
2011-11-06 03:47:48 +03:00
avformat_network_deinit ( ) ;
2012-03-29 09:51:17 +03:00
2011-07-27 21:56:59 +03:00
if ( received_sigterm ) {
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_INFO , " Received signal %d: terminating. \n " ,
( int ) received_sigterm ) ;
2011-07-27 21:56:59 +03:00
exit ( 255 ) ;
}
2012-03-29 09:51:17 +03:00
2011-12-08 04:17:18 +03:00
exit ( ret ) ;
2012-03-29 09:51:17 +03:00
}
2012-08-01 19:23:12 +03:00
void assert_avoptions ( AVDictionary * m )
2012-04-01 16:08:33 +03:00
{
2011-07-27 21:56:59 +03:00
AVDictionaryEntry * t ;
if ( ( t = av_dict_get ( m , " " , NULL , AV_DICT_IGNORE_SUFFIX ) ) ) {
2011-09-12 22:51:02 +03:00
av_log ( NULL , AV_LOG_FATAL , " Option %s not found. \n " , t - > key ) ;
2012-04-01 16:08:33 +03:00
exit_program ( 1 ) ;
}
2011-07-27 21:56:59 +03:00
}
2012-04-01 16:08:33 +03:00
2011-07-27 21:56:59 +03:00
static void assert_codec_experimental ( AVCodecContext * c , int encoder )
{
const char * codec_string = encoder ? " encoder " : " decoder " ;
AVCodec * codec ;
if ( c - > codec - > capabilities & CODEC_CAP_EXPERIMENTAL & &
c - > strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL ) {
2011-09-12 22:51:02 +03:00
av_log ( NULL , AV_LOG_FATAL , " %s '%s' is experimental and might produce bad "
2011-07-27 21:56:59 +03:00
" results. \n Add '-strict experimental' if you want to use it. \n " ,
codec_string , c - > codec - > name ) ;
codec = encoder ? avcodec_find_encoder ( c - > codec - > id ) : avcodec_find_decoder ( c - > codec - > id ) ;
if ( ! ( codec - > capabilities & CODEC_CAP_EXPERIMENTAL ) )
2011-09-12 22:51:02 +03:00
av_log ( NULL , AV_LOG_FATAL , " Or use the non experimental %s '%s'. \n " ,
2011-07-27 21:56:59 +03:00
codec_string , codec - > name ) ;
exit_program ( 1 ) ;
}
}
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
static void update_benchmark ( const char * fmt , . . . )
2011-07-27 21:56:59 +03:00
{
2012-08-09 01:26:38 +03:00
if ( do_benchmark_all ) {
int64_t t = getutime ( ) ;
va_list va ;
char buf [ 1024 ] ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
if ( fmt ) {
va_start ( va , fmt ) ;
vsnprintf ( buf , sizeof ( buf ) , fmt , va ) ;
va_end ( va ) ;
printf ( " bench: %8 " PRIu64 " %s \n " , t - current_time , buf ) ;
2012-04-01 16:08:33 +03:00
}
2012-08-09 01:26:38 +03:00
current_time = t ;
2012-04-01 16:08:33 +03:00
}
}
2012-01-01 23:51:26 +03:00
static void write_frame ( AVFormatContext * s , AVPacket * pkt , OutputStream * ost )
2012-04-01 16:08:33 +03:00
{
2012-01-01 23:51:26 +03:00
AVBitStreamFilterContext * bsfc = ost - > bitstream_filters ;
AVCodecContext * avctx = ost - > st - > codec ;
2012-04-01 16:08:33 +03:00
int ret ;
2012-08-09 01:26:38 +03:00
if ( ( avctx - > codec_type = = AVMEDIA_TYPE_VIDEO & & video_sync_method = = VSYNC_DROP ) | |
( avctx - > codec_type = = AVMEDIA_TYPE_AUDIO & & audio_sync_method < 0 ) )
pkt - > pts = pkt - > dts = AV_NOPTS_VALUE ;
2012-04-27 07:56:56 +03:00
2012-08-09 01:26:38 +03:00
if ( avctx - > codec_type = = AVMEDIA_TYPE_AUDIO & & pkt - > dts ! = AV_NOPTS_VALUE ) {
int64_t max = ost - > st - > cur_dts + ! ( s - > oformat - > flags & AVFMT_TS_NONSTRICT ) ;
if ( ost - > st - > cur_dts & & ost - > st - > cur_dts ! = AV_NOPTS_VALUE & & max > pkt - > dts ) {
av_log ( s , max - pkt - > dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG , " Audio timestamp % " PRId64 " < % " PRId64 " invalid, cliping \n " , pkt - > dts , max ) ;
pkt - > pts = pkt - > dts = max ;
}
2012-04-01 16:08:33 +03:00
}
2012-01-02 11:22:41 +03:00
/*
* Audio encoders may split the packets - - # frames in ! = # packets out .
* But there is no reordering , so we can limit the number of output packets
* by simply dropping them here .
* Counting encoded video frames needs to be done separately because of
* reordering , see do_video_out ( )
*/
if ( ! ( avctx - > codec_type = = AVMEDIA_TYPE_VIDEO & & avctx - > codec ) ) {
2012-03-20 22:36:28 +03:00
if ( ost - > frame_number > = ost - > max_frames ) {
av_free_packet ( pkt ) ;
2012-01-02 11:22:41 +03:00
return ;
2012-03-20 22:36:28 +03:00
}
2012-01-02 11:22:41 +03:00
ost - > frame_number + + ;
2012-04-27 07:56:56 +03:00
}
2011-12-29 23:28:29 +03:00
while ( bsfc ) {
AVPacket new_pkt = * pkt ;
int a = av_bitstream_filter_filter ( bsfc , avctx , NULL ,
& new_pkt . data , & new_pkt . size ,
pkt - > data , pkt - > size ,
pkt - > flags & AV_PKT_FLAG_KEY ) ;
2012-08-10 05:33:42 +03:00
if ( a = = 0 & & new_pkt . data ! = pkt - > data & & new_pkt . destruct ) {
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
if ( t ) {
memcpy ( t , new_pkt . data , new_pkt . size ) ;
memset ( t + new_pkt . size , 0 , FF_INPUT_BUFFER_PADDING_SIZE ) ;
new_pkt . data = t ;
a = 1 ;
} else
a = AVERROR ( ENOMEM ) ;
}
2011-12-29 23:28:29 +03:00
if ( a > 0 ) {
2011-07-27 21:56:59 +03:00
av_free_packet ( pkt ) ;
2011-12-29 23:28:29 +03:00
new_pkt . destruct = av_destruct_packet ;
} else if ( a < 0 ) {
2012-08-09 01:26:38 +03:00
av_log ( NULL , AV_LOG_ERROR , " Failed to open bitstream filter %s for stream %d with codec %s " ,
2011-09-13 08:31:21 +03:00
bsfc - > filter - > name , pkt - > stream_index ,
avctx - > codec ? avctx - > codec - > name : " copy " ) ;
2011-07-27 21:56:59 +03:00
print_error ( " " , a ) ;
if ( exit_on_error )
exit_program ( 1 ) ;
}
2011-12-29 23:28:29 +03:00
* pkt = new_pkt ;
2012-05-26 13:47:47 +03:00
2011-12-29 23:28:29 +03:00
bsfc = bsfc - > next ;
2012-05-26 13:47:47 +03:00
}
2012-02-01 12:23:28 +03:00
pkt - > stream_index = ost - > index ;
2011-12-29 23:28:29 +03:00
ret = av_interleaved_write_frame ( s , pkt ) ;
if ( ret < 0 ) {
2011-07-27 21:56:59 +03:00
print_error ( " av_interleaved_write_frame() " , ret ) ;
exit_program ( 1 ) ;
}
2012-04-01 16:08:33 +03:00
}
2012-02-05 16:32:10 +03:00
static int check_recording_time ( OutputStream * ost )
2012-05-17 14:22:17 +03:00
{
2012-04-15 16:28:30 +03:00
OutputFile * of = output_files [ ost - > file_index ] ;
2012-05-17 14:22:17 +03:00
2012-02-05 16:32:10 +03:00
if ( of - > recording_time ! = INT64_MAX & &
av_compare_ts ( ost - > sync_opts - ost - > first_pts , ost - > st - > codec - > time_base , of - > recording_time ,
AV_TIME_BASE_Q ) > = 0 ) {
2012-08-08 13:04:53 +03:00
ost - > finished = 1 ;
2012-02-05 16:32:10 +03:00
return 0 ;
2012-06-01 19:42:12 +03:00
}
2012-02-05 16:32:10 +03:00
return 1 ;
}
2012-06-01 19:42:12 +03:00
2012-05-05 19:22:46 +03:00
static void do_audio_out ( AVFormatContext * s , OutputStream * ost ,
AVFrame * frame )
2011-12-31 17:36:25 +03:00
{
AVCodecContext * enc = ost - > st - > codec ;
AVPacket pkt ;
2012-05-05 19:22:46 +03:00
int got_packet = 0 ;
2012-05-17 14:22:17 +03:00
2011-12-31 17:36:25 +03:00
av_init_packet ( & pkt ) ;
pkt . data = NULL ;
pkt . size = 0 ;
2012-05-17 14:22:17 +03:00
2012-05-05 19:22:46 +03:00
if ( ! check_recording_time ( ost ) )
return ;
2012-05-17 14:22:17 +03:00
2012-05-05 19:22:46 +03:00
if ( frame - > pts = = AV_NOPTS_VALUE | | audio_sync_method < 0 )
2012-03-01 21:02:49 +03:00
frame - > pts = ost - > sync_opts ;
2012-05-05 19:22:46 +03:00
ost - > sync_opts = frame - > pts + frame - > nb_samples ;
2012-05-30 04:32:32 +03:00
2012-08-09 01:26:38 +03:00
av_assert0 ( pkt . size | | ! pkt . data ) ;
update_benchmark ( NULL ) ;
2011-12-31 17:36:25 +03:00
if ( avcodec_encode_audio2 ( enc , & pkt , frame , & got_packet ) < 0 ) {
2012-08-09 01:26:38 +03:00
av_log ( NULL , AV_LOG_FATAL , " Audio encoding failed (avcodec_encode_audio2) \n " ) ;
2011-12-31 17:36:25 +03:00
exit_program ( 1 ) ;
2012-05-17 14:22:17 +03:00
}
2012-08-09 01:26:38 +03:00
update_benchmark ( " encode_audio %d.%d " , ost - > file_index , ost - > index ) ;
2012-05-17 14:22:17 +03:00
2011-12-31 17:36:25 +03:00
if ( got_packet ) {
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts = av_rescale_q ( pkt . pts , enc - > time_base , ost - > st - > time_base ) ;
2012-02-07 03:08:32 +03:00
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts = av_rescale_q ( pkt . dts , enc - > time_base , ost - > st - > time_base ) ;
2011-12-31 17:36:25 +03:00
if ( pkt . duration > 0 )
pkt . duration = av_rescale_q ( pkt . duration , enc - > time_base , ost - > st - > time_base ) ;
2012-05-17 14:22:17 +03:00
2012-08-09 01:26:38 +03:00
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " encoder -> type:audio "
" pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s \n " ,
av_ts2str ( pkt . pts ) , av_ts2timestr ( pkt . pts , & ost - > st - > time_base ) ,
av_ts2str ( pkt . dts ) , av_ts2timestr ( pkt . dts , & ost - > st - > time_base ) ) ;
}
2012-05-26 14:31:54 +03:00
2011-12-31 17:36:25 +03:00
write_frame ( s , & pkt , ost ) ;
2012-05-26 14:31:54 +03:00
2011-12-31 17:36:25 +03:00
audio_size + = pkt . size ;
2012-08-09 01:26:38 +03:00
av_free_packet ( & pkt ) ;
2012-05-17 14:22:17 +03:00
}
}
2011-07-27 21:56:59 +03:00
static void pre_process_video_frame ( InputStream * ist , AVPicture * picture , void * * bufp )
2012-05-26 12:18:21 +03:00
{
2011-07-27 21:56:59 +03:00
AVCodecContext * dec ;
AVPicture * picture2 ;
AVPicture picture_tmp ;
uint8_t * buf = 0 ;
2012-07-26 20:29:27 +03:00
2011-07-27 21:56:59 +03:00
dec = ist - > st - > codec ;
2012-05-26 17:52:58 +03:00
2011-07-27 21:56:59 +03:00
/* deinterlace : must be done before any resize */
if ( do_deinterlace ) {
int size ;
2012-05-26 17:52:58 +03:00
2011-07-27 21:56:59 +03:00
/* create temporary picture */
size = avpicture_get_size ( dec - > pix_fmt , dec - > width , dec - > height ) ;
2011-12-29 23:28:29 +03:00
buf = av_malloc ( size ) ;
2011-07-27 21:56:59 +03:00
if ( ! buf )
return ;
2012-05-26 17:52:58 +03:00
2011-07-27 21:56:59 +03:00
picture2 = & picture_tmp ;
avpicture_fill ( picture2 , buf , dec - > pix_fmt , dec - > width , dec - > height ) ;
2012-05-26 17:52:58 +03:00
2011-12-29 23:28:29 +03:00
if ( avpicture_deinterlace ( picture2 , picture ,
2011-07-27 21:56:59 +03:00
dec - > pix_fmt , dec - > width , dec - > height ) < 0 ) {
/* if error, do not deinterlace */
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_WARNING , " Deinterlacing failed \n " ) ;
2011-07-27 21:56:59 +03:00
av_free ( buf ) ;
buf = NULL ;
picture2 = picture ;
}
} else {
picture2 = picture ;
2012-05-26 17:52:58 +03:00
}
2011-07-27 21:56:59 +03:00
if ( picture ! = picture2 )
* picture = * picture2 ;
* bufp = buf ;
2012-05-26 12:18:21 +03:00
}
2011-07-27 21:56:59 +03:00
static void do_subtitle_out ( AVFormatContext * s ,
OutputStream * ost ,
InputStream * ist ,
AVSubtitle * sub ,
int64_t pts )
2012-05-26 12:18:21 +03:00
{
2011-07-27 21:56:59 +03:00
int subtitle_out_max_size = 1024 * 1024 ;
int subtitle_out_size , nb , i ;
AVCodecContext * enc ;
AVPacket pkt ;
2012-05-30 04:32:32 +03:00
2011-07-27 21:56:59 +03:00
if ( pts = = AV_NOPTS_VALUE ) {
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_ERROR , " Subtitle packets must have a pts \n " ) ;
2011-07-27 21:56:59 +03:00
if ( exit_on_error )
exit_program ( 1 ) ;
return ;
2012-05-26 13:47:47 +03:00
}
2012-05-26 12:18:21 +03:00
2011-07-27 21:56:59 +03:00
enc = ost - > st - > codec ;
2012-05-26 14:31:54 +03:00
2011-07-27 21:56:59 +03:00
if ( ! subtitle_out ) {
subtitle_out = av_malloc ( subtitle_out_max_size ) ;
2012-05-26 12:18:21 +03:00
}
2011-07-27 21:56:59 +03:00
/* Note: DVB subtitle need one packet to draw them and one other
packet to clear them */
/* XXX: signal it in the codec context ? */
2012-08-05 12:11:04 +03:00
if ( enc - > codec_id = = AV_CODEC_ID_DVB_SUBTITLE )
2011-07-27 21:56:59 +03:00
nb = 2 ;
else
nb = 1 ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
/* shift timestamp to honor -ss and make check_recording_time() work with -t */
pts = av_rescale_q ( pts , ist - > st - > time_base , AV_TIME_BASE_Q )
- output_files [ ost - > file_index ] - > start_time ;
2011-12-29 23:28:29 +03:00
for ( i = 0 ; i < nb ; i + + ) {
2012-08-09 01:26:38 +03:00
ost - > sync_opts = av_rescale_q ( pts , AV_TIME_BASE_Q , enc - > time_base ) ;
2012-02-05 16:32:10 +03:00
if ( ! check_recording_time ( ost ) )
return ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
sub - > pts = pts ;
2011-07-27 21:56:59 +03:00
// start_display_time is required to be 0
2011-12-29 23:28:29 +03:00
sub - > pts + = av_rescale_q ( sub - > start_display_time , ( AVRational ) { 1 , 1000 } , AV_TIME_BASE_Q ) ;
sub - > end_display_time - = sub - > start_display_time ;
2011-07-27 21:56:59 +03:00
sub - > start_display_time = 0 ;
2012-07-25 20:45:16 +03:00
if ( i = = 1 )
sub - > num_rects = 0 ;
2011-07-27 21:56:59 +03:00
subtitle_out_size = avcodec_encode_subtitle ( enc , subtitle_out ,
subtitle_out_max_size , sub ) ;
if ( subtitle_out_size < 0 ) {
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_FATAL , " Subtitle encoding failed \n " ) ;
2011-07-27 21:56:59 +03:00
exit_program ( 1 ) ;
}
av_init_packet ( & pkt ) ;
pkt . data = subtitle_out ;
pkt . size = subtitle_out_size ;
2011-12-29 23:28:29 +03:00
pkt . pts = av_rescale_q ( sub - > pts , AV_TIME_BASE_Q , ost - > st - > time_base ) ;
2012-08-09 01:26:38 +03:00
pkt . duration = av_rescale_q ( sub - > end_display_time , ( AVRational ) { 1 , 1000 } , ost - > st - > time_base ) ;
2012-08-05 12:11:04 +03:00
if ( enc - > codec_id = = AV_CODEC_ID_DVB_SUBTITLE ) {
2011-07-27 21:56:59 +03:00
/* XXX: the pts correction is handled here. Maybe handling
it in the codec would be better */
if ( i = = 0 )
pkt . pts + = 90 * sub - > start_display_time ;
else
pkt . pts + = 90 * sub - > end_display_time ;
}
2012-01-01 23:51:26 +03:00
write_frame ( s , & pkt , ost ) ;
2012-08-09 01:26:38 +03:00
subtitle_size + = pkt . size ;
2012-05-26 13:47:47 +03:00
}
2011-07-27 21:56:59 +03:00
}
2012-04-01 16:08:33 +03:00
2011-08-17 04:43:27 +03:00
static void do_video_out ( AVFormatContext * s ,
OutputStream * ost ,
AVFrame * in_picture ,
2012-08-09 01:26:38 +03:00
float quality )
2011-08-17 04:43:27 +03:00
{
2012-05-09 17:25:02 +03:00
int ret , format_video_sync ;
AVPacket pkt ;
AVCodecContext * enc = ost - > st - > codec ;
2012-08-09 01:26:38 +03:00
int nb_frames , i ;
double sync_ipts , delta ;
double duration = 0 ;
int frame_size = 0 ;
InputStream * ist = NULL ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
if ( ost - > source_index > = 0 )
ist = input_streams [ ost - > source_index ] ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
if ( ist & & ist - > st - > start_time ! = AV_NOPTS_VALUE & & ist - > st - > first_dts ! = AV_NOPTS_VALUE & & ost - > frame_rate . num )
duration = 1 / ( av_q2d ( ost - > frame_rate ) * av_q2d ( enc - > time_base ) ) ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
sync_ipts = in_picture - > pts ;
delta = sync_ipts - ost - > sync_opts + duration ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
/* by default, we output a single frame */
nb_frames = 1 ;
2012-04-01 16:08:33 +03:00
2011-08-17 05:06:46 +03:00
format_video_sync = video_sync_method ;
2011-11-26 13:01:33 +03:00
if ( format_video_sync = = VSYNC_AUTO )
2012-08-09 01:26:38 +03:00
format_video_sync = ( s - > oformat - > flags & AVFMT_VARIABLE_FPS ) ? ( ( s - > oformat - > flags & AVFMT_NOTIMESTAMPS ) ? VSYNC_PASSTHROUGH : VSYNC_VFR ) : 1 ;
switch ( format_video_sync ) {
case VSYNC_CFR :
// FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
if ( delta < - 1.1 )
nb_frames = 0 ;
else if ( delta > 1.1 )
nb_frames = lrintf ( delta ) ;
break ;
case VSYNC_VFR :
if ( delta < = - 0.6 )
nb_frames = 0 ;
else if ( delta > 0.6 )
ost - > sync_opts = lrint ( sync_ipts ) ;
break ;
case VSYNC_DROP :
case VSYNC_PASSTHROUGH :
ost - > sync_opts = lrint ( sync_ipts ) ;
break ;
default :
av_assert0 ( 0 ) ;
}
nb_frames = FFMIN ( nb_frames , ost - > max_frames - ost - > frame_number ) ;
if ( nb_frames = = 0 ) {
2012-02-06 23:47:41 +03:00
nb_frames_drop + + ;
av_log ( NULL , AV_LOG_VERBOSE , " *** drop! \n " ) ;
2011-08-17 04:43:27 +03:00
return ;
2012-08-09 01:26:38 +03:00
} else if ( nb_frames > 1 ) {
if ( nb_frames > dts_error_threshold * 30 ) {
av_log ( NULL , AV_LOG_ERROR , " %d frame duplication too large, skiping \n " , nb_frames - 1 ) ;
nb_frames_drop + + ;
return ;
2012-04-01 16:08:33 +03:00
}
2012-08-09 01:26:38 +03:00
nb_frames_dup + = nb_frames - 1 ;
av_log ( NULL , AV_LOG_VERBOSE , " *** %d dup! \n " , nb_frames - 1 ) ;
2012-04-01 16:08:33 +03:00
}
2012-08-09 01:26:38 +03:00
/* duplicates frame if needed */
for ( i = 0 ; i < nb_frames ; i + + ) {
2012-05-18 13:18:49 +03:00
av_init_packet ( & pkt ) ;
pkt . data = NULL ;
pkt . size = 0 ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
in_picture - > pts = ost - > sync_opts ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
if ( ! check_recording_time ( ost ) )
2012-05-18 13:18:49 +03:00
return ;
2012-04-01 16:08:33 +03:00
2012-05-18 13:18:49 +03:00
if ( s - > oformat - > flags & AVFMT_RAWPICTURE & &
2012-08-05 12:11:04 +03:00
enc - > codec - > id = = AV_CODEC_ID_RAWVIDEO ) {
2012-05-18 13:18:49 +03:00
/* raw pictures are written as AVPicture structure to
avoid any copies . We support temporarily the older
method . */
enc - > coded_frame - > interlaced_frame = in_picture - > interlaced_frame ;
enc - > coded_frame - > top_field_first = in_picture - > top_field_first ;
pkt . data = ( uint8_t * ) in_picture ;
pkt . size = sizeof ( AVPicture ) ;
pkt . pts = av_rescale_q ( in_picture - > pts , enc - > time_base , ost - > st - > time_base ) ;
pkt . flags | = AV_PKT_FLAG_KEY ;
2012-04-01 16:08:33 +03:00
2012-05-18 13:18:49 +03:00
write_frame ( s , & pkt , ost ) ;
2012-08-09 01:26:38 +03:00
video_size + = pkt . size ;
2012-05-18 13:18:49 +03:00
} else {
int got_packet ;
AVFrame big_picture ;
2001-07-22 17:37:44 +03:00
2012-05-18 13:18:49 +03:00
big_picture = * in_picture ;
/* better than nothing: use input picture interlaced
settings */
big_picture . interlaced_frame = in_picture - > interlaced_frame ;
if ( ost - > st - > codec - > flags & ( CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME ) ) {
if ( ost - > top_field_first = = - 1 )
big_picture . top_field_first = in_picture - > top_field_first ;
else
big_picture . top_field_first = ! ! ost - > top_field_first ;
}
2003-04-10 21:21:06 +03:00
2012-05-18 13:18:49 +03:00
/* handles same_quant here. This is not correct because it may
not be a global option */
big_picture . quality = quality ;
if ( ! enc - > me_threshold )
big_picture . pict_type = 0 ;
if ( ost - > forced_kf_index < ost - > forced_kf_count & &
big_picture . pts > = ost - > forced_kf_pts [ ost - > forced_kf_index ] ) {
big_picture . pict_type = AV_PICTURE_TYPE_I ;
ost - > forced_kf_index + + ;
}
2012-08-09 01:26:38 +03:00
update_benchmark ( NULL ) ;
2012-05-18 13:18:49 +03:00
ret = avcodec_encode_video2 ( enc , & pkt , & big_picture , & got_packet ) ;
2012-08-09 01:26:38 +03:00
update_benchmark ( " encode_video %d.%d " , ost - > file_index , ost - > index ) ;
2012-05-18 13:18:49 +03:00
if ( ret < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Video encoding failed \n " ) ;
exit_program ( 1 ) ;
}
2003-04-10 21:21:06 +03:00
2012-05-18 13:18:49 +03:00
if ( got_packet ) {
2012-08-09 01:26:38 +03:00
if ( pkt . pts = = AV_NOPTS_VALUE & & ! ( enc - > codec - > capabilities & CODEC_CAP_DELAY ) )
pkt . pts = ost - > sync_opts ;
2012-05-04 20:21:31 +03:00
2012-05-18 13:18:49 +03:00
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts = av_rescale_q ( pkt . pts , enc - > time_base , ost - > st - > time_base ) ;
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts = av_rescale_q ( pkt . dts , enc - > time_base , ost - > st - > time_base ) ;
2012-05-04 20:21:31 +03:00
2012-08-09 01:26:38 +03:00
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " encoder -> type:video "
" pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s \n " ,
av_ts2str ( pkt . pts ) , av_ts2timestr ( pkt . pts , & ost - > st - > time_base ) ,
av_ts2str ( pkt . dts ) , av_ts2timestr ( pkt . dts , & ost - > st - > time_base ) ) ;
}
2012-05-18 13:18:49 +03:00
write_frame ( s , & pkt , ost ) ;
2012-08-09 01:26:38 +03:00
frame_size = pkt . size ;
2012-05-18 13:18:49 +03:00
video_size + = pkt . size ;
2012-08-09 01:26:38 +03:00
av_free_packet ( & pkt ) ;
2012-02-01 12:25:19 +03:00
2012-05-18 13:18:49 +03:00
/* if two pass, output log */
if ( ost - > logfile & & enc - > stats_out ) {
fprintf ( ost - > logfile , " %s " , enc - > stats_out ) ;
2011-07-27 21:56:59 +03:00
}
2012-05-04 20:21:31 +03:00
}
2011-04-18 14:10:52 +03:00
}
2012-05-18 13:18:49 +03:00
ost - > sync_opts + + ;
/*
* For video , number of frames in = = number of packets out .
* But there may be reordering , so we can ' t throw away frames on encoder
* flush , we need to limit them here , before they go into encoder .
*/
ost - > frame_number + + ;
2012-08-09 01:26:38 +03:00
}
2011-03-30 21:58:13 +03:00
2012-08-09 01:26:38 +03:00
if ( vstats_filename & & frame_size )
do_video_stats ( output_files [ ost - > file_index ] - > ctx , ost , frame_size ) ;
2001-07-22 17:37:44 +03:00
}
2011-12-29 23:28:29 +03:00
static double psnr ( double d )
2001-07-22 17:37:44 +03:00
{
2011-12-29 23:28:29 +03:00
return - 10.0 * log ( d ) / log ( 10.0 ) ;
2011-07-27 21:56:59 +03:00
}
2011-03-30 21:58:13 +03:00
2011-07-27 21:56:59 +03:00
static void do_video_stats ( AVFormatContext * os , OutputStream * ost ,
int frame_size )
2008-04-15 01:31:49 +03:00
{
2011-07-27 21:56:59 +03:00
AVCodecContext * enc ;
int frame_number ;
double ti1 , bitrate , avg_bitrate ;
2012-03-29 09:51:17 +03:00
2011-07-27 21:56:59 +03:00
/* this is executed just the first time do_video_stats is called */
if ( ! vstats_file ) {
vstats_file = fopen ( vstats_filename , " w " ) ;
if ( ! vstats_file ) {
perror ( " fopen " ) ;
exit_program ( 1 ) ;
2012-05-26 14:31:54 +03:00
}
2012-03-29 09:51:17 +03:00
}
2008-04-15 01:31:49 +03:00
2011-07-27 21:56:59 +03:00
enc = ost - > st - > codec ;
if ( enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
frame_number = ost - > frame_number ;
2011-12-29 23:28:29 +03:00
fprintf ( vstats_file , " frame= %5d q= %2.1f " , frame_number , enc - > coded_frame - > quality / ( float ) FF_QP2LAMBDA ) ;
2011-07-27 21:56:59 +03:00
if ( enc - > flags & CODEC_FLAG_PSNR )
2011-12-29 23:28:29 +03:00
fprintf ( vstats_file , " PSNR= %6.2f " , psnr ( enc - > coded_frame - > error [ 0 ] / ( enc - > width * enc - > height * 255.0 * 255.0 ) ) ) ;
2012-06-22 23:15:24 +03:00
2011-07-27 21:56:59 +03:00
fprintf ( vstats_file , " f_size= %6d " , frame_size ) ;
/* compute pts value */
ti1 = ost - > sync_opts * av_q2d ( enc - > time_base ) ;
if ( ti1 < 0.01 )
ti1 = 0.01 ;
2012-01-17 03:40:45 +03:00
2011-12-29 23:28:29 +03:00
bitrate = ( frame_size * 8 ) / av_q2d ( enc - > time_base ) / 1000.0 ;
2011-07-27 21:56:59 +03:00
avg_bitrate = ( double ) ( video_size * 8 ) / ti1 / 1000.0 ;
fprintf ( vstats_file , " s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s " ,
2011-12-29 23:28:29 +03:00
( double ) video_size / 1024 , ti1 , bitrate , avg_bitrate ) ;
2011-07-27 21:56:59 +03:00
fprintf ( vstats_file , " type= %c \n " , av_get_picture_type_char ( enc - > coded_frame - > pict_type ) ) ;
2011-12-06 03:37:27 +03:00
}
2011-07-27 21:56:59 +03:00
}
2008-04-15 01:31:49 +03:00
2012-03-29 09:51:17 +03:00
/* check for new output on any of the filtergraphs */
static int poll_filters ( void )
{
AVFilterBufferRef * picref ;
AVFrame * filtered_frame = NULL ;
2012-08-09 01:26:38 +03:00
int i , ret , ret_all ;
unsigned nb_success = 1 , av_uninit ( nb_eof ) ;
int64_t frame_pts ;
2008-04-15 01:31:49 +03:00
2012-08-09 01:26:38 +03:00
while ( 1 ) {
/* Reap all buffers present in the buffer sinks */
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
OutputFile * of = output_files [ ost - > file_index ] ;
int ret = 0 ;
2011-05-22 23:12:35 +03:00
2012-08-09 01:26:38 +03:00
if ( ! ost - > filter )
continue ;
2009-04-13 06:47:12 +03:00
2012-08-09 01:26:38 +03:00
if ( ! ost - > filtered_frame & & ! ( ost - > filtered_frame = avcodec_alloc_frame ( ) ) ) {
return AVERROR ( ENOMEM ) ;
} else
avcodec_get_frame_defaults ( ost - > filtered_frame ) ;
filtered_frame = ost - > filtered_frame ;
2010-05-07 12:43:21 +03:00
2012-08-09 01:26:38 +03:00
while ( 1 ) {
ret = av_buffersink_get_buffer_ref ( ost - > filter - > filter , & picref ,
AV_BUFFERSINK_FLAG_NO_REQUEST ) ;
if ( ret < 0 ) {
if ( ret ! = AVERROR ( EAGAIN ) & & ret ! = AVERROR_EOF ) {
char buf [ 256 ] ;
av_strerror ( ret , buf , sizeof ( buf ) ) ;
av_log ( NULL , AV_LOG_WARNING ,
" Error in av_buffersink_get_buffer_ref(): %s \n " , buf ) ;
}
break ;
}
frame_pts = AV_NOPTS_VALUE ;
if ( picref - > pts ! = AV_NOPTS_VALUE ) {
filtered_frame - > pts = frame_pts = av_rescale_q ( picref - > pts ,
ost - > filter - > filter - > inputs [ 0 ] - > time_base ,
ost - > st - > codec - > time_base ) -
av_rescale_q ( of - > start_time ,
AV_TIME_BASE_Q ,
ost - > st - > codec - > time_base ) ;
2008-04-15 01:31:49 +03:00
2012-08-09 01:26:38 +03:00
if ( of - > start_time & & filtered_frame - > pts < 0 ) {
avfilter_unref_buffer ( picref ) ;
continue ;
}
}
//if (ost->source_index >= 0)
// *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2010-10-02 00:29:37 +03:00
2011-06-09 11:58:23 +03:00
2012-08-09 01:26:38 +03:00
switch ( ost - > filter - > filter - > inputs [ 0 ] - > type ) {
case AVMEDIA_TYPE_VIDEO :
avfilter_copy_buf_props ( filtered_frame , picref ) ;
filtered_frame - > pts = frame_pts ;
if ( ! ost - > frame_aspect_ratio )
ost - > st - > codec - > sample_aspect_ratio = picref - > video - > sample_aspect_ratio ;
2011-07-12 18:18:42 +03:00
2012-08-09 01:26:38 +03:00
do_video_out ( of - > ctx , ost , filtered_frame ,
same_quant ? ost - > last_quality :
ost - > st - > codec - > global_quality ) ;
break ;
case AVMEDIA_TYPE_AUDIO :
avfilter_copy_buf_props ( filtered_frame , picref ) ;
filtered_frame - > pts = frame_pts ;
do_audio_out ( of - > ctx , ost , filtered_frame ) ;
break ;
default :
// TODO support subtitle filters
av_assert0 ( 0 ) ;
2012-07-04 03:56:38 +03:00
}
2012-03-29 09:51:17 +03:00
2012-08-09 01:26:38 +03:00
avfilter_unref_buffer ( picref ) ;
}
2010-03-30 22:37:07 +03:00
}
2012-08-09 01:26:38 +03:00
if ( ! nb_success ) /* from last round */
break ;
/* Request frames through all the graphs */
ret_all = nb_success = nb_eof = 0 ;
for ( i = 0 ; i < nb_filtergraphs ; i + + ) {
ret = avfilter_graph_request_oldest ( filtergraphs [ i ] - > graph ) ;
if ( ! ret ) {
nb_success + + ;
} else if ( ret = = AVERROR_EOF ) {
nb_eof + + ;
} else if ( ret ! = AVERROR ( EAGAIN ) ) {
char buf [ 256 ] ;
av_strerror ( ret , buf , sizeof ( buf ) ) ;
av_log ( NULL , AV_LOG_WARNING ,
" Error in request_frame(): %s \n " , buf ) ;
ret_all = ret ;
2012-03-29 09:51:17 +03:00
}
2011-01-14 16:50:55 +02:00
}
2012-08-09 01:26:38 +03:00
/* Try again if anything succeeded */
2010-03-30 22:37:07 +03:00
}
2012-08-09 01:26:38 +03:00
return nb_eof = = nb_filtergraphs ? AVERROR_EOF : ret_all ;
2010-03-30 22:37:07 +03:00
}
2012-08-09 01:26:38 +03:00
static void print_report ( int is_last_report , int64_t timer_start , int64_t cur_time )
2011-09-12 12:44:14 +03:00
{
2011-07-27 21:56:59 +03:00
char buf [ 1024 ] ;
2012-08-09 01:26:38 +03:00
AVBPrint buf_script ;
2011-07-27 21:56:59 +03:00
OutputStream * ost ;
AVFormatContext * oc ;
int64_t total_size ;
AVCodecContext * enc ;
int frame_number , vid , i ;
2012-08-09 01:26:38 +03:00
double bitrate ;
int64_t pts = INT64_MAX ;
2011-07-27 21:56:59 +03:00
static int64_t last_time = - 1 ;
static int qp_histogram [ 52 ] ;
2012-08-09 01:26:38 +03:00
int hours , mins , secs , us ;
2012-07-03 21:34:27 +03:00
2012-08-09 01:26:38 +03:00
if ( ! print_stats & & ! is_last_report & & ! progress_avio )
2012-05-05 19:22:46 +03:00
return ;
2012-07-03 21:34:27 +03:00
2011-07-27 21:56:59 +03:00
if ( ! is_last_report ) {
if ( last_time = = - 1 ) {
last_time = cur_time ;
2002-11-20 05:06:12 +02:00
return ;
2009-05-31 23:19:16 +03:00
}
2011-07-27 21:56:59 +03:00
if ( ( cur_time - last_time ) < 500000 )
return ;
last_time = cur_time ;
2002-11-20 05:06:12 +02:00
}
2005-06-03 17:31:45 +03:00
2012-04-15 16:28:30 +03:00
oc = output_files [ 0 ] - > ctx ;
2005-06-03 17:31:45 +03:00
2011-07-27 21:56:59 +03:00
total_size = avio_size ( oc - > pb ) ;
2012-08-09 01:26:38 +03:00
if ( total_size < 0 ) { // FIXME improve avio_size() so it works with non seekable output too
2011-12-29 23:28:29 +03:00
total_size = avio_tell ( oc - > pb ) ;
2012-08-09 01:26:38 +03:00
if ( total_size < 0 )
total_size = 0 ;
2005-06-03 17:31:45 +03:00
}
2011-07-27 21:56:59 +03:00
buf [ 0 ] = ' \0 ' ;
vid = 0 ;
2012-08-09 01:26:38 +03:00
av_bprint_init ( & buf_script , 0 , 1 ) ;
2012-04-15 16:03:07 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2011-07-27 21:56:59 +03:00
float q = - 1 ;
2012-04-15 16:28:30 +03:00
ost = output_streams [ i ] ;
2011-07-27 21:56:59 +03:00
enc = ost - > st - > codec ;
2011-10-23 12:22:33 +03:00
if ( ! ost - > stream_copy & & enc - > coded_frame )
2011-12-29 23:28:29 +03:00
q = enc - > coded_frame - > quality / ( float ) FF_QP2LAMBDA ;
2011-07-27 21:56:59 +03:00
if ( vid & & enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " q=%2.1f " , q ) ;
2012-08-09 01:26:38 +03:00
av_bprintf ( & buf_script , " stream_%d_%d_q=%.1f \n " ,
ost - > file_index , ost - > index , q ) ;
2005-06-03 17:31:45 +03:00
}
2011-07-27 21:56:59 +03:00
if ( ! vid & & enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2012-08-09 01:26:38 +03:00
float fps , t = ( cur_time - timer_start ) / 1000000.0 ;
2005-06-03 17:31:45 +03:00
2011-07-27 21:56:59 +03:00
frame_number = ost - > frame_number ;
2012-08-09 01:26:38 +03:00
fps = t > 1 ? frame_number / t : 0 ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " frame=%5d fps=%3.*f q=%3.1f " ,
frame_number , fps < 9.95 , fps , q ) ;
av_bprintf ( & buf_script , " frame=%d \n " , frame_number ) ;
av_bprintf ( & buf_script , " fps=%.1f \n " , fps ) ;
av_bprintf ( & buf_script , " stream_%d_%d_q=%.1f \n " ,
ost - > file_index , ost - > index , q ) ;
2011-12-29 23:28:29 +03:00
if ( is_last_report )
2011-07-27 21:56:59 +03:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " L " ) ;
2011-12-29 23:28:29 +03:00
if ( qp_hist ) {
2011-07-27 21:56:59 +03:00
int j ;
int qp = lrintf ( q ) ;
2011-12-29 23:28:29 +03:00
if ( qp > = 0 & & qp < FF_ARRAY_ELEMS ( qp_histogram ) )
2011-07-27 21:56:59 +03:00
qp_histogram [ qp ] + + ;
2011-12-29 23:28:29 +03:00
for ( j = 0 ; j < 32 ; j + + )
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " %X " , ( int ) lrintf ( log ( qp_histogram [ j ] + 1 ) / log ( 2 ) ) ) ;
2001-07-22 17:37:44 +03:00
}
2011-12-29 23:28:29 +03:00
if ( enc - > flags & CODEC_FLAG_PSNR ) {
2011-07-27 21:56:59 +03:00
int j ;
2011-12-29 23:28:29 +03:00
double error , error_sum = 0 ;
double scale , scale_sum = 0 ;
2012-08-09 01:26:38 +03:00
double p ;
2011-12-29 23:28:29 +03:00
char type [ 3 ] = { ' Y ' , ' U ' , ' V ' } ;
2011-07-27 21:56:59 +03:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " PSNR= " ) ;
2011-12-29 23:28:29 +03:00
for ( j = 0 ; j < 3 ; j + + ) {
if ( is_last_report ) {
error = enc - > error [ j ] ;
scale = enc - > width * enc - > height * 255.0 * 255.0 * frame_number ;
} else {
error = enc - > coded_frame - > error [ j ] ;
scale = enc - > width * enc - > height * 255.0 * 255.0 ;
2011-10-30 04:26:48 +03:00
}
2011-12-29 23:28:29 +03:00
if ( j )
scale / = 4 ;
2011-07-27 21:56:59 +03:00
error_sum + = error ;
scale_sum + = scale ;
2012-08-09 01:26:38 +03:00
p = psnr ( error / scale ) ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " %c:%2.2f " , type [ j ] , p ) ;
av_bprintf ( & buf_script , " stream_%d_%d_psnr_%c=%2.2f \n " ,
ost - > file_index , ost - > index , type [ i ] | 32 , p ) ;
2011-07-27 21:56:59 +03:00
}
2012-08-09 01:26:38 +03:00
p = psnr ( error_sum / scale_sum ) ;
2011-12-29 23:28:29 +03:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " *:%2.2f " , psnr ( error_sum / scale_sum ) ) ;
2012-08-09 01:26:38 +03:00
av_bprintf ( & buf_script , " stream_%d_%d_psnr_all=%2.2f \n " ,
ost - > file_index , ost - > index , p ) ;
2011-07-27 21:56:59 +03:00
}
vid = 1 ;
2001-07-22 17:37:44 +03:00
}
2011-07-27 21:56:59 +03:00
/* compute min output value */
2012-08-09 01:26:38 +03:00
pts = FFMIN ( pts , av_rescale_q ( ost - > st - > pts . val ,
ost - > st - > time_base , AV_TIME_BASE_Q ) ) ;
2001-07-22 17:37:44 +03:00
}
2012-08-09 01:26:38 +03:00
secs = pts / AV_TIME_BASE ;
us = pts % AV_TIME_BASE ;
mins = secs / 60 ;
secs % = 60 ;
hours = mins / 60 ;
mins % = 60 ;
2010-02-03 00:23:09 +02:00
2012-08-09 01:26:38 +03:00
bitrate = pts ? total_size * 8 / ( pts / 1000.0 ) : 0 ;
2011-09-12 00:35:35 +03:00
2011-09-13 08:31:21 +03:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) ,
2012-08-09 01:26:38 +03:00
" size=%8.0fkB time= " , total_size / 1024.0 ) ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) ,
" %02d:%02d:%02d.%02d " , hours , mins , secs ,
( 100 * us ) / AV_TIME_BASE ) ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) ,
" bitrate=%6.1fkbits/s " , bitrate ) ;
av_bprintf ( & buf_script , " total_size=% " PRId64 " \n " , total_size ) ;
av_bprintf ( & buf_script , " out_time_ms=% " PRId64 " \n " , pts ) ;
av_bprintf ( & buf_script , " out_time=%02d:%02d:%02d.%06d \n " ,
hours , mins , secs , us ) ;
2011-07-27 21:56:59 +03:00
2011-09-13 08:31:21 +03:00
if ( nb_frames_dup | | nb_frames_drop )
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " dup=%d drop=%d " ,
nb_frames_dup , nb_frames_drop ) ;
2012-08-09 01:26:38 +03:00
av_bprintf ( & buf_script , " dup_frames=%d \n " , nb_frames_dup ) ;
av_bprintf ( & buf_script , " drop_frames=%d \n " , nb_frames_drop ) ;
2011-07-27 21:56:59 +03:00
2012-08-09 01:26:38 +03:00
if ( print_stats | | is_last_report ) {
2011-10-09 17:32:54 +03:00
av_log ( NULL , AV_LOG_INFO , " %s \r " , buf ) ;
2011-07-27 21:56:59 +03:00
2011-09-13 08:31:21 +03:00
fflush ( stderr ) ;
2001-07-22 17:37:44 +03:00
}
2012-08-09 01:26:38 +03:00
if ( progress_avio ) {
av_bprintf ( & buf_script , " progress=%s \n " ,
is_last_report ? " end " : " continue " ) ;
avio_write ( progress_avio , buf_script . str ,
FFMIN ( buf_script . len , buf_script . size - 1 ) ) ;
avio_flush ( progress_avio ) ;
av_bprint_finalize ( & buf_script , NULL ) ;
if ( is_last_report ) {
avio_close ( progress_avio ) ;
progress_avio = NULL ;
2007-08-20 11:12:08 +03:00
}
}
2009-03-11 08:06:18 +02:00
2011-09-13 08:31:21 +03:00
if ( is_last_report ) {
2012-08-09 01:26:38 +03:00
int64_t raw = audio_size + video_size + subtitle_size + extra_size ;
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2012-08-09 01:26:38 +03:00
av_log ( NULL , AV_LOG_INFO , " video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%% \n " ,
2011-12-29 23:28:29 +03:00
video_size / 1024.0 ,
audio_size / 1024.0 ,
2012-08-09 01:26:38 +03:00
subtitle_size / 1024.0 ,
2011-12-29 23:28:29 +03:00
extra_size / 1024.0 ,
100.0 * ( total_size - raw ) / raw
2011-07-27 21:56:59 +03:00
) ;
2012-08-09 01:26:38 +03:00
if ( video_size + audio_size + subtitle_size + extra_size = = 0 ) {
av_log ( NULL , AV_LOG_WARNING , " Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used) \n " ) ;
}
2009-03-11 08:06:18 +02:00
}
2011-07-27 21:56:59 +03:00
}
2009-03-11 08:06:18 +02:00
2012-04-15 16:03:07 +03:00
static void flush_encoders ( void )
2011-08-18 09:55:29 +03:00
{
int i , ret ;
2012-04-01 16:08:33 +03:00
2012-04-15 16:03:07 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
OutputStream * ost = output_streams [ i ] ;
2011-08-16 12:19:20 +03:00
AVCodecContext * enc = ost - > st - > codec ;
2012-04-15 16:28:30 +03:00
AVFormatContext * os = output_files [ ost - > file_index ] - > ctx ;
2011-12-31 17:36:25 +03:00
int stop_encoding = 0 ;
2011-08-16 12:19:20 +03:00
2011-08-19 18:52:46 +03:00
if ( ! ost - > encoding_needed )
2011-08-16 12:19:20 +03:00
continue ;
2011-12-29 23:28:29 +03:00
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO & & enc - > frame_size < = 1 )
2011-08-16 12:19:20 +03:00
continue ;
2012-08-05 12:11:04 +03:00
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & & ( os - > oformat - > flags & AVFMT_RAWPICTURE ) & & enc - > codec - > id = = AV_CODEC_ID_RAWVIDEO )
2011-08-16 12:19:20 +03:00
continue ;
2011-12-29 23:28:29 +03:00
for ( ; ; ) {
2012-05-05 19:22:46 +03:00
int ( * encode ) ( AVCodecContext * , AVPacket * , const AVFrame * , int * ) = NULL ;
const char * desc ;
int64_t * size ;
2011-08-16 12:19:20 +03:00
switch ( ost - > st - > codec - > codec_type ) {
case AVMEDIA_TYPE_AUDIO :
2012-05-05 19:22:46 +03:00
encode = avcodec_encode_audio2 ;
desc = " Audio " ;
size = & audio_size ;
2011-08-16 12:19:20 +03:00
break ;
case AVMEDIA_TYPE_VIDEO :
2012-05-05 19:22:46 +03:00
encode = avcodec_encode_video2 ;
desc = " Video " ;
size = & video_size ;
break ;
default :
stop_encoding = 1 ;
}
if ( encode ) {
AVPacket pkt ;
int got_packet ;
av_init_packet ( & pkt ) ;
pkt . data = NULL ;
pkt . size = 0 ;
2012-08-09 01:26:38 +03:00
update_benchmark ( NULL ) ;
2012-05-05 19:22:46 +03:00
ret = encode ( enc , & pkt , NULL , & got_packet ) ;
2012-08-09 01:26:38 +03:00
update_benchmark ( " flush %s %d.%d " , desc , ost - > file_index , ost - > index ) ;
2011-08-16 12:19:20 +03:00
if ( ret < 0 ) {
2012-05-05 19:22:46 +03:00
av_log ( NULL , AV_LOG_FATAL , " %s encoding failed \n " , desc ) ;
2011-08-16 12:19:20 +03:00
exit_program ( 1 ) ;
}
2012-08-09 01:26:38 +03:00
* size + = pkt . size ;
2011-08-16 12:19:20 +03:00
if ( ost - > logfile & & enc - > stats_out ) {
fprintf ( ost - > logfile , " %s " , enc - > stats_out ) ;
}
2012-02-01 12:51:36 +03:00
if ( ! got_packet ) {
2011-12-31 17:36:25 +03:00
stop_encoding = 1 ;
break ;
}
2012-02-01 12:51:36 +03:00
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts = av_rescale_q ( pkt . pts , enc - > time_base , ost - > st - > time_base ) ;
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts = av_rescale_q ( pkt . dts , enc - > time_base , ost - > st - > time_base ) ;
2011-12-31 17:36:25 +03:00
write_frame ( os , & pkt , ost ) ;
2012-04-01 16:08:33 +03:00
}
2012-05-05 19:22:46 +03:00
2011-12-31 17:36:25 +03:00
if ( stop_encoding )
2011-08-16 12:19:20 +03:00
break ;
2012-04-01 16:08:33 +03:00
}
}
2011-08-18 09:55:29 +03:00
}
2012-04-01 16:08:33 +03:00
2011-11-21 15:48:45 +03:00
/*
* Check whether a packet from ist should be written into ost at this time
*/
static int check_output_constraints ( InputStream * ist , OutputStream * ost )
{
2012-04-15 16:28:30 +03:00
OutputFile * of = output_files [ ost - > file_index ] ;
int ist_index = input_files [ ist - > file_index ] - > ist_index + ist - > st - > index ;
2011-11-04 03:44:06 +03:00
2011-11-21 15:48:45 +03:00
if ( ost - > source_index ! = ist_index )
return 0 ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
if ( of - > start_time & & ist - > pts < of - > start_time )
2011-11-21 15:48:45 +03:00
return 0 ;
2012-04-01 16:08:33 +03:00
2011-11-21 15:48:45 +03:00
return 1 ;
}
2012-04-01 16:08:33 +03:00
2011-11-21 15:48:45 +03:00
static void do_streamcopy ( InputStream * ist , OutputStream * ost , const AVPacket * pkt )
{
2012-04-15 16:28:30 +03:00
OutputFile * of = output_files [ ost - > file_index ] ;
2011-11-21 15:48:45 +03:00
int64_t ost_tb_start_time = av_rescale_q ( of - > start_time , AV_TIME_BASE_Q , ost - > st - > time_base ) ;
2012-08-09 01:26:38 +03:00
AVPicture pict ;
2011-11-21 15:48:45 +03:00
AVPacket opkt ;
2009-03-11 08:06:18 +02:00
2011-11-21 15:48:45 +03:00
av_init_packet ( & opkt ) ;
if ( ( ! ost - > frame_number & & ! ( pkt - > flags & AV_PKT_FLAG_KEY ) ) & &
! ost - > copy_initial_nonkeyframes )
return ;
2012-02-05 16:32:10 +03:00
if ( of - > recording_time ! = INT64_MAX & &
2012-08-09 01:26:38 +03:00
ist - > pts > = of - > recording_time + of - > start_time ) {
2012-08-08 13:04:53 +03:00
ost - > finished = 1 ;
2012-02-05 16:32:10 +03:00
return ;
2009-03-11 08:06:18 +02:00
}
2011-11-21 15:48:45 +03:00
/* force the input stream PTS */
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO )
audio_size + = pkt - > size ;
else if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
video_size + = pkt - > size ;
ost - > sync_opts + + ;
2012-08-09 01:26:38 +03:00
} else if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
subtitle_size + = pkt - > size ;
2001-07-22 17:37:44 +03:00
}
2011-11-21 15:48:45 +03:00
if ( pkt - > pts ! = AV_NOPTS_VALUE )
opkt . pts = av_rescale_q ( pkt - > pts , ist - > st - > time_base , ost - > st - > time_base ) - ost_tb_start_time ;
else
opkt . pts = AV_NOPTS_VALUE ;
2012-06-01 11:44:11 +03:00
2011-11-21 15:48:45 +03:00
if ( pkt - > dts = = AV_NOPTS_VALUE )
2012-08-09 01:26:38 +03:00
opkt . dts = av_rescale_q ( ist - > dts , AV_TIME_BASE_Q , ost - > st - > time_base ) ;
2011-11-21 15:48:45 +03:00
else
opkt . dts = av_rescale_q ( pkt - > dts , ist - > st - > time_base , ost - > st - > time_base ) ;
opkt . dts - = ost_tb_start_time ;
2012-06-01 11:44:11 +03:00
2011-11-21 15:48:45 +03:00
opkt . duration = av_rescale_q ( pkt - > duration , ist - > st - > time_base , ost - > st - > time_base ) ;
opkt . flags = pkt - > flags ;
2012-06-01 11:44:11 +03:00
2011-12-29 23:28:29 +03:00
// FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2012-08-05 12:11:04 +03:00
if ( ost - > st - > codec - > codec_id ! = AV_CODEC_ID_H264
& & ost - > st - > codec - > codec_id ! = AV_CODEC_ID_MPEG1VIDEO
& & ost - > st - > codec - > codec_id ! = AV_CODEC_ID_MPEG2VIDEO
& & ost - > st - > codec - > codec_id ! = AV_CODEC_ID_VC1
2011-11-21 15:48:45 +03:00
) {
if ( av_parser_change ( ist - > st - > parser , ost - > st - > codec , & opkt . data , & opkt . size , pkt - > data , pkt - > size , pkt - > flags & AV_PKT_FLAG_KEY ) )
opkt . destruct = av_destruct_packet ;
} else {
opkt . data = pkt - > data ;
opkt . size = pkt - > size ;
2012-06-01 11:44:11 +03:00
}
2012-08-09 01:26:38 +03:00
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & & ( of - > ctx - > oformat - > flags & AVFMT_RAWPICTURE ) ) {
/* store AVPicture in AVPacket, as expected by the output format */
avpicture_fill ( & pict , opkt . data , ost - > st - > codec - > pix_fmt , ost - > st - > codec - > width , ost - > st - > codec - > height ) ;
opkt . data = ( uint8_t * ) & pict ;
opkt . size = sizeof ( AVPicture ) ;
opkt . flags | = AV_PKT_FLAG_KEY ;
}
2012-06-01 11:44:11 +03:00
2012-01-01 23:51:26 +03:00
write_frame ( of - > ctx , & opkt , ost ) ;
2011-11-21 15:48:45 +03:00
ost - > st - > codec - > frame_number + + ;
av_free_packet ( & opkt ) ;
2012-07-21 23:54:08 +03:00
}
2012-06-01 12:00:27 +03:00
2011-11-21 16:05:38 +03:00
static void rate_emu_sleep ( InputStream * ist )
2012-07-21 23:54:08 +03:00
{
2012-04-15 16:28:30 +03:00
if ( input_files [ ist - > file_index ] - > rate_emu ) {
2012-08-09 01:26:38 +03:00
int64_t pts = av_rescale ( ist - > dts , 1000000 , AV_TIME_BASE ) ;
2011-11-21 16:05:38 +03:00
int64_t now = av_gettime ( ) - ist - > start ;
if ( pts > now )
2012-06-21 22:31:44 +03:00
av_usleep ( pts - now ) ;
2012-06-01 12:00:27 +03:00
}
}
2012-08-01 19:23:12 +03:00
int guess_input_channel_layout ( InputStream * ist )
2012-07-21 23:54:08 +03:00
{
2012-05-05 19:22:46 +03:00
AVCodecContext * dec = ist - > st - > codec ;
2012-07-21 23:54:08 +03:00
2012-05-05 19:22:46 +03:00
if ( ! dec - > channel_layout ) {
char layout_name [ 256 ] ;
2012-07-21 23:54:08 +03:00
2012-05-05 19:22:46 +03:00
dec - > channel_layout = av_get_default_channel_layout ( dec - > channels ) ;
if ( ! dec - > channel_layout )
return 0 ;
av_get_channel_layout_string ( layout_name , sizeof ( layout_name ) ,
dec - > channels , dec - > channel_layout ) ;
av_log ( NULL , AV_LOG_WARNING , " Guessed Channel Layout for Input Stream "
" #%d.%d : %s \n " , ist - > file_index , ist - > st - > index , layout_name ) ;
2012-07-21 23:54:08 +03:00
}
2012-05-05 19:22:46 +03:00
return 1 ;
2012-07-21 23:54:08 +03:00
}
2012-05-18 13:46:11 +03:00
static int decode_audio ( InputStream * ist , AVPacket * pkt , int * got_output )
2012-06-06 16:56:34 +03:00
{
2011-11-22 01:41:49 +03:00
AVFrame * decoded_frame ;
AVCodecContext * avctx = ist - > st - > codec ;
2012-05-05 19:22:46 +03:00
int i , ret , resample_changed ;
2012-08-09 01:26:38 +03:00
AVRational decoded_frame_tb ;
2011-11-21 16:39:22 +03:00
2011-12-05 19:49:38 +03:00
if ( ! ist - > decoded_frame & & ! ( ist - > decoded_frame = avcodec_alloc_frame ( ) ) )
2011-11-22 01:41:49 +03:00
return AVERROR ( ENOMEM ) ;
2011-12-05 19:49:38 +03:00
else
avcodec_get_frame_defaults ( ist - > decoded_frame ) ;
decoded_frame = ist - > decoded_frame ;
2011-11-21 16:39:22 +03:00
2012-08-09 01:26:38 +03:00
update_benchmark ( NULL ) ;
2011-11-22 01:41:49 +03:00
ret = avcodec_decode_audio4 ( avctx , decoded_frame , got_output , pkt ) ;
2012-08-09 01:26:38 +03:00
update_benchmark ( " decode_audio %d.%d " , ist - > file_index , ist - > st - > index ) ;
2012-08-09 16:14:57 +03:00
if ( ret > = 0 & & avctx - > sample_rate < = 0 ) {
2012-08-09 01:26:38 +03:00
av_log ( avctx , AV_LOG_ERROR , " Sample rate %d invalid \n " , avctx - > sample_rate ) ;
return AVERROR_INVALIDDATA ;
2012-06-06 16:56:34 +03:00
}
2011-11-21 16:39:22 +03:00
2012-08-08 13:27:50 +03:00
if ( ! * got_output | | ret < 0 ) {
if ( ! pkt - > size ) {
2012-05-05 19:22:46 +03:00
for ( i = 0 ; i < ist - > nb_filters ; i + + )
2012-08-09 01:26:38 +03:00
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter , NULL ,
AV_BUFFERSRC_FLAG_NO_COPY ) ;
2012-08-08 13:27:50 +03:00
}
2011-11-21 23:30:23 +03:00
return ret ;
2012-06-06 16:56:34 +03:00
}
2012-08-09 01:26:38 +03:00
# if 1
/* increment next_dts to use for the case where the input stream does not
have timestamps or there are multiple frames in the packet */
ist - > next_pts + = ( ( int64_t ) AV_TIME_BASE * decoded_frame - > nb_samples ) /
avctx - > sample_rate ;
ist - > next_dts + = ( ( int64_t ) AV_TIME_BASE * decoded_frame - > nb_samples ) /
avctx - > sample_rate ;
# endif
2012-06-02 08:26:41 +03:00
2011-11-21 16:39:22 +03:00
rate_emu_sleep ( ist ) ;
2012-06-02 08:26:41 +03:00
2012-05-05 19:22:46 +03:00
resample_changed = ist - > resample_sample_fmt ! = decoded_frame - > format | |
ist - > resample_channels ! = avctx - > channels | |
ist - > resample_channel_layout ! = decoded_frame - > channel_layout | |
ist - > resample_sample_rate ! = decoded_frame - > sample_rate ;
if ( resample_changed ) {
char layout1 [ 64 ] , layout2 [ 64 ] ;
2012-06-02 08:26:41 +03:00
2012-05-05 19:22:46 +03:00
if ( ! guess_input_channel_layout ( ist ) ) {
av_log ( NULL , AV_LOG_FATAL , " Unable to find default channel "
" layout for Input Stream #%d.%d \n " , ist - > file_index ,
ist - > st - > index ) ;
exit_program ( 1 ) ;
}
decoded_frame - > channel_layout = avctx - > channel_layout ;
2012-06-02 08:26:41 +03:00
2012-05-05 19:22:46 +03:00
av_get_channel_layout_string ( layout1 , sizeof ( layout1 ) , ist - > resample_channels ,
ist - > resample_channel_layout ) ;
av_get_channel_layout_string ( layout2 , sizeof ( layout2 ) , avctx - > channels ,
decoded_frame - > channel_layout ) ;
2012-06-02 08:26:41 +03:00
2012-05-05 19:22:46 +03:00
av_log ( NULL , AV_LOG_INFO ,
" 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 " ,
ist - > file_index , ist - > st - > index ,
ist - > resample_sample_rate , av_get_sample_fmt_name ( ist - > resample_sample_fmt ) ,
ist - > resample_channels , layout1 ,
decoded_frame - > sample_rate , av_get_sample_fmt_name ( decoded_frame - > format ) ,
avctx - > channels , layout2 ) ;
ist - > resample_sample_fmt = decoded_frame - > format ;
ist - > resample_sample_rate = decoded_frame - > sample_rate ;
ist - > resample_channel_layout = decoded_frame - > channel_layout ;
ist - > resample_channels = avctx - > channels ;
for ( i = 0 ; i < nb_filtergraphs ; i + + )
2012-08-09 01:26:38 +03:00
if ( ist_in_filtergraph ( filtergraphs [ i ] , ist ) ) {
FilterGraph * fg = filtergraphs [ i ] ;
int j ;
if ( configure_filtergraph ( fg ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Error reinitializing filters! \n " ) ;
exit_program ( 1 ) ;
}
for ( j = 0 ; j < fg - > nb_outputs ; j + + ) {
OutputStream * ost = fg - > outputs [ j ] - > ost ;
if ( ost - > enc - > type = = AVMEDIA_TYPE_AUDIO & &
! ( ost - > enc - > capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE ) )
av_buffersink_set_frame_size ( ost - > filter - > filter ,
ost - > st - > codec - > frame_size ) ;
}
2012-05-05 19:22:46 +03:00
}
2012-06-02 08:26:41 +03:00
}
2012-08-09 01:26:38 +03:00
/* if the decoder provides a pts, use it instead of the last packet pts.
the decoder could be delaying output by a packet or more . */
if ( decoded_frame - > pts ! = AV_NOPTS_VALUE ) {
ist - > dts = ist - > next_dts = ist - > pts = ist - > next_pts = av_rescale_q ( decoded_frame - > pts , avctx - > time_base , AV_TIME_BASE_Q ) ;
decoded_frame_tb = avctx - > time_base ;
} else if ( decoded_frame - > pkt_pts ! = AV_NOPTS_VALUE ) {
decoded_frame - > pts = decoded_frame - > pkt_pts ;
pkt - > pts = AV_NOPTS_VALUE ;
decoded_frame_tb = ist - > st - > time_base ;
} else if ( pkt - > pts ! = AV_NOPTS_VALUE ) {
decoded_frame - > pts = pkt - > pts ;
pkt - > pts = AV_NOPTS_VALUE ;
decoded_frame_tb = ist - > st - > time_base ;
} else {
decoded_frame - > pts = ist - > dts ;
decoded_frame_tb = AV_TIME_BASE_Q ;
}
avconv: Set audio filter time base to the sample rate
If the output frame size is smaller than the input sample rate,
and the input stream time base corresponds exactly to the input
frame size (getting input packet timestamps like 0, 1, 2, 3, 4 etc),
the output timestamps from the filter will be like
0, 1, 2, 3, 4, 4, 5 ..., leadning to non-monotone timestamps later.
A concrete example is input mp3 data having frame sizes of 1152
samples, transcoded to aac with 1024 sample frames.
By setting the audio filter time base to the sample rate, we will
get sensible timestamps for all output packets, regardless of
the ratio between the input and output frame sizes.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-06-30 11:26:11 +03:00
if ( decoded_frame - > pts ! = AV_NOPTS_VALUE )
decoded_frame - > pts = av_rescale_q ( decoded_frame - > pts ,
2012-08-09 01:26:38 +03:00
decoded_frame_tb ,
avconv: Set audio filter time base to the sample rate
If the output frame size is smaller than the input sample rate,
and the input stream time base corresponds exactly to the input
frame size (getting input packet timestamps like 0, 1, 2, 3, 4 etc),
the output timestamps from the filter will be like
0, 1, 2, 3, 4, 4, 5 ..., leadning to non-monotone timestamps later.
A concrete example is input mp3 data having frame sizes of 1152
samples, transcoded to aac with 1024 sample frames.
By setting the audio filter time base to the sample rate, we will
get sensible timestamps for all output packets, regardless of
the ratio between the input and output frame sizes.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-06-30 11:26:11 +03:00
( AVRational ) { 1 , ist - > st - > codec - > sample_rate } ) ;
2012-05-05 19:22:46 +03:00
for ( i = 0 ; i < ist - > nb_filters ; i + + )
2012-08-09 01:26:38 +03:00
av_buffersrc_add_frame ( ist - > filters [ i ] - > filter , decoded_frame , 0 ) ;
decoded_frame - > pts = AV_NOPTS_VALUE ;
2012-05-05 19:22:46 +03:00
2011-11-21 23:30:23 +03:00
return ret ;
2012-06-02 08:26:41 +03:00
}
2012-05-18 13:46:11 +03:00
static int decode_video ( InputStream * ist , AVPacket * pkt , int * got_output )
2012-06-02 08:26:41 +03:00
{
2012-03-29 09:51:17 +03:00
AVFrame * decoded_frame ;
2011-11-21 16:39:22 +03:00
void * buffer_to_free = NULL ;
2012-03-29 08:40:26 +03:00
int i , ret = 0 , resample_changed ;
2012-08-09 01:26:38 +03:00
int64_t best_effort_timestamp ;
AVRational * frame_sample_aspect ;
2011-11-21 16:39:22 +03:00
float quality ;
2012-06-02 08:26:41 +03:00
2011-12-05 19:49:38 +03:00
if ( ! ist - > decoded_frame & & ! ( ist - > decoded_frame = avcodec_alloc_frame ( ) ) )
2011-11-21 16:39:22 +03:00
return AVERROR ( ENOMEM ) ;
2011-12-05 19:49:38 +03:00
else
avcodec_get_frame_defaults ( ist - > decoded_frame ) ;
decoded_frame = ist - > decoded_frame ;
2012-08-09 01:26:38 +03:00
pkt - > dts = av_rescale_q ( ist - > dts , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
2012-06-02 08:26:41 +03:00
2012-08-09 01:26:38 +03:00
update_benchmark ( NULL ) ;
2011-11-21 16:39:22 +03:00
ret = avcodec_decode_video2 ( ist - > st - > codec ,
decoded_frame , got_output , pkt ) ;
2012-08-09 01:26:38 +03:00
update_benchmark ( " decode_video %d.%d " , ist - > file_index , ist - > st - > index ) ;
2012-08-08 13:27:50 +03:00
if ( ! * got_output | | ret < 0 ) {
if ( ! pkt - > size ) {
2012-04-01 20:01:37 +03:00
for ( i = 0 ; i < ist - > nb_filters ; i + + )
2012-08-09 01:26:38 +03:00
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter , NULL , AV_BUFFERSRC_FLAG_NO_COPY ) ;
2012-08-08 13:27:50 +03:00
}
2011-11-21 23:30:23 +03:00
return ret ;
2011-11-21 16:39:22 +03:00
}
2012-06-02 08:26:41 +03:00
2012-08-08 13:27:50 +03:00
quality = same_quant ? decoded_frame - > quality : 0 ;
2012-08-09 16:14:57 +03:00
2012-08-09 01:26:38 +03:00
if ( ist - > top_field_first > = 0 )
decoded_frame - > top_field_first = ist - > top_field_first ;
2012-06-02 08:26:41 +03:00
2012-08-09 01:26:38 +03:00
best_effort_timestamp = av_frame_get_best_effort_timestamp ( decoded_frame ) ;
if ( best_effort_timestamp ! = AV_NOPTS_VALUE )
ist - > next_pts = ist - > pts = av_rescale_q ( decoded_frame - > pts = best_effort_timestamp , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
2012-06-02 08:26:41 +03:00
2012-08-09 01:26:38 +03:00
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " decoder -> ist_index:%d type:video "
" frame_pts:%s frame_pts_time:%s best_effort_ts:% " PRId64 " best_effort_ts_time:%s keyframe:%d frame_type:%d \n " ,
ist - > st - > index , av_ts2str ( decoded_frame - > pts ) ,
av_ts2timestr ( decoded_frame - > pts , & ist - > st - > time_base ) ,
best_effort_timestamp ,
av_ts2timestr ( best_effort_timestamp , & ist - > st - > time_base ) ,
decoded_frame - > key_frame , decoded_frame - > pict_type ) ;
2012-06-02 08:26:41 +03:00
}
2011-11-21 16:39:22 +03:00
pkt - > size = 0 ;
pre_process_video_frame ( ist , ( AVPicture * ) decoded_frame , & buffer_to_free ) ;
2012-06-02 08:26:41 +03:00
2011-11-21 16:39:22 +03:00
rate_emu_sleep ( ist ) ;
2012-06-02 08:26:41 +03:00
2012-03-22 11:37:33 +03:00
if ( ist - > st - > sample_aspect_ratio . num )
decoded_frame - > sample_aspect_ratio = ist - > st - > sample_aspect_ratio ;
2012-06-02 08:26:41 +03:00
2012-03-29 08:40:26 +03:00
resample_changed = ist - > resample_width ! = decoded_frame - > width | |
ist - > resample_height ! = decoded_frame - > height | |
ist - > resample_pix_fmt ! = decoded_frame - > format ;
if ( resample_changed ) {
av_log ( NULL , AV_LOG_INFO ,
" Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s \n " ,
ist - > file_index , ist - > st - > index ,
ist - > resample_width , ist - > resample_height , av_get_pix_fmt_name ( ist - > resample_pix_fmt ) ,
decoded_frame - > width , decoded_frame - > height , av_get_pix_fmt_name ( decoded_frame - > format ) ) ;
2012-06-02 08:26:41 +03:00
2012-03-29 08:40:26 +03:00
ist - > resample_width = decoded_frame - > width ;
ist - > resample_height = decoded_frame - > height ;
ist - > resample_pix_fmt = decoded_frame - > format ;
2012-06-02 08:26:41 +03:00
2012-04-01 16:08:33 +03:00
for ( i = 0 ; i < nb_filtergraphs ; i + + )
if ( ist_in_filtergraph ( filtergraphs [ i ] , ist ) & &
configure_filtergraph ( filtergraphs [ i ] ) < 0 ) {
2012-01-02 17:02:46 +03:00
av_log ( NULL , AV_LOG_FATAL , " Error reinitializing filters! \n " ) ;
exit_program ( 1 ) ;
2012-04-01 16:08:33 +03:00
}
2012-06-02 08:26:41 +03:00
}
2012-08-09 01:26:38 +03:00
frame_sample_aspect = av_opt_ptr ( avcodec_get_frame_class ( ) , decoded_frame , " sample_aspect_ratio " ) ;
2012-04-01 16:08:33 +03:00
for ( i = 0 ; i < ist - > nb_filters ; i + + ) {
2012-08-09 01:26:38 +03:00
int changed = ist - > st - > codec - > width ! = ist - > filters [ i ] - > filter - > outputs [ 0 ] - > w
| | ist - > st - > codec - > height ! = ist - > filters [ i ] - > filter - > outputs [ 0 ] - > h
| | ist - > st - > codec - > pix_fmt ! = ist - > filters [ i ] - > filter - > outputs [ 0 ] - > format ;
2012-03-29 09:51:17 +03:00
// XXX what an ugly hack
if ( ist - > filters [ i ] - > graph - > nb_outputs = = 1 )
ist - > filters [ i ] - > graph - > outputs [ 0 ] - > ost - > last_quality = quality ;
2012-06-02 08:26:41 +03:00
2012-08-09 01:26:38 +03:00
if ( ! frame_sample_aspect - > num )
* frame_sample_aspect = ist - > st - > sample_aspect_ratio ;
if ( ist - > dr1 & & decoded_frame - > type = = FF_BUFFER_TYPE_USER & & ! changed ) {
2011-12-21 23:04:05 +03:00
FrameBuffer * buf = decoded_frame - > opaque ;
AVFilterBufferRef * fb = avfilter_get_video_buffer_ref_from_arrays (
decoded_frame - > data , decoded_frame - > linesize ,
AV_PERM_READ | AV_PERM_PRESERVE ,
ist - > st - > codec - > width , ist - > st - > codec - > height ,
ist - > st - > codec - > pix_fmt ) ;
2012-06-02 08:26:41 +03:00
2011-12-21 23:04:05 +03:00
avfilter_copy_frame_props ( fb , decoded_frame ) ;
fb - > buf - > priv = buf ;
fb - > buf - > free = filter_release_buffer ;
2012-08-09 01:26:38 +03:00
av_assert0 ( buf - > refcount > 0 ) ;
2011-12-21 23:04:05 +03:00
buf - > refcount + + ;
2012-08-09 01:26:38 +03:00
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter , fb ,
AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
AV_BUFFERSRC_FLAG_NO_COPY ) ;
2011-12-21 23:04:05 +03:00
} else
2012-08-09 01:26:38 +03:00
if ( av_buffersrc_add_frame ( ist - > filters [ i ] - > filter , decoded_frame , 0 ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Failed to inject frame into filter network \n " ) ;
exit_program ( 1 ) ;
}
2012-06-02 08:26:41 +03:00
2011-11-21 16:39:22 +03:00
}
2012-06-02 08:26:41 +03:00
2011-11-21 16:39:22 +03:00
av_free ( buffer_to_free ) ;
2012-06-02 08:26:41 +03:00
return ret ;
}
2011-11-21 16:39:22 +03:00
static int transcode_subtitles ( InputStream * ist , AVPacket * pkt , int * got_output )
2011-08-30 17:03:51 +03:00
{
2011-11-21 16:39:22 +03:00
AVSubtitle subtitle ;
int i , ret = avcodec_decode_subtitle2 ( ist - > st - > codec ,
& subtitle , got_output , pkt ) ;
2012-08-09 01:26:38 +03:00
if ( ret < 0 | | ! * got_output ) {
if ( ! pkt - > size )
sub2video_flush ( ist ) ;
2011-11-21 23:30:23 +03:00
return ret ;
2004-03-14 21:40:43 +02:00
}
2001-09-25 02:22:25 +03:00
2011-11-21 16:39:22 +03:00
rate_emu_sleep ( ist ) ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
sub2video_update ( ist , & subtitle , pkt - > pts ) ;
2002-10-21 20:42:47 +03:00
2011-11-21 16:39:22 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
OutputStream * ost = output_streams [ i ] ;
2012-06-02 08:26:41 +03:00
2011-11-21 16:39:22 +03:00
if ( ! check_output_constraints ( ist , ost ) | | ! ost - > encoding_needed )
2009-01-22 14:04:01 +02:00
continue ;
2012-04-02 21:13:29 +03:00
2012-04-15 16:28:30 +03:00
do_subtitle_out ( output_files [ ost - > file_index ] - > ctx , ost , ist , & subtitle , pkt - > pts ) ;
2011-11-21 16:39:22 +03:00
}
2004-01-22 21:48:28 +02:00
2011-11-21 16:39:22 +03:00
avsubtitle_free ( & subtitle ) ;
2011-11-21 23:30:23 +03:00
return ret ;
2011-11-21 16:39:22 +03:00
}
2009-03-03 21:50:04 +02:00
2011-07-27 21:56:59 +03:00
/* pkt = NULL means EOF (needed to flush decoder buffers) */
2012-04-15 16:03:07 +03:00
static int output_packet ( InputStream * ist , const AVPacket * pkt )
2011-07-27 21:56:59 +03:00
{
2012-08-09 01:26:38 +03:00
int ret = 0 , i ;
2011-07-27 21:56:59 +03:00
int got_output ;
2001-07-22 17:37:44 +03:00
2011-07-27 21:56:59 +03:00
AVPacket avpkt ;
2012-08-09 01:26:38 +03:00
if ( ! ist - > saw_first_ts ) {
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 ;
ist - > pts = 0 ;
if ( pkt ! = NULL & & pkt - > pts ! = AV_NOPTS_VALUE & & ! ist - > decoding_needed ) {
ist - > dts + = av_rescale_q ( pkt - > pts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
ist - > pts = ist - > dts ; //unused but better to set it to a value thats not totally wrong
2012-07-28 17:55:12 +03:00
}
2012-08-09 01:26:38 +03:00
ist - > saw_first_ts = 1 ;
}
2012-07-28 17:55:12 +03:00
2012-02-03 17:32:51 +03:00
if ( ist - > next_dts = = AV_NOPTS_VALUE )
2012-08-09 01:26:38 +03:00
ist - > next_dts = ist - > dts ;
if ( ist - > next_pts = = AV_NOPTS_VALUE )
ist - > next_pts = ist - > pts ;
2007-08-03 22:21:50 +03:00
2011-07-27 21:56:59 +03:00
if ( pkt = = NULL ) {
/* EOF handling */
av_init_packet ( & avpkt ) ;
avpkt . data = NULL ;
avpkt . size = 0 ;
goto handle_eof ;
} else {
avpkt = * pkt ;
}
2008-07-14 01:55:52 +03:00
2012-08-09 01:26:38 +03:00
if ( pkt - > dts ! = AV_NOPTS_VALUE ) {
ist - > next_dts = ist - > dts = av_rescale_q ( pkt - > dts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
if ( ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_VIDEO | | ! ist - > decoding_needed )
ist - > next_pts = ist - > pts = av_rescale_q ( pkt - > dts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
}
2012-01-20 19:06:26 +03:00
2011-12-29 23:28:29 +03:00
// while we have more to decode or while the decoder did output something on EOF
2011-11-21 16:05:38 +03:00
while ( ist - > decoding_needed & & ( avpkt . size > 0 | | ( ! pkt & & got_output ) ) ) {
2012-08-09 01:26:38 +03:00
int duration ;
2011-07-27 21:56:59 +03:00
handle_eof :
2004-06-12 06:41:36 +03:00
2012-08-09 01:26:38 +03:00
ist - > pts = ist - > next_pts ;
ist - > dts = ist - > next_dts ;
2012-07-26 20:29:27 +03:00
2011-11-22 09:16:23 +03:00
if ( avpkt . size & & avpkt . size ! = pkt - > size ) {
2011-09-13 08:31:21 +03:00
av_log ( NULL , ist - > showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING ,
" Multiple frames in a packet from stream %d \n " , pkt - > stream_index ) ;
2011-11-22 09:16:23 +03:00
ist - > showed_multi_packet_warning = 1 ;
2003-10-14 17:36:58 +03:00
}
2005-06-03 17:31:45 +03:00
2011-12-29 23:28:29 +03:00
switch ( ist - > st - > codec - > codec_type ) {
2011-11-21 17:37:40 +03:00
case AVMEDIA_TYPE_AUDIO :
2012-05-18 13:46:11 +03:00
ret = decode_audio ( ist , & avpkt , & got_output ) ;
2011-11-21 17:37:40 +03:00
break ;
case AVMEDIA_TYPE_VIDEO :
2012-05-18 13:46:11 +03:00
ret = decode_video ( ist , & avpkt , & got_output ) ;
2012-08-09 01:26:38 +03:00
if ( avpkt . duration ) {
duration = av_rescale_q ( avpkt . duration , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
} else if ( ist - > st - > codec - > time_base . num ! = 0 & & ist - > st - > codec - > time_base . den ! = 0 ) {
int ticks = ist - > st - > parser ? ist - > st - > parser - > repeat_pict + 1 : ist - > st - > codec - > ticks_per_frame ;
duration = ( ( int64_t ) AV_TIME_BASE *
ist - > st - > codec - > time_base . num * ticks ) /
ist - > st - > codec - > time_base . den ;
} else
duration = 0 ;
2005-12-17 20:14:38 +02:00
2012-08-09 01:26:38 +03:00
if ( ist - > dts ! = AV_NOPTS_VALUE & & duration ) {
ist - > next_dts + = duration ;
} else
ist - > next_dts = AV_NOPTS_VALUE ;
2003-12-15 16:43:44 +02:00
2012-08-09 01:26:38 +03:00
if ( got_output )
ist - > next_pts + = duration ; //FIXME the duration is not correct in some cases
2011-11-21 17:37:40 +03:00
break ;
case AVMEDIA_TYPE_SUBTITLE :
ret = transcode_subtitles ( ist , & avpkt , & got_output ) ;
break ;
2011-11-21 16:06:25 +03:00
default :
return - 1 ;
2003-12-15 16:43:44 +02:00
}
2001-07-22 17:37:44 +03:00
2011-09-23 17:17:42 +03:00
if ( ret < 0 )
return ret ;
2004-03-06 00:51:22 +02:00
2012-08-09 01:26:38 +03:00
avpkt . dts =
avpkt . pts = AV_NOPTS_VALUE ;
2004-04-15 19:34:38 +03:00
2011-11-24 02:18:33 +03:00
// touch data and size only if not EOF
if ( pkt ) {
2012-08-09 01:26:38 +03:00
if ( ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_AUDIO )
ret = avpkt . size ;
2011-11-24 02:18:33 +03:00
avpkt . data + = ret ;
avpkt . size - = ret ;
2001-07-22 17:37:44 +03:00
}
2011-11-21 17:37:40 +03:00
if ( ! got_output ) {
2011-11-21 23:30:23 +03:00
continue ;
2001-07-22 17:37:44 +03:00
}
}
2011-11-21 15:48:45 +03:00
/* handle stream copy */
2011-11-21 16:05:38 +03:00
if ( ! ist - > decoding_needed ) {
rate_emu_sleep ( ist ) ;
2012-08-09 01:26:38 +03:00
ist - > dts = ist - > next_dts ;
2011-11-21 16:05:38 +03:00
switch ( ist - > st - > codec - > codec_type ) {
case AVMEDIA_TYPE_AUDIO :
2012-02-03 17:32:51 +03:00
ist - > next_dts + = ( ( int64_t ) AV_TIME_BASE * ist - > st - > codec - > frame_size ) /
2011-11-21 16:05:38 +03:00
ist - > st - > codec - > sample_rate ;
break ;
case AVMEDIA_TYPE_VIDEO :
2012-08-09 01:26:38 +03:00
if ( pkt - > duration ) {
ist - > next_dts + = av_rescale_q ( pkt - > duration , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
} else if ( ist - > st - > codec - > time_base . num ! = 0 ) {
int ticks = ist - > st - > parser ? ist - > st - > parser - > repeat_pict + 1 : ist - > st - > codec - > ticks_per_frame ;
2012-02-03 17:32:51 +03:00
ist - > next_dts + = ( ( int64_t ) AV_TIME_BASE *
2011-11-21 16:05:38 +03:00
ist - > st - > codec - > time_base . num * ticks ) /
ist - > st - > codec - > time_base . den ;
2001-07-22 17:37:44 +03:00
}
2011-11-21 16:05:38 +03:00
break ;
2001-07-22 17:37:44 +03:00
}
2012-08-09 01:26:38 +03:00
ist - > pts = ist - > dts ;
ist - > next_pts = ist - > next_dts ;
2001-07-22 17:37:44 +03:00
}
2012-04-15 16:03:07 +03:00
for ( i = 0 ; pkt & & i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
OutputStream * ost = output_streams [ i ] ;
2002-09-01 10:19:38 +03:00
2011-11-21 15:48:45 +03:00
if ( ! check_output_constraints ( ist , ost ) | | ost - > encoding_needed )
continue ;
2004-04-08 21:54:40 +03:00
2011-11-21 15:48:45 +03:00
do_streamcopy ( ist , ost , pkt ) ;
}
2003-01-23 20:44:26 +02:00
2011-07-27 21:56:59 +03:00
return 0 ;
2003-06-25 13:21:45 +03:00
}
2012-04-15 16:03:07 +03:00
static void print_sdp ( void )
2001-07-22 17:37:44 +03:00
{
2011-07-27 21:56:59 +03:00
char sdp [ 2048 ] ;
2011-08-17 10:56:08 +03:00
int i ;
2012-04-15 16:03:07 +03:00
AVFormatContext * * avc = av_malloc ( sizeof ( * avc ) * nb_output_files ) ;
2001-07-22 17:37:44 +03:00
2011-08-17 10:56:08 +03:00
if ( ! avc )
exit_program ( 1 ) ;
2012-04-15 16:03:07 +03:00
for ( i = 0 ; i < nb_output_files ; i + + )
2012-04-15 16:28:30 +03:00
avc [ i ] = output_files [ i ] - > ctx ;
2011-08-30 05:06:57 +03:00
2012-04-15 16:03:07 +03:00
av_sdp_create ( avc , nb_output_files , sdp , sizeof ( sdp ) ) ;
2011-07-27 21:56:59 +03:00
printf ( " SDP: \n %s \n " , sdp ) ;
fflush ( stdout ) ;
2011-08-17 10:56:08 +03:00
av_freep ( & avc ) ;
2011-08-30 05:06:57 +03:00
}
2012-04-15 16:03:07 +03:00
static int init_input_stream ( int ist_index , char * error , int error_len )
2011-08-30 05:06:57 +03:00
{
2012-04-15 16:28:30 +03:00
InputStream * ist = input_streams [ ist_index ] ;
2011-08-30 05:06:57 +03:00
2011-07-06 09:49:07 +03:00
if ( ist - > decoding_needed ) {
AVCodec * codec = ist - > dec ;
if ( ! codec ) {
2012-08-09 01:26:38 +03:00
snprintf ( error , error_len , " Decoder (codec %s) not found for input stream #%d:%d " ,
avcodec_get_name ( ist - > st - > codec - > codec_id ) , ist - > file_index , ist - > st - > index ) ;
2011-07-06 09:49:07 +03:00
return AVERROR ( EINVAL ) ;
2011-08-30 05:06:24 +03:00
}
2012-08-09 01:26:38 +03:00
ist - > dr1 = ( codec - > capabilities & CODEC_CAP_DR1 ) & & ! do_deinterlace ;
if ( codec - > type = = AVMEDIA_TYPE_VIDEO & & ist - > dr1 ) {
2011-12-19 17:44:58 +03:00
ist - > st - > codec - > get_buffer = codec_get_buffer ;
ist - > st - > codec - > release_buffer = codec_release_buffer ;
2012-05-30 08:32:43 +03:00
ist - > st - > codec - > opaque = & ist - > buffer_pool ;
2012-04-01 16:08:33 +03:00
}
2011-12-19 17:44:58 +03:00
2012-01-18 12:53:41 +03:00
if ( ! av_dict_get ( ist - > opts , " threads " , NULL , 0 ) )
av_dict_set ( & ist - > opts , " threads " , " auto " , 0 ) ;
2011-07-06 09:49:07 +03:00
if ( avcodec_open2 ( ist - > st - > codec , codec , & ist - > opts ) < 0 ) {
2011-11-06 15:00:13 +03:00
snprintf ( error , error_len , " Error while opening decoder for input stream #%d:%d " ,
2011-07-06 09:49:07 +03:00
ist - > file_index , ist - > st - > index ) ;
return AVERROR ( EINVAL ) ;
2011-08-30 05:06:24 +03:00
}
2011-07-06 09:49:07 +03:00
assert_codec_experimental ( ist - > st - > codec , 0 ) ;
assert_avoptions ( ist - > opts ) ;
2012-04-01 16:08:33 +03:00
}
2011-08-30 05:06:24 +03:00
2012-08-09 01:26:38 +03:00
ist - > next_pts = AV_NOPTS_VALUE ;
2012-02-03 17:32:51 +03:00
ist - > next_dts = AV_NOPTS_VALUE ;
2011-07-06 09:49:07 +03:00
ist - > is_start = 1 ;
2011-08-30 05:06:24 +03:00
2011-05-24 19:14:42 +03:00
return 0 ;
2001-07-22 17:37:44 +03:00
}
2012-04-01 16:08:33 +03:00
static InputStream * get_input_stream ( OutputStream * ost )
2011-04-14 14:32:36 +03:00
{
2012-04-01 16:08:33 +03:00
if ( ost - > source_index > = 0 )
return input_streams [ ost - > source_index ] ;
return NULL ;
2011-04-14 14:32:36 +03:00
}
2012-06-22 15:36:27 +03:00
static void parse_forced_key_frames ( char * kf , OutputStream * ost ,
AVCodecContext * avctx )
2011-11-04 20:54:01 +03:00
{
2012-06-22 15:36:27 +03:00
char * p ;
int n = 1 , i ;
int64_t t ;
2011-11-04 20:54:01 +03:00
2012-06-22 15:36:27 +03:00
for ( p = kf ; * p ; p + + )
if ( * p = = ' , ' )
n + + ;
ost - > forced_kf_count = n ;
ost - > forced_kf_pts = av_malloc ( sizeof ( * ost - > forced_kf_pts ) * n ) ;
if ( ! ost - > forced_kf_pts ) {
av_log ( NULL , AV_LOG_FATAL , " Could not allocate forced key frames array. \n " ) ;
2011-11-04 20:54:01 +03:00
exit_program ( 1 ) ;
}
2012-04-30 23:48:42 +03:00
p = kf ;
2012-06-22 15:36:27 +03:00
for ( i = 0 ; i < n ; i + + ) {
2012-04-30 23:48:42 +03:00
char * next = strchr ( p , ' , ' ) ;
2011-11-04 20:54:01 +03:00
2012-04-30 23:48:42 +03:00
if ( next )
* next + + = 0 ;
2012-06-22 15:36:27 +03:00
t = parse_time_or_die ( " force_key_frames " , p , 1 ) ;
ost - > forced_kf_pts [ i ] = av_rescale_q ( t , AV_TIME_BASE_Q , avctx - > time_base ) ;
2012-04-30 23:48:42 +03:00
p = next ;
2011-11-04 20:54:01 +03:00
}
}
2012-08-09 01:26:38 +03:00
static void report_new_stream ( int input_index , AVPacket * pkt )
2010-11-02 08:01:28 +02:00
{
2012-08-09 01:26:38 +03:00
InputFile * file = input_files [ input_index ] ;
AVStream * st = file - > ctx - > streams [ pkt - > stream_index ] ;
if ( pkt - > stream_index < file - > nb_streams_warn )
return ;
av_log ( file - > ctx , AV_LOG_WARNING ,
" New %s stream %d:%d at pos:% " PRId64 " and DTS:%ss \n " ,
av_get_media_type_string ( st - > codec - > codec_type ) ,
input_index , pkt - > stream_index ,
pkt - > pos , av_ts2timestr ( pkt - > dts , & st - > time_base ) ) ;
file - > nb_streams_warn = pkt - > stream_index + 1 ;
2010-11-02 08:01:28 +02:00
}
2012-04-15 16:03:07 +03:00
static int transcode_init ( void )
2011-07-27 21:56:59 +03:00
{
2011-08-31 23:24:06 +03:00
int ret = 0 , i , j , k ;
2011-11-20 14:23:55 +03:00
AVFormatContext * oc ;
2012-08-05 09:30:24 +03:00
AVCodecContext * codec ;
2011-08-17 11:21:37 +03:00
OutputStream * ost ;
2011-07-27 21:56:59 +03:00
InputStream * ist ;
char error [ 1024 ] ;
int want_sdp = 1 ;
2012-03-16 06:07:59 +03:00
2011-08-29 10:16:42 +03:00
/* init framerate emulation */
for ( i = 0 ; i < nb_input_files ; i + + ) {
2012-04-15 16:28:30 +03:00
InputFile * ifile = input_files [ i ] ;
2011-08-29 10:16:42 +03:00
if ( ifile - > rate_emu )
for ( j = 0 ; j < ifile - > nb_streams ; j + + )
2012-04-15 16:28:30 +03:00
input_streams [ j + ifile - > ist_index ] - > start = av_gettime ( ) ;
2011-12-17 03:36:59 +03:00
}
2004-07-21 04:35:32 +03:00
2011-07-27 21:56:59 +03:00
/* output stream init */
2011-11-20 14:32:27 +03:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 16:28:30 +03:00
oc = output_files [ i ] - > ctx ;
2011-11-20 14:23:55 +03:00
if ( ! oc - > nb_streams & & ! ( oc - > oformat - > flags & AVFMT_NOSTREAMS ) ) {
av_dump_format ( oc , i , oc - > filename , 1 ) ;
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_ERROR , " Output file #%d does not contain any stream \n " , i ) ;
2011-08-20 00:45:02 +03:00
return AVERROR ( EINVAL ) ;
2011-12-17 03:36:59 +03:00
}
}
2004-07-21 04:35:32 +03:00
2012-04-01 16:08:33 +03:00
/* init complex filtergraphs */
for ( i = 0 ; i < nb_filtergraphs ; i + + )
if ( ( ret = avfilter_graph_config ( filtergraphs [ i ] - > graph , NULL ) ) < 0 )
return ret ;
2011-05-28 02:53:00 +03:00
2011-07-27 21:56:59 +03:00
/* for each output stream, we compute the right encoding parameters */
2011-08-17 11:21:37 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-08-05 09:30:24 +03:00
AVCodecContext * icodec = NULL ;
2012-04-15 16:28:30 +03:00
ost = output_streams [ i ] ;
oc = output_files [ ost - > file_index ] - > ctx ;
2012-04-01 16:08:33 +03:00
ist = get_input_stream ( ost ) ;
2008-07-14 01:55:52 +03:00
2011-10-30 09:10:08 +03:00
if ( ost - > attachment_filename )
continue ;
2004-04-06 09:31:12 +03:00
2011-11-20 14:32:27 +03:00
codec = ost - > st - > codec ;
2011-08-30 05:19:26 +03:00
2012-04-01 16:08:33 +03:00
if ( ist ) {
icodec = ist - > st - > codec ;
2011-08-30 05:19:26 +03:00
2012-04-01 16:08:33 +03:00
ost - > st - > disposition = ist - > st - > disposition ;
codec - > bits_per_raw_sample = icodec - > bits_per_raw_sample ;
codec - > chroma_sample_location = icodec - > chroma_sample_location ;
}
2007-08-08 17:34:51 +03:00
2011-10-23 12:22:33 +03:00
if ( ost - > stream_copy ) {
2012-04-21 08:03:06 +03:00
uint64_t extra_size ;
2011-08-30 15:07:49 +03:00
2012-04-21 08:03:06 +03:00
av_assert0 ( ist & & ! ost - > filter ) ;
2012-04-15 16:28:30 +03:00
2012-04-21 08:03:06 +03:00
extra_size = ( uint64_t ) icodec - > extradata_size + FF_INPUT_BUFFER_PADDING_SIZE ;
2011-08-30 15:07:49 +03:00
2011-08-19 21:26:21 +03:00
if ( extra_size > INT_MAX ) {
2011-08-20 00:45:02 +03:00
return AVERROR ( EINVAL ) ;
2011-08-19 21:26:21 +03:00
}
2012-04-15 16:28:30 +03:00
2011-07-27 21:56:59 +03:00
/* if stream_copy is selected, no need to decode or encode */
2011-11-20 14:32:27 +03:00
codec - > codec_id = icodec - > codec_id ;
2011-07-27 21:56:59 +03:00
codec - > codec_type = icodec - > codec_type ;
2011-08-30 15:07:49 +03:00
2011-11-20 14:32:27 +03:00
if ( ! codec - > codec_tag ) {
if ( ! oc - > oformat - > codec_tag | |
av_codec_get_id ( oc - > oformat - > codec_tag , icodec - > codec_tag ) = = codec - > codec_id | |
av_codec_get_tag ( oc - > oformat - > codec_tag , icodec - > codec_id ) < = 0 )
2011-07-27 21:56:59 +03:00
codec - > codec_tag = icodec - > codec_tag ;
}
2011-08-30 15:07:49 +03:00
2011-11-20 14:32:27 +03:00
codec - > bit_rate = icodec - > bit_rate ;
2011-07-27 21:56:59 +03:00
codec - > rc_max_rate = icodec - > rc_max_rate ;
codec - > rc_buffer_size = icodec - > rc_buffer_size ;
2011-12-14 05:49:06 +03:00
codec - > field_order = icodec - > field_order ;
2011-11-20 14:32:27 +03:00
codec - > extradata = av_mallocz ( extra_size ) ;
2011-08-19 21:26:21 +03:00
if ( ! codec - > extradata ) {
2011-08-20 00:45:02 +03:00
return AVERROR ( ENOMEM ) ;
2011-08-19 21:26:21 +03:00
}
2011-07-27 21:56:59 +03:00
memcpy ( codec - > extradata , icodec - > extradata , icodec - > extradata_size ) ;
2012-08-09 01:26:38 +03:00
codec - > extradata_size = icodec - > extradata_size ;
codec - > bits_per_coded_sample = icodec - > bits_per_coded_sample ;
2011-10-16 20:05:11 +03:00
2012-08-09 01:26:38 +03:00
codec - > time_base = ist - > st - > time_base ;
/*
* Avi is a special case here because it supports variable fps but
* having the fps and timebase differe significantly adds quite some
* overhead
*/
if ( ! strcmp ( oc - > oformat - > name , " avi " ) ) {
if ( copy_tb < 0 & & av_q2d ( ist - > st - > r_frame_rate ) > = av_q2d ( ist - > st - > avg_frame_rate )
& & 0.5 / av_q2d ( ist - > st - > r_frame_rate ) > av_q2d ( ist - > st - > time_base )
& & 0.5 / av_q2d ( ist - > st - > r_frame_rate ) > av_q2d ( icodec - > time_base )
& & av_q2d ( ist - > st - > time_base ) < 1.0 / 500 & & av_q2d ( icodec - > time_base ) < 1.0 / 500
| | copy_tb = = 2 ) {
codec - > time_base . num = ist - > st - > r_frame_rate . den ;
codec - > time_base . den = 2 * ist - > st - > r_frame_rate . num ;
codec - > ticks_per_frame = 2 ;
} else if ( copy_tb < 0 & & av_q2d ( icodec - > time_base ) * icodec - > ticks_per_frame > 2 * av_q2d ( ist - > st - > time_base )
& & av_q2d ( ist - > st - > time_base ) < 1.0 / 500
| | copy_tb = = 0 ) {
codec - > time_base = icodec - > time_base ;
codec - > time_base . num * = icodec - > ticks_per_frame ;
codec - > time_base . den * = 2 ;
codec - > ticks_per_frame = 2 ;
}
} else if ( ! ( oc - > oformat - > flags & AVFMT_VARIABLE_FPS )
& & strcmp ( oc - > oformat - > name , " mov " ) & & strcmp ( oc - > oformat - > name , " mp4 " ) & & strcmp ( oc - > oformat - > name , " 3gp " )
& & strcmp ( oc - > oformat - > name , " 3g2 " ) & & strcmp ( oc - > oformat - > name , " psp " ) & & strcmp ( oc - > oformat - > name , " ipod " )
) {
if ( copy_tb < 0 & & av_q2d ( icodec - > time_base ) * icodec - > ticks_per_frame > av_q2d ( ist - > st - > time_base )
& & av_q2d ( ist - > st - > time_base ) < 1.0 / 500
| | copy_tb = = 0 ) {
codec - > time_base = icodec - > time_base ;
codec - > time_base . num * = icodec - > ticks_per_frame ;
}
}
2011-08-30 15:07:49 +03:00
2012-08-09 01:26:38 +03:00
if ( ost - > frame_rate . num )
codec - > time_base = av_inv_q ( ost - > frame_rate ) ;
av_reduce ( & codec - > time_base . num , & codec - > time_base . den ,
codec - > time_base . num , codec - > time_base . den , INT_MAX ) ;
2011-11-20 14:32:27 +03:00
2011-12-29 23:28:29 +03:00
switch ( codec - > codec_type ) {
2011-07-27 21:56:59 +03:00
case AVMEDIA_TYPE_AUDIO :
2011-12-29 23:28:29 +03:00
if ( audio_volume ! = 256 ) {
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_FATAL , " -acodec copy and -vol are incompatible (frames are not decoded) \n " ) ;
2011-07-27 21:56:59 +03:00
exit_program ( 1 ) ;
}
2011-11-20 14:32:27 +03:00
codec - > channel_layout = icodec - > channel_layout ;
codec - > sample_rate = icodec - > sample_rate ;
codec - > channels = icodec - > channels ;
codec - > frame_size = icodec - > frame_size ;
2011-07-27 21:56:59 +03:00
codec - > audio_service_type = icodec - > audio_service_type ;
2011-11-20 14:32:27 +03:00
codec - > block_align = icodec - > block_align ;
2012-08-09 01:26:38 +03:00
if ( ( codec - > block_align = = 1 | | codec - > block_align = = 1152 ) & & codec - > codec_id = = AV_CODEC_ID_MP3 )
codec - > block_align = 0 ;
if ( codec - > codec_id = = AV_CODEC_ID_AC3 )
codec - > block_align = 0 ;
2011-07-27 21:56:59 +03:00
break ;
case AVMEDIA_TYPE_VIDEO :
2011-11-20 14:32:27 +03:00
codec - > pix_fmt = icodec - > pix_fmt ;
codec - > width = icodec - > width ;
codec - > height = icodec - > height ;
codec - > has_b_frames = icodec - > has_b_frames ;
2011-07-27 21:56:59 +03:00
if ( ! codec - > sample_aspect_ratio . num ) {
2011-11-20 14:32:27 +03:00
codec - > sample_aspect_ratio =
2011-07-27 21:56:59 +03:00
ost - > st - > sample_aspect_ratio =
ist - > st - > sample_aspect_ratio . num ? ist - > st - > sample_aspect_ratio :
ist - > st - > codec - > sample_aspect_ratio . num ?
ist - > st - > codec - > sample_aspect_ratio : ( AVRational ) { 0 , 1 } ;
}
2012-08-09 01:26:38 +03:00
ost - > st - > avg_frame_rate = ist - > st - > avg_frame_rate ;
2011-07-27 21:56:59 +03:00
break ;
case AVMEDIA_TYPE_SUBTITLE :
2011-11-20 14:32:27 +03:00
codec - > width = icodec - > width ;
2011-07-27 21:56:59 +03:00
codec - > height = icodec - > height ;
break ;
case AVMEDIA_TYPE_DATA :
2011-09-27 11:37:22 +03:00
case AVMEDIA_TYPE_ATTACHMENT :
2011-07-27 21:56:59 +03:00
break ;
default :
abort ( ) ;
}
} else {
2012-08-09 01:26:38 +03:00
if ( ! ost - > enc )
ost - > enc = avcodec_find_encoder ( codec - > codec_id ) ;
2012-04-18 07:53:11 +03:00
if ( ! ost - > enc ) {
/* should only happen when a default codec is not present. */
2012-08-09 01:26:38 +03:00
snprintf ( error , sizeof ( error ) , " Encoder (codec %s) not found for output stream #%d:%d " ,
avcodec_get_name ( ost - > st - > codec - > codec_id ) , ost - > file_index , ost - > index ) ;
2012-04-18 07:53:11 +03:00
ret = AVERROR ( EINVAL ) ;
goto dump_format ;
2011-08-30 15:07:49 +03:00
}
2012-04-01 16:08:33 +03:00
if ( ist )
ist - > decoding_needed = 1 ;
2011-09-27 09:16:26 +03:00
ost - > encoding_needed = 1 ;
2012-03-29 08:40:26 +03:00
2012-05-05 19:22:46 +03:00
if ( ! ost - > filter & &
( codec - > codec_type = = AVMEDIA_TYPE_VIDEO | |
codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) ) {
2012-04-01 16:08:33 +03:00
FilterGraph * fg ;
fg = init_simple_filtergraph ( ist , ost ) ;
2012-05-26 13:47:47 +03:00
if ( configure_filtergraph ( fg ) ) {
2012-04-01 16:08:33 +03:00
av_log ( NULL , AV_LOG_FATAL , " Error opening filters! \n " ) ;
exit ( 1 ) ;
}
2012-05-26 17:52:58 +03:00
}
2012-08-09 01:26:38 +03:00
if ( codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
if ( ost - > filter & & ! ost - > frame_rate . num )
ost - > frame_rate = av_buffersink_get_frame_rate ( ost - > filter - > filter ) ;
if ( ist & & ! ost - > frame_rate . num )
ost - > frame_rate = ist - > st - > r_frame_rate . num ? ist - > st - > r_frame_rate : ( AVRational ) { 25 , 1 } ;
// ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
if ( ost - > enc & & ost - > enc - > supported_framerates & & ! ost - > force_fps ) {
int idx = av_find_nearest_q_idx ( ost - > frame_rate , ost - > enc - > supported_framerates ) ;
ost - > frame_rate = ost - > enc - > supported_framerates [ idx ] ;
}
}
2012-05-31 13:29:07 +03:00
2012-05-05 19:22:46 +03:00
switch ( codec - > codec_type ) {
case AVMEDIA_TYPE_AUDIO :
codec - > sample_fmt = ost - > filter - > filter - > inputs [ 0 ] - > format ;
codec - > sample_rate = ost - > filter - > filter - > inputs [ 0 ] - > sample_rate ;
codec - > channel_layout = ost - > filter - > filter - > inputs [ 0 ] - > channel_layout ;
codec - > channels = av_get_channel_layout_nb_channels ( codec - > channel_layout ) ;
codec - > time_base = ( AVRational ) { 1 , codec - > sample_rate } ;
break ;
case AVMEDIA_TYPE_VIDEO :
2012-08-09 01:26:38 +03:00
codec - > time_base = av_inv_q ( ost - > frame_rate ) ;
if ( ost - > filter & & ! ( codec - > time_base . num & & codec - > time_base . den ) )
codec - > time_base = ost - > filter - > filter - > inputs [ 0 ] - > time_base ;
if ( av_q2d ( codec - > time_base ) < 0.001 & & video_sync_method ! = VSYNC_PASSTHROUGH
& & ( video_sync_method = = VSYNC_CFR | | ( video_sync_method = = VSYNC_AUTO & & ! ( oc - > oformat - > flags & AVFMT_VARIABLE_FPS ) ) ) ) {
av_log ( oc , AV_LOG_WARNING , " Frame rate very high for a muxer not efficiently supporting it. \n "
" Please consider specifying a lower framerate, a different muxer or -vsync 2 \n " ) ;
}
for ( j = 0 ; j < ost - > forced_kf_count ; j + + )
ost - > forced_kf_pts [ j ] = av_rescale_q ( ost - > forced_kf_pts [ j ] ,
AV_TIME_BASE_Q ,
codec - > time_base ) ;
2011-07-27 21:56:59 +03:00
2012-04-01 16:08:33 +03:00
codec - > width = ost - > filter - > filter - > inputs [ 0 ] - > w ;
codec - > height = ost - > filter - > filter - > inputs [ 0 ] - > h ;
codec - > sample_aspect_ratio = ost - > st - > sample_aspect_ratio =
ost - > frame_aspect_ratio ? // overridden by the -aspect cli option
av_d2q ( ost - > frame_aspect_ratio * codec - > height / codec - > width , 255 ) :
ost - > filter - > filter - > inputs [ 0 ] - > sample_aspect_ratio ;
codec - > pix_fmt = ost - > filter - > filter - > inputs [ 0 ] - > format ;
2012-03-23 17:46:30 +03:00
2012-08-09 01:26:38 +03:00
if ( ! icodec | |
codec - > width ! = icodec - > width | |
2012-03-23 22:59:09 +03:00
codec - > height ! = icodec - > height | |
codec - > pix_fmt ! = icodec - > pix_fmt ) {
2012-08-09 01:26:38 +03:00
codec - > bits_per_raw_sample = frame_bits_per_raw_sample ;
2012-03-23 17:46:30 +03:00
}
2012-05-05 19:22:46 +03:00
2012-06-22 15:36:27 +03:00
if ( ost - > forced_keyframes )
parse_forced_key_frames ( ost - > forced_keyframes , ost ,
ost - > st - > codec ) ;
2011-07-27 21:56:59 +03:00
break ;
case AVMEDIA_TYPE_SUBTITLE :
2012-02-05 16:28:19 +03:00
codec - > time_base = ( AVRational ) { 1 , 1000 } ;
2011-07-27 21:56:59 +03:00
break ;
default :
abort ( ) ;
break ;
}
/* two pass mode */
2012-08-09 01:26:38 +03:00
if ( codec - > flags & ( CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2 ) ) {
2011-07-27 21:56:59 +03:00
char logfilename [ 1024 ] ;
FILE * f ;
2012-05-05 19:22:46 +03:00
2011-07-27 21:56:59 +03:00
snprintf ( logfilename , sizeof ( logfilename ) , " %s-%d.log " ,
pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX ,
i ) ;
2012-03-12 19:42:57 +03:00
if ( ! strcmp ( ost - > enc - > name , " libx264 " ) ) {
av_dict_set ( & ost - > opts , " stats " , logfilename , AV_DICT_DONT_OVERWRITE ) ;
} else {
2012-08-09 01:26:38 +03:00
if ( codec - > flags & CODEC_FLAG_PASS2 ) {
2012-03-12 19:43:48 +03:00
char * logbuffer ;
size_t logbuffer_size ;
if ( cmdutils_read_file ( logfilename , & logbuffer , & logbuffer_size ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Error reading log file '%s' for pass-2 encoding \n " ,
logfilename ) ;
exit_program ( 1 ) ;
}
codec - > stats_in = logbuffer ;
2011-07-27 21:56:59 +03:00
}
2012-08-09 01:26:38 +03:00
if ( codec - > flags & CODEC_FLAG_PASS1 ) {
f = fopen ( logfilename , " wb " ) ;
if ( ! f ) {
av_log ( NULL , AV_LOG_FATAL , " Cannot write log file '%s' for pass-1 encoding: %s \n " ,
logfilename , strerror ( errno ) ) ;
exit_program ( 1 ) ;
}
ost - > logfile = f ;
}
2012-03-12 19:42:57 +03:00
}
2011-07-27 21:56:59 +03:00
}
2011-08-30 15:07:49 +03:00
}
}
2011-07-27 21:56:59 +03:00
/* open each encoder */
2011-08-17 11:21:37 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
ost = output_streams [ i ] ;
2011-07-27 21:56:59 +03:00
if ( ost - > encoding_needed ) {
2011-11-20 14:32:27 +03:00
AVCodec * codec = ost - > enc ;
2012-04-01 16:08:33 +03:00
AVCodecContext * dec = NULL ;
if ( ( ist = get_input_stream ( ost ) ) )
dec = ist - > st - > codec ;
if ( dec & & dec - > subtitle_header ) {
2012-08-09 01:26:38 +03:00
/* ASS code assumes this buffer is null terminated so add extra byte. */
ost - > st - > codec - > subtitle_header = av_mallocz ( dec - > subtitle_header_size + 1 ) ;
2011-07-27 21:56:59 +03:00
if ( ! ost - > st - > codec - > subtitle_header ) {
ret = AVERROR ( ENOMEM ) ;
goto dump_format ;
2011-11-04 03:44:06 +03:00
}
2011-07-27 21:56:59 +03:00
memcpy ( ost - > st - > codec - > subtitle_header , dec - > subtitle_header , dec - > subtitle_header_size ) ;
ost - > st - > codec - > subtitle_header_size = dec - > subtitle_header_size ;
2011-11-04 03:44:06 +03:00
}
2012-01-18 12:53:41 +03:00
if ( ! av_dict_get ( ost - > opts , " threads " , NULL , 0 ) )
av_dict_set ( & ost - > opts , " threads " , " auto " , 0 ) ;
2011-07-27 21:56:59 +03:00
if ( avcodec_open2 ( ost - > st - > codec , codec , & ost - > opts ) < 0 ) {
2011-11-06 15:00:13 +03:00
snprintf ( error , sizeof ( error ) , " Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height " ,
2011-07-27 21:56:59 +03:00
ost - > file_index , ost - > index ) ;
ret = AVERROR ( EINVAL ) ;
goto dump_format ;
2011-11-04 03:44:06 +03:00
}
2012-08-09 01:26:38 +03:00
if ( ost - > enc - > type = = AVMEDIA_TYPE_AUDIO & &
! ( ost - > enc - > capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE ) )
av_buffersink_set_frame_size ( ost - > filter - > filter ,
ost - > st - > codec - > frame_size ) ;
2011-07-27 21:56:59 +03:00
assert_codec_experimental ( ost - > st - > codec , 1 ) ;
assert_avoptions ( ost - > opts ) ;
if ( ost - > st - > codec - > bit_rate & & ost - > st - > codec - > bit_rate < 1000 )
av_log ( NULL , AV_LOG_WARNING , " The bitrate parameter is set too low. "
2012-08-09 01:26:38 +03:00
" It takes bits/s as argument, not kbits/s \n " ) ;
2011-07-27 21:56:59 +03:00
extra_size + = ost - > st - > codec - > extradata_size ;
2007-08-08 17:34:51 +03:00
2011-09-02 18:06:30 +03:00
if ( ost - > st - > codec - > me_threshold )
2012-04-15 16:28:30 +03:00
input_streams [ ost - > source_index ] - > st - > codec - > debug | = FF_DEBUG_MV ;
2011-07-27 21:56:59 +03:00
}
2007-08-08 17:34:51 +03:00
}
2011-11-04 03:44:06 +03:00
2011-07-06 09:49:07 +03:00
/* init input streams */
for ( i = 0 ; i < nb_input_streams ; i + + )
2012-04-15 16:03:07 +03:00
if ( ( ret = init_input_stream ( i , error , sizeof ( error ) ) ) < 0 )
2011-07-06 09:49:07 +03:00
goto dump_format ;
2011-11-04 03:44:06 +03:00
2011-08-31 23:24:06 +03:00
/* discard unused programs */
for ( i = 0 ; i < nb_input_files ; i + + ) {
2012-04-15 16:28:30 +03:00
InputFile * ifile = input_files [ i ] ;
2011-08-31 23:24:06 +03:00
for ( j = 0 ; j < ifile - > ctx - > nb_programs ; j + + ) {
AVProgram * p = ifile - > ctx - > programs [ j ] ;
int discard = AVDISCARD_ALL ;
2007-08-08 17:34:51 +03:00
2011-08-31 23:24:06 +03:00
for ( k = 0 ; k < p - > nb_stream_indexes ; k + + )
2012-04-15 16:28:30 +03:00
if ( ! input_streams [ ifile - > ist_index + p - > stream_index [ k ] ] - > discard ) {
2011-08-31 23:24:06 +03:00
discard = AVDISCARD_DEFAULT ;
break ;
}
p - > discard = discard ;
2010-03-02 02:01:16 +02:00
}
2009-10-30 11:57:34 +02:00
}
2011-07-27 21:56:59 +03:00
/* open files and write file headers */
2011-08-17 10:56:08 +03:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 16:28:30 +03:00
oc = output_files [ i ] - > ctx ;
2011-11-20 14:23:55 +03:00
oc - > interrupt_callback = int_cb ;
2012-05-26 00:55:56 +03:00
if ( ( ret = avformat_write_header ( oc , & output_files [ i ] - > opts ) ) < 0 ) {
char errbuf [ 128 ] ;
const char * errbuf_ptr = errbuf ;
if ( av_strerror ( ret , errbuf , sizeof ( errbuf ) ) < 0 )
errbuf_ptr = strerror ( AVUNERROR ( ret ) ) ;
snprintf ( error , sizeof ( error ) , " Could not write header for output file #%d (incorrect codec parameters ?): %s " , i , errbuf_ptr ) ;
2011-07-27 21:56:59 +03:00
ret = AVERROR ( EINVAL ) ;
goto dump_format ;
2012-04-16 19:51:24 +03:00
}
2012-08-09 01:26:38 +03:00
// assert_avoptions(output_files[i]->opts);
2011-11-20 14:23:55 +03:00
if ( strcmp ( oc - > oformat - > name , " rtp " ) ) {
2011-07-27 21:56:59 +03:00
want_sdp = 0 ;
2012-05-26 17:52:58 +03:00
}
2011-06-09 11:58:23 +03:00
}
2011-08-30 05:10:54 +03:00
2011-07-27 21:56:59 +03:00
dump_format :
/* dump the file output parameters - cannot be done before in case
of stream copy */
2011-11-20 14:32:27 +03:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 16:28:30 +03:00
av_dump_format ( output_files [ i ] - > ctx , i , output_files [ i ] - > ctx - > filename , 1 ) ;
2001-07-22 17:37:44 +03:00
}
2011-07-27 21:56:59 +03:00
/* dump the stream mapping */
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_INFO , " Stream mapping: \n " ) ;
2012-04-01 16:08:33 +03:00
for ( i = 0 ; i < nb_input_streams ; i + + ) {
ist = input_streams [ i ] ;
2004-09-20 18:49:24 +03:00
2012-04-01 16:08:33 +03:00
for ( j = 0 ; j < ist - > nb_filters ; j + + ) {
if ( ist - > filters [ j ] - > graph - > graph_desc ) {
av_log ( NULL , AV_LOG_INFO , " Stream #%d:%d (%s) -> %s " ,
ist - > file_index , ist - > st - > index , ist - > dec ? ist - > dec - > name : " ? " ,
2012-05-26 14:31:54 +03:00
ist - > filters [ j ] - > name ) ;
2012-04-01 16:08:33 +03:00
if ( nb_filtergraphs > 1 )
av_log ( NULL , AV_LOG_INFO , " (graph %d) " , ist - > filters [ j ] - > graph - > index ) ;
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
}
2003-11-10 20:54:17 +02:00
}
}
2011-09-13 08:31:21 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
ost = output_streams [ i ] ;
2011-11-04 03:44:06 +03:00
2011-10-30 09:10:08 +03:00
if ( ost - > attachment_filename ) {
/* an attached file */
av_log ( NULL , AV_LOG_INFO , " File %s -> Stream #%d:%d \n " ,
ost - > attachment_filename , ost - > file_index , ost - > index ) ;
continue ;
2011-11-04 03:44:06 +03:00
}
2011-10-18 02:33:09 +03:00
2012-04-01 16:08:33 +03:00
if ( ost - > filter & & ost - > filter - > graph - > graph_desc ) {
/* output from a complex graph */
2012-05-26 14:31:54 +03:00
av_log ( NULL , AV_LOG_INFO , " %s " , ost - > filter - > name ) ;
2012-04-01 16:08:33 +03:00
if ( nb_filtergraphs > 1 )
av_log ( NULL , AV_LOG_INFO , " (graph %d) " , ost - > filter - > graph - > index ) ;
2011-10-18 02:33:09 +03:00
2012-04-01 16:08:33 +03:00
av_log ( NULL , AV_LOG_INFO , " -> Stream #%d:%d (%s) \n " , ost - > file_index ,
ost - > index , ost - > enc ? ost - > enc - > name : " ? " ) ;
2011-10-18 02:33:09 +03:00
continue ;
2001-09-17 00:47:13 +03:00
}
2011-10-26 03:09:31 +03:00
2011-11-06 15:00:13 +03:00
av_log ( NULL , AV_LOG_INFO , " Stream #%d:%d -> #%d:%d " ,
2012-04-15 16:28:30 +03:00
input_streams [ ost - > source_index ] - > file_index ,
input_streams [ ost - > source_index ] - > st - > index ,
2011-09-13 08:31:21 +03:00
ost - > file_index ,
ost - > index ) ;
2012-04-15 16:28:30 +03:00
if ( ost - > sync_ist ! = input_streams [ ost - > source_index ] )
2011-11-06 15:00:13 +03:00
av_log ( NULL , AV_LOG_INFO , " [sync #%d:%d] " ,
2011-09-13 08:31:21 +03:00
ost - > sync_ist - > file_index ,
ost - > sync_ist - > st - > index ) ;
2011-10-23 12:22:33 +03:00
if ( ost - > stream_copy )
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_INFO , " (copy) " ) ;
else
2012-04-15 16:28:30 +03:00
av_log ( NULL , AV_LOG_INFO , " (%s -> %s) " , input_streams [ ost - > source_index ] - > dec ?
input_streams [ ost - > source_index ] - > dec - > name : " ? " ,
2011-09-13 08:31:21 +03:00
ost - > enc ? ost - > enc - > name : " ? " ) ;
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2011-08-30 05:19:26 +03:00
}
2011-07-27 21:56:59 +03:00
if ( ret ) {
2011-09-13 08:31:21 +03:00
av_log ( NULL , AV_LOG_ERROR , " %s \n " , error ) ;
2011-08-20 00:45:02 +03:00
return ret ;
2011-08-30 05:19:26 +03:00
}
2011-07-27 21:56:59 +03:00
if ( want_sdp ) {
2012-04-15 16:03:07 +03:00
print_sdp ( ) ;
2011-10-18 02:33:09 +03:00
}
2011-08-20 00:45:02 +03:00
return 0 ;
}
2011-09-05 23:10:26 +03:00
2012-06-01 11:44:11 +03:00
/**
* @ return 1 if there are still streams where more output is wanted ,
* 0 otherwise
*/
static int need_output ( void )
{
int i ;
2011-09-05 23:10:26 +03:00
2012-06-01 11:44:11 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
OutputFile * of = output_files [ ost - > file_index ] ;
AVFormatContext * os = output_files [ ost - > file_index ] - > ctx ;
2011-09-05 23:10:26 +03:00
2012-08-08 13:04:53 +03:00
if ( ost - > finished | |
2012-06-01 11:44:11 +03:00
( os - > pb & & avio_tell ( os - > pb ) > = of - > limit_filesize ) )
continue ;
2012-06-04 21:01:55 +03:00
if ( ost - > frame_number > = ost - > max_frames ) {
2012-06-01 11:44:11 +03:00
int j ;
for ( j = 0 ; j < of - > ctx - > nb_streams ; j + + )
2012-08-08 13:04:53 +03:00
output_streams [ of - > ost_index + j ] - > finished = 1 ;
2012-06-01 11:44:11 +03:00
continue ;
}
2011-09-10 21:52:48 +03:00
2012-06-01 11:44:11 +03:00
return 1 ;
2011-09-12 00:35:35 +03:00
}
2006-07-06 18:04:46 +03:00
2012-06-01 11:44:11 +03:00
return 0 ;
}
2012-03-29 16:45:50 +03:00
2012-08-09 01:26:38 +03:00
static int input_acceptable ( InputStream * ist )
2012-06-01 12:00:27 +03:00
{
2012-08-09 01:26:38 +03:00
av_assert1 ( ! ist - > discard ) ;
2012-08-09 16:14:57 +03:00
return ! input_files [ ist - > file_index ] - > eagain & &
2012-08-09 01:26:38 +03:00
! input_files [ ist - > file_index ] - > eof_reached ;
2011-08-30 05:19:26 +03:00
}
2012-08-09 01:26:38 +03:00
static int find_graph_input ( FilterGraph * graph )
2011-09-12 00:35:35 +03:00
{
2012-08-09 01:26:38 +03:00
int i , nb_req_max = 0 , file_index = - 1 ;
for ( i = 0 ; i < graph - > nb_inputs ; i + + ) {
int nb_req = av_buffersrc_get_nb_failed_requests ( graph - > inputs [ i ] - > filter ) ;
if ( nb_req > nb_req_max ) {
InputStream * ist = graph - > inputs [ i ] - > ist ;
if ( input_acceptable ( ist ) ) {
nb_req_max = nb_req ;
2012-06-01 12:00:27 +03:00
file_index = ist - > file_index ;
}
2011-09-12 00:35:35 +03:00
}
}
2012-06-01 12:00:27 +03:00
return file_index ;
2011-09-12 00:35:35 +03:00
}
2005-12-17 20:14:38 +02:00
2012-08-09 01:26:38 +03:00
/**
* Select the input file to read from .
*
* @ return > = 0 index of the input file to use ;
* - 1 if no file is acceptable ;
* - 2 to read from filters without reading from a file
*/
static int select_input_file ( void )
2001-07-22 17:37:44 +03:00
{
2012-08-09 01:26:38 +03:00
int i , ret , nb_active_out = nb_output_streams , ost_index = - 1 ;
int64_t opts_min ;
2011-06-23 20:14:08 +03:00
OutputStream * ost ;
2012-08-09 01:26:38 +03:00
AVFilterBufferRef * dummy ;
2005-12-17 20:14:38 +02:00
2012-08-09 01:26:38 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + )
nb_active_out - = output_streams [ i ] - > unavailable =
2012-08-09 20:09:39 +03:00
output_streams [ i ] - > finished ;
2012-08-09 01:26:38 +03:00
while ( nb_active_out ) {
opts_min = INT64_MAX ;
ost_index = - 1 ;
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
int64_t opts = av_rescale_q ( ost - > st - > cur_dts , ost - > st - > time_base ,
AV_TIME_BASE_Q ) ;
if ( ! ost - > unavailable & & opts < opts_min ) {
opts_min = opts ;
ost_index = i ;
2012-01-17 17:25:14 +03:00
}
}
2012-08-09 01:26:38 +03:00
if ( ost_index < 0 )
return - 1 ;
2005-12-17 20:14:38 +02:00
2012-08-09 01:26:38 +03:00
ost = output_streams [ ost_index ] ;
if ( ost - > source_index > = 0 ) {
/* ost is directly connected to an input */
InputStream * ist = input_streams [ ost - > source_index ] ;
if ( input_acceptable ( ist ) )
return ist - > file_index ;
} else {
/* ost is connected to a complex filtergraph */
av_assert1 ( ost - > filter ) ;
ret = av_buffersink_get_buffer_ref ( ost - > filter - > filter , & dummy ,
AV_BUFFERSINK_FLAG_PEEK ) ;
if ( ret > = 0 )
return - 2 ;
ret = find_graph_input ( ost - > filter - > graph ) ;
if ( ret > = 0 )
return ret ;
2005-06-03 17:31:45 +03:00
}
2012-08-09 01:26:38 +03:00
ost - > unavailable = 1 ;
nb_active_out - - ;
}
return - 1 ;
}
2005-06-03 17:31:45 +03:00
2012-08-09 01:26:38 +03:00
static int check_keyboard_interaction ( int64_t cur_time )
{
int i , ret , key ;
static int64_t last_time ;
if ( received_nb_signals )
return AVERROR_EXIT ;
/* read_key() returns 0 on EOF */
if ( cur_time - last_time > = 100000 & & ! run_as_daemon ) {
key = read_key ( ) ;
last_time = cur_time ;
} else
key = - 1 ;
if ( key = = ' q ' )
return AVERROR_EXIT ;
if ( key = = ' + ' ) av_log_set_level ( av_log_get_level ( ) + 10 ) ;
if ( key = = ' - ' ) av_log_set_level ( av_log_get_level ( ) - 10 ) ;
if ( key = = ' s ' ) qp_hist ^ = 1 ;
if ( key = = ' h ' ) {
if ( do_hex_dump ) {
do_hex_dump = do_pkt_dump = 0 ;
} else if ( do_pkt_dump ) {
do_hex_dump = 1 ;
} else
do_pkt_dump = 1 ;
av_log_set_level ( AV_LOG_DEBUG ) ;
}
if ( key = = ' c ' | | key = = ' C ' ) {
char buf [ 4096 ] , target [ 64 ] , command [ 256 ] , arg [ 256 ] = { 0 } ;
double time ;
int k , n = 0 ;
fprintf ( stderr , " \n Enter command: <target> <time> <command>[ <argument>] \n " ) ;
i = 0 ;
while ( ( k = read_key ( ) ) ! = ' \n ' & & k ! = ' \r ' & & i < sizeof ( buf ) - 1 )
if ( k > 0 )
buf [ i + + ] = k ;
buf [ i ] = 0 ;
if ( k > 0 & &
( n = sscanf ( buf , " %63[^ ] %lf %255[^ ] %255[^ \n ] " , target , & time , command , arg ) ) > = 3 ) {
av_log ( NULL , AV_LOG_DEBUG , " Processing command target:%s time:%f command:%s arg:%s " ,
target , time , command , arg ) ;
for ( i = 0 ; i < nb_filtergraphs ; i + + ) {
FilterGraph * fg = filtergraphs [ i ] ;
if ( fg - > graph ) {
if ( time < 0 ) {
ret = avfilter_graph_send_command ( fg - > graph , target , command , arg , buf , sizeof ( buf ) ,
key = = ' c ' ? AVFILTER_CMD_FLAG_ONE : 0 ) ;
fprintf ( stderr , " Command reply for stream %d: ret:%d res:%s \n " , i , ret , buf ) ;
} else {
ret = avfilter_graph_queue_command ( fg - > graph , target , command , arg , 0 , time ) ;
}
}
2005-06-03 17:31:45 +03:00
}
2012-08-09 01:26:38 +03:00
} else {
av_log ( NULL , AV_LOG_ERROR ,
" Parse error, at least 3 arguments were expected, "
" only %d given in string '%s' \n " , n , buf ) ;
2005-06-03 17:31:45 +03:00
}
2012-08-09 01:26:38 +03:00
}
if ( key = = ' d ' | | key = = ' D ' ) {
int debug = 0 ;
if ( key = = ' D ' ) {
debug = input_streams [ 0 ] - > st - > codec - > debug < < 1 ;
if ( ! debug ) debug = 1 ;
while ( debug & ( FF_DEBUG_DCT_COEFF | FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE ) ) //unsupported, would just crash
debug + = debug ;
} else
if ( scanf ( " %d " , & debug ) ! = 1 )
fprintf ( stderr , " error parsing debug value \n " ) ;
for ( i = 0 ; i < nb_input_streams ; i + + ) {
input_streams [ i ] - > st - > codec - > debug = debug ;
2005-06-03 17:31:45 +03:00
}
2012-08-09 01:26:38 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
ost - > st - > codec - > debug = debug ;
}
if ( debug ) av_log_set_level ( AV_LOG_DEBUG ) ;
fprintf ( stderr , " debug=%d \n " , debug ) ;
2005-06-03 17:31:45 +03:00
}
2012-08-09 01:26:38 +03:00
if ( key = = ' ? ' ) {
fprintf ( stderr , " key function \n "
" ? show this help \n "
" + increase verbosity \n "
" - decrease verbosity \n "
" c Send command to filtergraph \n "
" D cycle through available debug modes \n "
" h dump packets/hex press to cycle through the 3 states \n "
" q quit \n "
" s Show QP histogram \n "
) ;
}
return 0 ;
2005-06-03 17:31:45 +03:00
}
2012-06-11 16:34:12 +03:00
# if HAVE_PTHREADS
2012-06-02 08:26:41 +03:00
static void * input_thread ( void * arg )
2005-06-03 17:31:45 +03:00
{
2012-06-02 08:26:41 +03:00
InputFile * f = arg ;
int ret = 0 ;
2012-05-30 04:32:32 +03:00
2012-06-02 08:26:41 +03:00
while ( ! transcoding_finished & & ret > = 0 ) {
AVPacket pkt ;
ret = av_read_frame ( f - > ctx , & pkt ) ;
2012-05-17 20:31:35 +03:00
2012-06-02 08:26:41 +03:00
if ( ret = = AVERROR ( EAGAIN ) ) {
2012-06-21 22:31:44 +03:00
av_usleep ( 10000 ) ;
2012-06-02 08:26:41 +03:00
ret = 0 ;
continue ;
} else if ( ret < 0 )
break ;
2011-11-04 20:54:01 +03:00
2012-06-02 08:26:41 +03:00
pthread_mutex_lock ( & f - > fifo_lock ) ;
while ( ! av_fifo_space ( f - > fifo ) )
pthread_cond_wait ( & f - > fifo_cond , & f - > fifo_lock ) ;
2005-06-03 17:31:45 +03:00
2012-06-02 08:26:41 +03:00
av_dup_packet ( & pkt ) ;
av_fifo_generic_write ( f - > fifo , & pkt , sizeof ( pkt ) , NULL ) ;
2011-04-14 14:32:36 +03:00
2012-06-02 08:26:41 +03:00
pthread_mutex_unlock ( & f - > fifo_lock ) ;
2011-04-14 14:32:36 +03:00
}
2012-06-02 08:26:41 +03:00
f - > finished = 1 ;
return NULL ;
2011-09-28 02:31:38 +03:00
}
2011-04-14 14:32:36 +03:00
2012-06-02 08:26:41 +03:00
static void free_input_threads ( void )
2011-09-28 02:31:38 +03:00
{
2012-06-02 08:26:41 +03:00
int i ;
2011-04-14 14:32:36 +03:00
2012-06-02 08:26:41 +03:00
if ( nb_input_files = = 1 )
return ;
2005-12-17 20:14:38 +02:00
2012-06-02 08:26:41 +03:00
transcoding_finished = 1 ;
2005-06-03 17:31:45 +03:00
2012-06-02 08:26:41 +03:00
for ( i = 0 ; i < nb_input_files ; i + + ) {
InputFile * f = input_files [ i ] ;
AVPacket pkt ;
2009-03-11 10:14:19 +02:00
2012-06-13 14:33:42 +03:00
if ( ! f - > fifo | | f - > joined )
2012-06-02 08:26:41 +03:00
continue ;
2012-04-15 22:43:55 +03:00
2012-06-02 08:26:41 +03:00
pthread_mutex_lock ( & f - > fifo_lock ) ;
while ( av_fifo_size ( f - > fifo ) ) {
av_fifo_generic_read ( f - > fifo , & pkt , sizeof ( pkt ) , NULL ) ;
av_free_packet ( & pkt ) ;
}
pthread_cond_signal ( & f - > fifo_cond ) ;
pthread_mutex_unlock ( & f - > fifo_lock ) ;
2007-07-25 22:47:44 +03:00
2012-06-02 08:26:41 +03:00
pthread_join ( f - > thread , NULL ) ;
f - > joined = 1 ;
while ( av_fifo_size ( f - > fifo ) ) {
av_fifo_generic_read ( f - > fifo , & pkt , sizeof ( pkt ) , NULL ) ;
av_free_packet ( & pkt ) ;
}
av_fifo_free ( f - > fifo ) ;
2010-07-01 01:35:57 +03:00
}
}
2011-08-30 05:19:26 +03:00
2012-06-02 08:26:41 +03:00
static int init_input_threads ( void )
2011-08-30 05:15:30 +03:00
{
2012-06-02 08:26:41 +03:00
int i , ret ;
2011-08-30 05:15:30 +03:00
2012-06-02 08:26:41 +03:00
if ( nb_input_files = = 1 )
return 0 ;
2011-08-30 05:15:30 +03:00
2012-06-02 08:26:41 +03:00
for ( i = 0 ; i < nb_input_files ; i + + ) {
InputFile * f = input_files [ i ] ;
2011-08-30 05:15:30 +03:00
2012-06-02 08:26:41 +03:00
if ( ! ( f - > fifo = av_fifo_alloc ( 8 * sizeof ( AVPacket ) ) ) )
2011-08-30 05:15:30 +03:00
return AVERROR ( ENOMEM ) ;
2012-06-02 08:26:41 +03:00
pthread_mutex_init ( & f - > fifo_lock , NULL ) ;
pthread_cond_init ( & f - > fifo_cond , NULL ) ;
2011-08-30 05:15:30 +03:00
2012-06-02 08:26:41 +03:00
if ( ( ret = pthread_create ( & f - > thread , NULL , input_thread , f ) ) )
return AVERROR ( ret ) ;
2011-08-30 05:15:30 +03:00
}
return 0 ;
}
2012-06-02 08:26:41 +03:00
static int get_input_packet_mt ( InputFile * f , AVPacket * pkt )
2011-09-05 23:10:26 +03:00
{
2012-06-02 08:26:41 +03:00
int ret = 0 ;
2011-09-05 23:10:26 +03:00
2012-06-02 08:26:41 +03:00
pthread_mutex_lock ( & f - > fifo_lock ) ;
2012-04-01 16:08:33 +03:00
2012-06-02 08:26:41 +03:00
if ( av_fifo_size ( f - > fifo ) ) {
av_fifo_generic_read ( f - > fifo , pkt , sizeof ( * pkt ) , NULL ) ;
pthread_cond_signal ( & f - > fifo_cond ) ;
} else {
if ( f - > finished )
ret = AVERROR_EOF ;
else
ret = AVERROR ( EAGAIN ) ;
2012-04-01 16:08:33 +03:00
}
2012-06-02 08:26:41 +03:00
pthread_mutex_unlock ( & f - > fifo_lock ) ;
2012-04-01 16:08:33 +03:00
2012-06-02 08:26:41 +03:00
return ret ;
}
# endif
2012-04-21 08:03:06 +03:00
2012-06-02 08:26:41 +03:00
static int get_input_packet ( InputFile * f , AVPacket * pkt )
{
2012-06-11 16:34:12 +03:00
# if HAVE_PTHREADS
2012-06-02 08:26:41 +03:00
if ( nb_input_files > 1 )
return get_input_packet_mt ( f , pkt ) ;
# endif
return av_read_frame ( f - > ctx , pkt ) ;
2012-04-01 16:08:33 +03:00
}
2012-08-04 13:04:02 +03:00
static int got_eagain ( void )
{
int i ;
for ( i = 0 ; i < nb_input_files ; i + + )
if ( input_files [ i ] - > eagain )
return 1 ;
return 0 ;
}
static void reset_eagain ( void )
{
int i ;
for ( i = 0 ; i < nb_input_files ; i + + )
input_files [ i ] - > eagain = 0 ;
}
2012-08-09 19:04:17 +03:00
/**
* @ return
* - 0 - - one packet was read and processed
* - AVERROR ( EAGAIN ) - - no packets were available for selected file ,
* this function should be called again
* - AVERROR_EOF - - this function should not be called again
*/
static int process_input ( void )
{
InputFile * ifile ;
AVFormatContext * is ;
InputStream * ist ;
AVPacket pkt ;
int ret , i , j ;
int file_index ;
/* select the stream that we must read now */
file_index = select_input_file ( ) ;
/* if none, if is finished */
if ( file_index = = - 2 ) {
poll_filters ( ) ;
return AVERROR ( EAGAIN ) ;
}
if ( file_index < 0 ) {
if ( got_eagain ( ) ) {
reset_eagain ( ) ;
av_usleep ( 10000 ) ;
return AVERROR ( EAGAIN ) ;
}
av_log ( NULL , AV_LOG_VERBOSE , " No more inputs to read from, finishing. \n " ) ;
return AVERROR_EOF ;
}
ifile = input_files [ file_index ] ;
is = ifile - > ctx ;
ret = get_input_packet ( ifile , & pkt ) ;
if ( ret = = AVERROR ( EAGAIN ) ) {
ifile - > eagain = 1 ;
return ret ;
}
if ( ret < 0 ) {
if ( ret ! = AVERROR_EOF ) {
print_error ( is - > filename , ret ) ;
if ( exit_on_error )
exit_program ( 1 ) ;
}
ifile - > eof_reached = 1 ;
for ( i = 0 ; i < ifile - > nb_streams ; i + + ) {
ist = input_streams [ ifile - > ist_index + i ] ;
if ( ist - > decoding_needed )
output_packet ( ist , NULL ) ;
poll_filters ( ) ;
}
if ( opt_shortest )
return AVERROR_EOF ;
else
return AVERROR ( EAGAIN ) ;
}
reset_eagain ( ) ;
if ( do_pkt_dump ) {
av_pkt_dump_log2 ( NULL , AV_LOG_DEBUG , & pkt , do_hex_dump ,
is - > streams [ pkt . stream_index ] ) ;
}
/* the following test is needed in case new streams appear
dynamically in stream : we ignore them */
if ( pkt . stream_index > = ifile - > nb_streams ) {
report_new_stream ( file_index , & pkt ) ;
goto discard_packet ;
}
ist = input_streams [ ifile - > ist_index + pkt . stream_index ] ;
if ( ist - > discard )
goto discard_packet ;
if ( ! ist - > wrap_correction_done & & input_files [ file_index ] - > ctx - > start_time ! = AV_NOPTS_VALUE & & ist - > st - > pts_wrap_bits < 64 ) {
uint64_t stime = av_rescale_q ( input_files [ file_index ] - > ctx - > start_time , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
uint64_t stime2 = stime + ( 1LL < < ist - > st - > pts_wrap_bits ) ;
ist - > wrap_correction_done = 1 ;
if ( pkt . dts ! = AV_NOPTS_VALUE & & pkt . dts > stime & & pkt . dts - stime > stime2 - pkt . dts ) {
pkt . dts - = 1LL < < ist - > st - > pts_wrap_bits ;
ist - > wrap_correction_done = 0 ;
}
if ( pkt . pts ! = AV_NOPTS_VALUE & & pkt . pts > stime & & pkt . pts - stime > stime2 - pkt . pts ) {
pkt . pts - = 1LL < < ist - > st - > pts_wrap_bits ;
ist - > wrap_correction_done = 0 ;
}
}
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts + = av_rescale_q ( ifile - > ts_offset , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts + = av_rescale_q ( ifile - > ts_offset , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts * = ist - > ts_scale ;
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts * = ist - > ts_scale ;
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " demuxer -> ist_index:%d type:%s "
" 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:% " PRId64 " \n " ,
ifile - > ist_index + pkt . stream_index , av_get_media_type_string ( ist - > st - > codec - > codec_type ) ,
av_ts2str ( ist - > next_dts ) , av_ts2timestr ( ist - > next_dts , & AV_TIME_BASE_Q ) ,
av_ts2str ( ist - > next_pts ) , av_ts2timestr ( ist - > next_pts , & AV_TIME_BASE_Q ) ,
av_ts2str ( pkt . pts ) , av_ts2timestr ( pkt . pts , & ist - > st - > time_base ) ,
av_ts2str ( pkt . dts ) , av_ts2timestr ( pkt . dts , & ist - > st - > time_base ) ,
input_files [ ist - > file_index ] - > ts_offset ) ;
}
if ( pkt . dts ! = AV_NOPTS_VALUE & & ist - > next_dts ! = AV_NOPTS_VALUE & &
! copy_ts ) {
int64_t pkt_dts = av_rescale_q ( pkt . dts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
int64_t delta = pkt_dts - ist - > next_dts ;
if ( is - > iformat - > flags & AVFMT_TS_DISCONT ) {
if ( delta < - 1LL * dts_delta_threshold * AV_TIME_BASE | |
( delta > 1LL * dts_delta_threshold * AV_TIME_BASE & &
ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_SUBTITLE ) | |
pkt_dts + 1 < ist - > pts ) {
ifile - > ts_offset - = delta ;
av_log ( NULL , AV_LOG_DEBUG ,
" timestamp discontinuity % " PRId64 " , new offset= % " PRId64 " \n " ,
delta , ifile - > ts_offset ) ;
pkt . dts - = av_rescale_q ( delta , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts - = av_rescale_q ( delta , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
}
} else {
if ( delta < - 1LL * dts_error_threshold * AV_TIME_BASE | |
2012-08-12 00:38:48 +03:00
( delta > 1LL * dts_error_threshold * AV_TIME_BASE & & ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_SUBTITLE )
) {
2012-08-09 19:04:17 +03:00
av_log ( NULL , AV_LOG_WARNING , " DTS % " PRId64 " , next:% " PRId64 " st:%d invalid dropping \n " , pkt . dts , ist - > next_dts , pkt . stream_index ) ;
pkt . dts = AV_NOPTS_VALUE ;
}
if ( pkt . pts ! = AV_NOPTS_VALUE ) {
int64_t pkt_pts = av_rescale_q ( pkt . pts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
delta = pkt_pts - ist - > next_dts ;
if ( delta < - 1LL * dts_error_threshold * AV_TIME_BASE | |
2012-08-12 00:38:48 +03:00
( delta > 1LL * dts_error_threshold * AV_TIME_BASE & & ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_SUBTITLE )
) {
2012-08-09 19:04:17 +03:00
av_log ( NULL , AV_LOG_WARNING , " PTS % " PRId64 " , next:% " PRId64 " invalid dropping st:%d \n " , pkt . pts , ist - > next_dts , pkt . stream_index ) ;
pkt . pts = AV_NOPTS_VALUE ;
}
}
}
}
sub2video_heartbeat ( ist , pkt . pts ) ;
if ( ( ret = output_packet ( ist , & pkt ) ) < 0 | |
( ( ret = poll_filters ( ) ) < 0 & & ret ! = AVERROR_EOF ) ) {
char buf [ 128 ] ;
av_strerror ( ret , buf , sizeof ( buf ) ) ;
av_log ( NULL , AV_LOG_ERROR , " Error while decoding stream #%d:%d: %s \n " ,
ist - > file_index , ist - > st - > index , buf ) ;
if ( exit_on_error )
exit_program ( 1 ) ;
av_free_packet ( & pkt ) ;
return AVERROR ( EAGAIN ) ;
}
discard_packet :
av_free_packet ( & pkt ) ;
return 0 ;
}
2011-08-20 00:45:02 +03:00
/*
* The following code is the main loop of the file converter
*/
2012-04-15 16:03:07 +03:00
static int transcode ( void )
2005-06-03 17:31:45 +03:00
{
2011-08-20 00:45:02 +03:00
int ret , i ;
2012-08-09 19:04:17 +03:00
AVFormatContext * os ;
2011-08-30 05:05:20 +03:00
OutputStream * ost ;
2011-08-20 00:45:02 +03:00
InputStream * ist ;
int64_t timer_start ;
2001-07-22 17:37:44 +03:00
2012-04-15 16:03:07 +03:00
ret = transcode_init ( ) ;
2011-08-20 00:45:02 +03:00
if ( ret < 0 )
goto fail ;
2012-08-09 01:26:38 +03:00
if ( stdin_interaction ) {
av_log ( NULL , AV_LOG_INFO , " Press [q] to stop, [?] for help \n " ) ;
2012-04-01 16:08:33 +03:00
}
2011-07-27 21:56:59 +03:00
timer_start = av_gettime ( ) ;
2001-07-22 17:37:44 +03:00
2012-06-11 16:34:12 +03:00
# if HAVE_PTHREADS
2012-06-02 08:26:41 +03:00
if ( ( ret = init_input_threads ( ) ) < 0 )
goto fail ;
# endif
2001-07-22 17:37:44 +03:00
2012-08-04 13:06:30 +03:00
while ( ! received_sigterm ) {
2012-08-09 01:26:38 +03:00
int64_t cur_time = av_gettime ( ) ;
2012-04-01 16:08:33 +03:00
2012-08-09 01:26:38 +03:00
/* if 'q' pressed, exits */
if ( stdin_interaction )
if ( check_keyboard_interaction ( cur_time ) < 0 )
break ;
2011-07-27 21:56:59 +03:00
2012-04-01 16:08:33 +03:00
/* check if there's any stream where output is still needed */
2012-06-01 11:44:11 +03:00
if ( ! need_output ( ) ) {
av_log ( NULL , AV_LOG_VERBOSE , " No more output streams to write to, finishing. \n " ) ;
2012-04-01 16:08:33 +03:00
break ;
2012-06-01 11:44:11 +03:00
}
2012-04-01 16:08:33 +03:00
2012-08-09 19:04:17 +03:00
ret = process_input ( ) ;
2011-07-27 21:56:59 +03:00
if ( ret < 0 ) {
2012-08-09 19:04:17 +03:00
if ( ret = = AVERROR ( EAGAIN ) )
2011-07-27 21:56:59 +03:00
continue ;
2012-08-09 19:04:17 +03:00
if ( ret = = AVERROR_EOF )
break ;
av_log ( NULL , AV_LOG_ERROR , " Error while filtering. \n " ) ;
break ;
2011-10-29 21:25:39 +03:00
}
2011-07-27 21:56:59 +03:00
/* dump report by using the output first video and audio streams */
2012-08-09 01:26:38 +03:00
print_report ( 0 , timer_start , cur_time ) ;
2001-07-22 17:37:44 +03:00
}
2012-06-11 16:34:12 +03:00
# if HAVE_PTHREADS
2012-06-02 08:26:41 +03:00
free_input_threads ( ) ;
# endif
2001-07-22 17:37:44 +03:00
2011-07-27 21:56:59 +03:00
/* at the end of stream, we must flush the decoder buffers */
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
ist = input_streams [ i ] ;
2012-04-02 21:13:29 +03:00
if ( ! input_files [ ist - > file_index ] - > eof_reached & & ist - > decoding_needed ) {
2012-04-15 16:03:07 +03:00
output_packet ( ist , NULL ) ;
2002-05-20 19:32:49 +03:00
}
2001-09-17 00:47:13 +03:00
}
2012-03-29 09:51:17 +03:00
poll_filters ( ) ;
2012-04-15 16:03:07 +03:00
flush_encoders ( ) ;
2001-09-17 00:47:13 +03:00
2011-07-27 21:56:59 +03:00
term_exit ( ) ;
2001-07-22 17:37:44 +03:00
2011-07-27 21:56:59 +03:00
/* write the trailer if needed and close file */
2011-12-29 23:28:29 +03:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 16:28:30 +03:00
os = output_files [ i ] - > ctx ;
2011-07-27 21:56:59 +03:00
av_write_trailer ( os ) ;
2011-10-26 03:09:31 +03:00
}
2004-10-07 01:29:30 +03:00
2011-07-27 21:56:59 +03:00
/* dump report by using the first video and audio streams */
2012-08-09 01:26:38 +03:00
print_report ( 1 , timer_start , av_gettime ( ) ) ;
2011-06-15 09:00:03 +03:00
2011-07-27 21:56:59 +03:00
/* close each encoder */
2011-08-17 11:21:37 +03:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
ost = output_streams [ i ] ;
2011-07-27 21:56:59 +03:00
if ( ost - > encoding_needed ) {
av_freep ( & ost - > st - > codec - > stats_in ) ;
avcodec_close ( ost - > st - > codec ) ;
2011-12-17 03:36:59 +03:00
}
}
2011-07-27 21:56:59 +03:00
/* close each decoder */
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
ist = input_streams [ i ] ;
2011-07-27 21:56:59 +03:00
if ( ist - > decoding_needed ) {
avcodec_close ( ist - > st - > codec ) ;
2011-08-30 02:28:08 +03:00
}
}
2011-08-30 02:30:11 +03:00
2011-07-27 21:56:59 +03:00
/* finished ! */
ret = 0 ;
fail :
2012-06-11 16:34:12 +03:00
# if HAVE_PTHREADS
2012-06-02 08:26:41 +03:00
free_input_threads ( ) ;
# endif
2011-07-27 21:56:59 +03:00
2011-08-17 11:21:37 +03:00
if ( output_streams ) {
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 16:28:30 +03:00
ost = output_streams [ i ] ;
2011-07-27 21:56:59 +03:00
if ( ost ) {
2011-10-23 12:22:33 +03:00
if ( ost - > stream_copy )
2011-07-27 21:56:59 +03:00
av_freep ( & ost - > st - > codec - > extradata ) ;
if ( ost - > logfile ) {
fclose ( ost - > logfile ) ;
ost - > logfile = NULL ;
2011-12-17 03:36:59 +03:00
}
2011-07-27 21:56:59 +03:00
av_freep ( & ost - > st - > codec - > subtitle_header ) ;
av_free ( ost - > forced_kf_pts ) ;
av_dict_free ( & ost - > opts ) ;
2011-09-05 23:10:26 +03:00
}
}
}
2011-07-27 21:56:59 +03:00
return ret ;
2001-07-22 17:37:44 +03:00
}
2012-08-09 01:26:38 +03:00
2012-08-01 19:23:12 +03:00
static int64_t getutime ( void )
2002-10-10 20:09:01 +03:00
{
2012-08-01 19:23:12 +03:00
# if HAVE_GETRUSAGE
struct rusage rusage ;
2011-11-02 23:50:54 +03:00
2012-08-01 19:23:12 +03:00
getrusage ( RUSAGE_SELF , & rusage ) ;
return ( rusage . ru_utime . tv_sec * 1000000LL ) + rusage . ru_utime . tv_usec ;
# elif HAVE_GETPROCESSTIMES
HANDLE proc ;
FILETIME c , e , k , u ;
proc = GetCurrentProcess ( ) ;
GetProcessTimes ( proc , & c , & e , & k , & u ) ;
return ( ( int64_t ) u . dwHighDateTime < < 32 | u . dwLowDateTime ) / 10 ;
# else
return av_gettime ( ) ;
# endif
2002-10-10 20:09:01 +03:00
}
2001-09-25 02:22:25 +03:00
2010-02-23 00:21:58 +02:00
static int64_t getmaxrss ( void )
{
# if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
struct rusage rusage ;
getrusage ( RUSAGE_SELF , & rusage ) ;
return ( int64_t ) rusage . ru_maxrss * 1024 ;
# elif HAVE_GETPROCESSMEMORYINFO
HANDLE proc ;
PROCESS_MEMORY_COUNTERS memcounters ;
proc = GetCurrentProcess ( ) ;
memcounters . cb = sizeof ( memcounters ) ;
GetProcessMemoryInfo ( proc , & memcounters , sizeof ( memcounters ) ) ;
return memcounters . PeakPagefileUsage ;
# else
return 0 ;
# endif
}
2011-09-12 12:44:14 +03:00
static void log_callback_null ( void * ptr , int level , const char * fmt , va_list vl )
2011-04-18 14:10:52 +03:00
{
}
2012-03-04 18:46:45 +03:00
static void parse_cpuflags ( int argc , char * * argv , const OptionDef * options )
{
int idx = locate_option ( argc , argv , options , " cpuflags " ) ;
if ( idx & & argv [ idx + 1 ] )
opt_cpuflags ( " cpuflags " , argv [ idx + 1 ] ) ;
}
2007-09-16 21:08:51 +03:00
int main ( int argc , char * * argv )
{
2011-09-05 03:04:27 +03:00
OptionsContext o = { 0 } ;
2007-09-16 21:08:51 +03:00
int64_t ti ;
2011-09-05 04:11:18 +03:00
reset_options ( & o , 0 ) ;
2011-09-05 03:04:27 +03:00
2010-09-24 18:39:10 +03:00
av_log_set_flags ( AV_LOG_SKIP_REPEATED ) ;
2011-09-26 09:15:37 +03:00
parse_loglevel ( argc , argv , options ) ;
2010-09-24 18:39:10 +03:00
2011-04-18 14:10:52 +03:00
if ( argc > 1 & & ! strcmp ( argv [ 1 ] , " -d " ) ) {
2011-04-22 19:49:44 +03:00
run_as_daemon = 1 ;
2011-04-18 14:10:52 +03:00
av_log_set_callback ( log_callback_null ) ;
argc - - ;
argv + + ;
}
2007-11-22 18:10:02 +02:00
avcodec_register_all ( ) ;
2010-04-22 11:55:23 +03:00
# if CONFIG_AVDEVICE
2007-11-22 18:10:02 +02:00
avdevice_register_all ( ) ;
2010-05-07 12:43:21 +03:00
# endif
avfilter_register_all ( ) ;
2007-09-16 21:08:51 +03:00
av_register_all ( ) ;
2011-11-06 03:47:48 +03:00
avformat_network_init ( ) ;
2007-09-16 21:08:51 +03:00
2011-12-21 00:03:25 +03:00
show_banner ( argc , argv , options ) ;
2007-09-16 21:08:51 +03:00
2011-10-08 18:20:52 +03:00
term_init ( ) ;
2012-03-04 18:46:45 +03:00
parse_cpuflags ( argc , argv , options ) ;
2007-09-16 21:08:51 +03:00
/* parse options */
2011-09-05 03:04:27 +03:00
parse_options ( & o , argc , argv , options , opt_output_file ) ;
2007-09-16 21:08:51 +03:00
2011-12-30 05:46:24 +03:00
if ( nb_output_files < = 0 & & nb_input_files = = 0 ) {
2009-12-21 04:15:46 +02:00
show_usage ( ) ;
2011-09-27 03:14:37 +03:00
av_log ( NULL , AV_LOG_WARNING , " Use -h to get full help or, even better, run 'man %s' \n " , program_name ) ;
2011-08-30 02:11:54 +03:00
exit_program ( 1 ) ;
2009-12-21 04:15:46 +02:00
}
2009-12-13 15:49:14 +02:00
2007-09-16 21:08:51 +03:00
/* file converter / grab */
if ( nb_output_files < = 0 ) {
2011-09-27 03:14:37 +03:00
av_log ( NULL , AV_LOG_FATAL , " At least one output file must be specified \n " ) ;
2011-08-30 02:11:54 +03:00
exit_program ( 1 ) ;
2007-09-16 21:08:51 +03:00
}
2012-08-09 20:09:39 +03:00
// if (nb_input_files == 0) {
// av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
// exit_program(1);
// }
2007-09-16 21:08:51 +03:00
2012-04-11 20:26:09 +03:00
current_time = ti = getutime ( ) ;
2012-04-15 16:03:07 +03:00
if ( transcode ( ) < 0 )
2011-08-30 02:11:54 +03:00
exit_program ( 1 ) ;
2007-09-16 21:08:51 +03:00
ti = getutime ( ) - ti ;
if ( do_benchmark ) {
2010-02-23 00:21:58 +02:00
int maxrss = getmaxrss ( ) / 1024 ;
printf ( " bench: utime=%0.3fs maxrss=%ikB \n " , ti / 1000000.0 , maxrss ) ;
2007-09-16 21:08:51 +03:00
}
2011-08-29 08:03:24 +03:00
exit_program ( 0 ) ;
return 0 ;
2007-09-16 21:08:51 +03:00
}