updateBufferFromStream()

bool fl::video::VideoImpl::updateBufferFromStream ( fl::u32 now )

private

Definition at line 151 of file video_impl.cpp.hpp.

                                                {
    FASTLED_ASSERT(mTime, "mTime is null");
    if (!mStream) {
        FL_WARN("no stream");
        return false;
    }
    if (mStream->atEnd()) {
        return false;
    }
 
    fl::u32 currFrameNumber = 0;
    fl::u32 nextFrameNumber = 0;
    bool needs_frame =
        mFrameInterpolator->needsFrame(now, &currFrameNumber, &nextFrameNumber);
    if (!needs_frame) {
        return true;
    }
 
    if (mFrameInterpolator->capacity() == 0) {
        FL_WARN("capacity == 0");
        return false;
    }
 
    const bool has_current_frame = mFrameInterpolator->has(currFrameNumber);
    const bool has_next_frame = mFrameInterpolator->has(nextFrameNumber);
 
    fl::FixedVector<fl::u32, 2> frame_numbers;
    if (!has_current_frame) {
        frame_numbers.push_back(currFrameNumber);
    }
    size_t capacity = mFrameInterpolator->capacity();
    if (capacity > 1 && !has_next_frame) {
        frame_numbers.push_back(nextFrameNumber);
    }
 
    for (size_t i = 0; i < frame_numbers.size(); ++i) {
        FramePtr recycled_frame;
        if (mFrameInterpolator->full()) {
            fl::u32 frame_to_erase = 0;
            bool ok =
                mFrameInterpolator->get_oldest_frame_number(&frame_to_erase);
            if (!ok) {
                FL_WARN("get_oldest_frame_number failed");
                return false;
            }
            recycled_frame = mFrameInterpolator->erase(frame_to_erase);
            if (!recycled_frame) {
                FL_WARN("erase failed for frame: " << frame_to_erase);
                return false;
            }
        }
        fl::u32 frame_to_fetch = frame_numbers[i];
        if (!recycled_frame) {
            // Happens when we are not full and we need to allocate a new frame.
            recycled_frame = fl::make_shared<Frame>(mPixelsPerFrame);
        }
 
        if (!mStream->readFrame(recycled_frame.get())) {
            if (mStream->atEnd()) {
                if (!mStream->rewind()) {
                    FL_WARN("rewind failed");
                    return false;
                }
                mTime->reset(now);
                frame_to_fetch = 0;
                if (!mStream->readFrameAt(frame_to_fetch,
                                          recycled_frame.get())) {
                    FL_WARN("readFrameAt failed");
                    return false;
                }
            } else {
                // For streaming mode, buffer might not have data yet - this is OK
                // Producer (effect renderer) will fill buffer on next call
                // Just return success and we'll try again next frame
                if (mStream->getType() == PixelStream::kStreaming) {
                    return true;  // Gracefully handle empty streaming buffer
                }
                FL_WARN("We failed for some other reason");
                return false;
            }
        }
        bool ok = mFrameInterpolator->insert(frame_to_fetch, recycled_frame);
        if (!ok) {
            FL_WARN("insert failed");
            return false;
        }
    }
    return true;
}

References FL_WARN, fl::video::PixelStream::kStreaming, fl::make_shared(), mFrameInterpolator, mPixelsPerFrame, mStream, mTime, fl::FixedVector< T, N >::push_back(), and fl::FixedVector< T, N >::size().

Referenced by updateBufferIfNecessary().

Here is the call graph for this function:

Here is the caller graph for this function: