video.cpp.hpp

Go to the documentation of this file.

#include "fl/fx/video.h"
 
#include "crgb.h"
#include "fl/stl/detail/memory_file_handle.h"
#include "fl/log/log.h"
#include "fl/math/math.h"
#include "fl/stl/string.h"
#include "fl/log/log.h"
#include "fl/fx/frame.h"
#include "fl/video/frame_interpolator.h"
#include "fl/video/pixel_stream.h"
#include "fl/fled/color.h"
#include "fl/gfx/color_profile.h"
#include "fl/video/video_impl.h"
#include "fl/stl/noexcept.h"
 
#define DBG FL_DBG
 
namespace fl {
 
Video::Video() FL_NO_EXCEPT : Fx1d(0) {}
 
Video::Video(size_t pixelsPerFrame, float fps, size_t frame_history_count)
    FL_NO_EXCEPT : Fx1d(pixelsPerFrame) {
    mImpl = fl::make_shared<VideoImpl>(pixelsPerFrame, fps, frame_history_count);
}
 
void Video::setFade(fl::u32 fadeInTime, fl::u32 fadeOutTime) FL_NO_EXCEPT {
    mImpl->setFade(fadeInTime, fadeOutTime);
}
 
void Video::pause(fl::u32 now) FL_NO_EXCEPT { mImpl->pause(now); }
 
void Video::resume(fl::u32 now) FL_NO_EXCEPT { mImpl->resume(now); }
 
Video::~Video() FL_NO_EXCEPT = default;
Video::Video(const Video &) FL_NO_EXCEPT = default;
Video &Video::operator=(const Video &) FL_NO_EXCEPT = default;
 
bool Video::begin(filebuf_ptr handle) FL_NO_EXCEPT {
    if (!mImpl) {
        FL_WARN("Video::begin: mImpl is null, manually constructed videos "
                     "must include full parameters.");
        return false;
    }
    // Drop a previous admission failure before evaluating this attempt.
    // Rejecting one source says nothing about the next; only a persistent
    // setError() failure keeps blocking.
    if (mAdmissionError) {
        mError.clear();
        mAdmissionError = false;
    }
    if (!handle) {
        setAdmissionError("filebuf is null");
        FL_DBG(mError);
        return false;
    }
    if (mError.size()) {
        FL_DBG(mError);
        return false;
    }
    if (!mImpl->begin(handle)) {
        setAdmissionError("unsupported or malformed FLED container");
        return false;
    }
    return true;
}
 
bool Video::draw(fl::u32 now, fl::span<CRGB> leds) FL_NO_EXCEPT {
    if (!mError.empty()) {
        for (fl::size_t i = 0; i < leds.size(); ++i) {
            leds[i] = CRGB::Black;
        }
        return false;
    }
    if (!mImpl) {
        FL_WARN_IF(!mError.empty(), mError);
        return false;
    }
    bool ok = mImpl->draw(now, leds);
    if (!ok) {
        // Interpret not being able to draw as a finished signal.
        mFinished = true;
    }
    return ok;
}
 
void Video::draw(DrawContext context) FL_NO_EXCEPT {
    draw(context.now, context.leds);
}
 
i32 Video::durationMicros() const FL_NO_EXCEPT {
    if (!mImpl) {
        return -1;
    }
    return mImpl->durationMicros();
}
 
string Video::fxName() const FL_NO_EXCEPT { return "Video"; }
 
bool Video::draw(fl::u32 now, Frame *frame) FL_NO_EXCEPT {
    if (!frame) {
        return false;
    }
    return draw(now, frame->rgb());
}
 
void Video::end() FL_NO_EXCEPT {
    if (mImpl) {
        mImpl->end();
    }
}
 
void Video::setTimeScale(float timeScale) FL_NO_EXCEPT {
    if (!mImpl) {
        return;
    }
    mImpl->setTimeScale(timeScale);
}
 
float Video::timeScale() const FL_NO_EXCEPT {
    if (!mImpl) {
        return 1.0f;
    }
    return mImpl->timeScale();
}
 
string Video::error() const FL_NO_EXCEPT { return mError; }
 
bool Video::sourceProfile(SourceProfile *out) const FL_NO_EXCEPT {
    fled::VideoColor color;
    return out != nullptr && videoColor(&color) &&
           fled::toSourceProfile(color, out);
}
 
bool Video::videoColor(fled::VideoColor *out) const FL_NO_EXCEPT {
    return mImpl && mImpl->videoColor(out);
}
 
bool Video::pixelStorage(fled::PixelStorage *out) const FL_NO_EXCEPT {
    return mImpl && mImpl->pixelStorage(out);
}
 
bool Video::readSample(video::PixelSample *out) FL_NO_EXCEPT {
    return mImpl && mImpl->readSample(out);
}
 
void Video::setFledPlaybackMode(FledPlaybackMode mode) FL_NO_EXCEPT {
    if (mImpl) {
        mImpl->setBestEffortFled(mode == FledPlaybackMode::BestEffort);
    }
}
 
size_t Video::pixelsPerFrame() const FL_NO_EXCEPT {
    if (!mImpl) {
        return 0;
    }
    return mImpl->pixelsPerFrame();
}
 
bool Video::hasEmbeddedScreenMap() const FL_NO_EXCEPT {
    if (!mImpl) return false;
    return mImpl->hasEmbeddedScreenMap();
}
 
const fl::string &Video::embeddedScreenMapJson() const FL_NO_EXCEPT {
    static const fl::string kEmpty;
    if (!mImpl) return kEmpty;
    return mImpl->embeddedScreenMapJson();
}
 
bool Video::finished() FL_NO_EXCEPT {
    if (!mImpl) {
        return true;
    }
    return mFinished;
}
 
bool Video::rewind() FL_NO_EXCEPT {
    if (!mImpl) {
        return false;
    }
    return mImpl->rewind();
}
 
VideoFxWrapper::VideoFxWrapper(fl::shared_ptr<Fx> fx) FL_NO_EXCEPT : Fx1d(fx->getNumLeds()), mFx(fx) {
    if (!mFx->hasFixedFrameRate(&mFps)) {
        FL_WARN("VideoFxWrapper: Fx does not have a fixed frame rate, "
                     "assuming 30fps.");
        mFps = 30.0f;
    }
    mVideo = fl::make_shared<VideoImpl>(mFx->getNumLeds(), mFps, 2);
    mByteStream = fl::make_shared<memorybuf>(mFx->getNumLeds() * sizeof(CRGB));
    mVideo->begin(mByteStream);
}
 
VideoFxWrapper::~VideoFxWrapper() FL_NO_EXCEPT = default;
 
string VideoFxWrapper::fxName() const FL_NO_EXCEPT {
    string out = "video_fx_wrapper: ";
    out.append(mFx->fxName());
    return out;
}
 
void VideoFxWrapper::draw(DrawContext context) FL_NO_EXCEPT {
    if (mVideo->needsFrame(context.now)) {
        mFx->draw(context); // use the leds in the context as a tmp buffer.
        mByteStream->writeCRGB(
            context.leds.data(),
            mFx->getNumLeds()); // now write the leds to the byte stream.
    }
    bool ok = mVideo->draw(context.now, context.leds);
    if (!ok) {
        FL_WARN("VideoFxWrapper: draw failed.");
    }
}
 
void VideoFxWrapper::setFade(fl::u32 fadeInTime, fl::u32 fadeOutTime) FL_NO_EXCEPT {
    mVideo->setFade(fadeInTime, fadeOutTime);
}
 
} // namespace fl