Commit Graph
3016 Commits
Author SHA1 Message Date
Codex d434515a14 test: cover fractional PCM through calibrated RTMP output
Exercise source-rate conversion through the real worker and AAC calibration across AVC, HEVC/PQ and AV1 receiver cases, including TLS. Check normalized duration independently and compare every submitted PCM sample before packet replay.
2026-11-16 20:01:26 +01:00
Codex 06d6d80856 record: route fractional MediaCodec audio through owned conversion
Keep producer timestamps and queue capacity in source frames, configure AAC at a native rate and initialize conversion before exposing the Surface. Preserve direct standard-rate input. Cancel partial network startup on setup failure, retaining the original error.

Full Windows C89 and GCC/Clang sanitizer suites pass, including source clocks and conversion-startup rollback. Native device acceptance remains separate.
2026-11-16 20:01:26 +01:00
Codex 908c1ea783 record: convert source PCM on the MediaCodec worker
Borrow queue spans, convert at most 256 source frames per action and retain output across partial encoder acceptance. Track source and encoded ends separately through calibration, trim and cancellation. Calculate ceil durations exactly from the binary64 source rate.

Tests cover fractional mono/stereo, packet boundaries, anti-aliasing, empty/short EOF, source gaps, cancellation and file/live calibration. An independent Python rational oracle checks 176 duration cases.
2026-11-16 20:01:26 +01:00
Codex 4f24f73070 audio: retain fractional phase in aligned S16 conversion
Correct sub-phase rounding after bounded offline chunks without changing normal playback processing. Check the actual correction kernel against a nine-hour exact sample-clock oracle.
2026-11-16 20:01:26 +01:00
Codex 00904f5d64 audio: expose aligned cold starts for fixed-ratio S16 sinc conversion
Center offline output on source frame zero and report the input lookahead needed for tail draining. Existing processing and reset paths remain unchanged. This supplies latency handling for worker-owned fractional recording conversion.

Check impulses, independent fractional-rate tone phase, chunk invariance and tail drain at 8-192 kHz. GCC/Clang sanitizers, Windows C89 and four NDK ABI builds pass; missing and one-frame compensation mutants are rejected.
2026-11-16 20:01:26 +01:00
Codex 1a288ddfed record: admit AV1 file and RTMP recording through MediaCodec
Accept vcodec=av1, route its sized OBUs to enhanced FLV, and preserve SDR/HDR profile and source color admission. Select Android AV1 levels from Annex A main-tier display-rate, picture, dimension, header-rate and bitrate bounds; native inventory still validates the complete request.

Strict C89 Windows and Linux ASan/UBSan frontend/session/worker suites pass. File and stream tests cover SDR, PQ and scRGB; four actual-source MIME, routing and level-limit mutations are rejected. Native device encoder acceptance remains separate.
2026-11-16 20:01:26 +01:00
Codex 32c7981adb tests: set AV1 fixture CICP in the encoded bitstream
Some CI libaom builds leave primaries and transfer unspecified despite encoder options. Apply the independent FFmpeg AV1 metadata filter and verify the source CICP before transmission, keeping the production mux agreement checks strict.
2026-11-16 20:01:26 +01:00
Codex ca2a4c0665 tests: receive calibrated HEVC and AV1 streams independently
Add enhanced RTMP receiver cases for HEVC 8-bit, HEVC 10-bit PQ and AV1. Verify decoded pictures, complete source PCM, source epochs and color metadata over standard/legacy RTMP, TLS 1.2/1.3 and video-only output. Preserve ten-bit samples in the comparison and retain AVC coverage.
2026-11-16 20:01:26 +01:00
Codex 728277498e record: verify calibrated MediaCodec worker against real receivers
Replay independently encoded AVC/AAC only at the encoder boundary while running the actual worker, PCM queue, AAC probe, FLV adapter and RTMP/TLS client. Check partial PCM acceptance, silent preroll, calibration removal, source PCM recovery, video epoch and EOS drain. Keep adapter-only checks and run both targets in CI.

Validation: GCC and Clang ASan/UBSan five-case receiver runs pass (standard/legacy RTMP, TLS 1.2/1.3, video-only). A two-millisecond actual worker video epoch mutation is rejected after successful transport. This is portable integration evidence, not native MediaCodec device acceptance.
2026-11-16 20:01:26 +01:00
Codex 3ff13b8c1a tests: preserve receiver evidence and validate stream identity
Require fresh explicit artifact directories so reruns cannot overwrite failures. Verify received codec, sample rate and channel identity as well as packet clocks and decoded bytes. The strengthened five-case oracle passes with the previously built GCC sanitizer publisher.
2026-11-16 20:01:26 +01:00
Codex 15a19489d1 tests: independently receive MediaCodec output adapter over RTMP and TLS
Replay independently encoded AVC/AAC through the real native output adapter, shared FLV mux, owned RTMP client and TCP/TLS transport. Compare received packet counts, millisecond timestamps and independently decoded RGB/PCM bytes. Cover standard and legacy RTMP, TLS 1.2/1.3 and video-only output.

GCC and Clang ASan/UBSan matrices pass five cases each (120 pictures and 80 AAC packets per compiler). An adapter mutation shifting both media clocks by one second is rejected after successful transport drain. Metadata getters and encoded packet input are replayed: native MediaCodec, the calibrated worker and device capture are not established by this test. Add the matrix to Android CI and retain exact evidence.
2026-11-16 20:01:26 +01:00
Codex 1059e887b8 record: activate native Android streaming through the MediaCodec frontend
Select the owned stream dispatcher for RTMP(S), validate native FLV/AAC options, propagate coded HDR source metadata, and keep stream URLs out of file history. Expose backend streaming capability and enable shared RTMP/FLV in Vulkan Android NDK builds with crypto.

Windows frontend and native menu checks pass; full arm64 Android library builds and links with native streaming entry points and passes 16 KiB ELF alignment. This is build/contract acceptance, not physical-device or independent receiver acceptance. Direct integer source audio rates and AVC/HEVC are retained; fractional-rate resampling and AV1 frontend selection remain separate work.
2026-11-16 20:01:25 +01:00
Codex 4a5bde636f record: schedule owned MediaCodec streams on the I/O dispatcher
Copy native stream configuration and URL at cold startup. Negotiate the owned shared RTMP client before publishing Surface readiness, poll producer/resolver/socket interests together, and keep detached DNS notifications independent of dispatcher lifetime. Setup and drain deadlines are I/O-owner-only; no new frame/audio waits or clocks.

Windows contract suite, focused Linux ASan/UBSan and TSan thread/wake tests, and eight actual Android NDK dispatcher compiles pass. Client and recording session boundaries remain mocked; real receiver/device acceptance and frontend activation remain pending.
2026-11-16 20:01:25 +01:00
Codex af6b3b2c1c tests: reject file trim and early codec stop for network sessions
Fault injection exposed a fixture gap: a file audio-edit query on a network session did not fail. Track network output lifetime so trim queries and codec stop are rejected until the appropriate file mode or output retirement. Four actual-session mutations now fail; restored Linux sanitizer and Windows strict-C89 fixtures pass.
2026-11-16 20:01:25 +01:00
Codex 3ddbeb2a11 record: connect MediaCodec network output to owned session lifetime
Add an RTMP/FLV-gated network session constructor and bounded network service entry point. Select live AAC priming, skip file creation and MP4 edits, report socket interests, and retire the output before stopping codecs or releasing encoders. The caller retains client ownership.

Windows strict C89 suite plus focused completion check pass. Session fixtures cover cold rollback, file regressions, network failure, delayed retirement and source/GPU closure with native/output boundaries mocked. Dispatcher activation and real receiver/device acceptance remain pending.
2026-11-16 20:01:25 +01:00
Codex d3d8d404c4 record: prime live MediaCodec AAC without publishing calibration
Gate source PCM until measured delay determines the silent input boundary. Drop complete calibration packets before output, retain silent AAC preroll and shift video/source ends to the same epoch. Preserve the existing MP4 calibration/edit path and stable descriptors across output backpressure.

Strict C89 Windows suite passes; calibrated fixtures cover six delays, empty PCM, output backpressure and early cancellation. Native MediaCodec and network session activation still require acceptance.
2026-11-16 20:01:25 +01:00
Codex a3f1ac1471 record: define calibrated AAC live-stream source epochs
Calculate packet-aligned source input and coded origins from measured encoder delay, retaining two silent AAC frames before source audio and rounding the matching video epoch upward. Keep file edit semantics separate.

Check all delays 0-4096 at six rates. Independently encode/decode synthetic AAC-LC at 44.1/48 kHz mono/stereo, recover delay from the chirp, omit calibration packets and compare source PCM against continuous decoding. This is not MediaCodec device acceptance or dispatcher activation.
2026-11-16 20:01:25 +01:00
Codex dfaf13cfbd record: bridge MediaCodec packet borrows to shared RTMP output
Add a bounded I/O-worker output adapter with cold mux setup, serialized packet admission, transport backpressure, normal drain and cancellation retirement. Keep the MediaCodec descriptor live until both shared mux and RTMP transport borrows retire.

The controller must establish live AAC priming and source epochs separately; this adapter does not enable Android streaming or reuse MP4 calibration edits. Strict C89 Windows contract suite passes with the actual shared FLV mux and mocked transport.
2026-11-16 20:01:25 +01:00
Codex e41c91b7fc record: build shared FLV configuration from MediaCodec setup data
Create worker-side AVC/HEVC/AV1 mux configuration from bounded native CSD and optional AAC setup. Join separate AVC parameter sets only during cold setup, retain neither native format nor encoder metadata, and preserve microsecond packet clocks without rebasing. Reuse shared Annex B and AV1 mux validation, including codec-specific packet budgets and depth/color admission.

Add actual shared-mux fixtures for configuration copying, separate/combined AVC setup, AAC payload borrowing, microsecond timestamps, codec depth mismatch and early packet-budget refusal. This does not enable the unfinished Android network publisher.
2026-11-16 20:01:25 +01:00
Codex ea2af53aa4 record: retain MediaCodec output across consumer backpressure
Add a copied worker-owned output callback table, with the existing file mux as the default adapter. Retain one immutable native packet descriptor per encoder while output is BUSY; calibrate AAC only once for that packet and release the codec borrow only after output acceptance. Worker free waits for bounded output retirement before encoder destruction is allowed.

Exercise no-repump/no-early-release behavior, callback-table ownership, delayed cancellation retirement and calibrated coded/source clocks under BUSY. The strict-C89 native MinGW MediaCodec suite passes. Android network publisher integration remains unfinished.
2026-11-16 20:01:25 +01:00
Codex b2e921be5a record: expose bounded borrowed MediaCodec video configuration
Allow the owning worker to inspect native csd-0/csd-1 buffers before constructing shared stream output. Bound each buffer to 65535 bytes, clear outputs on refusal and preserve encoder state for optional/malformed metadata. No dequeue, release, allocation or encoded-payload copy occurs. Audio and stopped encoders cannot expose video configuration.

Cover separate CSD borrows, missing/malformed/oversized metadata, invalid arguments, audio refusal and stopped-state invalidation. Streaming remains disabled pending output/publisher and lifecycle integration.
2026-11-16 20:01:25 +01:00
Codex 8d0b716fca record: integrate native Vulkan frontend capture and A/V drain
Connect the admitted desktop Vulkan encode queue to viewport recording through
an asynchronous worker. Capture GPU pixels in the renderer submission, publish
only successful submissions, and retain source/device resources through stop,
resize and deferred video reinitialization. Refuse unsupported devices, HDR,
formats and audio layouts before creating output. Start after the first core
frame so admission uses its actual audio layout.

Hold PCM on the existing worker queue until encoded video establishes its
clock limit. Trim trailing queued PCM at video EOS before AC-3 padding and
publish the actual consumed count after worker retirement. This prevents a
threaded resize from leaving audio beyond the last captured picture. Add no
producer locks, waits, pixel readbacks or pacing logs.

Configure selects the driver on desktop Vulkan builds with its dependencies;
existing default driver priority is retained. Add frontend admission/lifetime,
delayed-video PCM, terminal-result publication and native isolated-window
resize/reinit/stop regression coverage.

Validation: GCC/Clang ASan+UBSan frontend contracts, Vulkan encode contracts,
recording output/session/dispatch contracts and independent MP4 A/V checks.
Windows native recording passes threaded/direct multichannel float PCM at
32/44.1/48 kHz, plus resize, reinit and stop with Khronos sync validation.
Desktop Linux and Windows frontends build with automatic feature selection.
Native Linux GPU acceptance remains open. The unrelated extended RSLC unsized
uniform-buffer fixture is rejected by the installed standalone SPIR-V validator;
that check is retained as a failure, not reported as an extended-suite pass.
2026-11-16 19:50:40 +01:00
Codex 64336dc2f7 record: bridge Vulkan capture and renderer submissions
Merge capture timeline dependencies without modifying caller batches, then publish slots only after native submission succeeds. Retain producer ownership through uncertain results, command discard and timeline retirement; preserve the pool borrow if admission disappears during a frame.

Strict C89 and Windows/GCC/Clang sanitizer fixtures cover semaphore chains, bounded admission and failure recovery. Native direct-image and buffer A/V checks exercise binary semaphores, an existing timeline and a reset/discard value gap with zero synchronization-validation errors. Frontend driver binding remains separate.
2026-11-16 18:56:35 +01:00
Codex b578db3004 record: own Vulkan capture resources on the recording worker
Compile and publish optional capture resources with dispatcher readiness, then retire them on the worker after the video producer proves its GPU commands complete. Keep the encoder pool alive through capture destruction and skip unused capture startup after early cancellation.

Lifecycle regressions cover startup refusal, cancellation and independent video/audio closure; an injected premature destruction fails. Native direct-image and buffer A/V runs pass with zero synchronization-validation errors, alongside Windows, GCC/Clang sanitizers, TSan and a linked threadless frontend. Renderer binding remains separate.
2026-11-16 18:41:14 +01:00
Codex ef75e4fa45 vulkan: reserve an optional dedicated recording queue
Preserve caller device requests and explicit feature opt-outs while adding supported H.264 encode queues, timeline semaphores and synchronization2. Failed optional device creation retries the untouched renderer request; cached devices retain their recording admission state.

Cover feature/queue ownership and fallback with strict C89 and GCC/Clang sanitizer tests. Native Vulkan 1.1 direct-image and buffer recording pass independent A/V checks with zero synchronization-validation errors; Vulkan-enabled frontend and supported threadless C89 builds link. Frontend recording activation remains separate.
2026-11-16 18:33:55 +01:00
Codex 266a1841ef record: dispatch Vulkan recording work away from producers
Own session startup, file output and retirement on a dedicated worker. Publish immutable pool borrows after startup, wake through the existing lock-free eventcount backend and wait for each producer to close itself before teardown. Add concurrent startup/cancel/error contracts and native GPU A/V acceptance for both capture paths. Threadless and locking-fallback configurations refuse admission.
2026-11-16 18:04:45 +01:00
Codex a59fb03764 test: exercise native file SRC packet and teardown helpers
Cover cached output, failed mux binding, converter setup failure and retryable reset retirement through the shipping adapter helpers for one through eight channels. Keep native API mocks distinct from macOS runtime acceptance.
2026-11-16 17:47:49 +01:00
Codex fa19896686 record: convert fractional core PCM for Metal file recording
Keep the producer clock and queue budget in source frames. Convert on the recording worker through AudioToolbox, retain converted packets across mux backpressure and retire native input borrows before queue teardown. Preserve the direct path for integral rates and extend conversion contracts through eight channels.
2026-11-16 17:47:49 +01:00
Codex bb28b71855 test: validate native Vulkan recording session A/V output
Exercise GPU capture, the session owner and actual MP4/AC3 file output. Independently decode pictures and channel tones, check residual error and inspect container packet clocks/durations. Keep direct-storage and GPU-buffer paths under synchronization validation; native completion waits remain fixture-only.
2026-11-16 17:43:45 +01:00
Codex 09778a7a2a record: own Vulkan encoder and file output through retirement
Add a worker-owned Vulkan recording session with rational video clocks and encoder-derived mux metadata. Producer closure gates output, GPU and queue retirement; cancellation preserves borrowed packets and startup errors. Exercise actual queue/worker/mux/audio contracts with delayed GPU/file completion, independent producers, threadless builds and emitted MP4 metadata checks.
2026-11-16 17:38:32 +01:00
Codex 5e48712074 test: overlap native Vulkan capture and verify cancellation
Submit two GPU-captured pictures before collecting either packet. Check full-ring backpressure, stable borrowed bytes during cancellation, refusal of premature free and successful drain after GPU retirement. Keep the twelve-picture independent decode and synchronization-validation gates for both storage paths.
2026-11-16 17:28:23 +01:00
Codex 081dc098a2 test: encode GPU-captured RGB through native Vulkan shaders
Exercise the shipping RSLC-compiled RGB-to-NV12 conversion on a compute queue and hand its direct-plane or packed-buffer output to the encode queue through GPU timelines. Independently verify decoded color planes, GOP and timing with synchronization validation enabled. Keep native fixture scratch within the C89 2 KiB stack gate.
2026-11-16 17:22:35 +01:00
Codex f268dfb8f4 test: independently decode native Vulkan H264 pictures
Submit twelve test-uploaded NV12 pictures through real GPU timelines and encoder packet leases. Independently check planes, GOP, color and SPS timing, retaining failed oracle evidence. Keep GPU capture and frontend activation as separate acceptance gates.
2026-11-16 17:09:44 +01:00
Codex 4b55acdbfe test: exercise native Vulkan H264 encoder resource startup
Require a real encode queue and Khronos validation layer. Probe supported extents and build 2/4/16-slot pools, including direct storage and buffer fallback, retrieve driver headers and retire empty sessions. Preserve native evidence and report unavailable hardware separately; no picture or pixel acceptance is claimed.
2026-11-16 16:58:01 +01:00
libretroadmin 862614ded5 X11: Display Pacing On VBlank Events holds on the window's CRTC vblanks
The X display server gains the vblank clock the setting's hold waits
on. It asks the Present extension for a notification at the vblank
count after the last one seen; the answer carries that vblank's count
and its time on the monotonic clock, for the CRTC the window is on.
The requests are made with xcb's own request call, so nothing beyond
libxcb is linked, on a connection of the clock's own: a wait is a
bounded poll of its socket, there is no thread, and no other thread's
events are read. A window destroyed, a server without Present or one
whose stamps are of another clock leave no clock, and the timer paces.

The GLX context says its swap tears with no swap interval where no
compositor shows the window: it asked to bypass one, or none runs.
samples/gfx/x11_vblank runs the clock against a real server in CI.
2026-11-16 16:51:20 +01:00
LibretroAdmin 2698c7a6c1 samples/tasks/content_load: the close-waits-for-save lane holds the save in the core
A fast machine wrote the whole state before the close came, leaving it
nothing to wait for. The lane now takes a background save on the
threaded queue, which the harness core holds inside retro_serialize
until the close has waited three frames, so the save is in flight
however fast the machine is.
2026-11-16 16:49:58 +01:00
LibretroAdmin 6c2fddef40 samples: core_signature_test's loop index on Linux only; FLIPS_ASKED in d3d_failure_paths
core_signature_test declared its statfs loop index where macOS's clang
found it unused. d3d_failure_paths compiles d3d11.c's resize, which now
clears D3D11_ST_FLAG_FLIPS_ASKED, so the harness declares it.
2026-11-16 16:49:55 +01:00
libretroadmin ec27910f77 State tasks: a Load State cannot slip between a save's backup load and the save
A save over an existing file is two tasks: a load of that file for the
undo, whose callback pushes the save. With threaded tasks the queue
stops refusing a blocking task once the one in flight has finished on
its thread, so a Load State pressed after the backup load was done and
before its callback had run was pushed there and then, and read the
file the save was about to replace. The state tasks' own counts say
whether one is in flight - pushed, its callback still to come - and a
request is held behind it until then, as it is behind one still
running.

The state-load-latency lane of content_load_test takes that case, and
bounds a load by a display's frames where the machine is too busy for
the harness's own, microseconds long, to mean anything.
2026-11-16 16:24:37 +01:00
LibretroAdmin 56e04f7096 samples/gfx/glcore_glsl_menu: a black screen is not a settled one
The still menu was shot once three grabs in a row matched. A RetroArch
slow to come up leaves the screen black for those three, so the shot
was taken before the menu was drawn. Black grabs no longer count
towards settling: the shot waits for the menu, and a menu that never
draws is still judged black at the deadline.
2026-11-16 16:10:31 +01:00
LibretroAdmin f54dea8c94 core signatures: volume facts from the VFS, asked once per check
The filesystem lists, the /proc mount lookup, the statvfs read-only
tests and the Windows drive-letter test move out of the check onto
retro_vfs_file_volume_impl() and retro_vfs_stat_volume_impl().

On the way, a quick check of a core with no record asks less:

- The open's one fstatfs() now gives both ctime_kept and whether the
  mount is read-only; before, the exemption and package rules each
  asked statvfs again.
- The identity the open took carries the owner, group and mode (never
  stored), so the exemption rule no longer fstat()s the file again;
  the macOS package re-check uses it too.
- RetroArch's own mount id is looked up once with the rest of its
  self lookup, instead of opening /proc/self/exe and asking its mount
  on every check.

Linux, unrecorded core, open + quick check: 21 -> 14 syscalls, about
5.9 -> 3.8 us. Every answer is unchanged: the rules read the same
uid, gid, mode, read-only and mount facts as before.

core_fd_mount(), core_fdinfo_mount() and core_fs_*_keeps_ctime() are
gone; core_file_unwritable() and core_file_in_package() take the
identity and RetroArch's own lookup.
2026-11-16 16:01:19 +01:00
libretroadmin 8054364e4a Vulkan: an immediate-mode swapchain on Windows asks its output
Display Pacing On VBlank Events holds a frame for a vblank only where
the present would otherwise tear. A Vulkan swapchain of its own in
immediate mode said so on any output, although DWM still composes a
fullscreen window where the output cannot flip it itself, and the hold
then costs latency for nothing. The driver asks the output its window
is on, once a swapchain, as the D3D drivers and the DXGI presenter do.

The DXGI bridge gains the query by window: it makes a factory, finds
the output showing the window's monitor on any adapter, and asks
CheckHardwareCompositionSupport. Covered by samples/gfx/dxgi_present
(window) and samples/gfx/dxgi_present_immediate (vulkan).
2026-11-16 14:52:15 +01:00
libretroadmin 22d3a9ee88 KMS: Display Pacing On VBlank Events holds on the CRTC's vblanks
The KMS display server gains wait_vblank. The CRTC's sequence is the
count and its stamp the time; the next vblank is a sequence event,
queued on a file description of the server's own - the context's
carries its page flips, which are left to it - and waited for with
the caller's bound. No thread. An inactive CRTC, one with a variable
refresh rate on, and a kernel or libdrm without the sequence ioctls
count nothing, and the timer paces as before.

The hold needs a present that tears, which on KMS is an async page
flip: the KMS context answers present_immediate as it queues one. KMS
shows nothing but fullscreen, so the hold no longer waits there for
the Fullscreen setting; that test moves from the wrapper to where the
frame info is filled. The setting is listed on KMS builds.

display_servers_kms_test drives the clock over a FIFO standing in for
the device, and drm_vkms_live runs it on a real kernel's vkms: thirty
vblanks one by one, a page flip's event still the master's.
2026-11-16 13:33:22 +01:00
Codex c27f8e4f1d video: queue nonblocking state updates on the worker
Produce no-result nonblocking-state commands directly in the existing ordered ring. This avoids mailbox packet copies and the video-thread round trip during FPS-only AV-info changes. Apply every request before the next frame, including repeated values; retain the existing reentrant and unavailable/full-ring paths.

Cover producer state, FIFO delivery, FPS updates, reentrancy and queue fallbacks in the shipping-frontend harness.
2026-11-16 13:27:08 +01:00
Codex 35aff88575 audio: avoid rate-change restarts for inactive output
Accept input-rate metadata changes when audio is deliberately disabled or uses the null backend and no device or resampler exists. This avoids rebuilding recording scratch and resynchronizing video for timing-only AV-info updates. Keep failed real backends on the reinitialization path.

Cover idle metadata, failed-backend recovery and scratch retention through real AV-info calls with threaded video on and off.
2026-11-16 13:13:00 +01:00
LibretroAdmin 7dfa207e36 samples/gfx/glcore_glsl_menu: the rest of a GLSL preset on glcore
glcore's GLSL path - what a build without slang draws through - had
only one-pass presets under test. Now, on the test core's software
frame:

- multi.glslp: two passes, the first into a framebuffer twice the
  frame's size, the second at the viewport's;
- history.glslp, the core swapping its frame's halves every frame: each
  half the average of this frame and the last, through PrevTexture;
- feedback.glslp: half the frame and half the pass's own last output,
  through PassFeedback0, which settles on the frame;
- invert.glslp with the menu opened and closed over it.

All four pass on master: nothing to fix there. The test core gains
PATTERN_FLIP for the history case, and the job installs xdotool to
press the menu key. What the test cannot reach on X11 is a frame drawn
under HDR, whose target is not the backbuffer.
2026-11-16 12:57:08 +01:00
LibretroAdmin ea782bddfc glcore: GLSL presets and software frames in a build without slang
With a core running, glcore's GLSL path - what a build without slang
draws through - showed two faults:

- A software frame was black, or garbage. With a GLSL chain the frame
  goes into a power-of-two square texture, and the upload wrote that
  whole square from the core's buffer, which holds only the frame: a
  read far past its end. Now only the frame is written.
- A GLSL preset was refused, the stock shader drawing instead. The
  frontend reads which shaders a context runs from the context's flags,
  and the window contexts (X11, WGL, DRM, Wayland, xegl, SDL3 and the
  consoles') gave glcore slang alone. They now give glcore GLSL where
  the build has no slang to draw through. glcore's own fallback to
  GLSL whatever the flags said, from the last change, goes again: the
  flags say it now, and the frontend and glcore agree.

The first pass also binds its own program before it draws, as gl2's
does, instead of drawing with whatever the menu or the last frame's
passes left bound.

Test: samples/gfx/glcore_glsl_menu/run.py goes on from the menu to a
test core (pattern_core.c, built by the test): a frame whose top
quarter is blue and whose rest is red on the left and green on the
right, as a software frame and on a GL core-profile hardware context,
320x240 and 640x480, with no preset and through invert.glslp (one pass
into a framebuffer, then the stock pass to the screen). Each must show
its colours where they belong and the right way up, inverted through
the preset. On master the software frames are black and the presets
are not applied; without the upload fix the 640x480 software frame
fails.
2026-11-16 12:43:02 +01:00
LibretroAdmin 9365458a10 menu: measure a firmware path's underline once
The missing firmware dialog underlines each file's path, and measured
the path and the text before it with the font for every line of it in
every frame the box was up. The width and offset are now kept with the
line and the font - its size and the font generation - they were
measured in, for the few lines such a box has, and the frames after
the first draw the underline from them.

msgbox_layout's firmware lane draws the dialog in Ozone, XMB and
MaterialUI and checks the one underline under the path, not under its
number, as wide as the path, in the frames drawn from what was kept as
well as the first.
2026-11-16 12:42:36 +01:00
LibretroAdmin 66205c7f73 samples/menu: msgbox_layout checks the input dialog's caret
The caret lane opens the input dialog in XMB and MaterialUI with 40
words typed, wrapped over several lines, at three screen sizes, and
puts the cursor at the start, inside a word, at the start of each
line the wrap made, on the space before it and at the end. The caret
must be drawn on the line of the character after the cursor, at its
left edge - for a space the wrap made a line end, after the line it
ends. The harness now also records the quads the drivers draw, the
caret being the one 2 px wide.

With the caret placed by wrapping the text up to the cursor again, as
both drivers did, the lane fails: before a word the wrap moved to the
next line, the caret sat at the end of the line above.
2026-11-16 12:35:59 +01:00
LibretroAdmin 0e2168d8b1 samples/menu: msgbox_layout counts RGUI's uploads of a box
The rgui redraw lane runs RGUI as the runloop does - the box's text
handed over, the render, the frame, the framebuffer handed to the
video driver - and counts the uploads: one when the box comes up, one
for a newer box in its place, for the lit button moving and for new
text, one when it goes, and none for the frames between. With RGUI
redrawing the box every iteration it was up, as it did, every frame
was an upload.
2026-11-16 12:27:02 +01:00
libretroadmin 213247f4d3 Vulkan, OpenGL: presented through DXGI, a tearing present is immediate
Display Pacing On VBlank Events holds only where the driver says its
present goes straight to the scanout, and Vulkan and OpenGL said
nothing once they presented through the DXGI bridge. The bridge now
answers: it may tear, and its chain's output flips a fullscreen window
itself rather than leave it to DWM - asked through IDXGIOutput6 when
the chain is made and after each resize, by its vtable slot, since
dxgi1_6.h is not in every SDK the bridge builds with. Vulkan passes
the answer on for the interval it presents with; OpenGL has no poke
for it, so the context driver gains present_immediate, WGL answers
there, and the threaded wrapper asks the context where the driver has
no answer of its own.

The dxgi_present sample checks the query and its slot against the
tree's dxgi1_6.h, and that a resize asks again; the harness checks
that a context's answer reaches the hold.
2026-11-16 12:06:07 +01:00