mirror of
https://github.com/spice2x/spice2x.github.io.git
synced 2026-09-30 14:04:55 -07:00
bicarus
d51de976b1
## Link to GitHub Issue or related Pull Request, if one exists #0 ## Description of change Moves the API capture readback off the game's Present thread while a video stream client is connected. The readback is a `LockRect` plus a memcpy of the whole back buffer, roughly 635us at 720p and 1270us at 1080p. On the Present thread that comes out of the game's frame budget: TDJ (at 120Hz) dropped to 117fps with a 60fps stream running, and reading on a pool thread instead gave the full 120 back. Only streaming takes the off-thread path, gated on a new `capture_pump::screen_claimed()`. Screenshots, one-off API captures, and `THREAD_BAN` games all keep the existing inline read for compat reasons. A pool thread in `LockRect` while the Present thread sat inside `GetRenderTargetData` deadlocks DDR X2 for example. `CLAIMED[]` becomes `std::atomic<bool>` so the capture path does not take a lock on the Present thread. The read pool has a single worker so frames cannot be enqueued out of order, and both capture pools are never destroyed so a late read cannot queue onto a torn-down pool. The capture pipeline itself is unchanged: `GetRenderTargetData` is still synchronous on the Present thread. ## Testing DDR X2 World IIDX TDJ SDVX VM
28 lines
906 B
C++
28 lines
906 B
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <memory>
|
|
|
|
namespace api::capture_pump {
|
|
|
|
struct Frame {
|
|
// packed 24bpp RGB, width * height * 3 bytes
|
|
std::shared_ptr<uint8_t[]> pixels;
|
|
uint64_t timestamp = 0;
|
|
int width = 0;
|
|
int height = 0;
|
|
};
|
|
|
|
// the graphics layer has one capture slot per screen, so concurrent waiters would steal
|
|
// each other's frames; everything that captures goes through here to keep it serialized
|
|
bool capture_direct(int screen, std::shared_ptr<uint8_t[]> &out, int divide,
|
|
uint64_t *timestamp = nullptr, int *width = nullptr, int *height = nullptr);
|
|
|
|
// a screen carries one stream at a time; false when another connection already holds it
|
|
bool claim_screen(int screen);
|
|
void release_screen(int screen);
|
|
|
|
// true while a video stream client holds this screen
|
|
bool screen_claimed(int screen);
|
|
}
|