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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.