void printProperties( const tth::ofx::property::OfxhSet properties, std::string context="" )
{
if( context.size() == 0 )
{
TUTTLE_COUT( _color._red << "Number of properties : " << properties.getSize() << _color._std );
}
else
{
TUTTLE_COUT( _color._red << "Number of properties for \"" << context << "\": " << properties.getSize() << _color._std );
}
TUTTLE_COUT( _color._red << "RW" << _color._std << " " << _color._red << "ModifiedBy" << _color._std << "\t" << _color._red << "Type" << _color._std << "\t" << _color._red << "Size" << _color._std << "\t" << _color._red <<std::setw (50) << std::left << "Property Name" << _color._std << "\t" << _color._red << "Default Values" << _color._std );
tth::ofx::property::PropertyMap propMap = properties.getMap();
for( tth::ofx::property::PropertyMap::const_iterator itProperty = propMap.begin(); itProperty != propMap.end(); ++itProperty )
{
const tth::ofx::property::OfxhProperty& prop = *( itProperty->second );
TUTTLE_COUT(
_color._green <<
( prop.getPluginReadOnly() ? (_color._green + "r-" + _color._std + " ") : (_color._green + "rw" + _color._std + " " ) ) <<
( prop.getModifiedBy() == tth::ofx::property::eModifiedByHost ? ( _color._green + "host" + _color._std + " \t" ) : ( _color._green + "plugin" + _color._std + "\t" ) ) <<
_color._green << ( tth::ofx::property::mapTypeEnumToString( prop.getType() ) ) << _color._std << "\t" << _color._green << "[" <<
prop.getDimension() << "]" << _color._std << "\t" <<
_color._blue <<
std::setw (50) << std::left <<
itProperty->first << _color._std << "\t" << _color._green << "{ " <<
getDefaultValues(prop) << " }" << _color._std
);
}
}
void WriterPlugin::render( const OFX::RenderArguments& args )
{
_oneRender = false;
TUTTLE_COUT( " --> " << getAbsoluteFilenameAt( args.time ) );
boost::scoped_ptr<OFX::Image> src( _clipSrc->fetchImage( args.time ) );
boost::scoped_ptr<OFX::Image> dst( _clipDst->fetchImage( args.time ) );
// Copy buffer
const OfxRectI bounds = dst->getBounds();
TUTTLE_TCOUT_VAR( bounds );
if( src->isLinearBuffer() && dst->isLinearBuffer() )
{
TUTTLE_TCOUT( "isLinearBuffer" );
const std::size_t imageDataBytes = dst->getBoundsImageDataBytes();
TUTTLE_TCOUT_VAR( imageDataBytes );
if( imageDataBytes )
{
void* dataSrcPtr = src->getPixelAddress( bounds.x1, bounds.y1 );
void* dataDstPtr = dst->getPixelAddress( bounds.x1, bounds.y1 );
memcpy( dataDstPtr, dataSrcPtr, imageDataBytes );
}
}
else
{
const std::size_t rowBytesToCopy = dst->getBoundsRowDataBytes();
for( int y = bounds.y1; y < bounds.y2; ++y )
{
void* dataSrcPtr = src->getPixelAddress( bounds.x1, y );
void* dataDstPtr = dst->getPixelAddress( bounds.x1, y );
memcpy( dataDstPtr, dataSrcPtr, rowBytesToCopy );
}
}
}
ConvolutionProcessParams ConvolutionPlugin::getProcessParams() const
{
ConvolutionProcessParams params;
OfxPointI size = _paramSize->getValue();
params._size.x = boost::numeric_cast<unsigned int>( size.x );
params._size.y = boost::numeric_cast<unsigned int>( size.y );
params._convMatrix.resize( params._size.x, params._size.y );
for( unsigned int y = 0; y < params._size.y; ++y )
{
// unsigned int yy = y * params._size.x;
for( unsigned int x = 0; x < params._size.x; ++x )
{
params._convMatrix(x, y) = _paramCoef[y][x]->getValue();
TUTTLE_COUT( "coef[" << y << "][" << x << "] = " << params._convMatrix(x, y) );
}
}
return params;
}
void OfxhPluginCache::scanDirectory( std::set<std::string>& foundBinFiles, const std::string& dir, bool recurse )
{
#ifdef CACHE_DEBUG
TUTTLE_TCOUT( "looking in " << dir << " for plugins" );
#endif
#if defined ( WINDOWS )
WIN32_FIND_DATA findData;
HANDLE findHandle;
#else
DIR* d = opendir( dir.c_str() );
if( !d )
{
return;
}
#endif
_pluginDirs.push_back( dir.c_str() );
#if defined ( UNIX )
while( dirent * de = readdir( d ) )
#elif defined ( WINDOWS )
findHandle = FindFirstFile( ( dir + "\\*" ).c_str(), &findData );
if( findHandle == INVALID_HANDLE_VALUE )
{
return;
}
while( 1 )
#endif
{
#if defined ( UNIX )
std::string name = de->d_name;
bool isdir = true;
#else
std::string name = findData.cFileName;
bool isdir = ( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) != 0;
#endif
if( name.find( ".ofx.bundle" ) != std::string::npos )
{
std::string barename = name.substr( 0, name.length() - strlen( ".bundle" ) );
std::string bundlepath = dir + DIRSEP + name;
std::string binpath = bundlepath + DIRSEP "Contents" DIRSEP + ARCHSTR + DIRSEP + barename;
foundBinFiles.insert( binpath );
if( _knownBinFiles.find( binpath ) == _knownBinFiles.end() )
{
#ifdef CACHE_DEBUG
TUTTLE_TCOUT( "found non-cached binary " << binpath );
#endif
setDirty();
try
{
// the binary was not in the cache
OfxhPluginBinary* pb = new OfxhPluginBinary( binpath, bundlepath, this );
_binaries.push_back( pb );
_knownBinFiles.insert( binpath );
for( int j = 0; j < pb->getNPlugins(); ++j )
{
OfxhPlugin& plug = pb->getPlugin( j );
APICache::OfxhPluginAPICacheI& api = plug.getApiHandler();
api.loadFromPlugin( plug );
}
}
catch(... )
{
TUTTLE_COUT( tuttle::common::kColorError << "warning: can't load " << binpath << tuttle::common::kColorStd );
TUTTLE_COUT_CURRENT_EXCEPTION;
}
}
else
{
#ifdef CACHE_DEBUG
TUTTLE_TCOUT( "found cached binary " << binpath );
#endif
}
}
else
{
if( isdir && ( recurse && name[0] != '@' && name != "." && name != ".." ) )
{
scanDirectory( foundBinFiles, dir + DIRSEP + name, recurse );
}
}
#if defined( WINDOWS )
int rval = FindNextFile( findHandle, &findData );
if( rval == 0 )
{
break;
}
#endif
}
#if defined( UNIX )
closedir( d );
#else
FindClose( findHandle );
#endif
}
void foundAssociateSpecificDummyNode( std::string& inputNode, const std::string& dummyNodeName, const std::string& dummyNodeFullName, const std::string& dummyNodeShortName, const std::vector<ttl::ofx::imageEffect::OfxhImageEffectPlugin*>& nodeList, const std::vector<std::string>& nodeArgs )
{
if( !std::strcmp( inputNode.c_str(), dummyNodeFullName.c_str() ) || !std::strcmp( inputNode.c_str(), dummyNodeName.c_str() ) || !std::strcmp( inputNode.c_str(), dummyNodeShortName.c_str() ) )
{
if( nodeArgs.size() == 0 )
{
BOOST_THROW_EXCEPTION( tuttle::exception::Value()
<< tuttle::exception::user() + "specify and input name (file or sequence)." );
}
boost::filesystem::path p( nodeArgs.at( 0 ) );
std::string inputExtension = p.extension().string();
boost::algorithm::to_lower( inputExtension );
if( inputExtension.size() == 0 )
{
BOOST_THROW_EXCEPTION( tuttle::exception::Value()
<< tuttle::exception::user() + "invalid extension of input file/sequence." );
}
inputExtension = inputExtension.substr( 1 ); // remove '.' at begining
unsigned int numberOfSupportedExtension = std::numeric_limits<unsigned int>::max();
BOOST_FOREACH( ttl::ofx::imageEffect::OfxhImageEffectPlugin* node, nodeList )
{
const std::string pluginName = node->getRawIdentifier();
if( boost::algorithm::find_first( pluginName, dummyNodeName ) )
{
tuttle::host::ofx::imageEffect::OfxhImageEffectPlugin* plugin = tuttle::host::Core::instance().getImageEffectPluginById( pluginName );
plugin->loadAndDescribeActions();
const tuttle::host::ofx::imageEffect::OfxhImageEffectPlugin::ContextSet contexts = plugin->getContexts();
const tuttle::host::ofx::property::OfxhSet& properties = plugin->getDescriptorInContext( *contexts.begin() ).getProperties();
if( properties.hasProperty( kTuttleOfxImageEffectPropSupportedExtensions ) )
{
const tuttle::host::ofx::property::OfxhProperty& prop = properties.fetchProperty( kTuttleOfxImageEffectPropSupportedExtensions );
const std::vector<std::string> supportedExtensions = getStringValues( prop );
BOOST_FOREACH( const std::string& ext, supportedExtensions )
{
// TUTTLE_TCOUT_VAR2( ext, inputExtension );
if( ext == inputExtension )
{
// TUTTLE_TCOUT( pluginName << " [" << supportedExtensions.size() << "] can read " << ext );
if( supportedExtensions.size() < numberOfSupportedExtension )
{
// Arbitrary solution...
// If we found multiple plugins that support the requested format,
// we select the plugin which supports the lowest number of formats.
// So by defaut, we select specialized plugin before
// plugin using generic libraries with all formats.
numberOfSupportedExtension = supportedExtensions.size();
inputNode = pluginName;
}
}
}
}
}
}
if( numberOfSupportedExtension == std::numeric_limits<unsigned int>::max() )
{
BOOST_THROW_EXCEPTION( tuttle::exception::Value()
<< tuttle::exception::user() + "Unsupported extension \"" + inputExtension + "\"." );
}
TUTTLE_COUT( _color._yellow << "Replace " << dummyNodeName << " with: " << inputNode << _color._std );
}
}
void getPluginProperties( const std::string& plugName )
{
tth::ofx::imageEffect::OfxhImageEffectPlugin* plug = tth::Core::instance().getImageEffectPluginById( plugName );
if( !plug )
{
TUTTLE_COUT( _color._red << "no plugin match to: " << plugName << _color._std );
return;
}
plug->loadAndDescribeActions();
TUTTLE_COUT("Identifier:\t\t" << plug->getIdentifier() );
TUTTLE_COUT("Raw identifier:\t\t" << plug->getRawIdentifier() );
TUTTLE_COUT("Minor version:\t\t" << plug->getVersionMinor() );
TUTTLE_COUT("Major version:\t\t" << plug->getVersionMajor() );
TUTTLE_COUT("API version:\t\t" << plug->getApiVersion() );
// list contexts of plugin
TUTTLE_COUT( _color._green << "Contexts:" << _color._std );
tth::ofx::imageEffect::OfxhImageEffectPlugin::ContextSet contexts = plug->getContexts();
tth::ofx::imageEffect::OfxhImageEffectPlugin::ContextSet::iterator itContext;
std::string strContexts;
for( itContext = contexts.begin(); itContext != contexts.end(); ++itContext )
{
strContexts += *itContext + ", ";
}
strContexts.erase(strContexts.size()-2, 2);
TUTTLE_COUT( "[ " << strContexts << " ]" );
itContext = contexts.begin();
// list properties of plugin for the first context
if( properties )
{
TUTTLE_COUT( std::endl << _color._red << "Properties" << _color._std );
const tth::ofx::property::OfxhSet properties = plug->getDescriptorInContext( *itContext ).getProperties();
printProperties( properties );
}
tth::ofx::imageEffect::OfxhImageEffectNode* plugInst = NULL;
if( clips | parameters )
{
if( plug->supportsContext( kOfxImageEffectContextReader ) )
{
plugInst = plug->createInstance( kOfxImageEffectContextReader );
}
else if( plug->supportsContext( kOfxImageEffectContextWriter ) )
{
plugInst = plug->createInstance( kOfxImageEffectContextWriter );
}
else if( plug->supportsContext( kOfxImageEffectContextGenerator ) )
{
plugInst = plug->createInstance( kOfxImageEffectContextGenerator );
}
else if( plug->supportsContext( kOfxImageEffectContextFilter ) )
{
plugInst = plug->createInstance( kOfxImageEffectContextFilter );
}
else if( plug->supportsContext( kOfxImageEffectContextGeneral ) )
{
plugInst = plug->createInstance( kOfxImageEffectContextGeneral );
}
else
{
TUTTLE_CERR( _color._error << "Plugin contexts not supported by the host. (" + plugName + ")" << _color._std );
return;
}
}
if( clips )
{
TUTTLE_COUT( std::endl << _color._red << "Clips" << _color._std );
typedef std::map<std::string, tth::ofx::attribute::OfxhClipImageDescriptor*> ContextMap;
// get contexts
ContextMap::const_iterator it = plugInst->getDescriptor( ).getClips().begin();
std::string strClipContexts;
for( ; it != plugInst->getDescriptor( ).getClips().end(); ++it )
{
strClipContexts += (*it).first + ", " ;
}
strClipContexts.erase( strClipContexts.size()-2, 2 );
TUTTLE_COUT( _color._green << "[ " << strClipContexts << " ]" << _color._std );
// get propeties in each context
ContextMap::const_iterator it2 = plugInst->getDescriptor( ).getClips().begin();
for( ; it2 != plugInst->getDescriptor().getClips().end(); ++it2 )
{
printProperties( (*it2).second->getProperties(), (*it2).first );
}
}
if( parameters )
{
TUTTLE_COUT( std::endl << _color._red << "Parameters" << _color._std );
typedef std::map<std::string, tth::ofx::attribute::OfxhParamDescriptor*> ParamDescriptorMap;
// get contexts
ParamDescriptorMap::const_iterator it = plugInst->getDescriptor( ).getParams().begin();
std::string strParamsContexts;
for( ; it != plugInst->getDescriptor( ).getParams().end(); ++it )
{
strParamsContexts += (*it).first + ", ";
}
strParamsContexts.erase( strParamsContexts.size()-2, 2 );
TUTTLE_COUT( _color._green << "[ " << strParamsContexts << " ]" << _color._std );
// get propeties in each context
ParamDescriptorMap::const_iterator it2 = plugInst->getDescriptor( ).getParams().begin();
for( ; it2 != plugInst->getDescriptor().getParams().end(); it2++ )
{
printProperties( (*it2).second->getProperties(), (*it2).first );
}
/*
const tth::ofx::property::OfxhSet paramProperties = plugInst->getDescriptor( ).getParamList().front().getProperties();
printProperties( paramProperties, "" );
*/
}
}
int main( int argc, char** argv )
{
bool verbose = false;
std::vector<std::string> plugins;
std::vector<std::string> foundPlugins;
std::vector<std::string> filters;
// Declare the supported options.
bpo::options_description mainOptions;
mainOptions.add_options()
("help,h" , "show this help")
("all,a" , "show list of all plugins available")
("filter,f" , bpo::value<std::string>(), "filtering the output for research a plugin. ex: -f \"*blur,*tuttle*\"")
("color" , "color the output")
("verbose,v" , "explain what is being done")
("properties" , "list properties of the OpenFX plugin")
("clips" , "list clips of the OpenFX plugin")
("parameters" , "list parameters of the OpenFX plugin")
("brief" , "brief summary of the tool")
;
// describe hidden options
bpo::options_description hidden;
hidden.add_options()
("plugin", bpo::value< std::vector<std::string> >(), "input directories")
;
// define default options
bpo::positional_options_description pod;
pod.add("plugin", -1);
bpo::options_description cmdline_options;
cmdline_options.add(mainOptions).add(hidden);
//parse the command line, and put the result in vm
bpo::variables_map vm;
try
{
bpo::store(bpo::command_line_parser(argc, argv).options(cmdline_options).positional(pod).run(), vm);
// get environnement options and parse them
if( const char* env_plugins_options = std::getenv("SAM_PLUGINS_OPTIONS") )
{
const std::vector<std::string> vecOptions = bpo::split_unix( env_plugins_options, " " );
bpo::store(bpo::command_line_parser(vecOptions).options(cmdline_options).positional(pod).run(), vm);
}
if( const char* env_options = std::getenv("SAM_OPTIONS") )
{
const std::vector<std::string> vecOptions = bpo::split_unix( env_options, " " );
bpo::store(bpo::command_line_parser(vecOptions).options(cmdline_options).positional(pod).run(), vm);
}
bpo::notify(vm);
}
catch( const bpo::error& e)
{
TUTTLE_COUT( "sam-plugins: command line error: " << e.what() );
exit( -2 );
}
catch(...)
{
TUTTLE_COUT( "sam-plugins: unknown error in command line.");
exit( -2 );
}
if (vm.count("color"))
{
color = true;
_color.enable();
}
if( vm.count("help") )
{
TUTTLE_COUT( _color._blue << "TuttleOFX project [http://sites.google.com/site/tuttleofx]" << _color._std << std::endl );
TUTTLE_COUT( _color._blue << "NAME" << _color._std );
TUTTLE_COUT( _color._green << "\tsam-plugins - show informations about OpenFX plugins" << _color._std << std::endl );
TUTTLE_COUT( _color._blue << "SYNOPSIS" << _color._std );
TUTTLE_COUT( _color._green << "\tsam-plugins [options] [specific_OpenFX_plugin]" << _color._std << std::endl );
TUTTLE_COUT( _color._blue << "DESCRIPTION" << _color._std );
TUTTLE_COUT( "List OpenFX in OFX_PLUGIN_PATH by default.");
TUTTLE_COUT( "And could print properties, parameters and clips for each plugins" << std::endl );
TUTTLE_COUT( _color._blue << "OPTIONS" << _color._std );
TUTTLE_COUT( mainOptions );
return 0;
}
if ( vm.count("brief") )
{
TUTTLE_COUT( _color._green << "show informations about OpenFX plugins" << _color._std );
return 0;
}
// defines plugins
if( vm.count("plugin") )
{
plugins = vm["plugin"].as< std::vector<std::string> >();
}
if( vm.count("filter") )
{
bal::split( filters, vm["filter"].as<std::string>(), bal::is_any_of(","));
}
if( vm.count("all") | (plugins.size() == 0) )
{
tth::Core::instance().preload();
const std::vector<tth::ofx::imageEffect::OfxhImageEffectPlugin*> plugs = tth::Core::instance().getImageEffectPluginCache().getPlugins();
for( std::size_t i = 0; i < plugs.size(); ++i )
{
const std::string plugName = plugs.at(i)->getRawIdentifier();
if( isNotFiltered( plugName, filters) )
{
TUTTLE_COUT( plugName );
}
}
return 0;
}
if (vm.count("verbose"))
{
verbose = true;
}
if (vm.count("properties"))
{
properties = true;
}
if (vm.count("clips"))
{
clips = true;
}
if (vm.count("parameters"))
{
parameters = true;
}
// for(unsigned int i=0; i< plugins.size(); i++)
// TUTTLE_COUT( plugins.at(i) );
try
{
tth::Core::instance().preload();
// get the plugins names for research partials names (rawreader need to make reference to the plug tuttle.reader)
const std::vector<tth::ofx::imageEffect::OfxhImageEffectPlugin*> plugs = tth::Core::instance().getImageEffectPluginCache().getPlugins();
unsigned int founded;
BOOST_FOREACH( const std::string& plugin, plugins )
{
std::vector< std::string > termsPlugin;
bal::split( termsPlugin, plugin, bal::is_any_of("."));
for( std::size_t i=0; i<plugs.size(); i++ )
{
founded = 0;
for( std::size_t t=0; t<termsPlugin.size(); t++ )
{
std::size_t found1 = plugs.at(i)->getRawIdentifier().find( "."+termsPlugin.at(t) );
std::size_t found2 = plugs.at(i)->getRawIdentifier().find( termsPlugin.at(t)+"." );
if( ( found1 == std::string::npos ) && ( found2 == std::string::npos ) )
{
break;
}
++founded;
if( founded == termsPlugin.size() )
{
/*TUTTLE_COUT("plug is " << plugs.at(i)->getRawIdentifier() );*/
foundPlugins.push_back( plugs.at(i)->getRawIdentifier() );
}
}
}
}
TUTTLE_COUT( _color._red << "################################################################################" << _color._std );
BOOST_FOREACH( const std::string& plugin, foundPlugins )
{
TUTTLE_COUT(_color._blue << "PLUGIN DESCRIPTION" << _color._std );
getPluginProperties( plugin );
TUTTLE_COUT( _color._red << "################################################################################" << _color._std );
}
int VideoFFmpegWriter::execute( boost::uint8_t* in_buffer, int in_width, int in_height, PixelFormat in_pixelFormat )
{
_error = IGNORE_FINISH;
if( !_avformatOptions )
{
// TODO avformat_alloc_context2 can guess format from filename
// if format name is NULL, find a way to expose the feature
if (avformat_alloc_output_context2(&_avformatOptions, NULL, _formatName.c_str(), filename().c_str()) < 0)
{
TUTTLE_CERR( "ffmpegWriter: output context allocation failed" );
return false;
}
_ofmt = _avformatOptions->oformat;
TUTTLE_CERR( "ffmpegWriter: " << std::string(_ofmt->name) << " format selected" );
}
if( !_stream )
{
_codec = avcodec_find_encoder_by_name( _codecName.c_str() );
if (!_codec)
{
TUTTLE_CERR( "ffmpegWriter: codec not found" );
return false;
}
TUTTLE_CERR( "ffmpegWriter: " << std::string(_codec->name) << " codec selected" );
_stream = avformat_new_stream( _avformatOptions, _codec );
if( !_stream )
{
TUTTLE_CERR( "ffmpegWriter: out of memory." );
return false;
}
avcodec_get_context_defaults3(_stream->codec, _codec);
if( _videoPresetName.length() !=0 )
{
TUTTLE_COUT( "ffmpegWriter: " << _videoPresetName << " preset selected" );
std::string presetFilename = getFilename( std::string(_codec->name), _videoPresetName );
PresetsOptions opts = getOptionsForPresetFilename( presetFilename );
PresetsOptions::iterator itOpt;
for ( itOpt = opts.begin() ; itOpt != opts.end(); itOpt++ )
{
int ret = av_opt_set( (void*)_stream->codec, (*itOpt).first.c_str(), (*itOpt).second.c_str(), 0);
switch( ret )
{
case AVERROR_OPTION_NOT_FOUND: TUTTLE_CERR( "ffmpegPreset: unable to find " << (*itOpt).first ); break;
case AVERROR(EINVAL): TUTTLE_CERR( "ffmpegPreset: invalid value " << (*itOpt).second.c_str() << " for option " << (*itOpt).first ); break;
case AVERROR(ERANGE): TUTTLE_CERR( "ffmpegPreset: invalid range for parameter " << (*itOpt).first << " : " << (*itOpt).second.c_str() ); break;
}
}
}
_stream->codec->bit_rate = _bitRate;
_stream->codec->bit_rate_tolerance = _bitRateTolerance;
_stream->codec->width = width();
_stream->codec->height = height();
_stream->codec->time_base = av_d2q( 1.0 / _fps, 100 );
_stream->codec->gop_size = _gopSize;
_stream->codec->sample_rate = 48000; ///< samples per second
_stream->codec->channels = 0; ///< number of audio channels
if( _bFrames )
{
_stream->codec->max_b_frames = _bFrames;
_stream->codec->b_frame_strategy = 0;
_stream->codec->b_quant_factor = 2.0;
}
_stream->codec->mb_decision = _mbDecision;
int pixfmt_allowed = 0, k;
if ( _codec->pix_fmts )
{
for ( k = 0; _codec->pix_fmts[k] != PIX_FMT_NONE; k++ )
{
if ( _codec->pix_fmts[k] == _out_pixelFormat )
{
pixfmt_allowed = 1;
break;
}
}
}
else
{
// If a codec does not contain a list of supported pixel
// formats, just assume that _out_PixelFormat is valid
pixfmt_allowed = 1;
}
if ( !pixfmt_allowed )
{
// av_get_pix_fmt_name requires lavu 51.3.0 or higher
TUTTLE_CERR( "ffmpegWriter: pixel format " << av_get_pix_fmt_name(_out_pixelFormat) << " not available in codec" );
_out_pixelFormat = _codec->pix_fmts[0];
TUTTLE_CERR( "ffmpegWriter: auto-selecting " << av_get_pix_fmt_name(_out_pixelFormat) );
}
_stream->codec->pix_fmt = _out_pixelFormat;
if( !strcmp( _avformatOptions->oformat->name, "mp4" ) || !strcmp( _avformatOptions->oformat->name, "mov" ) || !strcmp( _avformatOptions->oformat->name, "3gp" ) || !strcmp( _avformatOptions->oformat->name, "flv" ) )
_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
av_dump_format( _avformatOptions, 0, filename().c_str(), 1 );
if( avcodec_open2( _stream->codec, _codec, NULL ) < 0 )
{
TUTTLE_CERR( "ffmpegWriter: unable to open codec." );
freeFormat();
return false;
}
if( !( _ofmt->flags & AVFMT_NOFILE ) )
{
if( avio_open2( &_avformatOptions->pb, filename().c_str(),
AVIO_FLAG_WRITE, NULL, NULL ) < 0 )
{
TUTTLE_CERR( "ffmpegWriter: unable to open file." );
freeFormat();
return false;
}
}
avformat_write_header( _avformatOptions, NULL );
}
_error = CLEANUP;
AVFrame* in_frame = avcodec_alloc_frame();
avcodec_get_frame_defaults( in_frame );
avpicture_fill( (AVPicture*)in_frame, in_buffer, in_pixelFormat, in_width, in_height );
AVFrame* out_frame = avcodec_alloc_frame();
avcodec_get_frame_defaults( out_frame );
int out_picSize = avpicture_get_size( _out_pixelFormat, width(), height() );
boost::uint8_t* out_buffer = (boost::uint8_t*) av_malloc( out_picSize );
avpicture_fill( (AVPicture*) out_frame, out_buffer, _out_pixelFormat, width(), height() );
_sws_context = sws_getCachedContext( _sws_context, in_width, in_height, in_pixelFormat, width(), height(), _out_pixelFormat, SWS_BICUBIC, NULL, NULL, NULL );
TUTTLE_COUT( "ffmpegWriter: input format: " << av_get_pix_fmt_name( in_pixelFormat ) );
TUTTLE_COUT( "ffmpegWriter: output format: " << av_get_pix_fmt_name( _out_pixelFormat ) );
if( !_sws_context )
{
TUTTLE_CERR( "ffmpeg-conversion failed (" << in_pixelFormat << "->" << _out_pixelFormat << ")." );
return false;
}
int error = sws_scale( _sws_context, in_frame->data, in_frame->linesize, 0, height(), out_frame->data, out_frame->linesize );
if( error < 0 )
{
TUTTLE_CERR( "ffmpeg-conversion failed (" << in_pixelFormat << "->" << _out_pixelFormat << ")." );
return false;
}
int ret = 0;
if( ( _avformatOptions->oformat->flags & AVFMT_RAWPICTURE ) != 0 )
{
AVPacket pkt;
av_init_packet( &pkt );
pkt.flags |= AV_PKT_FLAG_KEY;
pkt.stream_index = _stream->index;
pkt.data = (boost::uint8_t*) out_frame;
pkt.size = sizeof( AVPicture );
ret = av_interleaved_write_frame( _avformatOptions, &pkt );
}
else
{
AVPacket pkt;
int hasFrame = 0;
av_init_packet( &pkt );
pkt.size = 0;
pkt.data = NULL;
pkt.stream_index = _stream->index;
if( _stream->codec->coded_frame && _stream->codec->coded_frame->pts != static_cast<boost::int64_t>( AV_NOPTS_VALUE ) ) // static_cast<unsigned long> (
pkt.pts = av_rescale_q( _stream->codec->coded_frame->pts, _stream->codec->time_base, _stream->time_base );
if( _stream->codec->coded_frame && _stream->codec->coded_frame->key_frame )
pkt.flags |= AV_PKT_FLAG_KEY;
out_frame->pts = pts++;
ret = avcodec_encode_video2( _stream->codec, &pkt, out_frame, &hasFrame );
if ( ret < 0 )
return false;
if ( hasFrame )
{
ret = av_interleaved_write_frame( _avformatOptions, &pkt );
if ( ret < 0 )
{
TUTTLE_CERR( "ffmpegWriter: error writing packet to file" );
return false;
}
}
}
av_free( out_buffer );
av_free( out_frame );
av_free( in_frame );
// in_buffer not free (function parameter)
if( ret )
{
TUTTLE_CERR( "ffmpegWriter: error writing frame to file." );
return false;
}
_error = SUCCESS;
return true;
}
void printImageProperties( std::string path )
{
try
{
Image *image;
ImageInfo *image_info;
// Read a file into image object
image_info = AcquireImageInfo();
GetImageInfo( image_info );
strcpy( image_info -> filename, path.c_str() );
ExceptionInfo* exceptionsInfo = AcquireExceptionInfo();
GetExceptionInfo( exceptionsInfo );
image = ReadImage( image_info, exceptionsInfo );
std::string imageType;
switch( image->type )
{
case UndefinedType : imageType = "Undefined type of image"; break;
case BilevelType : imageType = "Bilevel image"; break;
case GrayscaleType : imageType = "Grayscale image"; break;
case GrayscaleMatteType : imageType = "Grayscale image with opacity"; break;
case PaletteType : imageType = "Indexed color image"; break;
case PaletteMatteType : imageType = "Indexed color image with opacity"; break;
case TrueColorType : imageType = "Truecolor image"; break;
case TrueColorMatteType : imageType = "Truecolor image with opacity"; break;
case ColorSeparationType : imageType = "Cyan/Yellow/Magenta/Black (CYMK) image"; break;
case ColorSeparationMatteType : imageType = "Cyan/Yellow/Magenta/Black (CYMK) image with opacity"; break;
case OptimizeType : imageType = "Optimize image"; break;
case 11 : imageType = "Indexed bilevel image with opacity"; break; // PaletteBilevelMatteType
}
std::string resolutionType;
switch( image->units )
{
case UndefinedResolution : resolutionType = " [unknown units]"; break;
case PixelsPerInchResolution : resolutionType = " [dpi]"; break;
case PixelsPerCentimeterResolution : resolutionType = " [pixels/cm]"; break;
}
std::string colorSpaceType;
switch( image->colorspace )
{
case UndefinedColorspace : colorSpaceType = "unknown color space"; break;
case RGBColorspace : colorSpaceType = "RGB"; break;
case GRAYColorspace : colorSpaceType = "Gray"; break;
case TransparentColorspace : colorSpaceType = "Transparent"; break;
case OHTAColorspace : colorSpaceType = "OHTA"; break;
case XYZColorspace : colorSpaceType = "XYZ"; break;
case YCbCrColorspace : colorSpaceType = "Y Cb Cr"; break;
case YCCColorspace : colorSpaceType = "YCC"; break;
case YIQColorspace : colorSpaceType = "YIQ"; break;
case YPbPrColorspace : colorSpaceType = "Y Pb Pr"; break;
case YUVColorspace : colorSpaceType = "YUV"; break;
case CMYKColorspace : colorSpaceType = "CMYK"; break;
case sRGBColorspace : colorSpaceType = "sRGB"; break;
case LabColorspace : colorSpaceType = "Lab"; break;
case 14 : colorSpaceType = "HSB"; break; // HSBColorspace
case HSLColorspace : colorSpaceType = "HSL"; break;
case HWBColorspace : colorSpaceType = "HWB"; break;
case Rec601LumaColorspace : colorSpaceType = "Rec601 Luma"; break;
case 18 : colorSpaceType = "Rec601 Y Cb Cr"; break; // Rec601YCbCrColorspace
case Rec709LumaColorspace : colorSpaceType = "Rec709 Luma"; break;
case 20 : colorSpaceType = "Rec709 Y Cb Cr"; break; // Rec709YCbCrColorspace
case LogColorspace : colorSpaceType = "Log"; break;
case 22 : colorSpaceType = "CMY"; break; // CMYColorspace
}
std::string interlaceType;
switch( image->interlace )
{
case UndefinedInterlace : interlaceType = "undefined"; break;
case NoInterlace : interlaceType = "no interlacing"; break;
case LineInterlace : interlaceType = "line interlacing"; break;
case PlaneInterlace : interlaceType = "plane interlacing"; break;
case PartitionInterlace : interlaceType = "partition interlacing"; break;
case 5 : interlaceType = "GIF interlacing"; break; // GIFInterlace
case 6 : interlaceType = "Jpeg interlacing"; break; // JPEGInterlace
case 7 : interlaceType = "PNG interlacing"; break; // PNGInterlace
}
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "width" << image->columns );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "height" << image->rows );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "bit-depth" << image->depth << " bits" );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "compression quality" << image->quality );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "image type" << imageType );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "" );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "x resolution" << image->x_resolution << resolutionType );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "y resolution" << image->y_resolution << resolutionType );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "interlacing" << interlaceType );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "" );
//TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "format" << image->format() );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "channels" << colorSpaceType << ( GetImageAlphaChannel(image)==MagickTrue ? std::string("A") : "" ) );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "color space" << colorSpaceType );
TUTTLE_COUT( std::setw(FIRST_COLUMN_WIDTH) << "gamma" << image->gamma );
TUTTLE_COUT( "" );
}
catch( ... )
{
TUTTLE_COUT( "Caught exception" << "\n" );
}
}
void dumpImageProperties( const ttl::Sequence& s )
{
TUTTLE_COUT(s);
printImageProperties( s.getAbsoluteFirstFilename() );
sam::wasSthgDumped = true;
}
