begin()

bool fl::video::PixelStream::begin

(

fl::filebuf_ptr

h

)

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

                                     {
    close();
    mHandle = h;
    mPayloadOffset = 0;
    mEmbeddedScreenMapJson.clear();
    // Probe seekability: if seek-to-start succeeds, this is a seekable file.
    mType = mHandle->seek(0, seek_dir::beg) ? kFile : kStreaming;
    if (mType == kFile) {
        // Try to detect a FLED v1 container. Anything that fails the header
        // check (wrong magic, wrong version, unsupported pixel_format,
        // truncated) falls back to legacy headerless RGB — zero behavior
        // change for existing files.
        if (mHandle->size() >= kFledHeaderBytes) {
            char hdr[kFledHeaderBytes];
            fl::size_t got = mHandle->read(hdr, kFledHeaderBytes);
            bool isFled = got == kFledHeaderBytes
                && 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]
                && static_cast<fl::u8>(hdr[4]) == kFledVersionV1
                && static_cast<fl::u8>(hdr[5]) == kFledPixelFormatRgb8;
            if (isFled) {
                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;
                        // Stream is now positioned at the first frame byte.
                        return mHandle->available();
                    }
                    // JSON slurp short-read — abandon FLED interpretation.
                    mEmbeddedScreenMapJson.clear();
                }
            }
            // Not a FLED file (or header rejected). Rewind so subsequent
            // reads see the file from byte 0 as raw RGB triplets.
            mHandle->seek(0, seek_dir::beg);
        }
        return mHandle->available();
    }
    return mHandle->available(mbytesPerFrame);
}

References fl::beg, close(), kFile, kStreaming, mbytesPerFrame, mEmbeddedScreenMapJson, mHandle, mPayloadOffset, and mType.

Here is the call graph for this function: