begin()

bool fl::video::PixelStream::begin

(

fl::filebuf_ptr

h

)

Definition at line 40 of file pixel_stream.cpp.hpp.

                                                  {
    close();
    if (!h || mBaseBytesPerFrame <= 0) {
        return false;
    }
    mHandle = h;
    mbytesPerFrame = mBaseBytesPerFrame;
    mPayloadOffset = 0;
    mEmbeddedScreenMapJson.clear();
    mFledPixelFormat = 0;
    mFledBytesPerLed = 0;
    mHasVideoColor = false;
    mHasFledContainer = false;
    mStreamingPrefixSize = 0;
    mStreamingPrefixPos = 0;
    mStreamingProbePending = false;
    mStreamingRejected = false;
    // Probe seekability: if seek-to-start succeeds, this is a seekable file.
    mType = mHandle->seek(0, seek_dir::beg) ? kFile : kStreaming;
    if (mType == kFile) {
        // A file without FLED magic remains a legacy headerless RGB stream.
        // Once magic is recognized, though, every invalidity is a container
        // error: falling back would render its header bytes as LEDs.
        if (mHandle->size() >= 4) {
            char hdr[kFledHeaderBytes];
            fl::size_t got = mHandle->read(hdr, kFledHeaderBytes);
            const bool hasFledMagic = got >= 4
                && static_cast<fl::u8>(hdr[0]) == kFledMagic[0]
                && static_cast<fl::u8>(hdr[1]) == kFledMagic[1]
                && static_cast<fl::u8>(hdr[2]) == kFledMagic[2]
                && static_cast<fl::u8>(hdr[3]) == kFledMagic[3];
            if (hasFledMagic) {
                const bool supportedFled = got == kFledHeaderBytes
                && static_cast<fl::u8>(hdr[4]) == kFledVersionV1
                && static_cast<fl::u8>(hdr[6]) == 0
                && static_cast<fl::u8>(hdr[7]) == 0
                && fled::bytesPerLed(static_cast<fl::u8>(hdr[5])) != 0;
                if (!supportedFled) {
                    close();
                    return false;
                }
                const fl::u8 pixelFormat = static_cast<fl::u8>(hdr[5]);
                const fl::u32 jsonLen =
                    static_cast<fl::u32>(static_cast<fl::u8>(hdr[8]))
                    | (static_cast<fl::u32>(static_cast<fl::u8>(hdr[9])) << 8)
                    | (static_cast<fl::u32>(static_cast<fl::u8>(hdr[10])) << 16)
                    | (static_cast<fl::u32>(static_cast<fl::u8>(hdr[11])) << 24);
                // Cap the JSON length against a defensive maximum BEFORE
                // doing any size arithmetic — guards against a malformed
                // file declaring a multi-gigabyte json_length that would
                // either overflow the offset calc or trigger a huge resize.
                const fl::size_t jsonLenSz = static_cast<fl::size_t>(jsonLen);
                const fl::size_t fileSize = mHandle->size();
                const bool jsonInRange = jsonLenSz <= kFledMaxJsonBytes
                    && jsonLenSz <= fileSize - kFledHeaderBytes;
                if (jsonInRange) {
                    mEmbeddedScreenMapJson.resize(static_cast<fl::size>(jsonLenSz));
                    fl::size_t jr = jsonLenSz > 0
                        ? mHandle->read(&mEmbeddedScreenMapJson[0], jsonLenSz)
                        : 0;
                    if (jr == jsonLenSz) {
                        mPayloadOffset = kFledHeaderBytes + jsonLenSz;
                        mFledPixelFormat = pixelFormat;
                        mFledBytesPerLed = fled::bytesPerLed(pixelFormat);
                        mHasFledContainer = true;
                        if (mbytesPerFrame % 3 != 0) {
                            close();
                            return false;
                        }
                        const fl::i32 ledCount = mbytesPerFrame / 3;
                        const fl::i32 bytesPerLed =
                            static_cast<fl::i32>(mFledBytesPerLed);
                        if (ledCount > (fl::numeric_limits<fl::i32>::max)() /
                                bytesPerLed) {
                            close();
                            return false;
                        }
                        mbytesPerFrame = ledCount * bytesPerLed;
                        if ((fileSize - mPayloadOffset) %
                            static_cast<fl::size_t>(mbytesPerFrame) != 0) {
                            close();
                            return false;
                        }
                        fl::json envelope;
                        if (!mEmbeddedScreenMapJson.empty()) {
                            envelope = fl::json::parse(mEmbeddedScreenMapJson);
                        }
                        const bool validEnvelope = mEmbeddedScreenMapJson.empty() ||
                            (envelope.has_value() && envelope.is_object());
                        if (!validEnvelope) {
                            close();
                            return false;
                        }
                        const bool colorOk =
                            fled::resolveVideoColor(envelope, mFledPixelFormat,
                                                    &mVideoColor) ==
                            fled::ColorStatus::Ok;
                        mHasVideoColor = colorOk;
                        if (!colorOk) {
                            fled::PixelStorage storage;
                            const bool advisoryRgb8 = pixelStorage(&storage) &&
                                storage.mFormat == fl::PixelFormat::Rgb8;
                            if (!mBestEffortFled || !advisoryRgb8) {
                                close();
                                return false;
                            }
                            FL_WARN("FLED video.color rejected; using explicit best-effort RGB8 playback");
                        }
                        // Stream is now positioned at the first frame byte.
                        return mHandle->available();
                    }
                    mEmbeddedScreenMapJson.clear();
                }
                // FLED magic was recognized, so malformed/truncated
                // containers must not become headerless raw RGB.
                close();
                return false;
            }
            // No magic: rewind so subsequent reads see raw RGB triplets.
            mHandle->seek(0, seek_dir::beg);
        }
        return mHandle->available();
    }
    // A partial FLED prefix stays buffered until enough bytes arrive to
    // classify it. A raw mismatch is replayed through readBytes().
    mStreamingProbePending = true;
    if (!probeStreamingMagic()) {
        close();
        return false;
    }
    return true;
}

References fl::beg, fl::fled::bytesPerLed(), close(), fl::FL_NO_EXCEPT, FL_WARN, fl::json::has_value(), fl::json::is_object(), kFile, kStreaming, fl::numeric_limits< T >::max(), mBaseBytesPerFrame, mBestEffortFled, mbytesPerFrame, mEmbeddedScreenMapJson, mFledBytesPerLed, mFledPixelFormat, fl::fled::PixelStorage::mFormat, mHandle, mHasFledContainer, mHasVideoColor, mPayloadOffset, mStreamingPrefixPos, mStreamingPrefixSize, mStreamingProbePending, mStreamingRejected, mType, mVideoColor, fl::fled::Ok, fl::json::parse(), pixelStorage(), probeStreamingMagic(), fl::fled::resolveVideoColor(), and fl::Rgb8.

Here is the call graph for this function: