AVReaderPluginFactory.cpp

Go to the documentation of this file.

#include "AVReaderPluginFactory.hpp"
#include "AVReaderPlugin.hpp"
#include "AVReaderDefinitions.hpp"

#include <libav/LibAVOptionsFactory.hpp>

#include <tuttle/plugin/context/ReaderPluginFactory.hpp>

#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

#include <string>
#include <vector>

namespace tuttle {
namespace plugin {
namespace av {
namespace reader {

/**
 * @brief Function called to describe the plugin main features.
 * @param[in, out]   desc     Effect descriptor
 */
void AVReaderPluginFactory::describe( OFX::ImageEffectDescriptor& desc )
{
        desc.setLabels(
                "TuttleAVReader",
                "AVReader",
                "Audio Video reader" );
        desc.setPluginGrouping( "tuttle/image/io" );

        std::vector<std::string> supportedExtensions;
        {
                AVInputFormat* iFormat = av_iformat_next( NULL );
                while( iFormat != NULL )
                {
                        if( iFormat->extensions != NULL )
                        {
                                using namespace boost::algorithm;
                                const std::string extStr( iFormat->extensions );
                                std::vector<std::string> exts;
                                split( exts, extStr, is_any_of(",") );
                                supportedExtensions.insert( supportedExtensions.end(), exts.begin(), exts.end() );
                        }
                        iFormat = av_iformat_next( iFormat );
                }
        }
        
        desc.setDescription( "Video reader based on LibAV library\n\n"
                        "Supported extensions: \n" +
                        boost::algorithm::join( supportedExtensions, ", " )
                );
        
        // add the supported contexts
        desc.addSupportedContext( OFX::eContextReader );
        desc.addSupportedContext( OFX::eContextGeneral );

        // add supported pixel depths
        desc.addSupportedBitDepth( OFX::eBitDepthUByte );
        desc.addSupportedBitDepth( OFX::eBitDepthUShort );
        desc.addSupportedBitDepth( OFX::eBitDepthFloat );

        // add supported extensions
        desc.addSupportedExtensions( supportedExtensions );
        
        // plugin flags
        desc.setRenderThreadSafety( OFX::eRenderInstanceSafe );
        desc.setHostFrameThreading( false );
        desc.setSupportsMultiResolution( false );
        desc.setSupportsMultipleClipDepths( true );
        desc.setSupportsTiles( kSupportTiles );
}

/**
 * @brief Function called to describe the plugin controls and features.
 * @param[in, out]   desc       Effect descriptor
 * @param[in]        context    Application context
 */
void AVReaderPluginFactory::describeInContext( OFX::ImageEffectDescriptor& desc,
                                                   OFX::EContext               context )
{
        // Create the mandated output clip
        OFX::ClipDescriptor* dstClip = desc.defineClip( kOfxImageEffectOutputClipName );
        dstClip->addSupportedComponent( OFX::ePixelComponentRGBA );
        dstClip->addSupportedComponent( OFX::ePixelComponentRGB );
        dstClip->addSupportedComponent( OFX::ePixelComponentAlpha );
        dstClip->setSupportsTiles( kSupportTiles );

        describeReaderParamsInContext( desc, context );
        
        // Groups
        OFX::GroupParamDescriptor* formatGroup = desc.defineGroupParam( kParamFormatGroup );
        OFX::GroupParamDescriptor* videoGroup  = desc.defineGroupParam( kParamVideoGroup );
        OFX::GroupParamDescriptor* audioGroup  = desc.defineGroupParam( kParamAudioGroup );
        OFX::GroupParamDescriptor* metaGroup   = desc.defineGroupParam( kParamMetaGroup );
        
        formatGroup->setLabel( "Format" );
        videoGroup->setLabel( "Video" );
        audioGroup->setLabel( "Audio" );
        metaGroup->setLabel( "Metadata" );
        
        formatGroup->setAsTab( );
        videoGroup->setAsTab( );
        audioGroup->setAsTab( );
        metaGroup->setAsTab( );
        
        /// FORMAT PARAMETERS
        AVFormatContext* avFormatContext;
        avFormatContext = avformat_alloc_context();
        addOptionsFromAVOption( desc, formatGroup, (void*)avFormatContext, AV_OPT_FLAG_DECODING_PARAM, 0 );
        avformat_free_context( avFormatContext );
        
        /// VIDEO PARAMETERS
        AVCodecContext* avCodecContext;
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT( 53, 8, 0 )
        avCodecContext = avcodec_alloc_context();
        // deprecated in the same version
        //avCodecContext = avcodec_alloc_context2( AVMEDIA_TYPE_UNKNOWN );
#else
        AVCodec* avCodec = NULL;
        avCodecContext = avcodec_alloc_context3( avCodec );
#endif
        
        addOptionsFromAVOption( desc, videoGroup, (void*)avCodecContext, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM, 0 );
        
        OFX::BooleanParamDescriptor* useCustomSAR = desc.defineBooleanParam( kParamUseCustomSAR );
        useCustomSAR->setLabel( "Override SAR" );
        useCustomSAR->setDefault( false );
        useCustomSAR->setHint( "Override the file SAR (Storage Aspect Ratio) with a custom SAR value." );

        OFX::DoubleParamDescriptor* customSAR = desc.defineDoubleParam( kParamCustomSAR );
        customSAR->setLabel( "Custom SAR" );
        customSAR->setDefault( 1.0 );
        customSAR->setHint( "Choose a custom value to override the file SAR (Storage Aspect Ratio)." );
}

/**
 * @brief Function called to create a plugin effect instance
 * @param[in] handle  effect handle
 * @param[in] context    Application context
 * @return  plugin instance
 */
OFX::ImageEffect* AVReaderPluginFactory::createInstance( OfxImageEffectHandle handle,
                                                         OFX::EContext        context )
{
        return new AVReaderPlugin( handle );
}

}
}
}
}