Smart pointers

Objects created by the SDK are released with tsvb::IRelease::release(), never with delete. A deleter that calls it lets std::unique_ptr and std::shared_ptr own them, so they are released on every path out of a scope, early returns and exceptions included.

The deleter

#include <memory>
 
struct SdkReleaser
{
    void operator()(::tsvb::IRelease* object) const
    {
        object->release();
    }
};
 
template <typename T>
using SdkPtr = std::unique_ptr<T, SdkReleaser>;

SdkPtr takes any object the caller is responsible for releasing: tsvb::ISDKFactory, tsvb::IAuthResult, tsvb::IError, tsvb::IFrameFactory, tsvb::IFrame, tsvb::ILockedFrameData, tsvb::IPipeline, tsvb::IPipelineConfiguration and tsvb::IReplacementController.

Don't put into it what the SDK keeps for itself:

• the tsvb::IAuthResult passed into the callback of tsvb::ISDKFactory::auth();
• the interfaces returned by tsvb::IFrame::getInterface() and tsvb::IFrameFactory::getInterface(), which are not tsvb::IRelease objects at all.

unique_ptr

struct Effects
{
    SdkPtr<::tsvb::IFrameFactory> frameFactory;
    SdkPtr<::tsvb::IPipeline> pipeline;
    SdkPtr<::tsvb::IReplacementController> replacementController;
};
 
std::optional<Effects> createEffects(const char* customerID, const char* backgroundPath)
{
    SdkPtr<::tsvb::ISDKFactory> factory(createFactory());
    SdkPtr<::tsvb::IAuthResult> authResult(factory->auth(customerID, nullptr, nullptr));
    if (::tsvb::AuthStatus::active != authResult->status()) {
        // Authorization failed: report the status, the SDK can't be used.
        return std::nullopt;
    }
 
    Effects effects;
    effects.frameFactory.reset(factory->createFrameFactory());
    effects.pipeline.reset(factory->createPipeline());
    effects.pipeline->enableNoiseSuppression();
 
    ::tsvb::IReplacementController* controller = nullptr;
    effects.pipeline->enableReplaceBackground(&controller);
    effects.replacementController.reset(controller);
 
    SdkPtr<::tsvb::IFrame> background(effects.frameFactory->loadImage(backgroundPath));
    if (nullptr != background) {
        effects.replacementController->setBackgroundImage(background.get());
    }
    return effects;
}

The SDK factory is released when createEffects() returns: the frame factory and the pipeline it created don't need it. Frames, too, may outlive the frame factory that created them.

An out-parameter, such as the controller of tsvb::IPipeline::enableReplaceBackground(), goes through a plain pointer first and into the smart pointer after the call.

Processing a frame and reading the result:

SdkPtr<::tsvb::IFrame> input(
    effects.frameFactory->createBGRA(bgra, bytesPerLine, width, height, false)
);
::tsvb::PipelineError error = ::tsvb::PipelineErrorCode::ok;
SdkPtr<::tsvb::IFrame> output(effects.pipeline->process(input.get(), &error));
if (nullptr == output) {
    return;
}
 
{
    // The frame stays locked until the scope ends.
    SdkPtr<::tsvb::ILockedFrameData> data(output->lock(::tsvb::FrameLock::read));
    const void* pixels = data->dataPointer(0);
    unsigned int stride = data->bytesPerLine(0);
    // ...
}

shared_ptr

A tsvb::IPipeline is thread-safe, so it can be shared, for example between the thread that processes the frames and the one that turns the effects on and off. Pass the deleter to the constructor of std::shared_ptr:

std::shared_ptr<::tsvb::IPipeline> pipeline(factory->createPipeline(), SdkReleaser());

A SdkPtr converts into a std::shared_ptr with its deleter:

SdkPtr<::tsvb::IPipeline> owned(factory->createPipeline());
std::shared_ptr<::tsvb::IPipeline> shared = std::move(owned);

Unloading the library

A smart pointer calls code of the SDK library when it releases its object. If the application loads the library at run time, release every object before it frees the library: see Library lifetime.