Method KickAsyncLoad

engine/PoseidonOpenAL/WaveOAL.cpp:655–709

    }
    chunk.isLastChunk = isLast;

    _streaming.decodeOffsetBytes.store(offset + gotBytes, std::memory_order_release);
    if (isLast)
    {
        _streaming.eofReached.store(true, std::memory_order_release);
    }
    _streaming.queue.Push(std::move(chunk));
}

void WaveOAL::KickAsyncLoad()
{
    // Phase 3d: dispatch DecodePcm to a TaskPool worker if the wave
    // is large enough to benefit from async decode, otherwise decode
    // synchronously on the calling (main) thread.  Idempotent —
    // repeated calls while a decode is in flight are no-ops via CAS.
    //
    // The threshold matches the Phase A baseline shape: music tracks
    // (>=10 MB PCM) dominate the main-thread hitch and reliably want
    // async; voice lines and SFX (<1 MB) decode in 1-10 ms each and
    // would suffer a 16-33 ms playback delay if forced through the
    // worker round-trip.  1 MB cleanly separates the two populations.
    constexpr unsigned int kAsyncThresholdBytes = 1u * 1024u * 1024u;

    if (_loaded || _loadError)
    {
        return;
    }

    int expected = static_cast<int>(LoadState::NotStarted);
    if (!_loadState.compare_exchange_strong(expected, static_cast<int>(LoadState::DecodePending),
                                            std::memory_order_acq_rel))
    {
        // Decode already in flight, or wave has finished loading /
        // hit a failure.  Either way, nothing to do here.
        return;
    }

    auto* pool = ::Poseidon::GetGlobalTaskPool();
    if (_state.size < kAsyncThresholdBytes || !pool)
    {
        // Small asset or no worker pool (server / tools / very early
        // startup) — decode synchronously.  DecodePcm sets the state
        // to UploadPending on success, leaving us at the same place
        // as the async path's worker completion.
        LOG_DEBUG(Audio, "WaveOAL::KickAsyncLoad sync-fallback: {} ({} bytes, pool={})",
                  static_cast<const char*>(Name()), _state.size, pool ? "live" : "null");
        DecodePcm();
        return;
    }

    // Async dispatch.  AddRef keeps the wave alive across the decode
    // — TaskPool::Submit takes the lambda by value, so the captured
    // `this` plus the explicit refcount bump guarantees the object
    // outlives the worker even if every other holder drops their Ref
    // before decode completes.
    LOG_DEBUG(Audio, "WaveOAL::KickAsyncLoad async-dispatch: {} ({} bytes)",
              static_cast<const char*>(Name()), _state.size);
    AddRef();