Compare commits

..
Author SHA1 Message Date
Codex 249ba6f2e3 vp8: retain decoded arenas instead of copying reference planes
Bind last, golden and altref to completed frame arenas and decode into an unreferenced fourth arena. Preserve reference-copy ordering and borrowed-plane lifetime, and release retained macroblock state if an arena allocation fails. Generated independent pixel references cover hidden frames, cropped geometry and resolution changes; counted large copies and injected allocation failures guard the ownership path.
2026-10-24 02:46:44 +02:00
Codex 59e6caa7bf menu: reload active file media after a window context reset
Ozone and XMB must reopen the selected fullscreen file even when ordinary thumbnails are disabled. Exercise application fullscreen transitions with real movie pixels and seeking across all four menus, with direct and threaded GL presentation. Windows tests can require the DXGI bridge.
2026-10-24 02:27:01 +02:00
Codex 7169fb191d vulkan: route NVIDIA 610.47 H.264 through shared D3D11 exports
The Windows driver corrupts H.264 reference pictures through Vulkan Video, including in independent FFmpeg decoding. Reuse the matched-adapter packed GPU export path without CPU readback. Keep other drivers on Vulkan Video and leave correct software fallback when GPU interop is unavailable. Check generated H.264 exports against software, including cropping.
2026-10-24 02:27:00 +02:00
Codex 37c2964a10 io: retain the reserved media window file cursor
Avoid restoring a cursor that no prefix fill consumes. Consecutive window reads no longer seek; metadata probes still leave the residency frontier untouched. Keep cursor restoration for prefix fills and whole-file fallback. Count reads and seeks in the generated window regression.
2026-10-24 02:26:35 +02:00
Codex ec8e234dc3 tests: supply the GL queue harness context-release dependency
Abort if the scripted fence queue unexpectedly reaches single-context handoff. Keep the production publication path linked after it began calling the context-release helper.
2026-10-24 01:58:22 +02:00
Codex f817e27bab tests: complete synchronous shader harness dependencies
Fail fast if deferred shader ownership reaches the synchronous cycle harness. Normalize fixture and expected path separators for native Windows, preserving preset identity and order checks.
2026-10-24 01:46:49 +02:00
Codex 704ba2c4a1 media: retain WebM sound metadata before seeking its window
Create the prepared sound while the initial header is resident, before seeking can decommit earlier cluster headers. Retain its window owner immediately so cancelled preparations release borrowed data safely. Exercise later WebM seeks and cancellation with float and s16 output against resident reference audio.
2026-10-24 01:45:26 +02:00
Codex fafc841034 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline
# Conflicts:
#	.github/workflows/Linux-menu-media.yml
#	menu/menu_media_browser.c
#	menu/menu_media_browser.h
#	samples/menu/rgui_media/rgui_media_test.c
#	samples/menu/rgui_media/run.py
2026-10-24 01:09:33 +02:00
Codex 28912bfb19 media: disable the legacy imageviewer core in normal builds
Keep image browsing, settings and history available through the menu viewer without HAVE_IMAGEVIEWER. Build extension filters from the enabled image codecs instead of querying the legacy core. Preserve its sources and Griffin guard.
2026-10-24 00:55:53 +02:00
Codex 19b2ac1e53 media: own fullscreen refresh requests through the menu lifecycle
Add an opt-in Match Display Refresh Rate setting shared by all four menus. Keep one temporary display owner, release it on source/viewer/settings changes and display-server teardown, and respect CRT SwitchRes and SDL mode-server selection. Stable frames make no mode queries; output notifications validate ownership before rebinding.

Retain an applied mode across compatible cadence changes instead of cycling the display. Core AV information remains unchanged. Win32 backend support is connected, but X11 and other relevant backend parity, precise fractional inventory, physical acceptance and VRR remain incomplete; keep this development feature off master.

GCC/Clang ASan+UBSan threaded/threadless controls, TSan, Win32 backend profiles and native Windows models pass. Full Linux C89 and native Windows frontends link. Real four-menu source/settings lifecycle, settings reference/unity/capacity/order and MSVC6 standin pass. No physical mode switch or completed VRR acceptance is claimed.
2026-10-24 00:42:20 +02:00
Codex 1215f526b9 media: add temporary Win32 refresh ownership callbacks
Select an advertised progressive mode at the captured geometry and depth using the shared cadence policy. Keep a separate snapshot for temporary playback ownership so release returns to the immediately preceding mode, including a paused core's mode, while preserving later external changes.

The backend and optional display-server callbacks are implemented; menu lifecycle ownership and settings are not connected yet. Keep this development checkpoint off master until integration acceptance.

C89 legacy/current ANSI/Unicode models pass GCC/Clang sanitizers, Wine and native Windows, covering matching/current/unsupported modes, geometry/depth/interlace filters, failures and conditional release. Real Windows-header ANSI/Unicode builds and read-only queries pass; physical playback refresh and VRR remain unaccepted.
2026-10-24 00:31:03 +02:00
Codex 8b084b8f02 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-24 00:26:15 +02:00
Codex a37d9e5025 win32: restore owned display modes on their original outputs
Keep each changed output's original DEVMODE and last successfully applied mode. Teardown queries that named output and restores only while the applied mode remains current; external changes and disconnected outputs end ownership. A later successful switch after an external change saves that newer desktop state.

Allocate bookkeeping before applying a first change, preserve the first original across repeated owned changes, and free records after failure or teardown. This replaces primary-screen geometry and current-window restoration.

Legacy/current ANSI/Unicode profiles pass GCC/Clang ASan+UBSan, Wine and native Windows, covering two outputs, repeat switches, external changes, disconnect and allocation failure. An unconditional-restore negative control fails. Real Windows-header/read-only checks and actual Wine/Xorg listed-mode switching pass; physical multi-monitor acceptance remains open.
2026-10-24 00:25:50 +02:00
Codex 7c5a1e511c Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-24 00:21:34 +02:00
Codex 5c91c6a297 win32: keep mode enumeration on the captured monitor
Capture the monitor once for a resolution change, then read current settings, enumerate candidates and apply the mode to that same device. A window move must not combine one output's mode with another output's name.

Legacy/modern ANSI/Unicode profiles pass GCC/Clang sanitizers, MinGW/Wine and native Windows. The monitor-recapture negative control fails. Real Windows-header builds and read-only display queries pass in ANSI and Unicode; no physical mode was changed.
2026-10-24 00:21:14 +02:00
Codex e13540d39b Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-24 00:18:01 +02:00
Codex cf5a318410 win32: report rejected display mode changes as failures
Stop if current mode discovery fails and only report success after Windows applies the requested mode. No matching advertised mode, failed validation, failed application and registry-not-updated results must not be accepted as a successful refresh change.

Seven outcome cases pass strict C89 in legacy/modern ANSI/Unicode profiles with GCC/Clang ASan+UBSan, MinGW/Wine and native Windows. The previous setter fails the result assertion. Tests mock the mode API and do not change a physical display.
2026-10-24 00:17:38 +02:00
Codex 6bc9be5d67 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-24 00:14:24 +02:00
Codex 4781239614 x11: identify the output under the current window
Return the connected output name and geometry from the same CRTC under the window center. Before window creation use the first active output; clear failed queries rather than leave stale results. Handle disappeared output records and bound copies by the RandR name length.

GCC/Clang ASan+UBSan fixtures cover two outputs, movement, query failure, off-output coordinates and short names; the old getter fails the new test. C89 compilation passes with and without RandR. A real isolated Xorg dummy server passes output identity, modeline switching and restoration; physical multi-monitor acceptance remains open.
2026-10-24 00:13:48 +02:00
Codex e3a48f3a16 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-24 00:09:59 +02:00
Codex 14a0a9102f win32: report output identity with its captured geometry
Capture one monitor for both the output name and current display settings. Clear failed queries, handle missing monitors, and convert Unicode device names to bounded UTF-8. This supplies the output identity needed to bind future media display restoration to the correct monitor.

Exercise legacy and modern ANSI/Unicode paths, monitor movement, failures and bounded buffers with GCC/Clang sanitizers and MinGW. Native Windows ANSI/Unicode read-only queries, full frontend startup and the MSVC6 standin passed. No native physical display mode was changed.
2026-10-24 00:08:47 +02:00
Codex eefe17dd5b tests: supply the deferred shader cancellation boundary
The directory-cycle harness links the real shader parser without the video driver. Supply its new cancellation symbol and abort if the synchronous harness unexpectedly enters that path.

Validated the five directory-cycle scenarios with GCC and Clang under AddressSanitizer and UndefinedBehaviorSanitizer.
2026-10-24 00:08:17 +02:00
Codex 60de19825c Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 23:54:33 +02:00
Codex c0657f9b9f Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 23:50:23 +02:00
Codex 67d9d2e704 media: open external files in the fullscreen menu viewer
Prefer the internal viewer for supported movie and image arguments without an explicit core. Wait for content loading to finish before selecting the file in its browser directory. Keep unsupported formats, no-menu builds and explicit core requests on their existing paths.

Image confirmation now uses the fullscreen thumbnail viewer in all four menus and cannot launch an image-viewer core from that view. Add real startup/browser coverage and regenerate label fallbacks for menu-disabled builds.
2026-10-23 23:48:22 +02:00
Codex 1f5682f3bd media: offer fullscreen movie timing to CRT SwitchRes
Add a default-off Media Player option and publish dimensions and measured cadence to the existing display owner. Preserve core timing and hold a stable rate across seeks and timestamp quantization; withdraw the request when fullscreen closes or settings open.

Cover all four menu adapters, settings restoration, fractional rate changes, and concurrent numeric publication. Physical CRT scanout and desktop VRR acceptance remain separate gates.
2026-10-23 23:41:45 +02:00
Codex eb2c94efd7 vulkan: initialize published capabilities in import fixtures
Exercise the shipping capability publishers before checking imported formats. Cover immutable device support and revocation of the published format mask.
2026-10-23 23:19:55 +02:00
Codex a7961703e6 modeline: bound scale selection for invalid timings
A listed server mode with zero refresh makes the incrementing scale search loop forever. Compute the first candidate directly, reject non-positive and unrepresentable inputs, and guard integer and floating products.

Cover zero-rate mode rejection, integer overflow, extreme scales and fractional rounding. GCC/Clang sanitizers, MinGW64/Wine and native Windows tests pass; the complete modeline golden matrix remains unchanged.
2026-10-23 23:04:30 +02:00
Codex 0adb2302a9 x11: contain errors from rejected modeline requests
Do not forward a modeline connection error to Xlib after trapping it: the default handler terminates the process when a server rejects a mode. Forward only errors from other connections, preserving their handler result without contaminating the modeline failure flags.

Exercise rejected additions and unrelated connections through the real backend. Run the production handler separately on Windows without Xlib, and require the original handler to fail the regression assertions.
2026-10-23 22:50:23 +02:00
Codex 63ea9b5ae0 Batch file refills during builtin movie seeking
Expose the next MP4 packet span without reading media or advancing its cursor. Refill forward seek windows within the existing four-millisecond parser slice, capped at eight bounded reads, instead of yielding to the menu after each byte frontier. Preserve backward-frontier yields and decoder waits.

On the 4K60 AV1 sample, a rendered Windows Vulkan seek to 20:00.375 falls from 16.59 to 2.39 seconds. Repeated alternating seeks, all four rendered menu adapters, ASan/UBSan/TSan preview checks and codec regressions pass.
2026-10-23 22:22:20 +02:00
Codex f36c998b6c Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 21:50:40 +02:00
Codex a58bb21a15 Measure movie cadence from accepted presentation timestamps
Publish a bounded rational-rate estimate after 32 near-uniform intervals, tolerating millisecond timestamp quantization. Invalidate evidence on seeks, stopped playback and timing discontinuities. Carry measured cadence through shared CPU and texture playback state without querying decoder-owned data.

Cover variable timing, fractional and quantized rates, hardware backpressure and all four menu adapters. Display switching remains unchanged.
2026-10-23 21:49:59 +02:00
Codex a9b70a16aa Publish movie timestamps with presented player frames
Pass the existing decoder-owned timestamp through the threaded and inline presentation paths. Sinks can observe fractional movie timing without reading decoder state or inferring cadence from rounded frame durations. Cover leading gaps, loop epochs, unavailable timestamps and fractional intervals.
2026-10-23 21:37:59 +02:00
Codex 0a9d017609 Open media settings from fullscreen playback controls
Pause through the shared transport and open the existing Media Player settings list. Hide each menu viewer only after navigation succeeds and preserve browser return selection. Expose the action through mouse and existing keyboard/gamepad focus without adding input mappings.

Cover all four menus, failed pause/navigation, and threaded and inline playback.
2026-10-23 21:31:52 +02:00
Codex a9a6b925a8 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 21:20:18 +02:00
Codex 356d382c11 Add continuous folder playback to the builtin menu player
Keep a natural-order folder snapshot for opt-in continuous playback and shared previous/next file controls. Distinguish clean movie EOF from decoder failure and retain the final picture for transport actions. Apply repeat policy to video and mixer voices without restarting playback.

Cover all four menus, threaded and inline playback, folder boundaries, invalid next files, Stop and Back.
2026-10-23 21:19:18 +02:00
Codex b2bd15fe7d Choose Android recording levels from picture rate and bitrate limits
Replace the fixed 1080p level split with AVC and HEVC picture-size, processing-rate, bitrate and dimension limits. Prefer HEVC main tier when it fits, retain explicit video_level values and refuse automatic requests beyond known limits. Native inventory and session admission remain mandatory.

Validate 1080p, 4K, 8K, fractional rates, bitrate boundaries, extreme aspect ratios and explicit overrides in both frontend profiles. Recording suites pass Windows GCC and Linux GCC/Clang ASan/UBSan; sixteen Android ABI/API/file-offset/history profiles compile under strict C89 and the 2048-byte stack ceiling. Physical device acceptance remains outstanding.
2026-10-23 18:27:43 +02:00
Codex 12f968b9fc Capture no-core menu recording from final video and mixed audio
Use full-window Vulkan menu capture with monotonic presentation timestamps and a bounded post-mixer PCM tap. Attach and retire the tap only through nonblocking cold operations on the existing audio owner lock; retain all I/O and GPU owners until independent retirement. Keep core AV information unchanged and Android native recording behind its explicit acceptance flag.

Validate the recording and shipping hook contracts on Windows and Linux, GCC/Clang ASan/UBSan and TSan, both NDK workflow matrices, object inventories and a default C89 frontend. Physical Android A/V and recovery acceptance remains open.
2026-10-23 18:20:56 +02:00
Codex 008b672bac Include Android recording objects in the source inventory contracts
The capture registry added a record-directory implementation include to Griffin. The inventory preprocessor only normalized gfx/common includes, so the JNI-contract CI tried to open the new file relative to stdin and failed before executing the remaining contracts.

Normalize every captured C implementation include into an object token, include the recording/frontend registry sections, and compare both real Makefile and Griffin inventories. Cover 24 valid codec/thread/recording profiles, require each selected object once, and verify that all eight threadless recording profiles are refused.

Validate the complete JNI-contract make check under GCC and Clang ASan/UBSan after reproducing the hosted failure. Production source, budgets and native capability admission are unchanged. The failing Clang job and cancelled GCC job from Android run 39980257395 are not passes.
2026-10-23 17:43:20 +02:00
Codex 4ef797f16d Publish Android recording history after successful native collection
Retain the original bounded output path in the cold frontend owner, independently of caller storage. Add it to video history exactly once after nonempty successful mux/file completion and GPU/I/O collection, with no session, file or system errors. Respect disabled or unavailable history and settings teardown; failed or cancelled output is never published.

Exercise history-enabled and history-free frontend profiles, deferred collection, caller filename mutation, path bounds, empty output, cancellation, native errors and missing settings/history. Compile the history branch explicitly in Android CI. All 23 suites pass Windows GCC C89 and Linux GCC/Clang ASan/UBSan; the native frontend passes 16 ABI/API/file-offset/history profiles and the exact new workflow command passes all eight history configurations. Native Android hardware acceptance remains open; ADB currently lists no connected device.
2026-10-23 17:36:28 +02:00
Codex 99c07ab0e0 Connect the Android recording frontend behind native acceptance opt-in
Wire the MediaCodec backend into viewport capture, PCM production, deferred startup, finalization and collection. Arm both clocks after render-owner acknowledgment, retain rational microsecond cadence independently of movie seeking, split bounded PCM packets without waiting, and fail rather than silently losing audio. Preserve PQ and convert scRGB once in the existing worker; unknown mastering metadata stays unknown.

Separate reset admission from full resource collection. A cold render-owner quiescence acknowledgment lets the existing Vulkan teardown drain prove ambiguous native work instead of deadlocking before that drain. It frees no native resources and grants no completion or device-death proof. Retain queued bindings, partial startup, GLES and I/O owners through collection; collect cancelled streams whose source end was already fixed by renderer failure.

Keep default registration off. Explicit HAVE_RECORD_MEDIACODEC builds require Android/Vulkan/threads/configuration support and link each native module once, including encoder-only device prerequisites. Test full frontend lifecycles, clocks, audio backpressure, output changes, queued closure and reset ownership with modeled platform boundaries.

Validate 22 suites on Windows GCC C89 and Linux GCC/Clang ASan/UBSan, reset guards, both eight-configuration NDK workflow groups including the enabled frontend and encoder-only variant, native registry compilation, actual Makefile profiles, C89 and ASan/UBSan shipping threaded-video harnesses, fresh CI frontend and unchanged hot/wait limits, MSVC6 stand-in and a full threadless frontend forcing 39 ownership APIs. Native hardware A/V/pixel/recovery acceptance, no-core player recording and final history integration remain open.
2026-10-23 17:25:58 +02:00
Codex 553d650782 Build Android capture configuration from enabled Vulkan device state
Resolve required native operations and copy memory properties into a stable cold controller. Require the enabled AHB/FOREIGN/SYNC_FD capability before admission; procedure availability alone cannot enable recording. Preserve the existing queue serialization contract and fd ownership without allocating native resources.

Publish immutable Vulkan device capabilities at initialization and use the existing atomic format cache for get_device, avoiding reads of mutable renderer flags and pipelines. Exercise the shipping getter concurrently and test resolver faults, admission, memory validation, submission and fd lifetimes.

Validate 21 recording suites on Windows GCC C89 and Linux GCC/Clang ASan/UBSan, getter ASan/UBSan/TSan and Wine profiles, both eight-configuration NDK workflow groups, full C89 threadless frontend with 38 forced ownership APIs, unchanged wait limits and MSVC6 unity stand-in. Actual Android recording hardware acceptance and frontend registration remain open.
2026-10-23 16:53:21 +02:00
Codex cd1963571c Marshal Android capture setup and collection through asynchronous render jobs
Reuse the shipping caller-owned upload queue for explicit cold operations, preserving opaque results through completion and teardown without treating them as textures. The Android capture request consumes this path for EGL/pool setup, service, closure, child preparation and collection. It uses the current Vulkan queue lock, drains queued binding references before closure, and retains stale-device owners until actual destruction proof.

Keep setup away from frame capture, copy cold memory properties, and guard unused GPU closure with the I/O claim. Validate Windows C89 and Linux sanitizer ownership suites, both Android NDK compile groups with final request rechecks, the real GL cold-job lane, TSan and ASan/UBSan shipping frontend lanes, full ASan/UBSan threaded harness, unchanged hot/wait budgets, MSVC6 stand-in and a full threadless link forcing 35 APIs. Recorder settings/audio-clock wiring and Android device acceptance remain open.
2026-10-23 16:22:18 +02:00
Codex a2744181aa Retire Android capture pools around actual Vulkan device destruction
Register each pool on its serialized render owner before native allocation, covering partial startup and recordings that have not published a frame. The existing Vulkan teardown drain supplies completion or device-loss proof. Prepare matching capture children before device destruction, refuse device caching while an owner remains, and notify source leases only after actual vkDestroyDevice. Failed closure freezes submission and service; unproven children retain the device.

Exercise matching and unrelated devices, partial preparation, failed drains, cache refusal, post-destruction callbacks and retained GLES reads. Validate 19 Windows/Linux recording suites, both NDK compile groups with final pool/registry rechecks in all eight configurations, and a full C89 threadless frontend forcing all 29 owner APIs. Android hardware recording acceptance and frontend registration remain open.
2026-10-23 15:45:56 +02:00
Codex cd33fb9062 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 15:42:38 +02:00
Codex 3af4ff288d Declare std::terminate through its owning exception header 2026-10-23 15:42:38 +02:00
Codex a36a066959 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 15:30:36 +02:00
Codex 4f07a54e5e Prepare single GL context ownership during poke installation 2026-10-23 15:30:36 +02:00
Codex 23132fdf7d Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 15:21:22 +02:00
Codex b90e83ac00 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 15:11:10 +02:00
Codex 5e1a160d7f Connect Android capture pools to Vulkan frame submissions
Record final-image capture before presentation and report actual submission results under the existing queue synchronization. Bind stable pool leases, reject changed mode or extent, suppress duplicate timestamps and retain ownership on native errors. Expose the borrowed render queue for cold setup.
2026-10-23 15:11:09 +02:00
Codex eb1c4c979e Retire capture Vulkan objects independently of GLES reads
Keep Android buffers and the GLES executor owned after Vulkan child retirement. Freeze relay service once device preparation begins so partial teardown cannot poll destroyed child objects or prematurely collect their shared buffers. Require actual device destruction and terminal GLES ownership before collection.
2026-10-23 14:44:52 +02:00
Codex 4beb10789e Merge commit 'cd005310ec2347c91092cc717e327cd705df30cb' into codex/builtin-media-baseline 2026-10-23 14:36:12 +02:00
Codex 8de9161c6e Merge commit '01a88010' into codex/builtin-media-baseline 2026-10-23 14:22:06 +02:00
Codex 8995fac08a Merge commit 'c0e4be82' into codex/builtin-media-baseline 2026-10-23 14:20:24 +02:00
Codex 3b1631163e Defer video reinit until native recording resources retire
Finish native GPU recording before resetting its video device. Coalesce pending reinit flags and apply them once through the existing main-thread recorder poll after all native users retire. Drop superseded requests during content or quit teardown, with no waits, locks, frame allocations or new runloop call.
2026-10-23 14:18:52 +02:00
Codex c0e4be8251 Defer video reinit until native recording resources retire
Finish native GPU recording before resetting its video device. Coalesce pending reinit flags and apply them once through the existing main-thread recorder poll after all native users retire. Drop superseded requests during content or quit teardown, with no waits, locks, frame allocations or new runloop call.
2026-10-23 14:18:52 +02:00
Codex 4c3cf90d73 Merge commit '255f4be8' into codex/builtin-media-baseline
# Conflicts:
#	libretro-common/samples/formats/h265/Makefile
2026-10-23 14:03:48 +02:00
Codex fae6ebc8eb Route renderer capture ownership through the Android handoff
Keep uncommitted renderer work out of the encoder queue and expose record, commit and proven abort through the joint resource owner. Preserve unresolved source leases across cancellation so accepted work can still obtain completion proof without replay, and forbid native bookkeeping changes after device preparation.
2026-10-23 14:02:34 +02:00
Codex ffd49befc6 Record Android capture copies in renderer commands
Separate recording a capture copy from committing its completion after the renderer submits the frame. A dedicated empty command signals the existing exportable semaphore and fence; busy completion retries never replay the image copy. Retain source ownership until completion or explicit proof that an unsubmitted renderer command cannot execute.
2026-10-23 13:51:57 +02:00
Codex bd33b2ab28 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 13:43:54 +02:00
Codex 9f87fa089b Own Android recording EGL display and libraries
Hold a balanced Android system EGL initialization reference and keep both procedure libraries alive through recording collection. Select exact RGB8 or RGB10 recordable configurations without changing the controller context. Retain failed termination ownership without repeating a potentially consumed reference release.
2026-10-23 13:42:31 +02:00
Codex a23020bbd5 Merge commit '4b4c0a8b' into codex/builtin-media-baseline 2026-10-23 13:41:39 +02:00
Codex ccac4dc5b3 Load Android recording EGL and GLES operations atomically
Resolve the Surface, capture and draw procedures during cold setup. Missing procedures clear every operation table while preserving the borrowed display, buffers and format configuration, so startup cannot use a partially refreshed table. Capability checks remain with the native owners.
2026-10-23 13:35:49 +02:00
Codex 58363d892a Own Android capture resources through joint retirement
Construct the fixed capture images, Vulkan entries, GLES executor and handoff under one cold owner. Retain partial startup ownership, keep I/O borrowed, and collect only after copy/read retirement. Preserve two-phase Vulkan device teardown and source-only completion checks without adding frame-path allocation or waits.
2026-10-23 13:06:37 +02:00
Codex 12659387f1 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 12:47:57 +02:00
Codex d2b5462b87 Verify recording PCM across device stop and resume
Keep the stopped-output regression tied to recording behavior: all core callback styles must still deliver complete PCM to the recorder while device writes are disabled and after output resumes. Verify both frame counts and sample values.
2026-10-23 12:46:15 +02:00
Codex 5668d9afc4 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 12:42:06 +02:00
Codex 52c80ab0be Expose completed capture source leases to the renderer
Provide a cached source-only completion check for renderer resource changes after production stops. Keep capture-buffer and device retirement separate, and verify multiple slots, reuse and outstanding GLES ownership.
2026-10-23 12:39:51 +02:00
Codex 6640500010 Retire original capture sources during open recording
Poll one unfinished copy per renderer service step even while the GLES consumer still owns its capture slot. Cache copy retirement separately from slot ownership so source leases do not remain pinned until slot reuse or recording closure.
2026-10-23 12:33:30 +02:00
Codex ea35cd2973 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 12:28:25 +02:00
Codex c5fe577bcf Add shared Media Player settings below File Browser
Expose fullscreen seek interval and controls auto-hide preferences through shared menu navigation. Preserve the existing five-second seek and three-second hide defaults, keep zero-delay controls visible, and publish the configured seek interval for matching button captions. Exercise actual navigation, editing, persistence and kiosk visibility in all four menu drivers.
2026-10-23 12:25:48 +02:00
Codex 6394afc9c3 Exercise capture relay with actual entry and slot queue
Cover direct and deferred submissions, cancellation before queued copy execution, normal worker drain and device-loss retirement using the shipping capture entry, deferred Vulkan queue and GPU slot queue. Mock only native Vulkan and executor boundaries.
2026-10-23 12:12:56 +02:00
Codex 2cbd669641 Relay Android Vulkan captures to the GLES executor
Retain deferred submissions without replay, transfer ready descriptors once, and require both Vulkan copy and GLES read retirement before slot reuse and final cleanup. Keep producer closure separate from GPU completion and preserve ambiguous submission ownership.
2026-10-23 12:07:27 +02:00
Codex 8b3296ee7f Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 11:58:48 +02:00
Codex 35899e65e4 Resolve GLES oracle recovery callbacks at runtime
Use the already loaded GLES runtime for recovery callbacks so the software oracle does not require a development-library linker symlink.
2026-10-23 11:53:56 +02:00
Codex c4f0967df7 Recover recording reads with a terminal GLES fence
A missing slot fence can leave recording slots permanently held. Stop drawing and fence the same context stream once, then query completion without waiting. Retire source reads only after that fence signals; failures keep ownership and no frame is replayed.

Test fence creation/query faults, exact sync ownership and threadless execution. Run the shipping recovery on actual software GLES commands before pixel readback, with GCC and Clang and mandatory assertion checks.
2026-10-23 11:37:05 +02:00
Codex bcb51f41de Run Android recording GLES work on a separate executor
Create the recording Surface, fixed imports and draw resources on their own thread while codec output drains independently. Publish read retirement separately from Surface release and retain resources when completion cannot be proven.

Enforce one GPU executor per input window and collect it before the I/O owner. Validate dimensions and SDR/PQ configuration before startup. Exercise real slot queues, partial startup, cleanup retries and cancellation under sanitizers and TSan; extend native ABI and threadless checks.
2026-10-23 11:16:53 +02:00
Codex dbfcccfc6d Run Android recording I/O on an independent worker
Copy startup configuration and attach JNI on the I/O thread. Publish source ends and GPU retirement separately, coalesce nonblocking eventfd notifications, and keep native startup and finalization off producer threads.

Exercise concurrent submissions, closure during startup, cancellation, notification failures and thread faults. Compile the dispatcher in both native ABI/private-link groups; unsupported and threadless builds retain stubs.
2026-10-23 10:49:39 +02:00
Codex c473ac1470 Coordinate Android recording session ownership
Own encoders, PCM queue, mux and exclusive output on the independent I/O worker. Publish immutable producer ends separately from GPU read and Surface retirement; cancel without freeing resources still used by the GPU.

Cover startup rollback, delayed producer closure, ordered cancellation and file failures with a real PCM queue and concurrent producer notifications. Include the session in native ABI and private-link checks.
2026-10-23 10:31:29 +02:00
Codex e06385a2cc Separate Android encoder stop from GPU resource release
Allow terminal cancellation on the I/O owner while retaining the input window and codec until GPU retirement. Cache the native stop result, invalidate packet access and avoid repeating stop during final teardown.

Exercise held output, prior codec errors, EOS, stop failure and AAC cancellation with resource retention checks.
2026-10-23 10:20:03 +02:00
Codex c29a5ef860 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline
# Conflicts:
#	.github/workflows/Android.yml
2026-10-23 10:07:45 +02:00
Codex df2cfda5d8 Own fresh Android recording output descriptors
Create native paths exclusively and validate fresh adopted descriptors before transferring ownership. Preserve existing files and caller descriptors on refusal, and perform final sync and one-shot close only on the cold I/O owner.
2026-10-23 09:57:21 +02:00
Codex cf0dd22df8 Configure and verify Android encoder color metadata
Match hardware admission and native configuration for explicit profile/level, SDR or HDR10 color aspects and static HDR metadata. Copy managed metadata ownership and reject contradictory output formats before muxing. Leave transfer conversion in the capture shader and do not request codec tone mapping.
2026-10-23 09:28:09 +02:00
Codex 5460adac99 Service Android capture frames through the GLES worker
Connect the fixed capture queue to readiness import, drawing, source-read fences and Surface posts. Hold queue slots through GPU retirement and refuse encoder EOS until closed input fully retires. Preserve partial Surface cleanup ownership and permit terminal context scopes after posting failures.
2026-10-23 09:10:45 +02:00
Codex dacf2d7a9f Draw Android recording RGB inputs with explicit transfer modes
Preserve encoded SDR and PQ values, and convert linear scRGB to PQ once using the existing capture primaries and luminance scale. Validate shader output independently on software GLES across native source formats and both orientations, alongside portable ownership and failure tests.
2026-10-23 09:00:08 +02:00
Codex f180af2c5a Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline
# Conflicts:
#	.github/workflows/Android.yml
2026-10-23 08:51:00 +02:00
Codex e3cc552c34 Import fixed Android recording textures with GPU retirement
Keep readiness-fd consumption separate from completed texture reads. Retain partial cleanup ownership and refuse capture-slot reuse until a zero-timeout completion query succeeds.
2026-10-23 08:46:23 +02:00
Codex 6c35eb1b64 Submit Android capture copies with retained GPU source leases
Record fixed-slot Vulkan copies and foreign ownership transfers without warm allocation or CPU waits. Retain source leases through copy completion, transfer readiness fds once, and prevent binary semaphore reuse after an unconsumed export failure.

Separate child-object destruction from final source/native-buffer retirement so device teardown remains ordered. Exercise direct and deferred submission, cancellation, device loss and repeated reuse with the real deferred queue. Keep mock EGL tests independent of X11 headers.
2026-10-23 08:29:15 +02:00
Codex 781853a905 Allocate fixed Android RGB capture image pools
Query native RGB external-memory import and usage support before allocating AHardwareBuffers. Own dedicated Vulkan images and memory for RGB8, RGB10 and FP16 capture, preserve optimal native usage flags, and unwind partial resources without CPU mapping.

Exercise allocation faults, buffer identity and reference ownership with portable mocks, and compile standalone and combined Android recording units across both ABIs and file-offset modes. GPU readiness, foreign ownership transitions and worker reads remain with the capture producer/worker integration.
2026-10-23 07:50:13 +02:00
Codex 78cc0196d9 Own worker EGL surfaces and exact encoder presentation times
Create a validated recordable ES3 context and encoder window surface on the recording worker. Preserve zero-based source PTS, restore prior GLES bindings after posting, and retain failed restores or native destruction for explicit retry. Accept promoted EGL 1.5 context/colorspace support and require explicit PQ output capability.

Exercise context, format, timestamp and cleanup faults with portable mocks; compile the Surface and combined recording unit against every Android SDK ABI/file-offset configuration. GPU capture and recording registration remain separate work.
2026-10-23 07:30:58 +02:00
Codex 766a365f61 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 07:17:59 +02:00
Codex 01a54a9fd2 Coordinate Android video, AAC and MP4 worker ownership
Drain both encoders without losing borrowed packets while mux tracks start. Consume PCM incrementally across backpressure and finalize tracks with explicit source ends only after encoder drain. Exercise real PCM queue ownership with delayed codec formats and failures, and link the worker dependencies in the Android SDK matrix.
2026-10-23 07:10:54 +02:00
Codex d09da7b20e Link threaded codec dependencies in the AV1 Metal fixture
Build the thread pool and event count before the first Metal fixture link, including when native AV1 decoding is unavailable.
2026-10-23 07:04:23 +02:00
Codex dd38c0dab3 Encode worker-owned AAC PCM with sample-clock timestamps
Reuse encoded-output ownership for platform AAC-LC input. Submit one bounded native buffer at zero timeout, retain unconsumed PCM across backpressure, fill sample-clock gaps with bounded silence and fix EOS before retries. Validate actual output rate/channels and preserve the Android queue offset ABI.
2026-10-23 07:00:03 +02:00
Codex 2b12a040c2 Own Android MP4 muxing and explicit track end timestamps
Bind native video/AAC formats before start, borrow compressed packets only during worker writes, and preserve source timestamps and encoder order. Require explicit source end markers before finalization and keep native errors sticky. Extend portable fault tests and NDK ABI/unity checks; recording frontend and device output acceptance remain open.
2026-10-23 06:45:07 +02:00
Codex 6e28729120 Own Android Surface encoding and borrowed output on the worker
Create an explicitly admitted native encoder and input Surface with ordered partial cleanup. Pump one zero-timeout output action, retain packet borrows until acknowledgement, and preserve format/EOS/error ownership. Add portable fault tests and native NDK ABI/unity compilation; GPU capture and mux integration remain separate.
2026-10-23 06:35:34 +02:00
Codex b71ce6e61d Require libaom in macOS AV1 acceptance tooling
Use the Homebrew full FFmpeg formula when the current binary lacks libaom-av1. Check the selected encoder before generating grain and chroma fixtures.
2026-10-23 06:31:19 +02:00
Codex f5acdc1722 Query complete Android Surface encoder input formats
Add cold hardware admission for bitrate, fractional frame rate and COLOR_FormatSurface alongside profile and dimensions. Preserve decoder selection and exception ownership; exercise encoder filtering, rejection and local-reference bounds through real JNI.
2026-10-23 06:25:29 +02:00
Codex a56e1b006a Compile AV1 native fixtures when hardware is unavailable
Keep unavailable decoder probes distinct from native SDK and linker validation. Build Metal and container fixtures even after an unavailable probe, while preserving compiler failures and exit 77.
2026-10-23 06:21:53 +02:00
Codex f901aa40d4 Keep Darwin loader declarations visible in AV1 acceptance
Remove the unnecessary POSIX feature restriction, which hides RTLD_DEFAULT on Apple and prevents the native AV1 fixture from compiling.
2026-10-23 06:18:53 +02:00
Codex 93b3114029 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 06:14:21 +02:00
Codex e0c48b473d Exercise native AV1 MP4 and WebM Metal playback
Check independent decoded-plane and FrameView pixels through container streams, alternating warm seeks, reopen and retained pool exports. Require one native session per stream and explicit native completion; portable probes report unavailable.
2026-10-23 06:13:38 +02:00
Codex 33996131a1 Release the AV1 fixture lease before Metal submission
Avoid an extra fixture reference masking consumer ownership during asynchronous GPU completion. Check that completion has not advanced before submitting the command buffer.
2026-10-23 06:07:22 +02:00
Codex 44d4e9c5ac Exercise AV1 decoder exports through native Metal movie conversion
Use the published backend, retained pool leases and shipping FrameView path for non-square decoded images. Check GPU plane hashes and independent chroma-aware RGB references across warm seek, renderer teardown and reopen. Keep raw decode and Metal acceptance modes distinct.
2026-10-23 05:58:50 +02:00
Codex 54b9271633 Distinguish AV1 native setup failures from unavailable hardware
Only known decoder availability errors return 77. Require the native completion marker before recording a successful device case, so an empty-success executable cannot produce a false acceptance result.
2026-10-23 05:40:50 +02:00
Codex 51dce116c6 Add native VideoToolbox AV1 pixel and seek acceptance
Compare eight generated 8/10-bit chroma/grain cases with independent decoded references. Require hardware decoding, preserve a native image across warm keyframe seek and retirement, and report unavailable devices separately from passes. Metal import acceptance remains separate.
2026-10-23 05:37:51 +02:00
Codex 2f7e664d88 Publish AV1 decoding through the shared Metal lifecycle
Use the retained renderer snapshot for AV1 startup and withdraw only its offer on matching renderer teardown. Extend native lifecycle checks across AV1-only and combined-codec builds in both ARC modes.
2026-10-23 05:28:40 +02:00
Codex 599c35c247 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 05:24:55 +02:00
Codex 731d95f52c Add serialized AV1 dispatch and Metal backend admission
Follow the existing VP9 executor pattern with preallocated signal/timer sources and deferred retirement. Admit AV1 using retained renderer snapshots, bounded session storage, supported conversion metadata and current device generations.
2026-10-23 05:20:23 +02:00
Codex 823de371e8 Carry explicit AV1 chroma placement through Metal conversion
Keep placement in private leases and reconstruct explicit vertical/top-left chroma with bounded taps. Preserve legacy unspecified sampling and core HDR ABI. Extend native HDR references and macOS AV1 configuration/ownership checks; native execution remains pending.
2026-10-23 05:15:10 +02:00
Codex 8c5e4473cc Adapt AV1 owner output to retained Metal frame leases
Snapshot accepted display dimensions and grain parameters, preserve images on export backpressure, and reuse native sessions on restart. Exercise sequence mismatch refusal, show-existing output and leases held through decoder retirement with the mock pool.
2026-10-23 05:11:04 +02:00
Codex bdad7a1acd Own bounded VideoToolbox AV1 service and completion slots
Follow the VP9 queue and retirement pattern for staged AV1 samples. Retain native output independently of owner shutdown and reject stale callback cookies before marking errors. Cover backpressure, hidden drain, restart, delayed release and concurrent callback publication.
2026-10-23 05:08:24 +02:00
Codex ce6d74fc2d Stage bounded AV1 samples for VideoToolbox ownership
Normalize sized OBUs into preallocated packet storage, seal hidden/display batches, and retain borrowed bytes through the CoreMedia release callback. Exercise busy retries, overlapping input, allocation errors and delayed native sample release.
2026-10-23 05:04:27 +02:00
Codex 151a67d06d Keep AV1 sample presentation delay unspecified in Android setup
The sequence display delay counts frames; av1C presentation delay counts samples and needs container grouping information. Preserve the coded sequence delay without copying it into the configuration prefix.
2026-10-23 05:00:27 +02:00
Codex bfd3f884d0 Add cold VideoToolbox AV1 format and session setup
Validate the sequence and container color before building av1C and requesting a hardware-only Metal-compatible session. Keep sample presentation delay unspecified when only frame display delay is known.

Exercise portable configuration, setup allocation failures and partial native creation errors. Native Apple format execution and decoder integration remain pending.
2026-10-23 04:58:11 +02:00
Codex d355ae237b Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 04:42:49 +02:00
Codex e89a508e9a Add VA AV1 native pixel and seek acceptance runner
Generate 8/10-bit streams and independent FFmpeg pixel references for chroma placement and film grain. Exercise keyframe seek/reopen cycles, retained exports, native Vulkan import and owner retirement.

Keep portable fixture checks distinct from native acceptance, reject mismatched binary modes, and report unavailable hardware without counting a pass. Extend the shared import oracle to validate chroma placement.
2026-10-23 04:39:43 +02:00
Codex 7e8587cbcf Carry AV1 chroma placement through VA Vulkan conversion
Preserve signaled vertical and colocated chroma positions in private frame leases and reconstruct sampled planes at their specified locations. Clamp interpolation to the coded extent so allocation padding cannot bleed into the picture. Unspecified positions retain existing sampling; reserved values refuse.

Validate metadata lifetime and admission, 8/10-bit SDR/PQ/HLG GPU pixels, padding/crop boundaries, and a negative control that drops placement.
2026-10-23 04:20:52 +02:00
Codex 12d11e8322 Terminate generated Vulkan oracle headers with a newline
Clang rejects freshly compiled shader initializers under the strict C89 oracle flags when the generated include has no final newline. Write an explicit LF on every host while keeping the shader payload and pixel assertions intact.
2026-10-23 03:59:42 +02:00
Codex e736b5aa75 Merge commit 'bf777848c63eee8dd84f5bb94df2245d221d3038' into codex/builtin-media-baseline 2026-10-23 03:47:19 +02:00
Codex 7cce0be1a2 Verify packed settings table keys
Resolve label offsets from preprocessed blob declarations instead of dropping generated settings rows. Refresh the reference for ten already-landed settings and microphone row ordering, with all existing keys and defaults preserved. Cover packed and literal keys, ordering and missing labels, and run table and unity checks in settings CI.
2026-10-23 03:46:30 +02:00
Codex d2a2fdc37e Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 03:34:47 +02:00
Codex ab554a3ab7 Offer VA AV1 decoding on eligible Vulkan devices
Keep native Vulkan Video AV1 preferred and publish VA only for the actual DRM PRIME import device. Reserve 32 physical surfaces independently of the nine logical stream slots, bound cold sessions and defer native retirement. Detect AV1 SDK headers separately so absent headers leave HEVC and VP9 available. Exercise admission, epoch changes, retirement, threadless refusal and notification lifetime under sanitizers and TSan.
2026-10-23 03:34:17 +02:00
Codex 54c3407bb0 Own native VA AV1 startup and deferred retirement
Combine AV1 runtime, physical pool and decoder lifetimes without terminating while renderer exports remain owned. Keep partial startup retireable and retry termination without repeating native cleanup. Share source color admission with the decoder and cover 8/10-bit runtime faults, retained grain exports and nine-surface non-grain admission.
2026-10-23 03:22:44 +02:00
Codex 6695043ce9 Map VA AV1 references and retained grain outputs
Keep physical reference and grain display pairs for each logical AV1 slot. Preserve cached display images across inter frames and exported leases across logical reuse, with bounded BUSY and identical-packet retry when surfaces are held. Snapshot output geometry, grain and source color metadata, and defer decoder retirement until renderer ownership returns. Explicit chroma placement still refuses pending renderer support.
2026-10-23 03:15:57 +02:00
Codex d7182ccea7 Export completed VA AV1 display surfaces
Reuse the shared DMA-BUF descriptor and opaque frame ownership path with AV1 pool generation checks. Cover 8/10-bit grain display export, pending completion refusal, retained renderer ownership, close retries and duplicate native descriptors.
2026-10-23 03:04:15 +02:00
Codex 6ddc16eff2 Protect AV1 VA reference and grain surface ownership
Track native reads and both write destinations through bounded completion and retirement. Retained exports use incarnation tickets, and grained output cannot become a reference. Allocate picture and tile work storage with the cold pool instead of on the frame stack.
2026-10-23 03:00:42 +02:00
Codex 1dbb4ecb04 Track both VA AV1 submission destinations
Submit bounded typed picture and tile buffers with the shared VA transaction operations. Poll reference and grain display surfaces without waiting, retain uncertain work until display termination, and retry failed buffer destruction. Validate surface membership, tile spans and session geometry before native ownership.
2026-10-23 02:56:57 +02:00
Codex 2dbc25edaf Build native VA AV1 picture parameters
Map effective AV1 references, filters, restoration, global motion and film grain into typed VA buffers. Reject malformed state without changing caller output and keep separate grain display ownership explicit. Cover parsed 8/10-bit fixtures, reference mapping and bounded refusal without claiming native hardware decode.
2026-10-23 02:52:10 +02:00
Codex 2f26f56198 Build bounded native VA AV1 tile records
Translate validated whole-frame tile spans into SDK-native slice records using caller-owned storage. Recheck every span before publishing output and preserve output on refusal. Validate reserved fields and maximum capacity, and compare native offsets and sizes against independent AV1 traces on real coded streams.
2026-10-23 02:39:26 +02:00
Codex 5e5ba8b90c Merge master Exynos and CI package-cache updates 2026-10-23 02:22:48 +02:00
Codex 9a697765f8 Add VA AV1 session admission and runtime ownership
Admit AV1 profile 0 with 8/10-bit render formats and nine to thirty-two surfaces through the existing native VA lifecycle. Preserve partial initialization and retryable cleanup, and refuse AV1 before native ownership on older SDKs. Cover startup faults, boundaries and compatibility without registering an incomplete decoder.
2026-10-23 02:21:55 +02:00
Codex 89364ba943 Keep retained VA VP9 surfaces independent of logical slots
Map logical DPB slots to native surfaces on accepted decode, including references, previous pictures and output. Select an unheld surface when a logical slot is reused so retained renderer exports cannot stall otherwise available decode capacity. Cover remapped output and references, full 32-surface backpressure, retry and stale ticket refusal.
2026-10-23 02:13:48 +02:00
Codex 37fb6dd13e Add native VA VP9 pixel and import acceptance runner
Check profile 0/2 decode against independent fixture hashes and retain an exported frame across later pictures and decoder detach. Reuse the Vulkan modifier import oracle for conversion and exact-device ownership checks. Build both native variants in the Linux sample lane; require an explicit render node to execute them and report unavailable without a device.
2026-10-23 02:02:35 +02:00
Codex 6fa9e490f0 Register VA VP9 decoding on eligible Vulkan devices
Publish the parsed VP9 backend only for matching PRIME import devices, preserving native Vulkan Video preference. Retire decoder contexts off the frame path and retain outstanding exports across renderer replacement. Add factory admission and lifetime coverage, plus the deferred queue dependency for the native import oracle.
2026-10-23 01:57:19 +02:00
Codex 6a9886de64 Merge master shader compiler changes 2026-10-23 01:41:16 +02:00
Codex ac35f9fa36 Keep VA queue inclusion outside the Android unity block
Preserve the Android source-matrix anchor while compiling the shared conversion queue for non-Android VA builds. The sixteen codec/thread configurations and renderer lifecycle variants pass locally.
2026-10-23 01:40:03 +02:00
Codex 6a6b492626 Build VA VP9 ownership and defer Vulkan conversion submits
Add profile 0/2 parameters, bounded submission, surface generations and decoder retirement using the existing VA runtime and opaque export path.

Prepare VA imports on the cold owner and drain conversions under existing renderer queue serialization. Preserve exports on deferred or ambiguous GPU use, and find the required libdrm headers independently of KMS.

Native VA playback acceptance and VP9 frontend registration remain pending.
2026-10-23 01:38:12 +02:00
Codex b9392ebf46 Test VP9 WebM playback through the display API
WebM skip intentionally discards display output. Use next for the native playback oracle so its frame, pixel, seek and retained-lease assertions exercise exported frames.
2026-10-23 01:17:30 +02:00
Codex 20ebf595cd Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 00:35:07 +02:00
Codex a4b20df274 vulkan: collect retired Android imports during cold setup 2026-10-23 00:35:07 +02:00
Codex 7744736d83 Merge remote-tracking branch 'origin/master' into codex/builtin-media-baseline 2026-10-23 00:29:26 +02:00
Codex ab25c98feb media: defer Android imports through the renderer submission queue
Drain conversions under the existing queue lock, retain queued leases until completion, and prepare native identities through owner resource work before warm imports.
2026-10-23 00:29:21 +02:00
Codex de524e63d9 media: reconcile public Vulkan Android warm path 2026-10-23 00:05:13 +02:00
Codex 4613d47bc0 vulkan: make Android warm-path ownership checks portable
Run the positive-FD ownership and retirement cases on Windows CRT pipes while retaining real POSIX paths on Linux and Android. Add a portable warm-path runner, strict NDK coverage and project formatting without changing the production ownership algorithm.
2026-10-23 00:05:11 +02:00
Codex f01298f246 media: reconcile public Vulkan Android resources 2026-10-22 23:54:11 +02:00
Codex 8465e993b4 vulkan: validate portable Android import resource contracts
Use portable model and pixel runners, execute embedded and fresh-source shader oracles, and extend strict Android ABI coverage. Apply the project style and distinguish legacy descriptor reservation from native admission.
2026-10-22 23:54:08 +02:00
Codex 2c21231c86 media: reconcile public Android color export 2026-10-22 23:44:09 +02:00
Codex 616b915dc3 android: align color export with shared VP9 metadata
Use the published libretro-common VP9 color resolver, add a portable three-codec export runner and extend Android ABI coverage. Apply the project style without changing the metadata or lease contract.
2026-10-22 23:44:06 +02:00
Codex f8ee96bc96 media: reconcile public Android frame leases 2026-10-22 23:40:18 +02:00
Codex 266761837b android: make opaque frame lease checks portable
Use RetroArch threads on Windows and Unix, preserve native Linux fence checks and exercise actual stale generation reuse. Add a portable lease/HDR runner and Android ABI coverage with the project code style.
2026-10-22 23:40:14 +02:00
Codex e8e2ff3396 media: reconcile public codec worker sessions 2026-10-22 23:36:06 +02:00
Codex fe199993a3 android: make worker session contracts portable
Add a temporary-output session runner for Windows and Unix, test codec-configuration output and timestamp overflow, and check session SDK signatures in the Android ABI matrix. Apply the project code style.
2026-10-22 23:35:38 +02:00
Codex 035e1b0a53 media: reconcile image ownership with current master 2026-10-22 23:31:33 +02:00
Codex be3e85bb5b android: reject empty native image acquisitions
Do not publish an image wrapper when the native API reports success without an AImage. Keep the reader fault test portable, apply the project style and give image ownership its own CI job.
2026-10-22 23:31:06 +02:00
Codex 95adc8c060 android: make image ownership tests portable
Use RetroArch threads for concurrent image returns and exercise no-fence lifecycle contracts on Windows while retaining native-fence polling tests on Linux. Apply the project style to the queue and its tests.
2026-10-22 23:28:30 +02:00
Codex 3cbfdbb91e android: make codec inventory contracts portable
Run the real JVM tests from temporary output directories on Windows and Unix, retain separate inventory CI coverage, and apply the project code style.
2026-10-22 23:25:03 +02:00
Codex f89b4a8fb7 vp9: reuse native sessions across key-frame seeks
Append an optional nonblocking restart callback. Drain discarded work before resetting reference state, preserving exported leases and avoiding repeated VideoToolbox session creation. Cover pending restart, repeated seeks and restart failure.
2026-10-22 23:20:53 +02:00
Codex 8218c1923a media: reconcile hardware migration with current master
Preserve the current shader and CI layout and published backend prefixes while integrating the pending platform decoder work. Keep device acceptance on the candidate branch.
2026-10-22 23:05:02 +02:00
Codex ff7cef3da1 av1: withdraw only the retiring backend offer 2026-10-22 22:52:36 +02:00
Codex 620405d736 test: distinguish VP9 reopen and output failures 2026-10-22 22:45:20 +02:00
Codex 1482dab102 av1: preserve the published backend prefix 2026-10-22 22:41:26 +02:00
Codex b316823902 media: add explicit play and pause actions 2026-10-22 22:33:08 +02:00
Codex d89cec4bdf vp9: match published calloc argument ordering 2026-10-22 22:28:21 +02:00
Codex a93d2c4663 test: identify VP9 seek output refusal 2026-10-22 22:21:36 +02:00
Codex 9a22d549c1 test: guard immutable CoreFoundation mock values
Assert non-null retained values and return before atomic object refcounts for mock CF booleans. This preserves the real constant-ownership contract and avoids GCC15 treating sentinel booleans as possible objects. Windows64 and Linux sanitizer mock suites pass without disabling warnings.
2026-10-22 22:13:44 +02:00
Codex 9fd92b3a68 video: declare VP9 color properties to VideoToolbox
Supply primaries, transfer, matrix and full-range CoreMedia format extensions in addition to vpcC. Native run39842936896 decoded BT709 content into buffers tagged SMPTE-C/BT601, causing strict Metal import to reject the first frame. Preserve coded/container metadata validation; do not override output attachments or weaken import checks. Verify explicit SDR/sRGB/PQ/HLG and range properties plus unchanged setup failure cleanup.
2026-10-22 22:05:33 +02:00
Codex a35a2b36da vp9: correct Matroska vertical chroma mapping
Map left/half-row siting to VPCC vertical 4:2:0 and top-left to colocated 4:2:0. Reject horizontal-half descriptions that neither supported VPCC value represents. Fix the swapped-axis candidate logic and cover both valid locations plus horizontal-half software fallback against the published container/binding definitions.
2026-10-22 22:05:33 +02:00
Codex 300be42cea vp9: preserve replacement offers during renderer retirement
Use conditional registry withdrawal for Vulkan and D3D11 shutdown. Verify that a stale backend cannot withdraw a newer offer and that a subsequent open snapshots the replacement. This is cold lifecycle work; decoder frame processing is unchanged.
2026-10-22 21:52:35 +02:00
Codex f1ddffb95a test: diagnose native VP9 CoreVideo export refusal
Instrument the extracted acceptance-only Metal export failure branch with native pixel format and borrowed color attachments. Require an exact shipping-source anchor; preserve production code and export return behavior.
2026-10-22 21:42:22 +02:00
Codex 1f53fc376c test: identify native VP9 stream output failures
Print the active container/color/repeat case and stopped output count before the existing strict assertion. Keep diagnostics in the acceptance fixture; do not change native decoder behavior or weaken expected output.
2026-10-22 21:37:02 +02:00
Codex 166835d878 vp9: preserve published backend prefix for color extensions
Keep user/open/close/packet_decoder offsets when appending color, drain and configuration callbacks. Update positional test offers and verify mode offsets plus callback append placement with C89 compile-time checks. This aligns the pending native backends with the incrementally landed master API.
2026-10-22 21:35:50 +02:00
Codex a4ef3b5f4a h264: remove unused variadic dispatch macro
The bit-depth wrappers already call the typed C89 functions directly. Remove the unused RH264_K2 definition and undef so Apple Clang can compile the pipeline support objects with strict C89 warnings as errors. No decoder call sites or generated code change.
2026-10-22 21:25:20 +02:00
Codex 6a2aa0b6e9 vp8: retain legacy MSVC support in stack helper
Match the existing VP9 noinline compiler guard: declspec(noinline) requires MSVC 1300 or newer. Older compilers keep the portable helper definition. Apple/GCC/Clang paths are unchanged.
2026-10-22 21:24:18 +02:00
Codex 725afac1f5 vp8: bound picture-header setup stack usage
Keep the inherited probability/reference snapshot in a separate non-inlined reset helper, outside picture-header parser temporaries. Preserve the same state and arena without new allocation. Apple Clang reported a 2240-byte rvp8_begin frame under the 2048-byte LRC budget. GCC/Clang sanitizer pixel comparisons across repeated key/inter frames and four ABI stack builds pass; native acceptance remains required.
2026-10-22 21:18:57 +02:00
Codex 5bb8d13270 test: cover hidden VP9 pictures and native repeat packets
Add valid hidden-keyframe/show-existing superframes to every MP4/WebM depth and color fixture. Independently verify with FFmpeg that visible output remains byte-identical. Carry the cases through native Metal plane/color, repeated-seek and retained-export acceptance. Host software pixel and seek checks pass; native execution remains pending.
2026-10-22 21:14:23 +02:00
Codex 1e1bc0d3e4 test: exercise native VP9 Metal playback and repeated seeks
Run the shipping Metal decoder factory, MP4/WebM streams and FrameView conversion against independent decoded-plane CRC and color references. Cover 8/10-bit SDR, PQ and HLG, alternating seeks and an exported frame retained through stream and pool close. Keep GPU waits and readbacks confined to acceptance fixtures; require native execution and report missing devices separately.
2026-10-22 21:08:30 +02:00
Codex d74c08de2c test: execute native VP9 hardware pixels and retained output
Decode fixed lossless 8/10-bit pictures through the shipping owner and a separate serialized worker. Compare native planar output against FFmpeg-derived references, reopen sessions and retain decoded images through retirement. Report unavailable hardware explicitly without claiming pixel acceptance.
2026-10-22 20:34:29 +02:00
Codex 6d418fd6a5 ci: recover stalled VA oracle dependency downloads
Apply bounded package download and mirror recovery to the VA matrix job after its dependency installation exhausted the deadline before any tests ran. Preserve all test commands and reserve time beyond dependency recovery.
2026-10-22 20:22:47 +02:00
Codex 48c17098a6 mp4: connect VP9 hardware sessions to stream playback
Use configuration-aware cold admission and bounded superframe submission with retained input on BUSY. Preserve output leases, drain terminal packet decoders, and reopen from retained initial headers during seeks. Keep software fallback and reject coded color changes before native submission.
2026-10-22 20:22:47 +02:00
Codex 4d9642f844 mp4: resolve VP9 configuration and coded color metadata
Interpret retained vpcC before decoder setup and reconcile coded profile, depth, subsampling and range with container color. Preserve mastering and light metadata across rewind, and refuse contradictory descriptions. Add portable metadata and configuration ownership regressions.
2026-10-22 20:09:24 +02:00
Codex 4891a5de59 ci: recover stalled Metal mock dependency downloads
The Metal mock job exhausted its ten-minute deadline while installing packages, before any test ran. Use the established bounded download and mirror recovery recipe, and allow its existing twenty-minute dependency bound plus test execution. Preserve every test command.
2026-10-22 20:02:08 +02:00
Codex e02fc1a467 ci: budget graphics job for dependency recovery and full regressions
A healthy preview pass took 8m40s in the prior successful job. After mirror recovery, the next run reached that step with only 7m28s before its 30-minute job cutoff. Allow the existing 20-minute dependency bound plus the measured regression workload and setup overhead; preserve every test command and per-command timeout.
2026-10-22 19:31:14 +02:00
Codex ef4956ee82 vp9: carry container chroma through hardware admission
Add an append-only cold configuration callback while preserving legacy callback selection. Carry Matroska siting to VideoToolbox codec setup, reject truncated or unrepresentable descriptions, and retain resolved coded/container color for presentation. Share the existing renderer color policy with the stream layer without changing the core HDR ABI.
2026-10-22 19:30:27 +02:00
Codex ee5eed049b vp9: parse container codec configuration records
Validate vpcC FullBox bounds and profile, depth, chroma and level constraints while preserving raw CICP values for later admission. Register the portable configuration regression in the common sample runner.
2026-10-22 13:44:54 +02:00
Codex 415735875e ci: bound shader dependency downloads and retry stalled mirrors
Use the existing formats-job package download and mirror fallback pattern in the two shader jobs that stalled before checkout. Fetch under a bound before installation, retain visible package output, and preserve all shader steps and the existing overall job deadline.
2026-10-22 13:39:49 +02:00
Codex b8b6fca0b2 mp4: preserve VP8 and VP9 codec configuration metadata
Retain the complete vpcC box for later color and chroma admission even when codecInitializationData is empty. Cover configuration ownership after input release and allocation failure for both sample entries.
2026-10-22 13:36:52 +02:00
Codex 2891916ad7 tests: keep combined Metal codec declarations C89 compatible 2026-10-22 13:32:55 +02:00
Codex eea612586b metal: publish VP9 and HEVC decoder offers from shared lifecycle
Reuse the existing retained setup snapshot and lifecycle lock for both codecs. Keep VP9 independent of MP4 support, resolve optional macOS registration at setup, and preserve compare-withdrawal of foreign offers. Exercise native lifecycle builds with each codec and both ARC modes.
2026-10-22 13:29:26 +02:00
Codex c7622782cc video: share retained Metal decoder capability snapshots
Reuse the HEVC setup lock and publication ordering for device, HDR capability and nonwrapping generation snapshots. Keep owner queries lock-free and expose the same snapshot contract to VP9 without a HEVC dependency.
2026-10-22 13:10:45 +02:00
Codex f036a9c764 video: admit VP9 sessions with stable Metal capability snapshots
Build the packet-decoder backend around an owned device/HDR snapshot and validate its generation before and after native setup. Balance failed setup resources and retire stale sessions through the existing executor.
2026-10-22 12:52:17 +02:00
Codex c047f15028 video: schedule VP9 native work with preallocated dispatch sources
Use coalesced source wakes for serialized native submission and deferred retirement. Retain the close-notification source across concurrent cancellation and use a setup-time timer for outstanding native block retirement. Check native C, ARC and MRC SDK builds separately from host dispatch models.
2026-10-22 12:40:17 +02:00
Codex f90e2de655 queues: bound POSIX SPSC shared-memory name formatting
Use snprintf and reject formatting failures before shm_open. This keeps the shared-memory setup branch buildable with modern Apple SDK deprecation warnings treated as errors.
2026-10-22 12:26:38 +02:00
Codex bda2fbea3f video: export VideoToolbox VP9 output through Metal pools
Connect the VP9 packet-decoder contract to the bounded native owner and retain images across busy Metal exports. Discard superseded display results by generation so reused DPB slots cannot return stale pictures, while exported leases survive deferred retirement.
2026-10-22 12:24:37 +02:00
Codex e20ba583e4 video: connect bounded VideoToolbox VP9 owner service
Queue startup-owned compressed batches for serialized native submission, preserve final visible output and recycle storage only after submission and native block release. Close admission before deferred retirement and keep owners alive while native blocks remain retained.
2026-10-22 12:16:18 +02:00
Codex 9c3e97f739 video: guard VP9 completion slots against stale callbacks
Match callbacks with nonrepeating generation cookies and claim completion atomically. Transfer retained images to the owner and keep null-image success separate from visible output; retiring owners keep slot pools until native callbacks quiesce.
2026-10-22 12:04:08 +02:00
Codex 77ef1c7d95 video: pin VP9 sample storage through native block release
Create and submit CoreMedia samples on the serialized worker. Keep staged input pinned until CoreMedia releases its block, independently of decode callbacks, and suppress display output for hidden-only batches.
2026-10-22 11:57:00 +02:00
Codex 0f0ee60703 video: stage bounded VP9 batches for VideoToolbox
Own accepted packet bytes in startup-provided storage and emit Annex B indexes. Seal on display, capacity or terminal input, retaining unaccepted input for retry without growing buffers.
2026-10-22 11:51:52 +02:00
Codex bcc0d9bdcb video: create hardware-only VideoToolbox VP9 sessions
Build CoreMedia VP9 formats and request Metal-compatible IOSurface pools. Release partial format/session state on setup failures and keep supplemental decoder registration optional for older platforms.
2026-10-22 11:47:32 +02:00
Codex cbbf6d2a43 video: share VP9 color admission and build VideoToolbox configuration
Reuse the existing coded/container color intersection for Android and the new VideoToolbox configuration helper. Build the versioned vpcC payload for 8/10-bit 4:2:0 with explicit chroma position, unspecified level and preserved metadata. Reject reserved color fields, conflicts and unsupported output layouts rather than guessing HDR.

Add portable strict-C89 configuration conformance to Linux and macOS CI. GCC/Clang configuration and full MediaCodec sanitizers, Windows64 runtime and sixteen Android compile objects pass. Twenty measured frames remain below2048 bytes. Win32 compiles but Windows security blocked copying its executable, so Win32 runtime is not claimed. Native VideoToolbox session/packet/Metal integration remains separate work.
2026-10-22 11:34:57 +02:00
Codex 1d862204fa av1: retain admitted startup sequences for container reopen
Keep the actual sequence bytes after compatible pre-frame admission changes, so MP4 and WebM seeks reopen with the accepted decoding flags even when original packet input is temporarily unavailable. Bound owned configuration to 1 MiB, reuse identical storage, and free it with the outer stream. Retention runs only during cold sequence admission; later sequence changes remain rejected.

Preserve configured level/tier, close cleanly if retention fails, and cover borrowed-input overwrite and ownership. Reproduce stale reopen state in MP4 and both WebM startup modes, then validate GCC/Clang sanitizers, ten Windows32/64 runtime cases, C89 frontends, seventy-two strict stack objects and sixteen Android root links.
2026-10-22 11:24:26 +02:00
Codex e8733ab179 android: publish AV1 MediaCodec through Vulkan renderer admission
Select the AV1 native owner and backend in Makefile and Griffin builds, including AV1-only configurations. Extend shared device/import/cache gates, publish only after Android image admission, preserve Vulkan Video preference and withdraw with renderer lifecycle ownership.

Exercise all sixteen codec/thread source and renderer lifecycle combinations, including init retry and stale teardown. Validate GCC/Clang sanitizers, thirty-two Windows runtime cases, both C89 frontends and sixteen combined/AV1-only native Android root links. Vulkan continues to require threads; threadless source/registry exclusion is tested separately.
2026-10-22 11:10:53 +02:00
Codex f2512de8b5 av1: drain native output across terminal hidden packets
Let packet decoders accept hidden input while retaining one visible output, then drain only at real container EOF. Preserve presentation timestamps, HDR metadata and native format snapshots across delayed output. Keep surface backends on their existing contract.

Cover partial input, terminal BUSY and failure, discard and rewind in MP4/WebM, plus native format changes while an image is pending. Validate GCC/Clang sanitizers, Windows32/64 runtime cases, two C89 frontends, sixty strict stack builds and eight Android native root links.
2026-10-22 11:01:49 +02:00
Codex a8286d93fa media: add bounded MediaCodec AV1 backend and registry
Normalize admitted sequence OBUs into validated av1C during cold startup and export native-grained NV12/P010 with reconciled color metadata. Bound active and retiring sessions, retain notifier ownership through deferred cleanup, and reject stale opens and foreign withdrawals by publication epoch.

Cover configuration normalization, admission failures, retained exports, color conflicts, pool reuse and concurrent renderer replacement. Factory publication and container terminal drain remain separate integration work.
2026-10-22 10:21:13 +02:00
Codex 19f37ff656 av1: admit hardware with sequence and container metadata
Pass borrowed sequence OBUs and known color/HDR metadata through an optional factory admission callback. Preserve legacy surface factories and snapshot the admitted packet mode.

Retain the initial WebM sequence bytes during cold admission so decoder reopens do not depend on the feeder keeping startup bytes available. Exercise both admission paths through MP4/WebM seek, HDR and reduced-availability cases.
2026-10-22 10:05:30 +02:00
Codex 1758ffd469 media: add the MediaCodec AV1 Surface decoder owner
Validate av1C sequence admission and reconcile coded/container color before native startup. Correlate hidden and repeated-display packets with Surface images using bounded local timestamps, preserve grain and crop snapshots, and defer destruction until exported leases retire.

Cover malformed configuration, input and output BUSY, PQ/HLG, grain mismatch, cropped output, delayed EOS delivery and retained leases. Include the owner in native Android signature and root-link checks; factory registration remains separate.
2026-10-22 09:50:41 +02:00
Codex 4f7abb7734 av1: submit repeated display to opaque packet decoders
Snapshot an explicit packet-decoder mode at stream admission. Submit show-existing header OBUs before committing reference refresh, preserving immutable BUSY retries, cancellation and independent output leases. Existing surface factories keep output-only repeats.

Exercise both modes against generated 8/10-bit reordered and grain streams, including invalid repeats, and verify packet acceptance before keyframe reference refresh.
2026-10-22 09:41:54 +02:00
Codex dcfdc099d6 vp9: bound reconstruction and probability decoder stacks
Keep predictor and coefficient-band expansion out of reconstruction and header frames. Reuse inverse-transform scratch after its previous use has ended for coefficient token decoding, without changing decoder size or allocating per frame.

Check whole-decoder C89 stack budgets with and without workers, compile both Android ABIs, and compare 8/10-bit cropped and tiled output against FFmpeg.
2026-10-22 09:32:28 +02:00
Codex 939c5ed088 media: publish admitted Android decoders from Vulkan
Publish HEVC and VP9 MediaCodec registries only for frontend devices with Android image import enabled, preserving working Vulkan Video codecs. Withdraw offers before renderer teardown and link shared imports independently of MP4 so VP9-only builds work. Keep the worker JNIEnv declaration available without legacy JNI macros and check Makefile/Griffin feature gates.
2026-10-22 08:53:09 +02:00
Codex bdb9f5a3ee media: drain terminal VP9 packets before ending WebM playback
Preserve the last visible output across trailing hidden packets and signal terminal input only after confirmed demux EOF. Poll EOS and delayed Surface delivery without waiting, retain exported leases, and keep the existing timestamp-table shortcut. Leave surface backends on their existing output path.
2026-10-22 08:34:54 +02:00
Codex d0bd247a9a media: bound MediaCodec VP9 backend retirement and registry
Own exporter pools and deferred decoder cleanup through bounded session admission. Preserve color-aware packet decoding, keep retained frame leases alive across close, and reject opens whose registry generation changes during native startup. Add conditional VP9 offer withdrawal so stale owners cannot remove a replacement backend.
2026-10-22 08:22:04 +02:00
Codex c11aae0554 media: pass WebM color metadata into VP9 admission
Allow color-aware factories to inspect container metadata before native startup. Keep legacy factories and their close snapshots, and clean up refused or incomplete opens without disabling software playback.
2026-10-22 08:14:44 +02:00
Codex 27c38530e2 media: preserve VP9 container color through MediaCodec export
Intersect VP9 color-space/range syntax with container metadata without inferring a transfer curve. Supply explicit Android input color hints and select the ten-bit HDR profile for PQ/HLG. Carry the immutable metadata to the output adapter and reuse the shared frame exporter with native-color conflict refusal. Cover input hints, PQ/HLG leases, mastering/light refinement, depth mismatches and retirement while retaining HEVC behavior.
2026-10-22 08:04:56 +02:00
Codex bc1cdfa00d media: own MediaCodec VP9 Surface output and retirement
Add a bounded VP9 decoder owner using the existing MediaCodec session and Android image queue. Match visible and repeated output by local timestamps, discard late hidden or dropped images, and retire codec resources only after leased images return. Cover input backpressure, EOS, startup faults and deferred release. Include the owner in native Android signature/link checks and update the optional-extension fixture for Linux PRIME and XR.
2026-10-22 07:44:24 +02:00
Codex 63f30c9569 media: preserve VP9 repeat packets for opaque decoders
Add an explicit packet-decoder factory mode so opaque codecs receive show-existing packets without committing new DPB state. Retain output-only repeats for surface backends. Cover hidden references, repeat backpressure and cancellation, WebM superframe/lacing dispatch and output surviving close.
2026-10-22 07:25:52 +02:00
Codex a153d185ff test: compare real VA imports through Vulkan conversion
Extend the explicit native modifier gate through production submission, fence retirement and RGBA readback against an independent SDR reference. Restore claimed exports after GPU retirement to retain the parser-close lifetime checks. Exercise the new readback oracle with synthetic Vulkan planes in host CI and reject corrupted reference pixels; native VA device acceptance remains separate.
2026-10-22 07:17:04 +02:00
Codex 6e1b2318c8 test: import real VA exports on the matching Vulkan device
Add an explicit Linux modifier allocation gate to the native decode oracle. Require reported render-node identity, import both planes through production helpers, and retire each import before returning its VA claim, including retained outputs after parser close. Keep GPU sampling and pixel acceptance separate from allocation success.
2026-10-22 07:17:04 +02:00
Codex 4874c400c7 test: cover real weighted WPP HEVC streams in VA acceptance
Add four reproducible Main8/Main10 full/limited weighted-B streams with multi-row WPP and independent FFmpeg CRCs. Preserve the reference range explicitly and exercise every picture through software decode and NORMAL subset submission.

Extend the required-device oracle to 192 pictures and verify WPP entries in NORMAL mode. Native hardware success remains unexecuted without a DRM render node.
2026-10-22 07:17:04 +02:00
Codex b9198c8886 test: add required-device VA HEVC decode and export oracle
Build a Linux native oracle against the production decoder owner. Require hardware admission, compare display-order NV12/P010 output to the existing FFmpeg fixture CRCs, retain an exported surface after source close, and check FD retirement across reopened sequences.

Keep CPU image transfer and bounded polling inside the test executable. Independently validate cropped/padded image checksums and reject unavailable devices or assertions-disabled acceptance builds. The hardware success path remains unexecuted on this host without a DRM render node.
2026-10-22 07:17:04 +02:00
Codex 9d12250174 vaapi: connect NORMAL HEVC decoding to the native owner
Select NORMAL when advertised or when the API default applies, retaining BASE-only support. Preallocate both packet workspaces on the cold owner and release the parser borrow at decoder detach before deferred native retirement.

Exercise both pool modes, parsed owner decode and held exports after parser destruction, four allocation failures and partial-context termination retry. Share parser objects across the host fixtures, with separate TSan instrumentation.
2026-10-22 07:17:03 +02:00
Codex bfff7f90df vaapi: pack NORMAL HEVC slices and own WPP subset buffers
Pack escaped NALs and coded entry offsets into a preallocated owner workspace after validating every header and extent. Extend native submission to retain a fifth subset buffer through failure, completion and retirement.

Exercise Main8/Main10 I/P/B WPP packets, parsed sequence submission and all five buffer failures under sanitizers and strict C89 builds. Shipping pool/owner selection remains separate work.
2026-10-22 07:17:03 +02:00
Codex 42b32da45e vaapi: map parsed HEVC long-slice parameters
Map coded short- and long-term reference order, list modifications and effective prediction weights into VA long-slice metadata. Preserve output on refusal and account for escaped header bytes without allocation or native operations.

Exercise independent boundary/refusal cases and 64 parsed Main8/Main10 I/P/B pictures. NORMAL packet packing and native owner integration remain separate work.
2026-10-22 07:17:03 +02:00
Codex 87224b14b4 rh265: expose parsed long-slice metadata
Publish slice flags, reference-list modifications, effective prediction weights and WPP entry lengths without pixel or DPB advancement. Keep output storage separate from existing access-unit state and exercise the query through the byte-exact decode oracle.
2026-10-22 07:17:03 +02:00
Codex 90c70f94fc video: register the VA HEVC fallback factory
Keep a stable offer with atomic DRM identity and renderer epochs. Resolve the actual render node through libdrm, preserve Vulkan Video preference, and transfer closed or partially opened owners to bounded cold retirement workers. Refuse admission without threads or lock-free atomics.
2026-10-22 07:17:03 +02:00
Codex 61db8ae149 video: preserve track HDR metadata in VA imports
Accept the supported YUV flag bits, carry container HDR metadata into conversion, and allow track-visible dimensions within the decoded surface. Preserve specified coded color while using track metadata for unspecified values and light levels.
2026-10-22 07:17:03 +02:00
Codex b75a7f373c video: own cold VA session setup and deferred cleanup
Keep the runtime, native pool, packet workspace and decoder adapter under one owner. Preserve partial setup failures and renderer-held exports, poll pending work once per retirement pass, and retain libraries and context through termination retries. Registration and executor policy remain with the factory.
2026-10-22 07:17:03 +02:00
Codex fdd27c04ce video: adapt VA HEVC pool completion to opaque frame leases
Connect parsed-picture submission and bounded completion polling to opaque output carriers. Keep crop/color metadata immutable and detach without freeing renderer-held frames; the decoder owner retries native returns before retiring the adapter. The native pool, session and runtime stay explicitly borrowed.
2026-10-22 07:17:03 +02:00
Codex d4932e8f25 video: connect optional VA cache to Vulkan renderer lifetime
Detect Linux HEVC/PRIME2 headers without a link-time VA dependency. Route opaque leases through the existing queue callbacks, poll returns on renderer ticks, and retain failed source/destination use through exact-device retirement. Cover native resolution and adapter transport with portable typed fixtures.
2026-10-22 07:17:02 +02:00
Codex 3eff27b52c video: own bounded VA Vulkan cache and deferred retirement
Reuse immutable imported-image identities with the opaque lease bridge and owned conversion resources. Poll completion during paused ticks, retain uncertain submissions through exact-device teardown, and retry failed owner returns. Cover reuse, eviction, allocation failures and retirement with portable fixtures.
2026-10-22 07:17:02 +02:00
Codex 28221097e0 style: follow project conventions in recent VA migration code
Use Allman braces, three-space indentation, separate statements and readable alignment. Initialize fixed Vulkan resource, barrier and submission structs through explicit member stores while retaining clearing for project-owned state.
2026-10-22 07:17:02 +02:00
Codex de28925f7b vulkan: own cold VA conversion resources
Create bounded sampler, descriptor, pipeline, command and fence resources for persistent VA conversion entries. Unwind partial creation in dependency order and preserve exact-device teardown. Exercise the production owner in the native pixel oracle across all 32 slots.
2026-10-22 07:17:02 +02:00
Codex 60834a9628 vulkan: bridge opaque VA leases through conversion fence retirement
Borrow completed exports for cold import preparation, then claim and adopt matching opaque frames for warm conversion. Restore refused submissions and publish completed exports to decoder collection without native calls on the renderer. Retain uncertain submissions and failed returns through exact-device teardown.
2026-10-22 07:17:02 +02:00
Codex 0a69266bc2 vulkan: reuse imported VA images across returned frame leases
Capture unique DMA-BUF identities on the decoder owner. Return completed export tickets independently of cached imports, and re-adopt only matching buffers and layouts without renderer-side native calls. Require per-picture submission reconfiguration and retain pending or uncertain GPU ownership.
2026-10-22 07:17:02 +02:00
Codex 2fd1326943 tests: stub software fallback in GPU format transport fixture
Keep the format-only harness independent of the player worker while satisfying callback references retained by the MinGW linker. Count either fallback call as a test failure.
2026-10-22 07:17:02 +02:00
Codex 22de713719 video: carry VA exports through opaque owner-return leases
Publish completed exports through the existing internal hardware-frame callback contract. Bounded lock-free claim/take/restore/return states retain tickets through GPU use; only the decoder owner collects and closes returned exports. Add stale/abandonment and 10000 SPSC handoff tests with an isolated TSan target; refuse unsupported atomics without changing frame ABI.
2026-10-22 07:17:02 +02:00
Codex 0beecd021c vulkan: execute VA conversion submission pixel oracle
Exercise real exportable plane images, foreign ownership, destination layouts and fences through the production command helper under Vulkan validation. Compare cropped 8/10-bit SDR and PQ/HLG RGBA8/FP16 pixels with independent references. This proves conversion commands, not native VA DMA-BUF decode/import.
2026-10-22 07:17:02 +02:00
Codex 3ad02e2935 vulkan: record warm VA plane conversion submissions
Use borrowed sampled-YUV pipeline resources and immutable crop/color uniforms. Preserve source foreign ownership, tracked destination layout and existing queue serialization. Busy or stale entries submit nothing; uncertain GPU submission retains the source through device retirement.
2026-10-22 07:17:01 +02:00
Codex 3076c7e936 vulkan: retain VA export tickets through imported frame use
Move a VA export only after both sampled layer imports succeed. Record paired foreign-queue barriers and retain resources across pending or failed renderer fences. Retire Vulkan resources before returning the owned export through the decoder-owner handoff; device-destruction recovery makes no invalid Vulkan calls.
2026-10-22 07:17:01 +02:00
Codex b97e28a05b vulkan: own DRM modifier image imports and memory
Create explicit sampled images, validate FD size and image/FD memory-type intersections, then import CLOEXEC duplicates and bind memory planes. Honor dedicated requirements and unwind view, image, memory and unconsumed FDs on refusal. This remains private resource-cache groundwork; producer completion, foreign ownership and VA ticket retirement are separate admission gates.
2026-10-22 07:17:01 +02:00
Codex 9eb993f011 vulkan: preflight exported VA layer formats and modifiers
Query sampled DRM modifier planes and external DMA-BUF image limits before taking FDs. Admit both NV12/P010 layers atomically and reject dedicated-only disjoint imports. This prepares the private VA importer; no renderer capability or decoder registration is enabled.
2026-10-22 07:17:01 +02:00
Codex d247c3b353 vulkan: negotiate optional PRIME device prerequisites
Enable the complete DMA-BUF/modifier/foreign-queue bundle only on frontend-owned flat Linux devices with a render identity and compatible API dependencies. Keep core and XR device requests unchanged, preserve the actual enabled state across cache reuse, and do not advertise surface import support. On creation refusal, retry without PRIME using a copied enable list while retaining video queues/features. Validate version/missing-extension gates, candidate fallback, local Vulkan playback/validation, native ABI checks and Android root links.
2026-10-22 07:17:01 +02:00
Codex be479b7b6e vulkan: cache the selected GPU render-node identity
Query advertised DRM properties during device initialization and expose bounded render-node major/minor metadata through the internal device handoff. Retain the actual instance API/properties2 capability through cached-instance reuse and refuse queries for an unverified instance. Device reads copy cached metadata without queries on playback paths. Validate fault gates, native context/cache lifecycle, builtin media Vulkan playback, legacy syntax, Android roots and production stack budgets. This does not advertise PRIME import support or activate VA decoding.
2026-10-22 07:17:01 +02:00
Codex 727936f331 video: own VA PRIME exports through surface retirement
Retain completed pool tickets while importing or using exported PRIME objects. Validate bounded NV12/P010 descriptors, preserve modifiers and auxiliary planes, seal FDs close-on-exec and transfer each FD only once. Close partial exports without duplicate FD closes, including descriptor zero. Bind the real export API and test metadata/fault ownership on Linux and Windows; hardware export and renderer import remain unvalidated.
2026-10-22 07:17:01 +02:00
Codex 631d770472 video: retain VA surfaces across reads and exported frames
Track bounded in-flight submissions separately from shared DPB selection. Prevent surface reuse while a write, later GPU reader or exported incarnation retains it; validate reference picture identity and decode serials. Preserve ticket generations across cold reset, allow exactly one frame ticket per incarnation and retain broken owners until display termination. Exercise real parsed batches, delayed/out-of-order completion, stale returns, cleanup retries and failure recovery on Linux and Windows.
2026-10-22 07:17:01 +02:00
Codex 54909c62d6 video: pack parsed HEVC pictures for VA short submission
Build BASE-mode start-code slice buffers with escaped payloads and aligned zero padding using preallocated storage. Connect native picture/matrix translation and bounded submission without advancing the shared DPB until acceptance. Refuse unsupported modes, malformed metadata, overlapping storage and capacity failures before writing output. Roundtrip 64 real Main/Main10 I/P/B packets and exercise failure boundaries on Linux and Windows; native VA pixels remain untested.
2026-10-22 07:17:00 +02:00
Codex 89a310a69a video: retain VA decode submissions through completion
Keep bounded picture, matrix, slice and data buffers until zero-timeout surface synchronization completes. Refuse reuse while pending, retain failed destruction for retry and poison uncertain native failures until display termination. Bind the six native submission entrypoints and preserve explicit short/long slice mode. Exercise both modes and depths, partial creation, duplicate IDs, native failure, polling and retirement on Linux and Windows.
2026-10-22 07:17:00 +02:00
Codex b0c79b4b01 video: own the VA-API DRM runtime lifecycle
Bind the actual VA/DRM ABI, validate the renderer node identity, and retain display, libraries and FD until termination succeeds. Once termination starts, retry only vaTerminate because a failed call may already unload its driver. Exercise partial initialization and teardown on Linux and Windows; verify real library binding and rejected Linux devices without claiming hardware decode.
2026-10-22 07:17:00 +02:00
Codex 389516d408 video: own VA-API HEVC context admission and retirement
Validate the requested profile, decode entrypoint, slice mode and surface format before creating a bounded context. Preserve partial native ownership across setup errors and retry failed destruction in dependency order. A closing owner can release remaining IDs only after successful display termination. Verify the real SDK function signatures and exercise allocation, creation and retirement faults without registering a decoder backend.
2026-10-22 07:17:00 +02:00
Codex b9d5dd0460 video: map prepared HEVC pictures to VA-API parameter buffers
Translate shared HEVC picture/reference metadata and effective raster scaling lists to the native libva ABI without allocating or taking a frame lease. Track slice types across the access unit so mixed-slice pictures set NoBiPredFlag correctly. Cover parsed Main/Main10 I/P/B streams and invalid reference/surface descriptions. This is buffer preparation only; no VA backend is registered.
2026-10-22 07:17:00 +02:00
Codex 29f05b9f4a mp4: keep software decoding after hardware admission fails
Clear the hardware preference when H.264 or HEVC admission fails. A later rewind must not silently enable hardware after the player selected its software sink; an explicit admission request can retry. Cover refusal followed by rewinds and an explicit retry.
2026-10-22 07:17:00 +02:00
Codex 026ec76bde player: schedule cold hardware admission on the decoder worker
Queue initial hardware admission before starting the sink, reusing its job block for normal decoding. Preserve polling-thread sink callbacks and stream ownership through queued or running cancellation. Keep inline frame decoding and the no-thread path, and only query existing hardware when the worker is unavailable.
2026-10-22 07:17:00 +02:00
Codex 9b12d82ef5 media: complete HEVC drain without losing delayed Surface frames
Invoke the backend drain hook even when no parser display slots remain. Report confirmed missing codec output at EOS instead of waiting indefinitely, while retaining BUSY for a rendered Surface image that has not arrived yet. Preserve pressure-only output handling and make drain failures sticky.
2026-10-22 07:17:00 +02:00
Codex 5ccfb36f1d media: guard Android decoder admission across driver replacement
Keep registry offers and decoder configuration stable while a generation gate controls new sessions. Reject and asynchronously close opens that overlap withdrawal or replacement. Existing sessions retain their callbacks; stale owners cannot withdraw a replacement. Stop admission permanently before generation reuse.
2026-10-22 07:17:00 +02:00
Codex a43188f642 media: retire Android decoders without caller locks or joins
Publish retirement through an eventcount to a detached worker. Keep publisher and worker references until notification and cleanup both finish, including failed startup. Exercise delayed workers and notifier lifetime under sanitizers and provide a no-native-fence host mode for the Windows lifecycle fixture.
2026-10-22 07:16:59 +02:00
Codex 8bff865216 media: preserve container HDR metadata in Android imports
Resolve container mastering and light levels against the native frame before cache lookup and submission. Inherit unspecified fields and reject explicit CICP or range conflicts without consuming the lease.
2026-10-22 07:16:59 +02:00
Codex 344648123e player: recover in software when the first hardware frame is refused
Quiesce queued decode work and restart on its exclusive owner before initializing the software sink. Preserve the movie clock and prevent reselection of the failing backend. Keep inline queued frame ownership until sink release. Hardware-only codecs still require an available software decoder to recover.

Validate startup, decode and import refusal; bounded restart, failed/canceled recovery, held slots and old exported leases. GCC/Clang sanitizers, TSan, native MinGW thread/no-thread tests, C89 application link, MSVC6 stand-in, stack checks and expanded NDK root/player links pass. Environment-dependent compile-matrix skips remain unverified.
2026-10-22 07:16:59 +02:00
Codex e411036f18 media: add bounded Android HEVC backend lifecycle and native link checks
Compose the Surface decoder and opaque frame exporter with pre-created cold retirement workers. Bound admission across live and retiring sessions, preserve old leases across seek epochs, and roll back JNI/native/thread startup failures. Registration remains disabled pending native playback acceptance.

Scope C89 static-inline compatibility to the Android native-window SDK header. NDK r29 otherwise emits duplicate ANativeWindow_clearFrameRate definitions and an unused newer-API dependency under GNU89 inline semantics. Validate helper and shipping renderer/context objects together with relocatable links.

Validation: GCC/Clang C89 ASan+UBSan and TSan lifecycle tests; held real exporter lease; native/thread/detach failure injection; 136 NDK individual compiles, eight unity builds, sixteen shipping root compiles and eight relocatable links. Actual Android playback is not executed.
2026-10-22 07:16:59 +02:00
Codex 010683ca31 vulkan: integrate Android frame imports with renderer cache and staged teardown
Recognize opaque Android leases before raw VkImage interpretation, validate source geometry and color, prepare immutable per-buffer conversion resources on first use, and route submissions through the existing queue lock. Preserve the previous destination on busy or failed conversion.

Destroy deferred Vulkan children before vkDestroyDevice as required by VUID-vkDestroyDevice-device-05137, while retaining external AImage leases until device destruction returns. Transfer dedicated command-pool and deferred destination ownership with the cache. Decoder registration remains disabled pending native Android validation.

Validation: GCC/Clang C89 ASan/UBSan component and shipping-helper tests; eight real NDK renderer/context/unity configurations; GCC/Clang non-Android shipping renderer/context compilation. Native Android playback is not yet executed.
2026-10-22 07:16:59 +02:00
Codex 0dfc3b8124 vulkan: retire deferred Android image caches after actual device destruction 2026-10-22 07:16:59 +02:00
Codex b1bf9ee6b1 samples: verify Android cache holds failed submissions until device destruction 2026-10-22 07:16:59 +02:00
Codex 8cd312ba2f vulkan: route Android imports through renderer queue submission callback 2026-10-22 07:16:58 +02:00
Codex 3ae1b5ad3b vulkan: negotiate Android import features only on frontend-owned devices 2026-10-22 07:16:58 +02:00
Codex 746b5d3db2 media: prefix Android helpers and validate native unity compilation 2026-10-22 07:16:58 +02:00
Codex dbcd658b9c media: retain Android decoder owner until import context retires 2026-10-22 07:16:58 +02:00
Codex 94b995efc7 video: bound Android Vulkan import cache and evict only retired entries 2026-10-22 07:16:58 +02:00
Codex 720fbf5056 video: create and retire cold Android Vulkan import entries 2026-10-22 07:16:58 +02:00
Codex e0ca7b3b0d video: submit warm Android image conversions through GPU fence retirement 2026-10-22 07:16:58 +02:00
Codex 202ec8e8f6 video: scope Android image ownership barriers to compute or fragment reads 2026-10-22 07:16:58 +02:00
Codex 26069ee954 media: export HEVC Android image leases with verified color metadata 2026-10-22 07:16:58 +02:00
Codex 2bc182435e video: retain Android image tickets through opaque renderer frame leases 2026-10-22 07:16:57 +02:00
Codex a83d3c997a test: execute external RGB shader crop and HDR pixel oracle 2026-10-22 07:16:57 +02:00
Codex ac2eb32e7a video: build immutable external-sampler compute pipeline resources 2026-10-22 07:16:57 +02:00
Codex a0d7749922 video: convert external sampler RGB through the shared HDR shader 2026-10-22 07:16:57 +02:00
Codex fa43677c9a video: record Android foreign image acquire and release barriers 2026-10-22 07:16:57 +02:00
Codex 83579a04d8 media: validate native Android buffer allocation before GPU import 2026-10-22 07:16:57 +02:00
Codex ff1ceafe1d video: transfer Android readiness and completion through Vulkan sync fds 2026-10-22 07:16:57 +02:00
Codex b77d37a65d video: import Android Vulkan external image resources with dedicated memory 2026-10-22 07:16:57 +02:00
Codex 954539d87e media: return Android pictures excluded from display immediately 2026-10-22 07:16:57 +02:00
Codex 275eafab01 test: cover Android HEVC startup refusal and malformed timestamps 2026-10-22 07:16:57 +02:00
Codex b3789ce352 test: keep the Android HEVC fixture whitespace clean 2026-10-22 07:16:57 +02:00
Codex f8444c1d98 media: own HEVC Surface decoding through Android image retirement 2026-10-22 07:16:57 +02:00
Codex 256a5f48f9 media: expose image retirement before stopping the Android codec 2026-10-22 07:16:56 +02:00
Codex 82be334b42 h265: let asynchronous hardware backends submit explicit EOF 2026-10-22 07:16:56 +02:00
Codex e81d767dae media: validate Android native ABI with the pinned NDK
Scope the modern native_window.h inline spelling to its SDK includes for strict C89. Compare every loaded media function pointer with its SDK declaration without introducing direct symbol references. Cover both Android file-offset ABIs in cross-compile CI.

All 40 actual NDK r29 combinations pass locally: ARM32/64, API 21/29, five sources and default/64-bit offsets. Undefined-symbol inspection confirms no newer media APIs became mandatory load dependencies. Decoder/GPU/device acceptance remains pending.
2026-10-22 07:16:56 +02:00
Codex 6aa0e45313 test: roundtrip real HEVC parser output through Android packet packing
Generate Main/Main10 test samples with test-only libx265, feed packed parameter sets through rh265, verify retained bytes and access-unit metadata, and roundtrip every escaped VCL NAL through Annex-B packing. Exercise the shipping parser under GCC/Clang C89 ASan/UBSan.
2026-10-22 07:16:56 +02:00
Codex 11e76e7abf media: pack validated HEVC NALs for Android Surface decoding
Construct Annex-B VPS/SPS/PPS csd-0 and complete VCL access units from existing rh265 parser views. Preserve escaped bytes, validate type/temporal consistency and exact coded sizes, bound staging needs, and reject overlapping input before modifying output. No allocation or decoder capability activation.

GCC and Clang C89 ASan/UBSan tests cover exact lengths, emulation-prevention bytes, insufficient storage, mismatched units and alias refusal. Actual native MediaCodec decode and GPU import remain pending.
2026-10-22 07:16:56 +02:00
Codex 4f39c8a27a media: add runtime MediaCodec Surface decoder session
Create only an explicitly admitted hardware component and verify its actual name. Configure bounded codec-specific CSD and whole access-unit input, use zero-timeout input/output dequeue, track output format/crop/color without invented metadata, and deliver Surface buffers with explicit presentation timestamps. Teardown belongs to the decoder worker after GPU image retirement.

GCC/Clang C89 ASan/UBSan stand-in tests cover missing symbols, partial creation, identity mismatch, input backpressure/overflow, format changes, EOS and sticky failures. Actual NDK compilation, native decoding and renderer integration remain pending.
2026-10-22 07:16:56 +02:00
Codex 42f0cc2075 media: retain Android reader images through GPU fence retirement
Add bounded cold image ownership and runtime-loaded AImageReader PRIVATE/GPU-sampled output. Keep native images, reader and media library alive through renderer leases; perform only zero-timeout fence polls and native image destruction on the worker. Renderer returns transfer a completion fence without allocation or native image calls.

GCC/Clang C89 ASan/UBSan tests cover delayed ready/done fences, stale tickets, malformed metadata, missing symbols and partial startup. A 10000-handoff worker/render test passes ThreadSanitizer. Actual NDK compilation and Android decoder/GPU integration remain pending.
2026-10-22 07:16:56 +02:00
Codex 5c2db2becf media: add cold Android hardware codec inventory admission
Query explicit API 29 hardware identity, direction, aliases and profile/size support through bounded JNI local frames. Reject unknown/software/contradictory identities and preserve caller exceptions. No decoder or renderer capability is enabled.

Exercise real JNI with synthetic Android codec classes, vendor/metadata faults and 10000 local-frame iterations under GCC/Clang C89 and UBSan. Add actual NDK 32/64-bit API 21/29 cross-compile gates; native device/session/import acceptance remains pending.
2026-10-22 07:16:56 +02:00
6830 changed files with 459305 additions and 358281 deletions

No files matched your search

+1 -17
View File
@@ -3,23 +3,7 @@ name: CI 3DS
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/3DS.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/3DS.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-devkitpro:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: taiki-e/checkout-action@v1
+236 -41
View File
@@ -3,19 +3,7 @@ name: CI Android
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Android.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Android.yml'
# ci_paths: end
workflow_dispatch:
repository_dispatch:
types: [run_build]
@@ -69,14 +57,6 @@ jobs:
done
find . -iname "*.apk" -exec ls -l "{}" \;
- name: Verify 64-bit APK alignment
run: |
set -eu
for apk in pkg/android/phoenix/build/outputs/apk/{aarch64,quest}/debug/*.apk; do
python3 tools/android_elf_alignment.py "$apk"
"$ANDROID_HOME/build-tools/36.0.0/zipalign" -c -P 16 4 "$apk"
done
- name: Get short SHA
id: slug
run: echo "::set-output name=sha8::$(echo ${GITHUB_SHA} | cut -c1-8)"
@@ -107,12 +87,17 @@ jobs:
bin="$MEDIA_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin"
unity="$RUNNER_TEMP/android-record-unity.c"
: > "$unity"
for source in gfx/common/mediacodec_inventory.c record/record_mediacodec_encoder.c \
for source in record/record_audio_tap.c record/drivers/record_mediacodec.c gfx/common/mediacodec_inventory.c record/record_mediacodec_encoder.c \
record/record_mux_mediacodec.c record/record_mediacodec_worker.c \
record/record_mediacodec_surface.c record/record_android_capture_images.c \
record/record_android_capture_submit.c record/record_android_capture_gl.c \
record/record_android_capture_submit.c record/record_android_capture_pipe.c \
record/record_android_capture_pool.c record/record_android_capture_device.c record/record_android_capture_request.c record/record_android_capture_config.c record/record_android_capture_ops.c \
record/record_android_capture_egl.c \
record/record_android_capture_gl.c \
record/record_android_capture_draw.c record/record_mediacodec_gpu_worker.c \
record/record_mediacodec_file.c record/record_gpu_queue.c \
record/record_mediacodec_file.c record/record_session_mediacodec.c \
record/record_dispatch_mediacodec.c record/record_gpu_dispatch_mediacodec.c \
record/record_gpu_queue.c \
record/record_audio_queue.c libretro-common/queues/retro_spsc.c; do
printf '#include "%s/%s"\n' "$PWD" "$source" >> "$unity"
done
@@ -123,11 +108,12 @@ jobs:
if [ "$offset" = 64 ]; then extra="-D_FILE_OFFSET_BITS=64"; fi
CC="$bin/$target$api-clang $extra" python3 libretro-common/samples/formats/vp9/check_stack.py
"$bin/$target$api-clang" $extra -O1 -std=c89 -pedantic -Wall -Wextra -Werror \
-Wno-long-long -Wno-c99-extensions -Wno-c11-extensions -Wframe-larger-than=2048 \
-Wno-long-long -Wno-c99-extensions -Wframe-larger-than=2048 \
-DANDROID -DHAVE_VULKAN -DHAVE_RECORD_MEDIACODEC -DHAVE_CONFIGFILE \
-DHAVE_THREADS -DHAVE_DYLIB -Ilibretro-common/include -Igfx/include \
-c "$unity" -o "$RUNNER_TEMP/record-$target-$api-$offset.o"
if "$bin/llvm-nm" -u "$RUNNER_TEMP/record-$target-$api-$offset.o" | \
grep -Eq ' U (AMedia|ANativeWindow|AHardwareBuffer|egl|gl[A-Z]|record_android_capture_|record_mediacodec_|record_mux_mediacodec_|record_audio_queue_|record_gpu_queue_|retro_spsc_|mediacodec_inventory_)'; then
grep -Eq ' U (AMedia|ANativeWindow|AHardwareBuffer|egl|gl[A-Z]|record_android_capture_|record_mediacodec_|record_session_mediacodec_|record_dispatch_mediacodec_|record_gpu_dispatch_mediacodec_|record_mux_mediacodec_|record_audio_tap_|record_audio_queue_|record_gpu_queue_|retro_spsc_|mediacodec_inventory_)'; then
echo "Unresolved Android recording dependency"
exit 1
fi
@@ -136,7 +122,7 @@ jobs:
vulkan_android_image vulkan_android_pipeline vulkan_android_sync \
vulkan_android_submit vulkan_android_cache_entry vulkan_android_cache vulkan_android_queue; do
"$bin/$target$api-clang" $extra -O1 -std=c89 -pedantic -Wall -Wextra -Werror \
-Wno-long-long -Wno-c99-extensions -Wno-c11-extensions -Wframe-larger-than=2048 \
-Wno-long-long -Wno-c99-extensions -Wframe-larger-than=2048 \
-DHAVE_THREADS -DHAVE_DYLIB -Ilibretro-common/include -Igfx/include \
-c "gfx/common/$source.c" -o "$RUNNER_TEMP/$source-$target-$api-$offset.o"
done
@@ -144,21 +130,6 @@ jobs:
done
done
- name: Link media-enabled Android unity frontend
run: |
set -eu
features="-DHAVE_RAAC -DHAVE_RMP4 -DHAVE_RWEBM -DHAVE_RVP9 -DHAVE_RAV1 -DHAVE_RVORBIS -DHAVE_ROPUS"
"$MEDIA_NDK/ndk-build" -j2 \
NDK_PROJECT_PATH=. \
APP_BUILD_SCRIPT=pkg/android/phoenix-common/jni/Android.mk \
NDK_APPLICATION_MK=pkg/android/phoenix-common/jni/Application.mk \
NDK_OUT="$RUNNER_TEMP/android-media-obj" \
NDK_LIBS_OUT="$RUNNER_TEMP/android-media-libs" \
TARGET_ABIS=arm64-v8a APP_ABI=arm64-v8a \
GLES=3 NDK_GL_HEADER_VER=android-29 APP_PLATFORM=android-29 \
APP_CFLAGS="$features" APP_CPPFLAGS="$features"
test -s "$RUNNER_TEMP/android-media-libs/arm64-v8a/libretroarch-activity.so"
codec-inventory:
runs-on: ubuntu-latest
strategy:
@@ -243,3 +214,227 @@ jobs:
run: make -C samples/gfx/mediacodec_session vulkan-gpu-check CC=${{ matrix.cc }} SANITIZER=
- name: GLES recording SDR PQ and scRGB pixel oracle
run: EGL_PLATFORM=surfaceless LIBGL_ALWAYS_SOFTWARE=1 CC=${{ matrix.cc }} python3 samples/record/mediacodec_encode/draw_pixels.py
jni-contract:
runs-on: ubuntu-latest
strategy:
matrix:
cc: [gcc, clang]
env:
APT_PKGS: libvulkan-dev mesa-vulkan-drivers ffmpeg
steps:
- uses: actions/checkout@v6
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install test dependencies
timeout-minutes: 20
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- uses: actions/setup-java@v4
with:
distribution: temurin
java-version: '21'
- name: Native decoder session failure and Surface timestamp contracts
run: make -C samples/gfx/mediacodec_session clean all check CC=${{ matrix.cc }} SANITIZER=address,undefined
- name: Hardware startup, first-frame refusal and software playback recovery
run: |
for threads in 0 1; do
make -C libretro-common/samples/formats/video_player clean all CC=${{ matrix.cc }} THREADS="$threads" SANITIZER=address,undefined
libretro-common/samples/formats/video_player/video_player_test
done
- name: HEVC drain and software output after hardware admission refusal
run: |
make -C samples/gfx/d3d11_video_decode rh265_hw_stream_test hevc_color_stream_test CC=${{ matrix.cc }} SANITIZER=address,undefined
(cd samples/gfx/d3d11_video_decode && ./rh265_hw_stream_test && ./hevc_color_stream_test)
- name: Execute RGB shader crop and SDR PQ HLG pixel oracle on Vulkan software device
run: make -C samples/gfx/mediacodec_session gpu-check CC=${{ matrix.cc }} SANITIZER=
- name: HEVC Annex-B configuration and packet preservation
run: make -C samples/gfx/mediacodec_hevc_packet clean all check parser-check CC=${{ matrix.cc }} SANITIZER=address,undefined
ndk-compile:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- name: Use the Android project NDK version
run: |
set -eu
version=$(sed -n 's/.*ndkVersion "\([^"]*\)".*/\1/p' pkg/android/phoenix/build.gradle)
test -n "$version"
"$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager" "ndk;$version"
echo "MEDIA_NDK=$ANDROID_HOME/ndk/$version" >> "$GITHUB_ENV"
- name: Strict C89, SDK function signatures and Android file-offset ABIs
run: |
set -euo pipefail
bin="$MEDIA_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin"
sources=(mediacodec_inventory android_image_queue android_image_ndk android_frame mediacodec_session mediacodec_color mediacodec_frame_export mediacodec_hevc_packet mediacodec_hevc_decoder mediacodec_hevc_backend mediacodec_vp9_decoder mediacodec_vp9_backend mediacodec_av1_decoder mediacodec_av1_backend vulkan_android_image vulkan_android_sync vulkan_android_pipeline vulkan_android_submit vulkan_android_queue vulkan_android_cache_entry vulkan_android_cache vulkan_android_device)
unity="$RUNNER_TEMP/android-media-unity.c"
printf '#include "%s/gfx/common/mediacodec_hevc_registry.h"\n' "$PWD" > "$unity"
printf '#include "%s/gfx/common/mediacodec_vp9_registry.h"\n' "$PWD" >> "$unity"
printf '#include "%s/gfx/common/mediacodec_av1_registry.h"\n' "$PWD" >> "$unity"
printf '#ifndef MEDIACODEC_HEVC_REGISTRY\n#error registry atomics unavailable\n#endif\n' >> "$unity"
for source in "${sources[@]}"; do
printf '#include "%s/gfx/common/%s.c"\n' "$PWD" "$source" >> "$unity"
done
printf '#include "%s/record/record_mediacodec_encoder.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_mux_mediacodec.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_mediacodec_worker.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_mediacodec_surface.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_audio_tap.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/drivers/record_mediacodec.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_images.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_submit.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_pipe.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_config.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_request.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_device.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_pool.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_ops.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_egl.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_gl.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_android_capture_draw.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_mediacodec_gpu_worker.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_mediacodec_file.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_session_mediacodec.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_dispatch_mediacodec.c"\n' "$PWD" >> "$unity"
printf '#include "%s/record/record_gpu_dispatch_mediacodec.c"\n' "$PWD" >> "$unity"
for target in aarch64-linux-android armv7a-linux-androideabi; do
for api in 21 29; do
for offset in default 64; do
extra=()
if [ "$offset" = 64 ]; then extra=(-D_FILE_OFFSET_BITS=64); fi
for source in "${sources[@]}"; do
object="$RUNNER_TEMP/$source-$target-$api-$offset.o"
"$bin/$target$api-clang" \
-std=c89 -pedantic -Wall -Wextra -Werror -Wno-long-long -Wno-c99-extensions \
-DHAVE_THREADS -DHAVE_DYLIB -Wframe-larger-than=2048 -Ilibretro-common/include -Igfx/include \
"${extra[@]}" -c "gfx/common/$source.c" -o "$object"
if "$bin/llvm-nm" -u "$object" | grep -Eq ' U (AMedia|AImage|AHardwareBuffer|ANativeWindow_setFrameRateWithChangeStrategy)'; then
echo "Unexpected direct media API dependency: $object"
exit 1
fi
done
for record_source in record_audio_tap record_mediacodec_encoder record_mux_mediacodec record_mediacodec_worker record_mediacodec_surface record_android_capture_images record_android_capture_submit record_android_capture_pipe record_android_capture_pool record_android_capture_device record_android_capture_request record_android_capture_config record_android_capture_gl record_android_capture_draw record_mediacodec_gpu_worker record_mediacodec_file record_session_mediacodec record_dispatch_mediacodec record_gpu_dispatch_mediacodec record_gpu_queue record_audio_queue; do
"$bin/$target$api-clang" \
-std=c89 -pedantic -Wall -Wextra -Werror -Wno-long-long -Wno-c99-extensions \
-DHAVE_THREADS -DHAVE_DYLIB -Wframe-larger-than=2048 -Ilibretro-common/include -Igfx/include \
"${extra[@]}" -c "record/$record_source.c" \
-o "$RUNNER_TEMP/$record_source-$target-$api-$offset.o"
done
"$bin/$target$api-clang" \
-std=c89 -pedantic -Wall -Wextra -Werror -Wno-long-long -Wno-c99-extensions \
-DANDROID -DHAVE_VULKAN -DHAVE_RECORD_MEDIACODEC -DHAVE_CONFIGFILE \
-DHAVE_THREADS -DHAVE_DYLIB -Wframe-larger-than=2048 -Ilibretro-common/include -Igfx/include \
"${extra[@]}" -c "$unity" -o "$RUNNER_TEMP/unity-$target-$api-$offset.o"
"$bin/$target$api-clang" \
-std=c89 -pedantic -Wall -Wextra -Werror -Wno-long-long -Wno-c99-extensions \
-DANDROID -DHAVE_VULKAN -DHAVE_RECORD_MEDIACODEC -DHAVE_CONFIGFILE \
-DHAVE_WEBMPLAYER -DHAVE_THREADS -DHAVE_DYLIB -Wframe-larger-than=2048 \
-Ilibretro-common/include -Igfx/include "${extra[@]}" \
-c record/drivers/record_mediacodec.c \
-o "$RUNNER_TEMP/record-history-$target-$api-$offset.o"
for root_source in gfx/common/vulkan_common.c gfx/drivers/vulkan.c gfx/gfx_surface_player.c libretro-common/jni/rjni.c; do
"$bin/$target$api-clang" \
-DANDROID -DHAVE_MENU -DHAVE_GFX_WIDGETS \
-DHAVE_VULKAN -DHAVE_RMP4 -DHAVE_RVP9 -DHAVE_RAV1 -DHAVE_DYLIB -DHAVE_THREADS \
-Dinline=__inline__ -O1 -std=c89 \
-Werror=declaration-after-statement -Werror=frame-larger-than -Wframe-larger-than=4096 \
-I. -Ilibretro-common/include -Igfx/include "${extra[@]}" \
-c "$root_source" -o "$RUNNER_TEMP/$(basename "$root_source")-$target-$api-$offset.o"
done
for variant in vp9-only av1-only no-codecs recording-only; do
codec_flags=()
case "$variant" in
vp9-only) codec_flags=(-DHAVE_RVP9 -DHAVE_THREADS) ;;
av1-only) codec_flags=(-DHAVE_RAV1 -DHAVE_THREADS) ;;
no-codecs) codec_flags=(-DHAVE_THREADS) ;;
recording-only) codec_flags=(-DHAVE_THREADS -DHAVE_CONFIGFILE -DHAVE_RECORD_MEDIACODEC) ;;
esac
for root_source in gfx/common/vulkan_common.c gfx/drivers/vulkan.c; do
"$bin/$target$api-clang" \
-DANDROID -DHAVE_MENU -DHAVE_GFX_WIDGETS \
-DHAVE_VULKAN -DHAVE_DYLIB "${codec_flags[@]}" \
-Dinline=__inline__ -O1 -std=c89 \
-Werror=declaration-after-statement -Werror=frame-larger-than -Wframe-larger-than=4096 \
-I. -Ilibretro-common/include -Igfx/include "${extra[@]}" \
-c "$root_source" -o "$RUNNER_TEMP/$variant-$(basename "$root_source")-$target-$api-$offset.o"
done
done
for player_source in libretro-common/formats/video_player.c libretro-common/formats/image_transfer.c libretro-common/formats/webm/rwebm_video.c libretro-common/formats/mp4/rmp4_video.c; do
"$bin/$target$api-clang" \
-DHAVE_RMP4 -DHAVE_RWEBM -DHAVE_RVP9 -DHAVE_RAV1 -DHAVE_THREADS \
-Dinline=__inline__ -O1 -std=c89 -Wno-long-long -Wno-c99-extensions \
-Werror=declaration-after-statement -Werror=frame-larger-than -Wframe-larger-than=2048 \
-I. -Ilibretro-common/include "${extra[@]}" \
-c "$player_source" -o "$RUNNER_TEMP/$(basename "$player_source")-$target-$api-$offset.o"
done
for parser_source in libretro-common/formats/h265/rh265.c libretro-common/formats/vp9/rvp9.c libretro-common/formats/av1/rav1_hw.c libretro-common/queues/retro_spsc.c; do
"$bin/$target$api-clang" \
-DHAVE_THREADS -O2 -std=c89 -pedantic -Wall -Wextra -Werror \
-Wno-unused-parameter -Wno-long-long -Wno-c99-extensions -Wframe-larger-than=2048 -fstack-usage \
-Ilibretro-common/include "${extra[@]}" -c "$parser_source" \
-o "$RUNNER_TEMP/$(basename "$parser_source")-$target-$api-$offset.o"
done
"$bin/$target$api-clang" \
-O2 -std=c89 -pedantic -Wall -Wextra -Werror \
-Wno-unused-parameter -Wno-long-long -Wno-c99-extensions -Wframe-larger-than=2048 -fstack-usage \
-Ilibretro-common/include "${extra[@]}" -c libretro-common/formats/vp9/rvp9.c \
-o "$RUNNER_TEMP/threadless-rvp9.c-$target-$api-$offset.o"
# Link AV1-only roots with exactly their selected native sources.
av1_objects=()
for source in mediacodec_inventory android_image_queue android_image_ndk android_frame mediacodec_session mediacodec_color mediacodec_frame_export mediacodec_av1_decoder mediacodec_av1_backend vulkan_android_image vulkan_android_sync vulkan_android_pipeline vulkan_android_submit vulkan_android_queue vulkan_android_cache_entry vulkan_android_cache vulkan_android_device; do
av1_objects+=("$RUNNER_TEMP/$source-$target-$api-$offset.o")
done
"$bin/ld.lld" -r "${av1_objects[@]}" \
"$RUNNER_TEMP/av1-only-vulkan_common.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/av1-only-vulkan.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rjni.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rav1_hw.c-$target-$api-$offset.o" \
-o "$RUNNER_TEMP/av1-only-root-$target-$api-$offset.o"
if "$bin/llvm-nm" -u "$RUNNER_TEMP/av1-only-root-$target-$api-$offset.o" | \
grep -Eq ' U (rav1_|rvp9_|rh265_|rjni_env$|mediacodec_|android_frame_|android_image_|vulkan_android_)'; then
echo "Unresolved private helper in AV1-only Android root"
exit 1
fi
for variant in no-codecs; do
if "$bin/llvm-nm" -u "$RUNNER_TEMP/$variant-vulkan.c-$target-$api-$offset.o" | \
grep -Eq ' U (mediacodec_|rav1_(set|unset)_hw_backend)'; then
echo "Unexpected native decoder dependency: $variant"
exit 1
fi
done
"$bin/ld.lld" -r \
"$RUNNER_TEMP/unity-$target-$api-$offset.o" \
"$RUNNER_TEMP/vulkan_common.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/vulkan.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/gfx_surface_player.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rjni.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/video_player.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/image_transfer.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rwebm_video.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rmp4_video.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rh265.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rvp9.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/rav1_hw.c-$target-$api-$offset.o" \
"$RUNNER_TEMP/record_audio_queue-$target-$api-$offset.o" \
"$RUNNER_TEMP/record_gpu_queue-$target-$api-$offset.o" \
"$RUNNER_TEMP/retro_spsc.c-$target-$api-$offset.o" \
-o "$RUNNER_TEMP/media-root-$target-$api-$offset.o"
if "$bin/llvm-nm" -u "$RUNNER_TEMP/media-root-$target-$api-$offset.o" | \
grep -Eq ' U (record_android_capture_|record_mediacodec_|record_session_mediacodec_|record_dispatch_mediacodec_|record_gpu_dispatch_mediacodec_|record_mux_mediacodec_|record_audio_tap_|record_audio_queue_|record_gpu_queue_|retro_spsc_|rav1_|rvp9_|rjni_env$|mediacodec_|android_frame_|android_image_|vulkan_android_|video_player_(request_software|set_hw_fallback)|image_transfer_anim_stream_stop_hw|rwebm_video_stream_stop_hw)'; then
echo "Unresolved private Android media helper in root link"
exit 1
fi
done
done
done
-16
View File
@@ -12,23 +12,7 @@ name: CI Apple
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Apple.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Apple.yml'
# ci_paths: end
permissions:
contents: read
-10
View File
@@ -71,16 +71,6 @@ jobs:
python3 tools/ci_apt_check.py --selftest
python3 tools/ci_apt_check.py
- name: Every workflow's paths filter names the samples it runs
shell: bash
run: |
set -eu
# A workflow skips a push that touches only samples it does not
# build or run; a step that starts naming another sample, or a
# sample's files that start reaching into another, leave the
# filter written by tools/ci_paths.py out of date.
python3 tools/ci_paths.py --check
- name: compile_commands.py self-test
shell: bash
run: |
+2 -16
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Compile-Matrix.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Compile-Matrix.yml'
# ci_paths: end
permissions:
contents: read
@@ -29,11 +17,9 @@ concurrency:
jobs:
compile-matrix: # every codec combination real builds select, not just this one
# Ubuntu 26.04 ships no MIPS cross toolchain; the mipsel lanes
# need 24.04's gcc-mipsel-linux-gnu.
runs-on: ubuntu-24.04
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libgl-dev libegl-dev libgles-dev libsdl1.2-dev gcc-mingw-w64-x86-64 clang gcc-aarch64-linux-gnu gcc-mipsel-linux-gnu libdrm-dev libgbm-dev
APT_PKGS: build-essential libgl-dev libegl-dev libgles-dev libsdl1.2-dev gcc-mingw-w64-x86-64 clang gcc-aarch64-linux-gnu gcc-mipsel-linux-gnu libdrm-dev
timeout-minutes: 30
steps:
- name: Checkout
@@ -100,8 +100,6 @@ jobs:
./vfs_seek_contract_test
./vfs_mapped_ptr_test
./vfs_v5_metadata_test
./vfs_readahead_test
./vfs_close_result_test
}
# Mapping on (what the platform actually ships), mapping off
# with the descriptor path forced (what the consoles have),
@@ -197,15 +195,6 @@ jobs:
# Exercises the Win32 CreateFileMapping/MapViewOfFile
# backend, which no other job in the tree reaches.
./vfs_mapped_ptr_test.exe
# Mapped read-ahead: PrefetchVirtualMemory, the pre-Windows 8
# toucher thread (forced) and neither.
./vfs_readahead_test.exe
RETRO_VFS_PREFETCH=touch ./vfs_readahead_test.exe
RETRO_VFS_PREFETCH=none ./vfs_readahead_test.exe
# ... and never on, or stalling, the reader's thread.
./vfs_prefetch_offthread_test.exe
# The descriptor path's close() result, with PS2's semantics.
./vfs_close_result_test.exe
# The Win64 fastjmp_set stores xmm6-xmm15 with movaps and faults
# on a misaligned buffer. Linux has no such stores, so the Linux
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Ctx-Presentable-Check.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Ctx-Presentable-Check.yml'
# ci_paths: end
workflow_dispatch:
permissions:
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI DOS/DJGPP
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/DOS-DJGPP.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/DOS-DJGPP.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-djgpp-build-container:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI Emscripten
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Emscripten.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Emscripten.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-emscripten:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: taiki-e/checkout-action@v1
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Extern-C-Prototype-Check.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Extern-C-Prototype-Check.yml'
# ci_paths: end
workflow_dispatch:
permissions:
-16
View File
@@ -15,23 +15,7 @@ name: CI FreeBSD
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/FreeBSD.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/FreeBSD.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI GameCube
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/GameCube.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/GameCube.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: devkitpro/devkitppc:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: taiki-e/checkout-action@v1
+1 -17
View File
@@ -4,25 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-Headless.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-Headless.yml'
# ci_paths: end
permissions:
contents: read
@@ -38,7 +22,7 @@ jobs:
linux-nomenu: # Smoketest build with no menu support compiled in
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev zlib1g-dev libfreetype-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev nvidia-cg-toolkit nvidia-cg-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm ccache
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev nvidia-cg-toolkit nvidia-cg-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm ccache
timeout-minutes: 30
steps:
- name: Checkout
-104
View File
@@ -1,104 +0,0 @@
name: CI Linux (aarch64, OpenXR)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-aarch64.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-aarch64.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
workflow_dispatch:
permissions:
contents: read
env:
ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
jobs:
build:
runs-on: ubuntu-24.04-arm
timeout-minutes: 30
env:
APT_PKGS: >-
build-essential pkg-config
libwayland-dev wayland-protocols libxkbcommon-dev libdecor-0-dev
libx11-dev libxext-dev libxrandr-dev libxinerama-dev libxxf86vm-dev
libxi-dev libx11-xcb-dev libxcb1-dev
libegl-dev libgl-dev libgles-dev libgbm-dev libdrm-dev libvulkan-dev
libasound2-dev libpulse-dev libpipewire-0.3-dev
libudev-dev libusb-1.0-0-dev libdbus-1-dev libsystemd-dev
libfreetype-dev libfontconfig-dev zlib1g-dev libsdl2-dev libv4l-dev
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install dependencies
timeout-minutes: 10
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: Configure
run: |
./configure --disable-qt --disable-ffmpeg --disable-cg --enable-openxr
grep -q '^HAVE_OPENXR = 1' config.mk
grep -q '^HAVE_XSCRNSAVER = 1' config.mk
- name: Compile RA
run: make -j$(getconf _NPROCESSORS_ONLN)
- name: Check and strip
run: |
./retroarch --version
if readelf -d retroarch | grep -q 'libXss'; then
echo 'retroarch must load libXss at run time, not link it'
exit 1
fi
strip retroarch
- name: Get short SHA
id: slug
run: echo "sha8=$(echo ${GITHUB_SHA} | cut -c1-8)" >> $GITHUB_OUTPUT
- uses: actions/upload-artifact@v4
with:
name: retroarch-linux-aarch64-${{ steps.slug.outputs.sha8 }}
path: retroarch
if-no-files-found: error
+1 -17
View File
@@ -40,25 +40,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-asan-ubsan.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-asan-ubsan.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -76,7 +60,7 @@ jobs:
name: Build with ASan+UBSan and run headless smoke
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev nvidia-cg-toolkit nvidia-cg-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm ccache
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev nvidia-cg-toolkit nvidia-cg-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm ccache
timeout-minutes: 25
steps:
+1 -26
View File
@@ -3,20 +3,8 @@ name: CI Linux native audio transport
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-audio-transport.yml'
# ci_paths: end
pull_request:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-audio-transport.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -90,12 +78,6 @@ jobs:
ASAN_OPTIONS: detect_leaks=1:detect_stack_use_after_return=1
UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
run: make check-pause SANITIZER='${{ matrix.sanitizer }}'
- name: Fast-forward stall on the real wrapper
working-directory: samples/audio/pipeline_wakeups
env:
ASAN_OPTIONS: detect_leaks=1:detect_stack_use_after_return=1
UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
run: make check-ff-stall SANITIZER='${{ matrix.sanitizer }}'
- name: Consumer leaving under a parked producer
working-directory: samples/audio/pipeline_wakeups
env:
@@ -108,12 +90,6 @@ jobs:
ASAN_OPTIONS: detect_leaks=1:detect_stack_use_after_return=1
UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
run: make check-kept-device SANITIZER='${{ matrix.sanitizer }}'
- name: Menu mixer continues without frame submissions
working-directory: samples/audio/pipeline_wakeups
env:
ASAN_OPTIONS: detect_leaks=1:detect_stack_use_after_return=1
UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
run: make check-menu SANITIZER='${{ matrix.sanitizer }}'
- name: Consumer leaving and a kept device (ThreadSanitizer)
if: matrix.sanitizer == ''
working-directory: samples/audio/pipeline_wakeups
@@ -124,5 +100,4 @@ jobs:
# pipe_consumer_gone handshake and a stopped wrapper beside the
# state rebuilt under it, which only the race detector can judge.
make clean
make check-consumer-exit check-kept-device check-menu check-ff-stall \
SANITIZER=thread
make check-consumer-exit check-kept-device SANITIZER=thread
+3 -15
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-autoconf-tests.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-autoconf-tests.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -36,7 +24,7 @@ jobs:
name: Build and run the autoconfig regression suite (${{ matrix.lane }})
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential zlib1g-dev libfreetype-dev ccache
APT_PKGS: build-essential zlib1g-dev libfreetype6-dev ccache
timeout-minutes: ${{ matrix.sanitizer == '' && 15 || 40 }}
strategy:
fail-fast: false
@@ -125,9 +113,9 @@ jobs:
if [ "${{ matrix.sanitizer }}" = thread ]; then
# TSan cannot map its shadow under the runner's ASLR
# entropy; setarch -R carries to every child the suite runs.
setarch "$(uname -m)" -R ./samples/input/test_input/test_autoconf.sh ./retroarch
setarch "$(uname -m)" -R ./tests-other/test_autoconf.sh ./retroarch
else
./samples/input/test_input/test_autoconf.sh ./retroarch
./tests-other/test_autoconf.sh ./retroarch
fi
- name: ccache statistics
-1
View File
@@ -67,7 +67,6 @@ jobs:
working-directory: libretro-common/samples/formats/cdfs
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make -j2 CC=x86_64-w64-mingw32-gcc OS=Windows_NT EXE=.exe SAMPLE_OBJDIR=obj-ci-win
WINEDEBUG=-all wine ./cdfs_dir_record_test.exe
WINEDEBUG=-all wine ./cdfs_pure_api_test.exe
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-driver-vtables.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-driver-vtables.yml'
# ci_paths: end
workflow_dispatch:
permissions:
-1
View File
@@ -77,7 +77,6 @@ jobs:
working-directory: libretro-common/samples/file/vfs_cdrom
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make -j2 dvd_blocks_test.exe CC=x86_64-w64-mingw32-gcc OS=Windows_NT EXE=.exe SAMPLE_OBJDIR=obj-dvd-win
WINEDEBUG=-all wine ./dvd_blocks_test.exe
make -j2 disc_dump_test.exe CC=x86_64-w64-mingw32-gcc OS=Windows_NT EXE=.exe SAMPLE_OBJDIR=obj-dvd-win
+1 -25
View File
@@ -9,12 +9,7 @@ name: CI Linux filter plugins
# takes more than one worker must give the single-worker output byte for
# byte with 2, 3 and 4 workers running at once. The same run is repeated
# with the plugins and the harness built under ASan, UBSan and
# LeakSanitizer, and under ThreadSanitizer. The NTSC, 2xBR, NTSC-CRT,
# 2xSaI-family, Phosphor2x, Blargg NTSC SNES, De-Dither, Pixel Art AA,
# Scale2x, Scanline2x, Upscale 1.5x/1.66x and the Normal, Grid, Game Boy
# and Dot Matrix scalers are also held byte for byte to output hashes
# recorded from their earlier implementations
# (samples/gfx/{ntsc,crt}_filter_golden and samples/gfx/filter_golden).
# LeakSanitizer, and under ThreadSanitizer.
on:
push:
@@ -25,9 +20,6 @@ on:
- 'libretro-common/audio/dsp_filters/**'
- 'libretro-common/include/libretro_dspfilter.h'
- 'samples/gfx/filter_plugins/**'
- 'samples/gfx/ntsc_filter_golden/**'
- 'samples/gfx/crt_filter_golden/**'
- 'samples/gfx/filter_golden/**'
- '.github/workflows/Linux-filter-plugins.yml'
pull_request:
paths:
@@ -35,9 +27,6 @@ on:
- 'libretro-common/audio/dsp_filters/**'
- 'libretro-common/include/libretro_dspfilter.h'
- 'samples/gfx/filter_plugins/**'
- 'samples/gfx/ntsc_filter_golden/**'
- 'samples/gfx/crt_filter_golden/**'
- 'samples/gfx/filter_golden/**'
- '.github/workflows/Linux-filter-plugins.yml'
workflow_dispatch:
@@ -84,19 +73,6 @@ jobs:
make -C samples/gfx/filter_plugins clean
make -C samples/gfx/filter_plugins check SANITIZER=address,undefined
- name: NTSC, 2xBR, NTSC-CRT and 2xSaI-family filter output against their recorded hashes
env:
ASAN_OPTIONS: abort_on_error=1:detect_leaks=1:print_stacktrace=1
UBSAN_OPTIONS: halt_on_error=1:print_stacktrace=1
run: |
set -eu
jobs=$(getconf _NPROCESSORS_ONLN)
for t in ntsc_filter_golden crt_filter_golden filter_golden; do
make -C samples/gfx/$t -j"$jobs" check
make -C samples/gfx/$t clean
make -C samples/gfx/$t -j"$jobs" check SANITIZER=address,undefined
done
- name: Load and run every plugin under ThreadSanitizer
env:
TSAN_OPTIONS: halt_on_error=1
+1 -117
View File
@@ -19,125 +19,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'libretro-common/samples/encodings/rbzip2/**'
- 'samples/runloop/auto_state_load/**'
- 'samples/runloop/autosave_snapshot/**'
- 'samples/runloop/cloudsync_unload/**'
- 'samples/runloop/content_closing/**'
- 'samples/runloop/core_status_defer/**'
- 'samples/runloop/frontend_overhead/**'
- 'samples/runloop/hw_context_request/**'
- 'samples/runloop/log_ring/**'
- 'samples/runloop/pacing/**'
- 'samples/tasks/autodetect_handoff/**'
- 'samples/tasks/bluetooth_scan/**'
- 'samples/tasks/bps_patch/**'
- 'samples/tasks/bsv_checkpoint/**'
- 'samples/tasks/bsv_replay/**'
- 'samples/tasks/bsv_replay_init/**'
- 'samples/tasks/bsv_statestream/**'
- 'samples/tasks/cloudsync/**'
- 'samples/tasks/content_load/**'
- 'samples/tasks/content_prefetch/**'
- 'samples/tasks/core_backup/**'
- 'samples/tasks/core_updater/**'
- 'samples/tasks/database/**'
- 'samples/tasks/decompress/**'
- 'samples/tasks/exit_drain/**'
- 'samples/tasks/file_transfer/**'
- 'samples/tasks/http/**'
- 'samples/tasks/http_emscripten/**'
- 'samples/tasks/image_decode_slice/**'
- 'samples/tasks/input_remap/**'
- 'samples/tasks/natt_desc/**'
- 'samples/tasks/netplay_nat/**'
- 'samples/tasks/ordering/**'
- 'samples/tasks/overlay/**'
- 'samples/tasks/patch_stream/**'
- 'samples/tasks/pl_thumbnail/**'
- 'samples/tasks/playlist_manager/**'
- 'samples/tasks/progress_push/**'
- 'samples/tasks/save_state/**'
- 'samples/tasks/steam_dlc/**'
- 'samples/tasks/subtitle_load/**'
- 'samples/tasks/translation_reply/**'
- 'samples/tasks/turbo_bind/**'
- 'samples/tasks/video_shader_parse/**'
- 'samples/tasks/wait_timeout/**'
- 'samples/tasks/watchdog/**'
- 'samples/tasks/wifi_tasks/**'
- 'samples/runloop/**'
- 'samples/tasks/**'
- 'samples/ui_companion_log_stub.c'
- '.github/workflows/Linux-frontend-overhead.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'libretro-common/samples/encodings/rbzip2/**'
- 'samples/runloop/auto_state_load/**'
- 'samples/runloop/autosave_snapshot/**'
- 'samples/runloop/cloudsync_unload/**'
- 'samples/runloop/content_closing/**'
- 'samples/runloop/core_status_defer/**'
- 'samples/runloop/frontend_overhead/**'
- 'samples/runloop/hw_context_request/**'
- 'samples/runloop/log_ring/**'
- 'samples/runloop/pacing/**'
- 'samples/tasks/autodetect_handoff/**'
- 'samples/tasks/bluetooth_scan/**'
- 'samples/tasks/bps_patch/**'
- 'samples/tasks/bsv_checkpoint/**'
- 'samples/tasks/bsv_replay/**'
- 'samples/tasks/bsv_replay_init/**'
- 'samples/tasks/bsv_statestream/**'
- 'samples/tasks/cloudsync/**'
- 'samples/tasks/content_load/**'
- 'samples/tasks/content_prefetch/**'
- 'samples/tasks/core_backup/**'
- 'samples/tasks/core_updater/**'
- 'samples/tasks/database/**'
- 'samples/tasks/decompress/**'
- 'samples/tasks/exit_drain/**'
- 'samples/tasks/file_transfer/**'
- 'samples/tasks/http/**'
- 'samples/tasks/http_emscripten/**'
- 'samples/tasks/image_decode_slice/**'
- 'samples/tasks/input_remap/**'
- 'samples/tasks/natt_desc/**'
- 'samples/tasks/netplay_nat/**'
- 'samples/tasks/ordering/**'
- 'samples/tasks/overlay/**'
- 'samples/tasks/patch_stream/**'
- 'samples/tasks/pl_thumbnail/**'
- 'samples/tasks/playlist_manager/**'
- 'samples/tasks/progress_push/**'
- 'samples/tasks/save_state/**'
- 'samples/tasks/steam_dlc/**'
- 'samples/tasks/subtitle_load/**'
- 'samples/tasks/translation_reply/**'
- 'samples/tasks/turbo_bind/**'
- 'samples/tasks/video_shader_parse/**'
- 'samples/tasks/wait_timeout/**'
- 'samples/tasks/watchdog/**'
- 'samples/tasks/wifi_tasks/**'
- 'samples/runloop/**'
- 'samples/tasks/**'
- 'samples/ui_companion_log_stub.c'
- '.github/workflows/Linux-frontend-overhead.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -152,7 +36,7 @@ jobs:
name: Release build, frame-path heap and cost
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev zlib1g-dev libfreetype-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libxml2-dev yasm
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libxml2-dev yasm
timeout-minutes: 30
steps:
-104
View File
@@ -1,104 +0,0 @@
name: CI Linux Griffin [Unity build]
on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-griffin.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-griffin.yml'
# ci_paths: end
permissions:
contents: read
env:
ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
jobs:
linux-griffin: # griffin/griffin.c as Makefile.griffin builds it for Linux
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libgl-dev libudev-dev libpulse-dev libx11-dev libx11-xcb-dev libxcb1-dev libxxf86vm-dev ccache
timeout-minutes: 30
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install dependencies
timeout-minutes: 20
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: Link with lld
run: sh .github/workflows/scripts/use-lld.sh
- name: Restore ccache
uses: actions/cache/restore@v4
with:
path: ~/.ccache
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ github.sha }}
restore-keys: |
ccache-${{ github.workflow }}-${{ github.job }}-
- name: Enable ccache
run: |
set -eu
export CCACHE_DIR="$HOME/.ccache"
echo "CCACHE_DIR=$CCACHE_DIR" >> "$GITHUB_ENV"
echo "/usr/lib/ccache" >> "$GITHUB_PATH"
ccache -M 250M
ccache -z
- name: Build
run: make -f Makefile.griffin platform=unix -j"$(nproc)"
- name: ccache statistics
if: ${{ !cancelled() }}
continue-on-error: true
run: ccache -sv
- name: Save ccache
# Only master's pushes keep a cache: pull requests restore
# master's, so one push does not evict the next one's.
if: success() && github.event_name == 'push' && github.ref == 'refs/heads/master'
uses: actions/cache/save@v4
with:
path: ~/.ccache
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ github.sha }}
@@ -13,31 +13,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/network/cheevos_login/**'
- 'samples/network/smb_retro/**'
- 'samples/network/tls_retro/**'
- '.github/workflows/Linux-library-net-backends.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/network/cheevos_login/**'
- 'samples/network/smb_retro/**'
- 'samples/network/tls_retro/**'
- '.github/workflows/Linux-library-net-backends.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -52,7 +30,7 @@ jobs:
name: ${{ matrix.lane }}
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential pkg-config cmake libgl1-mesa-dev libx11-dev libxext-dev libasound2-dev libsdl2-dev zlib1g-dev libfreetype-dev python3 openssl libmbedtls-dev libbearssl-dev samba ccache
APT_PKGS: build-essential pkg-config cmake libgl1-mesa-dev libx11-dev libxext-dev libasound2-dev libsdl2-dev zlib1g-dev libfreetype6-dev python3 openssl libmbedtls-dev libbearssl-dev samba ccache
timeout-minutes: 60
strategy:
fail-fast: false
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-libretro-common-samples.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-libretro-common-samples.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -33,15 +21,10 @@ concurrency:
jobs:
samples:
name: Build and run libretro-common/samples (${{ matrix.group }})
name: Build and run libretro-common/samples
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
group: [codecs, formats, core]
env:
SAMPLE_GROUP: ${{ matrix.group }}
APT_PKGS: build-essential zlib1g-dev clang ffmpeg ccache curl
APT_PKGS: build-essential zlib1g-dev clang ffmpeg ccache
timeout-minutes: 15
steps:
@@ -77,9 +60,8 @@ jobs:
uses: actions/cache/restore@v4
with:
path: ~/.ccache
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ matrix.group }}-${{ github.sha }}
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ github.sha }}
restore-keys: |
ccache-${{ github.workflow }}-${{ github.job }}-${{ matrix.group }}-
ccache-${{ github.workflow }}-${{ github.job }}-
- name: Enable ccache
@@ -114,53 +96,22 @@ jobs:
# self-contained test and exits 0 on success / non-zero on
# failure. These are built AND executed.
declare -a RUN_TARGETS=(
rwma_test
audio_transfer_wma_test
flv_mux_test
rtmp_chunk_test
rtmp_handshake_test
rtmp_receive_test
rtmp_command_test
rtmp_reply_test
rtmp_publish_test
rtmp_control_test
rtmp_session_test
rtmp_socket_test
rslc_test
rslc_build_test
rslc_ext_test
s16_to_float_test
float_to_s16_test
float_to_s32_test
compat_fnmatch_test
snprintf
unbase64_test
crc32_test
# encoding_crc32.c through an assembler without VPCLMULQDQ,
# and beside encoding_rzstd.c under an unguarded <cpuid.h>.
crc32_gas_test
xxhash_test
rzstd_raw_block_test
rzstd_raw_block_test_novec
rzstd_dict_test
rbzip2_test
rinflate_window_test
rdeflate_hash_test
emscripten_mmap_test
archive_zip_test
archive_zstd_test
archive_zst_test
archive_bz2_test
archive_zip_methods_test
archive_zip64_test
archive_rar_test
archive_stream_test
archive_7z_test
config_file_test
path_resolve_realpath_test
fill_pathname_test
path_mkdir_test
path_parent_dir_test
rpng
rzip_chunk_size_test
rzip_matches_buf_test
@@ -178,14 +129,10 @@ jobs:
rh264_lossless_test_volatile
# The hardware path's sequencing against a checking backend.
rh264_hw_test
# Savestates: saved mid-stream, loaded into a new decoder.
rh264_state_test
# rmp3's frame-at-a-time API against its pull API.
rmp3_frame_test
# raac_last_size over units followed by more.
raac_size_test
# raac's savestates: saved between units, loaded into a new decoder.
raac_state_test
rh265_lossless_test
rh265_lossless_test_nothreads
rh265_lossless_test_volatile
@@ -193,10 +140,6 @@ jobs:
rh265_weight_test
r7z_lzma_props_test
r7z_archive_detach_test
r7z_bcj2_test
r7z_stored_test
r7z_methods_test
r7z_stream_test
rzip_archive_test
# The RAR reader on real archives (LZ and PPMd blocks,
# filters, Unicode names) and on mangled copies of them.
@@ -206,11 +149,6 @@ jobs:
vfs_read_overflow_test
vfs_mapped_ptr_test
vfs_prefetch_test
vfs_readahead_test
vfs_prefetch_offthread_test
vfs_view_test
vfs_prefetch_retarget_test
vfs_prefetch_view_test
vfs_large_file_test
vfs_seek_contract_test
vfs_bulk_read_test
@@ -218,7 +156,6 @@ jobs:
vfs_hybrid_test
filestream_rbuf_fault_test
vfs_rename_replace_test
vfs_close_result_test
cdrom_cuesheet_overflow_test
rdvd_h262_test
rdvd_lpcm_test
@@ -234,21 +171,11 @@ jobs:
cdfs_pure_api_test
cdfs_io_error_test
chd_meta_overflow_test
chd_stream_threads_test
chd_stream_ahead_test
chd_map_alloc_test
rvz_test
ciso_test
xdvdfs_test
wux_test
zar_test
filestream_printf_test
strlcpy_append_test
http_parse_test
rjson_test
rm3u_test
rmp4_fragment_test
rmp4_language_test
rav1_test
rav1_picture_test
rav1_reference_test
@@ -265,21 +192,14 @@ jobs:
rav1_tiles_test
rav1_sequence_test
rav1_container_test
subtitle_srt_test
subtitle_srt_fault_test
rtga_test
rbmp_test
rbmp_encode_test
# Every 16-bit input through each pixconv converter, with
# SSE2, with MMX only, and with no SIMD at all; the wide
# build also runs each AVX2 / AVX-512 tier the runner has.
# SSE2, with MMX only, and with no SIMD at all.
pixconv_test
pixconv_test_nosimd
pixconv_test_scalar
pixconv_test_wide
scaler_point_test
image_scale_transfer_test
file_list_oom_test
rpng_chunk_overflow_test
rpng_roundtrip_test
rpng_decode_corpus_test
@@ -305,12 +225,6 @@ jobs:
# A parked handler runs again on a wake, a cancel or its
# horizon, and not before.
task_queue_park_test
# Parallel tasks on the extra workers, beside the one
# worker plain tasks keep to.
task_queue_parallel_test
# Which tasks run at once, and pushes from several
# threads with some stopped half way into the ring.
task_queue_overlap_test
# The worker below the main thread as Horizon schedules
# them; the lanes need SCHED_FIFO and skip without root.
task_queue_fifo_prio_test
@@ -334,10 +248,6 @@ jobs:
# The PS2 EE backend, built off-target against a stub
# <kernel.h>: the PS2 CI lane compiles it, this runs it.
retro_atomic_ps2_backend_test
# The Wii U backend, built off-target against stand-in
# coreinit OS*Atomic: each read-modify-write is one coreinit
# call, loads, stores and fences none.
retro_atomic_wiiu_backend_test
retro_spsc_test
mpsc_stack_test
# A frame handoff where neither side waits: no read sees a
@@ -360,7 +270,6 @@ jobs:
fast_cores_test
memshm_test
fastjmp_test
context_test
rdds_block_test
faulthandler_test
memshm_area_test
@@ -405,23 +314,12 @@ jobs:
# VP9 reference-slot sizing, the hardware session's
# metadata, retries and frame leases, and WebM dispatch
# into it.
rmp4_vp9_config_test
rmp4_vp9_hw_stream_test
rmp4_vp9_config_test
rvp9_config_test
rvp9_reference_test
rvp9_hw_session_test
rwebm_language_test
rwebm_hw_stream_test
# The NGX and NVAPI loaders against a stand-in NGX core
# library on LD_LIBRARY_PATH; the Windows discovery runs
# in the mingw job below.
nvidia_loader_test
# The FidelityFX API and XeSS loaders against stand-in
# libraries planted in a directory of the test's, as the
# user's runtime directory is; the Windows file names run
# in the mingw job below.
ffx_loader_test
xess_loader_test
)
# Targets that are built but deliberately not executed, each
@@ -432,9 +330,6 @@ jobs:
# self-contained regression tests came to be compiled every
# run and never executed.
declare -a NORUN_TARGETS=(
# Fixture-driven checks run in Linux-samples-record.yml.
flv_remux_test
rtmp_socket_native_test
# CLI tools that print usage and exit non-zero without
# arguments; they have no self-test mode.
rzip
@@ -458,7 +353,6 @@ jobs:
# its own, and with it the faults never reach the code under
# test. handle_segv=0 is how a fastmem core runs.
[faulthandler_test]="ASAN_OPTIONS=detect_leaks=1:handle_segv=0 UBSAN_OPTIONS=handle_segv=0"
[nvidia_loader_test]="LD_LIBRARY_PATH=."
)
# Samples that are build-only (either they require command-line
@@ -509,14 +403,6 @@ jobs:
for d in "${MKDIRS[@]}"; do
rel=${d#./}
case "$rel" in
formats/av1|formats/h264|formats/h265|formats/vp9) group=codecs ;;
formats/*) group=formats ;;
*) group=core ;;
esac
if [[ "$group" != "$SAMPLE_GROUP" ]]; then
continue
fi
printf '========================================\n'
printf '[%s] %s\n' "$(is_in "$rel" "${SKIP_DIRS[@]}" && echo skip || echo build)" "$rel"
printf '========================================\n'
@@ -527,7 +413,7 @@ jobs:
fi
# Build
if ! ( cd "$d" && make clean && timeout 300 make -j2 all $MAKE_ARGS ); then
if ! ( cd "$d" && make clean all $MAKE_ARGS ); then
printf '\n::error title=Build failed::%s failed to build\n' "$rel"
fails=$((fails+1))
continue
@@ -598,28 +484,7 @@ jobs:
exit 1
fi
- name: Compare native XMA2 startup and multistream tail against reference PCM
if: matrix.group == 'formats'
shell: bash
working-directory: libretro-common/samples/formats/wma
run: |
set -euo pipefail
fixture=$(mktemp -d)
trap 'rm -rf "$fixture"' EXIT
for suffix in xma pcm; do
curl --fail --location --retry 2 --connect-timeout 10 --max-time 45 \
"https://fate-suite.ffmpeg.org/xma2/xma2-multistream-tail.$suffix" \
-o "$fixture/input.$suffix"
done
printf '%s %s\n' \
9f0a3fbee3f2da4833b3e385905e1edebacf086c53a2e5eb358941e74fc67d80 "$fixture/input.xma" \
154755c1d14cddcc497ceef2996a98c3ee9c054735a8fe6d5c1d790cf93981cf "$fixture/input.pcm" | sha256sum -c -
make -j2 file-reference SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 \
./rwma_file_reference "$fixture/input.xma" "$fixture/input.pcm"
- name: Parse a generated DVD VOB with the native readers
if: matrix.group == 'formats'
shell: bash
working-directory: libretro-common/samples/formats/dvd
run: |
@@ -644,7 +509,6 @@ jobs:
done
- name: Reconstruct progressive H262 I pictures against a reference
if: matrix.group == 'formats'
shell: bash
working-directory: libretro-common/samples/formats/dvd
run: |
@@ -662,7 +526,6 @@ jobs:
./rdvd_h262_test "$fixture" "$reference"
- name: Compile-test retro_atomic.h from a C++11 TU
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common
run: |
@@ -777,7 +640,6 @@ jobs:
rm -rf "$tmpdir"
- name: Run retro_atomic_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/atomic/retro_atomic_test
run: |
@@ -799,7 +661,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./retro_atomic_test
- name: Run video_player_test under Clang + ThreadSanitizer, and threadless
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/formats/video_player
run: |
@@ -815,14 +676,8 @@ jobs:
make clean
make -j$(nproc) all THREADS=0 SANITIZER=address,undefined
./video_player_test
for threads in 1 0; do
make clean
make -j$(nproc) all THREADS=$threads FAULT_ALLOC=1 SANITIZER=address,undefined || exit $?
VP_TEST_RECOVERY_ONLY=1 ./video_player_test || exit $?
done
- name: Run rtime_localtime_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/time/rtime_localtime_test
run: |
@@ -838,7 +693,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./rtime_localtime_test
- name: Run retro_triple_buffer_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/queues/retro_triple_buffer_test
run: |
@@ -854,7 +708,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./retro_triple_buffer_test
- name: Run audio_mixer_voice_threads_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/audio/audio_mixer_voice_threads
run: |
@@ -870,7 +723,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./audio_mixer_voice_threads_test
- name: Run mpsc_stack_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/queues/mpsc_stack_test
run: |
@@ -892,7 +744,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./mpsc_stack_test
- name: Run retro_spsc_test on the POSIX shm mirror
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/queues/retro_spsc_test
run: |
@@ -905,7 +756,6 @@ jobs:
./retro_spsc_test
- name: Run retro_spsc_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/queues/retro_spsc_test
run: |
@@ -931,7 +781,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./retro_spsc_test
- name: Run retro_eventcount_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/rthreads/retro_eventcount_test
run: |
@@ -957,15 +806,7 @@ jobs:
make clean
CC=clang make check SANITIZER=thread
- name: WMA codec disabled
if: matrix.group == 'formats'
working-directory: libretro-common/samples/formats/audio_transfer_wma
run: |
make -j2 WMA=0 SAMPLE_OBJDIR=obj-disabled TARGET=audio_transfer_wma_disabled_test SANITIZER=address,undefined
./audio_transfer_wma_disabled_test
- name: Run rzip_parallel_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/streams/rzip
run: |
@@ -986,7 +827,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./rzip_parallel_test
- name: Run crc32_test under Clang + ThreadSanitizer
if: matrix.group == 'core'
shell: bash
working-directory: libretro-common/samples/encodings/crc32
run: |
@@ -1007,7 +847,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./crc32_test
- name: Prefix refill boundaries and sliding-window I/O
if: matrix.group == 'formats'
run: |
make -B -C libretro-common/samples/formats/data_transfer data_transfer_prefix_test data_transfer_window_test COUNT_IO=1 SAMPLE_OBJDIR=obj-inert-strict CFLAGS='-Wall -pedantic -std=gnu99 -O2 -g1 -DDT_STRICT -DDT_COUNT_IO -DHAVE_MMAP -D_GNU_SOURCE -I../../../include'
cd libretro-common/samples/formats/data_transfer
@@ -1026,7 +865,7 @@ jobs:
uses: actions/cache/save@v4
with:
path: ~/.ccache
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ matrix.group }}-${{ github.sha }}
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ github.sha }}
# memmap.h picks between libretro-common's mman shim and the
# platform's own <sys/mman.h>, and Emscripten is the target where
@@ -1163,7 +1002,7 @@ jobs:
# at the hardware level even when the macros emit no barriers at all.
#
# This job cross-compiles retro_atomic_test for AArch64 and ARMv7 and
# runs the binary under qemu-user. qemu-user emulates the
# runs the binary under qemu-user-static. qemu-user emulates the
# weak memory model faithfully enough to expose missing-barrier bugs
# in the SPSC stress test, and is cheap enough to run on every push.
#
@@ -1330,7 +1169,6 @@ jobs:
run: |
set -u
set -o pipefail
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The samples job above runs these on Linux only. On Win32
# retro_sleep() is a function in time/rtime.c rather than a
# macro, so a Makefile that links on Linux can still fail to
@@ -1356,64 +1194,12 @@ jobs:
done
[[ $fails -eq 0 ]]
- name: Build and run the NVIDIA loaders under Wine
shell: bash
working-directory: libretro-common/samples/gfx/nvidia
env:
WINEDEBUG: -all
run: |
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The Windows half of the loaders: _nvngx.dll beside the
# program and nvapi64.dll by LoadLibrary, the Direct3D 12
# table resolved, the stand-ins built with mingw.
make clean
make CC=x86_64-w64-mingw32-gcc all
timeout 120 wine ./nvidia_loader_test.exe
make clean
- name: Build and run the FidelityFX and XeSS loaders under Wine
shell: bash
working-directory: libretro-common/samples/gfx
env:
WINEDEBUG: -all
run: |
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The Windows half of the loaders: the SDK's .dll names by
# LoadLibraryEx from the directory, the stand-ins built with
# mingw.
for d in amd intel; do
t=$(sed -nE 's/^TARGET[[:space:]]*:?=[[:space:]]*//p' "$d/Makefile")
( cd "$d" && make clean && make CC=x86_64-w64-mingw32-gcc all && timeout 120 wine "./$t.exe" && make clean )
done
- name: Build and run the mapped read-ahead test under Wine
shell: bash
working-directory: libretro-common/samples/file/vfs
env:
WINEDEBUG: -all
run: |
set -eu
set -o pipefail
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean MMAP=0
make CC=x86_64-w64-mingw32-gcc MMAP=0 vfs_readahead_test vfs_prefetch_offthread_test vfs_close_result_test
timeout 120 wine ./vfs_readahead_test.exe
RETRO_VFS_PREFETCH=touch timeout 120 wine ./vfs_readahead_test.exe
RETRO_VFS_PREFETCH=none timeout 120 wine ./vfs_readahead_test.exe
# The prefetch never runs on, or stalls, the reader.
timeout 120 wine ./vfs_prefetch_offthread_test.exe
# A close() that reports the descriptor number on success, as
# ps2sdk's does, is not a failure on the descriptor path.
timeout 120 wine ./vfs_close_result_test.exe
make clean MMAP=0
- name: Build and run native DVD packets under Wine
shell: bash
working-directory: libretro-common/samples/formats/dvd
env:
WINEDEBUG: -all
run: |
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make CC=x86_64-w64-mingw32-gcc EXE=.exe all
timeout 120 wine ./rdvd_h262_test.exe
timeout 120 wine ./rdvd_lpcm_test.exe
@@ -1430,7 +1216,7 @@ jobs:
name: Cross-arch retro_atomic_test (${{ matrix.arch }})
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential ${{ matrix.apt_pkgs }} qemu-user ccache
APT_PKGS: build-essential ${{ matrix.apt_pkgs }} qemu-user-static ccache
timeout-minutes: 10
strategy:
fail-fast: false
@@ -1439,12 +1225,12 @@ jobs:
- arch: aarch64
cc: aarch64-linux-gnu-gcc
apt_pkgs: gcc-aarch64-linux-gnu
qemu: qemu-aarch64
qemu: qemu-aarch64-static
sysroot: /usr/aarch64-linux-gnu
- arch: armv7
cc: arm-linux-gnueabihf-gcc
apt_pkgs: gcc-arm-linux-gnueabihf
qemu: qemu-arm
qemu: qemu-arm-static
sysroot: /usr/arm-linux-gnueabihf
steps:
@@ -1578,7 +1364,7 @@ jobs:
name: Cross-arch crc32_test (${{ matrix.name }})
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential ${{ matrix.apt_pkgs }} qemu-user ccache
APT_PKGS: build-essential ${{ matrix.apt_pkgs }} qemu-user-static ccache
timeout-minutes: 20
strategy:
fail-fast: false
@@ -1588,25 +1374,25 @@ jobs:
cc: aarch64-linux-gnu-gcc
cflags: ""
apt_pkgs: gcc-aarch64-linux-gnu
qemu: qemu-aarch64
qemu: qemu-aarch64-static
sysroot: /usr/aarch64-linux-gnu
- name: aarch64+crc
cc: aarch64-linux-gnu-gcc
cflags: "-march=armv8-a+crc"
apt_pkgs: gcc-aarch64-linux-gnu
qemu: qemu-aarch64
qemu: qemu-aarch64-static
sysroot: /usr/aarch64-linux-gnu
- name: armv7
cc: arm-linux-gnueabihf-gcc
cflags: ""
apt_pkgs: gcc-arm-linux-gnueabihf
qemu: qemu-arm
qemu: qemu-arm-static
sysroot: /usr/arm-linux-gnueabihf
- name: powerpc-big-endian
cc: powerpc-linux-gnu-gcc
cflags: ""
apt_pkgs: gcc-powerpc-linux-gnu
qemu: qemu-ppc
qemu: qemu-ppc-static
sysroot: /usr/powerpc-linux-gnu
steps:
@@ -10,21 +10,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-libretro-common-tests.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-libretro-common-tests.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -40,11 +28,9 @@ concurrency:
jobs:
libretro-common-tests:
name: Build and run libretro-common/Makefile.test
# Ubuntu 26.04 ships no MIPS cross toolchain; the mipsel lanes
# need 24.04's gcc-mipsel-linux-gnu.
runs-on: ubuntu-24.04
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential check pkg-config zlib1g-dev gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 wine wine64 ffmpeg gcc-aarch64-linux-gnu gcc-arm-linux-gnueabihf gcc-mipsel-linux-gnu qemu-user ccache
APT_PKGS: build-essential check pkg-config zlib1g-dev lcov gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 wine wine64 ffmpeg gcc-aarch64-linux-gnu gcc-arm-linux-gnueabihf gcc-mipsel-linux-gnu qemu-user ccache
# The suites and the stack check have grown with the tree; the
# companion harnesses are a job of their own, run beside this one.
timeout-minutes: 30
@@ -105,8 +91,8 @@ jobs:
WINEPREFIX: "/tmp/wineprefix"
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The recipe builds each suite and runs it, in order.
# The recipe builds each suite, runs it, and collects
# coverage, in order -- coverage files collide otherwise.
# Any suite failing to build, or any check failing, or any
# sanitizer report, fails the job.
# 'unit-tests' by name: the default goal of Makefile.test is
@@ -114,9 +100,7 @@ jobs:
# matrix and none of the suites this step exists to run. The
# 'all' target adds the concurrency and I/O samples, whose
# runtime depends on how many processors the runner has.
# COVERAGE=0: nothing here reads the coverage, and collecting
# it instruments every compile and runs lcov once a suite
make -f Makefile.test unit-tests COVERAGE=0 \
make -f Makefile.test unit-tests \
LIBCHECK_CFLAGS="$(pkg-config --cflags check)" \
CFLAGS="$(pkg-config --cflags check)"
echo "[pass] libretro-common unit test suites"
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-libretro-db-samples.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-libretro-db-samples.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -105,7 +93,6 @@ jobs:
# failure. These are built AND executed.
declare -a RUN_TARGETS=(
rmsgpack_overflow_test
rmsgpack_window_test
libretrodb_leak_test
)
+2 -24
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-mcp-stdio.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-mcp-stdio.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -33,7 +21,7 @@ jobs:
name: retroarch --mcp-stdio driving a core
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential pkg-config zlib1g-dev libfreetype-dev python3 ccache
APT_PKGS: build-essential pkg-config zlib1g-dev libfreetype6-dev python3 ccache
timeout-minutes: 40
steps:
@@ -74,14 +62,6 @@ jobs:
grep -q '^HAVE_MCP = 1' config.mk
make -j"$(nproc)" CC="ccache gcc" CXX="ccache g++"
make -C samples/cores/video_views
# a core that maps memory, for the tools that read it
gcc -O1 -shared -fPIC -Ilibretro-common/include \
-o samples/network/command_frames/harness_core.so \
samples/network/command_frames/harness_core.c
# and one that maps none, handing its RAM over as snes9x does
gcc -O1 -shared -fPIC -DHARNESS_NO_MAP -Ilibretro-common/include \
-o samples/network/command_frames/harness_core_nomap.so \
samples/network/command_frames/harness_core.c
- name: MCP over stdin and stdout, end to end
shell: bash
@@ -89,6 +69,4 @@ jobs:
set -eu
# null drivers: no display on the runner
timeout 300 python3 samples/network/mcp_server/stdio_e2e.py \
./retroarch samples/cores/video_views/video_views_libretro.so \
samples/network/command_frames/harness_core.so \
samples/network/command_frames/harness_core_nomap.so
./retroarch samples/cores/video_views/video_views_libretro.so
+1 -3
View File
@@ -430,9 +430,7 @@ jobs:
set -eu
# Load Content with no core lists every file an installed core
# or a built-in player opens, however long the installed cores'
# extensions run together. Content Scan's Content Location
# lists files and folders, and Import Content offers Content
# Scan alone.
# extensions run together.
samples/menu/load_content_filter/build.sh
./samples/menu/load_content_filter/load_content_filter_test
make -C samples/menu/load_content_filter clean
+21 -149
View File
@@ -2,20 +2,8 @@ name: CI fullscreen media menu
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-menu-media.yml'
# ci_paths: end
pull_request:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-menu-media.yml'
# ci_paths: end
workflow_dispatch:
permissions:
contents: read
@@ -53,47 +41,19 @@ jobs:
key: ${{ steps.apt.outputs.key }}
- name: Configure C89 frontend
run: ./configure --disable-qt --disable-vulkan --disable-wayland --disable-x11 --disable-opengl --disable-opengl1 --disable-opengl_core --disable-ffmpeg --disable-cheevos --disable-webmplayer --${{ matrix.threads }}-threads
run: ./configure --disable-qt --disable-vulkan --disable-wayland --disable-x11 --disable-opengl --disable-opengl1 --disable-opengl_core --disable-ffmpeg --disable-cheevos --enable-webmplayer --${{ matrix.threads }}-threads
- name: Build shipping frontend
run: make -j2 C89_BUILD=1
- name: Generate movie fixture
run: ffmpeg -v error -y -f lavfi -i testsrc2=size=320x240:rate=30 -f lavfi -i sine=frequency=440:sample_rate=48000 -t 3 -c:v libx264 -preset ultrafast -pix_fmt yuv420p -c:a aac -shortest samples/menu/rgui_media/fixture.mp4
- name: Real RGUI framebuffer and playback controls
run: python3 samples/menu/rgui_media/run.py --c89 --cadence-hz 30 samples/menu/rgui_media/fixture.mp4
run: python3 samples/menu/rgui_media/run.py --c89 samples/menu/rgui_media/fixture.mp4
- name: Real MaterialUI file-browser playback controls
run: python3 samples/menu/rgui_media/run.py --c89 --cadence-hz 30 --driver materialui samples/menu/rgui_media/fixture.mp4
run: python3 samples/menu/rgui_media/run.py --c89 --driver materialui samples/menu/rgui_media/fixture.mp4
- name: Real XMB file-browser playback controls
run: python3 samples/menu/rgui_media/run.py --c89 --cadence-hz 30 --driver xmb samples/menu/rgui_media/fixture.mp4
run: python3 samples/menu/rgui_media/run.py --c89 --driver xmb samples/menu/rgui_media/fixture.mp4
- name: Real Ozone file-browser playback controls
run: python3 samples/menu/rgui_media/run.py --c89 --cadence-hz 30 --driver ozone samples/menu/rgui_media/fixture.mp4
- name: UTF-8 subtitle sidecars across all four menus
run: |
python3 -c "from pathlib import Path; Path('samples/menu/rgui_media/fixture.srt').write_text('1\n00:00:00,000 --> 00:10:00,000\nSubtitle sidecar\nUTF-8 \u00e9\n\n', encoding='utf-8')"
python3 -c "from pathlib import Path; Path('samples/menu/rgui_media/fixture.en.srt').write_text('1\n00:00:00,000 --> 00:10:00,000\nEnglish track\n', encoding='utf-8')"
for driver in rgui materialui xmb ozone; do
python3 samples/menu/rgui_media/run.py --c89 --subtitles --driver "$driver" samples/menu/rgui_media/fixture.mp4
done
- name: Embedded MP4 subtitles across all four menus
run: |
python3 -c "from pathlib import Path; [Path('samples/menu/rgui_media/embedded-'+n+'.srt').write_text('1\n00:00:00,000 --> 00:10:00,000\nEmbedded '+n+' UTF-8 \u00e9\n', encoding='utf-8') for n in ('first', 'second')]"
ffmpeg -v error -y -i samples/menu/rgui_media/fixture.mp4 -i samples/menu/rgui_media/embedded-first.srt -i samples/menu/rgui_media/embedded-second.srt -map 0:v:0 -map 1:0 -map 2:0 -c:v copy -c:s mov_text samples/menu/rgui_media/embedded.mp4
for driver in rgui materialui xmb ozone; do
MEDIA_TEST_EMBEDDED_SUBTITLES=1 python3 samples/menu/rgui_media/run.py --c89 --driver "$driver" samples/menu/rgui_media/embedded.mp4
done
- name: Embedded Matroska subtitles across all four menus
run: |
ffmpeg -v error -y -f lavfi -i testsrc2=size=320x240:rate=30 -i samples/menu/rgui_media/embedded-first.srt -i samples/menu/rgui_media/embedded-second.srt -map 0:v:0 -map 1:0 -map 2:0 -t 4 -c:v libvpx-vp9 -deadline realtime -cpu-used 8 -g 30 -auto-alt-ref 0 -threads 1 -c:s srt samples/menu/rgui_media/embedded.mkv
for driver in rgui materialui xmb ozone; do
MEDIA_TEST_EMBEDDED_SUBTITLES=1 python3 samples/menu/rgui_media/run.py --c89 --driver "$driver" samples/menu/rgui_media/embedded.mkv
done
- name: Folder playback and fullscreen settings across all menus
run: |
ffmpeg -v error -y -i samples/menu/rgui_media/embedded.mkv -map 0:v:0 -c:v copy samples/menu/rgui_media/folder.mkv
for driver in rgui materialui xmb ozone; do
python3 samples/menu/rgui_media/run.py --c89 --desktop-refresh --driver "$driver" samples/menu/rgui_media/fixture.mp4
python3 samples/menu/rgui_media/run.py --c89 --continuous-error --driver "$driver" samples/menu/rgui_media/fixture.mp4
python3 samples/menu/rgui_media/run.py --c89 --continuous --driver "$driver" samples/menu/rgui_media/folder.mkv
done
run: python3 samples/menu/rgui_media/run.py --c89 --driver ozone samples/menu/rgui_media/fixture.mp4
- name: External movies and internal image activation across all menus
run: |
ffmpeg -v error -y -f lavfi -i color=c=orange:size=32x32 -frames:v 1 -threads 1 samples/menu/rgui_media/fixture.png
@@ -102,17 +62,16 @@ jobs:
python3 samples/menu/rgui_media/run.py --c89 --external --driver "$driver" samples/menu/rgui_media/fixture.png
python3 samples/menu/rgui_media/run.py --c89 --browser-image --driver "$driver" samples/menu/rgui_media/fixture.png
done
- name: Background setting browser picks images instead of viewing them
- name: Natural MP4 folder playback and file controls across all menus
run: |
ffmpeg -v error -y -f lavfi -i color=c=orange:size=32x32 -frames:v 1 -threads 1 samples/menu/rgui_media/fixture.png
for driver in xmb materialui; do
python3 samples/menu/rgui_media/run.py --c89 --wallpaper-pick --driver "$driver" samples/menu/rgui_media/fixture.png
done
- name: Images history entries open in the viewer and Back returns to the list
run: |
ffmpeg -v error -y -f lavfi -i color=c=orange:size=32x32 -frames:v 1 -threads 1 samples/menu/rgui_media/fixture.png
for driver in rgui materialui xmb ozone; do
python3 samples/menu/rgui_media/run.py --c89 --history-image --driver "$driver" samples/menu/rgui_media/fixture.png
python3 samples/menu/rgui_media/run.py --c89 --continuous --fullscreen-settings --require-cadence --driver "$driver" samples/menu/rgui_media/fixture.mp4
python3 samples/menu/rgui_media/run.py --c89 --continuous-error --driver "$driver" samples/menu/rgui_media/fixture.mp4
done
- name: Desktop refresh source lifecycle across all menus
run: |
for driver in rgui materialui xmb ozone; do
python3 samples/menu/rgui_media/run.py --c89 --desktop-refresh --driver "$driver" samples/menu/rgui_media/fixture.mp4
done
- name: Generate WebM transport fixtures
run: |
@@ -124,6 +83,12 @@ jobs:
python3 samples/menu/rgui_media/run.py --c89 --driver "$driver" samples/menu/rgui_media/fixture-opus.webm
python3 samples/menu/rgui_media/run.py --c89 --driver "$driver" samples/menu/rgui_media/fixture-vorbis.webm
done
- name: Natural WebM folder playback across all menus
run: |
for driver in rgui materialui xmb ozone; do
python3 samples/menu/rgui_media/run.py --c89 --continuous --fullscreen-settings --require-cadence --driver "$driver" samples/menu/rgui_media/fixture-vorbis.webm
python3 samples/menu/rgui_media/run.py --c89 --continuous-error --driver "$driver" samples/menu/rgui_media/fixture-vorbis.webm
done
window-toggle-media:
runs-on: ubuntu-latest
@@ -151,28 +116,11 @@ jobs:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: Configure C89 GL frontend
run: ./configure --disable-qt --disable-vulkan --disable-wayland --disable-ffmpeg --disable-cheevos --disable-webmplayer
run: ./configure --disable-qt --disable-vulkan --disable-wayland --disable-ffmpeg --disable-cheevos --enable-webmplayer
- name: Build shipping frontend
run: make -j2 C89_BUILD=1
- name: Generate moving VP8 fixture
run: |
ffmpeg -v error -y -f lavfi -i "testsrc2=size=320x240:rate=30,hue=h=90*t" -t 3 -c:v libvpx -deadline realtime -cpu-used 8 -g 90 -auto-alt-ref 0 samples/menu/rgui_media/window-toggle.webm
ffmpeg -v error -y -f lavfi -i "color=orange:size=320x240:rate=30" -t 3 -c:v libvpx -deadline realtime -cpu-used 8 -g 90 -auto-alt-ref 0 samples/menu/rgui_media/settings-preview.webm
- name: External media starts without browser frames and recovers from failure
run: |
set -eu
ffmpeg -v error -y -f lavfi -i color=c=orange:size=32x32 -frames:v 1 -threads 1 samples/menu/rgui_media/startup.png
python3 -c "from pathlib import Path; root = Path('samples/menu/rgui_media'); [(root / name).write_bytes(b'not decodable media') for name in ('corrupt.mp4', 'corrupt.png')]"
for driver in rgui materialui xmb ozone; do
for threaded in '' --threaded; do
for fixture in window-toggle.webm startup.png; do
xvfb-run -a python3 samples/menu/rgui_media/run.py --c89 --external --first-frame --video-driver gl --driver "$driver" $threaded "samples/menu/rgui_media/$fixture"
done
for fixture in corrupt.mp4 corrupt.png; do
xvfb-run -a python3 samples/menu/rgui_media/run.py --c89 --external --startup-failure --video-driver gl --driver "$driver" $threaded "samples/menu/rgui_media/$fixture"
done
done
done
run: ffmpeg -v error -y -f lavfi -i "testsrc2=size=320x240:rate=30,hue=h=90*t" -t 3 -c:v libvpx -deadline realtime -cpu-used 8 -g 90 -auto-alt-ref 0 samples/menu/rgui_media/window-toggle.webm
- name: Fullscreen window transitions retain movie pixels and seeking
run: |
for driver in rgui materialui xmb ozone; do
@@ -180,79 +128,3 @@ jobs:
xvfb-run -a python3 samples/menu/rgui_media/run.py --c89 --window-toggle --video-driver gl --driver "$driver" $threaded samples/menu/rgui_media/window-toggle.webm
done
done
- name: GPU folder playback and fullscreen settings across all menus
run: |
for driver in rgui materialui xmb ozone; do
for threaded in '' --threaded; do
MEDIA_TEST_SETTINGS_ORANGE=1 xvfb-run -a python3 samples/menu/rgui_media/run.py --c89 --fullscreen-settings --video-driver gl --driver "$driver" $threaded samples/menu/rgui_media/settings-preview.webm
xvfb-run -a python3 samples/menu/rgui_media/run.py --c89 --continuous-error --video-driver gl --driver "$driver" $threaded samples/menu/rgui_media/window-toggle.webm
done
done
- name: Generate delayed first-picture fixture
run: ffmpeg -v error -y -f lavfi -i "testsrc2=size=320x240:rate=30,hue=h=90*t" -vf "setpts=PTS+0.2/TB" -t 3 -c:v libvpx -deadline realtime -cpu-used 8 -g 90 -auto-alt-ref 0 samples/menu/rgui_media/delayed.webm
- name: Compare actual visible pictures after delayed-start seeks
run: |
for driver in rgui materialui xmb ozone; do
xvfb-run -a python3 samples/menu/rgui_media/run.py --c89 --video-driver gl --driver "$driver" --first-video-us 200000 samples/menu/rgui_media/delayed.webm
done
subtitle-sidecars:
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential clang ffmpeg
timeout-minutes: 20
steps:
- uses: actions/checkout@v6
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install dependencies
timeout-minutes: 10
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: SubRip parsing, task ownership and drawing (GCC and Clang sanitizers)
shell: bash
run: |
set -eu
for compiler in gcc clang; do
for sample in libretro-common/samples/formats/subtitle_srt samples/tasks/subtitle_load samples/gfx/media_subtitle samples/gfx/media_controls; do
extra_flags=''
if [ "$compiler" = clang ]; then extra_flags="-Wno-c99-extensions -Wno-c11-extensions"; fi
make -C "$sample" clean
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 CFLAGS="$extra_flags" \
make -C "$sample" check CC="$compiler" SANITIZER=address,undefined
done
done
- name: Subtitle ownership and publication races
shell: bash
run: |
set -eu
for sample in samples/tasks/subtitle_load samples/gfx/media_subtitle samples/gfx/media_controls; do
make -C "$sample" clean
TSAN_OPTIONS=halt_on_error=1 CFLAGS="-Wno-c99-extensions -Wno-c11-extensions" \
make -C "$sample" check CC=clang SANITIZER=thread
done
- name: Threadless subtitle loading and drawing
shell: bash
run: |
set -eu
for sample in libretro-common/samples/formats/subtitle_srt samples/tasks/subtitle_load samples/gfx/media_subtitle samples/gfx/media_controls; do
make -C "$sample" clean
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 \
make -C "$sample" check THREADS=0 SANITIZER=address,undefined
done
-15
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-msvc6-standin.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-msvc6-standin.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -68,9 +56,6 @@ jobs:
- name: Link with lld
run: sh .github/workflows/scripts/use-lld.sh
- name: Check the VC8 dialog optimizer workaround
run: python3 tools/msvc2005_dialog_check.py
- name: Compile and link what pkg/msvc/msvc-6 builds
shell: bash
run: |
-94
View File
@@ -1,94 +0,0 @@
name: CI Linux netplay end to end
on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/network/netplay_e2e/**'
- '.github/workflows/Linux-netplay-e2e.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/network/netplay_e2e/**'
- '.github/workflows/Linux-netplay-e2e.yml'
# ci_paths: end
workflow_dispatch:
permissions:
contents: read
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
jobs:
netplay-e2e:
name: Two retroarch processes in netplay
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential pkg-config zlib1g-dev python3 ccache
timeout-minutes: 40
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install dependencies
timeout-minutes: 10
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: Link with lld
run: sh .github/workflows/scripts/use-lld.sh
- name: Build RetroArch with no menu, video or sound
shell: bash
run: |
set -eu
./configure --disable-qt --disable-ffmpeg --disable-vulkan \
--disable-wayland --disable-x11 --disable-opengl --disable-egl \
--disable-kms --disable-sdl2 --disable-pulse --disable-alsa \
--disable-jack --disable-oss --disable-freetype --disable-menu
grep -q '^HAVE_NETWORKGAMEPAD = 1' config.mk
make -j"$(nproc)" CC="ccache gcc" CXX="ccache g++"
- name: Host and client over the loopback
shell: bash
run: |
set -eu
# analog sticks synced and not, lockstep asked for, a lockstep
# host with a rollback client, and a state too large to roll
# back; the peers' RAM agrees on every frame
make -C samples/network/netplay_e2e
timeout 600 make -C samples/network/netplay_e2e check RETROARCH=$PWD/retroarch
make -C samples/network/netplay_e2e clean
@@ -10,21 +10,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-network-clients.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-network-clients.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -124,20 +112,6 @@ jobs:
make -C samples/network/mcp_server check
make -C samples/network/mcp_server clean
- name: Netplay input bookkeeping
shell: bash
working-directory: ${{ github.workspace }}
run: |
set -eu
# netplay_frontend.c's input decode, real-client mask, analog
# joypad ports and relay host setup, as they ship
make -C samples/network/netplay_input clean
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 \
make -C samples/network/netplay_input check SANITIZER=address,undefined
make -C samples/network/netplay_input clean
make -C samples/network/netplay_input CC=x86_64-w64-mingw32-gcc LDFLAGS=-static
make -C samples/network/netplay_input clean
- name: GET_LOG's ring, written from four threads while read
shell: bash
working-directory: ${{ github.workspace }}
-18
View File
@@ -4,27 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/frontend/dbus_runtime/**'
- '.github/workflows/Linux-no-pkg-config.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/frontend/dbus_runtime/**'
- '.github/workflows/Linux-no-pkg-config.yml'
# ci_paths: end
workflow_dispatch:
permissions:
+2 -32
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-openxr-input.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-openxr-input.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -233,10 +221,8 @@ jobs:
# the tree, so nothing has to be installed. Qt has to go: the
# menu harness below replaces main(), which lives in ui_qt.o
# with Qt enabled.
# The screens' windows too, which video_screens_test runs.
./configure --disable-qt --enable-openxr --enable-video_windows
./configure --disable-qt --enable-openxr
grep -q '^HAVE_OPENXR = 1' config.mk
grep -q '^HAVE_VIDEO_WINDOWS = 1' config.mk
make -j$(nproc)
# Vulkan's headset host and the desktop GL drivers', side by
# side.
@@ -244,13 +230,6 @@ jobs:
test -f obj-unix/release/gfx/common/gl_openxr.o
test -f obj-unix/release/gfx/common/openxr_binding_gl.o
- name: Build and run video_screens_test
shell: bash
run: |
set -eu
python3 samples/settings/video_screens/build.py \
--output-dir "$RUNNER_TEMP/video-screens"
- name: Build and run stereo_headset_test
shell: bash
run: |
@@ -325,23 +304,14 @@ jobs:
set -eu
# The gl and glcore drivers' headset output has to configure,
# build and link without Vulkan.
./configure --disable-qt --enable-openxr --disable-vulkan \
--enable-video_windows
./configure --disable-qt --enable-openxr --disable-vulkan
grep -q '^HAVE_OPENXR = 1' config.mk
grep -q '^HAVE_VIDEO_WINDOWS = 1' config.mk
grep -q '^HAVE_VULKAN = 0' config.mk
make -j$(nproc)
test -f obj-unix/release/gfx/common/openxr_frame.o
test -f obj-unix/release/gfx/common/gl_openxr.o
test ! -e obj-unix/release/gfx/common/vulkan_openxr.o
- name: Build and run video_screens_test
shell: bash
run: |
set -eu
python3 samples/settings/video_screens/build.py \
--output-dir "$RUNNER_TEMP/video-screens"
- name: Build and run stereo_headset_test
shell: bash
run: |
@@ -171,14 +171,6 @@ jobs:
set -eu
timeout 180 python3 samples/input/overlay_on_screen/overlay_apng_press_on_screen_test.py ./retroarch
- name: Run overlay_stick_on_screen_test (a movable stick follows the finger and returns, threaded off and on)
shell: bash
run: |
set -eu
# A movable stick's geometry is sent only when it moves; the
# picture shows nothing a move needed was left out.
timeout 180 python3 samples/input/overlay_on_screen/overlay_stick_on_screen_test.py ./retroarch
- name: Run statistics_on_screen_test (threaded video off, then on)
shell: bash
run: |
+1 -13
View File
@@ -19,21 +19,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-pace-shadow.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-pace-shadow.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -50,7 +38,7 @@ jobs:
timeout-minutes: 45
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
# Line tables are all a sanitizer report needs. configure and
# make take these in place of DEBUG=1's -O0 -g, adding their own.
CFLAGS: -O0 -g1
-12
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-qnx-standin.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-qnx-standin.yml'
# ci_paths: end
workflow_dispatch:
permissions:
-12
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-qt-companion.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-qt-companion.yml'
# ci_paths: end
permissions:
contents: read
+43 -160
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-audio.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-audio.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -325,7 +313,7 @@ jobs:
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./upmix_test
echo "[pass] upmix_test (ASan)"
- name: Build and run discrete_multichannel_test (plain, ASan + UBSan, TSan)
- name: Build and run discrete_multichannel_test (plain, ASan + UBSan)
shell: bash
working-directory: samples/audio/discrete_multichannel
run: |
@@ -341,26 +329,12 @@ jobs:
# 5.1 core reaches a Dolby Digital decoder as AC-3 bursts
# that decode back to its own channels. Includes the
# shipping audio_driver.c.
# The builds in turn, the runs at once: each run is one
# thread, so a runner's second core takes another.
# Under ThreadSanitizer only the lane with a core submitting
# from a thread of its own beside the main thread's frame
# ends, pauses and fast-forward changes: the fast-forward
# measurement is the submitter's, and no other thread may
# write it.
. "$GITHUB_WORKSPACE/.github/workflows/scripts/run-parallel.sh"
make clean && make -j$(nproc) all
mv discrete_multichannel_test discrete_multichannel_test_plain
make clean && make -j$(nproc) all SANITIZER=thread
mv discrete_multichannel_test discrete_multichannel_test_tsan
./discrete_multichannel_test
echo "[pass] discrete_multichannel_test"
make clean && make -j$(nproc) all SANITIZER=address,undefined
par "discrete_multichannel_test" ./discrete_multichannel_test_plain
par "discrete_multichannel_test (ASan)" env ASAN_OPTIONS=detect_leaks=0 \
UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./discrete_multichannel_test
par "discrete_multichannel_test (TSan: core thread)" env DM_ONLY=inlinethread \
TSAN_OPTIONS=halt_on_error=1 ./discrete_multichannel_test_tsan
par_wait
rm -f discrete_multichannel_test_plain discrete_multichannel_test_tsan
ASAN_OPTIONS=detect_leaks=0 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./discrete_multichannel_test
echo "[pass] discrete_multichannel_test (ASan)"
- name: Build and run embedded_alsa_test (the embedded ALSA driver, mock kernel device)
shell: bash
@@ -580,7 +554,7 @@ jobs:
# audio/drivers/rwebaudio.c against a stand-in for its
# JavaScript half: frames of the layout the page took go out
# one plane per channel, and every byte count is in frames of
# that layout. Then os/emscripten/library_rwebaudio.js itself
# that layout. Then emscripten/library_rwebaudio.js itself
# under Node with a mock AudioContext: the destination is
# widened only past stereo and only as far as its
# maxChannelCount allows, and a stereo one is left as it was.
@@ -633,10 +607,6 @@ jobs:
make clean && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./oss_report_test
echo "[pass] oss_report_test (ASan)"
# RetroFW's jz4760 driver plays whole 16-byte DMA units only.
make clean && make -j$(nproc) all RETROFW=1 SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./oss_report_test
echo "[pass] oss_report_test (RetroFW, ASan)"
- name: Build and run live_drivers_test (a live PulseAudio server, a null ALSA PCM)
shell: bash
@@ -714,39 +684,38 @@ jobs:
# ratio at a bound and the pipe overflows behind it. Real time,
# so a loaded runner can shift the mean; the tolerance is ten
# times the settled residual.
make clean && make -j$(nproc) all SANITIZER=address,undefined
test -x pipeline_rate_control_test
ASAN_OPTIONS=detect_leaks=0 UBSAN_OPTIONS=print_stacktrace=1 timeout 120 \
./pipeline_rate_control_test
echo "[pass] pipeline_rate_control_test (ASan)"
# A core late by 60 ms every 2 s, audio sync off: the silence is
# the stalls' own and no more, the late audio is not kept, and
# rate control is not pinned against a backlog. And with sync on:
# the writer waits, nothing is dropped.
ASAN_OPTIONS=detect_leaks=0 timeout 120 ./pipeline_rate_control_test 12 4 jitter
ASAN_OPTIONS=detect_leaks=0 timeout 120 ./pipeline_rate_control_test 12 4 sync-jitter
echo "[pass] pipeline_rate_control_test (late core, ASan)"
# The 64 ms default buffer, sync off, a steady core and a late one:
# the consumer's chunks are whole publishes and the pipe's fill
# swings by one with the phase; nothing is dropped from a steady
# core at any phase.
ASAN_OPTIONS=detect_leaks=0 timeout 120 ./pipeline_rate_control_test 16 4 big
ASAN_OPTIONS=detect_leaks=0 timeout 120 ./pipeline_rate_control_test 16 4 big-jitter
echo "[pass] pipeline_rate_control_test (64 ms device, ASan)"
# The producer held 4 ms every five seconds, as a loaded runner
# holds it: a publish pushed across a sink window boundary. The
# estimate must settle and apply about zero, not the shift.
ASAN_OPTIONS=detect_leaks=0 timeout 120 ./pipeline_rate_control_test 16 4 big-stall
echo "[pass] pipeline_rate_control_test (stalled producer, ASan)"
# A float core on a float ring into a float device: a signal a
# tenth of an int16 LSB high arrives as published, not as zero.
# Every run is seconds of audio against a device that drains
# in real time, on almost no CPU: all eight at once, so the
# step takes as long as the longest of them.
. "$GITHUB_WORKSPACE/.github/workflows/scripts/run-parallel.sh"
make clean && make -j$(nproc) all SANITIZER=address,undefined
mv pipeline_rate_control_test pipeline_rate_control_test_asan
ASAN_OPTIONS=detect_leaks=0 timeout 120 ./pipeline_rate_control_test 16 4 float
echo "[pass] pipeline_rate_control_test (float core, ASan)"
make clean && make -j$(nproc) all SANITIZER=thread
test -x pipeline_rate_control_test_asan && test -x pipeline_rate_control_test
A="env ASAN_OPTIONS=detect_leaks=0 UBSAN_OPTIONS=print_stacktrace=1 timeout 120 ./pipeline_rate_control_test_asan"
par "pipeline_rate_control_test (ASan)" $A
par "pipeline_rate_control_test (late core, ASan)" $A 12 4 jitter
par "pipeline_rate_control_test (late core, Audio Sync, ASan)" $A 12 4 sync-jitter
par "pipeline_rate_control_test (64 ms device, ASan)" $A 16 4 big
par "pipeline_rate_control_test (64 ms device, late core, ASan)" $A 16 4 big-jitter
par "pipeline_rate_control_test (stalled producer, ASan)" $A 16 4 big-stall
par "pipeline_rate_control_test (float core, ASan)" $A 16 4 float
par "pipeline_rate_control_test (TSan)" env TSAN_OPTIONS=halt_on_error=1 \
timeout 240 ./pipeline_rate_control_test
par_wait
rm -f pipeline_rate_control_test_asan
TSAN_OPTIONS=halt_on_error=1 timeout 240 ./pipeline_rate_control_test
echo "[pass] pipeline_rate_control_test (TSan)"
- name: Build and run resampler_reset_test (ASan + UBSan)
shell: bash
working-directory: samples/audio/resampler_reset
@@ -1012,36 +981,11 @@ jobs:
./asio_ring_test
echo "[pass] asio_ring_test (ASan)"
- name: Build and run asio_teardown_test (TSan, ASan, MinGW under wine)
shell: bash
working-directory: samples/audio/asio_teardown
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The ASIO teardown's wait for a callback still inside after
# ASIOStop, the driver's code pulled out of asio.c: it ends as
# the last callback leaves, never while one is inside, and at
# 200 ms for one that never leaves. A build whose last callback
# out does not notify must fail.
for san in thread address,undefined; do
make clean && make -j$(nproc) all SANITIZER=$san
timeout 60 ./asio_teardown_test
done
make clean && make -j$(nproc) all TEST_DEFINES=-DASIO_TEST_NO_OUT_NOTIFY
if timeout 60 ./asio_teardown_test; then
echo "negative build passed"; exit 1
fi
make clean && make -j$(nproc) all CC=x86_64-w64-mingw32-gcc LDFLAGS=-static
WINEDEBUG=-all timeout 120 make check CC=x86_64-w64-mingw32-gcc LDFLAGS=-static
make clean
echo "[pass] asio_teardown_test"
- name: Build and run dsound_pump_test (MinGW, under wine)
shell: bash
working-directory: samples/audio/dsound_pump
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# audio/drivers/dsound.c end to end on wine's DirectSound, fed
# by an ALSA null PCM, which plays at real-time pace on a
# runner with no sound card. Pins that the pump - which now
@@ -1060,7 +1004,6 @@ jobs:
working-directory: samples/audio/wdmks_loop
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# audio/drivers/wdmks.c compiled whole, its WaveRT loop driven
# by hand: the test owns the driver's state, points the
# position register at a word of its own and moves the
@@ -1086,7 +1029,6 @@ jobs:
working-directory: samples/audio/mmdevice_notification
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
for threads in 0 1; do
make clean check THREADS=$threads SANITIZER=address,undefined
make clean THREADS=$threads CC=x86_64-w64-mingw32-gcc LDFLAGS=-static && make -j$(nproc) all THREADS=$threads CC=x86_64-w64-mingw32-gcc LDFLAGS=-static
@@ -1094,24 +1036,6 @@ jobs:
done
make clean
- name: Build and run xaudio_lend_test (wine)
shell: bash
working-directory: samples/audio/xaudio_lend
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The XAudio2 driver lends the free span at the head of its
# buffers (write_begin / write_end), so the frontend's output
# lands in the buffer XAudio2 plays instead of being copied
# in by write(). On wine's XAudio2: a lend stays within the
# free room and the allocation, lends and writes make one
# stream, write_end publishes all it is given without
# waiting, an abandoned lend takes nothing, and lent audio
# plays at the pace written audio does.
make clean && make -j$(nproc) all
REQUIRE_XAUDIO=1 WINEDEBUG=-all timeout 120 make check
echo "[pass] xaudio_lend_test (wine)"
- name: Build and run wasapi_exclusive_pacing_test (ASan + UBSan, then TSan)
shell: bash
working-directory: samples/audio/wasapi_exclusive_pacing
@@ -1127,24 +1051,14 @@ jobs:
# thread and the drain-first shared write this run gave 3-10% of
# periods unanswered; the first smaller-period attempt without the
# pump gave 75%.
# Each scenario is seconds of a fake device on the wall clock,
# on next to no CPU: every scenario under both sanitizers at
# once, so the step takes as long as one scenario.
. "$GITHUB_WORKSPACE/.github/workflows/scripts/run-parallel.sh"
make clean && make -j$(nproc) all SANITIZER=address,undefined
mv wasapi_exclusive_pacing_test wasapi_exclusive_pacing_test_asan
test -x wasapi_exclusive_pacing_test
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1 timeout 120 \
./wasapi_exclusive_pacing_test 3
echo "[pass] wasapi_exclusive_pacing_test (ASan)"
make clean && make -j$(nproc) all SANITIZER=thread
test -x wasapi_exclusive_pacing_test_asan && test -x wasapi_exclusive_pacing_test
n=$(PACING_SCENARIO=count ./wasapi_exclusive_pacing_test_asan)
for sc in $(seq 0 $((n - 1))) rest; do
par "wasapi_exclusive_pacing_test $sc (ASan)" env PACING_SCENARIO=$sc \
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1 \
timeout 120 ./wasapi_exclusive_pacing_test_asan 3
par "wasapi_exclusive_pacing_test $sc (TSan)" env PACING_SCENARIO=$sc \
timeout 180 ./wasapi_exclusive_pacing_test 3
done
par_wait
rm -f wasapi_exclusive_pacing_test_asan
timeout 180 ./wasapi_exclusive_pacing_test 3
echo "[pass] wasapi_exclusive_pacing_test (TSan)"
- name: Build and run sink_rate_test (ASan + UBSan)
shell: bash
@@ -1262,9 +1176,7 @@ jobs:
- name: Build and run sinc kernel dispatch test (C89, ASan + UBSan)
working-directory: samples/audio/sinc_dispatch
run: |
# A baseline build carries the AVX and AVX-512 kernels through
# per-function targets and runs each one the runner supports
# against the scalar kernel; the -mavx build must agree.
# The SSE-only build must still pick SSE when AVX is requested.
make -j$(nproc) check SANITIZER=address,undefined
if grep -qw avx /proc/cpuinfo; then
make clean
@@ -1277,40 +1189,24 @@ jobs:
# Live ratios under the table's design are decimated first:
# rejection as a table built for that ratio, the nominal path
# untouched, the output bound, crossfaded stage changes.
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
. "$GITHUB_WORKSPACE/.github/workflows/scripts/run-parallel.sh"
# Each build its own binary, then the runs at once: each is one
# thread, so the runner's cores take them side by side.
make clean
make TARGET=sff_asan SANITIZER=address,undefined
par "sinc_fastforward_test (ASan)" ./sff_asan
make -j$(nproc) check SANITIZER=address,undefined
if grep -qw avx /proc/cpuinfo; then
make TARGET=sff_avx CC="gcc -mavx" SANITIZER=address,undefined
par "sinc_fastforward_test (AVX, ASan)" ./sff_avx
make clean
make -j$(nproc) check CC="gcc -mavx" SANITIZER=address,undefined
fi
make TARGET=sff_mingw CC=x86_64-w64-mingw32-gcc
par "sinc_fastforward_test (MinGW, wine)" env WINEDEBUG=-all \
timeout 300 wine ./sff_mingw.exe
par_wait
rm -f sff_asan sff_avx sff_mingw.exe
make clean
WINEDEBUG=-all timeout 300 make check CC=x86_64-w64-mingw32-gcc \
RUN="wine ./sinc_fastforward_test.exe"
- name: Build and run sinc sibling test (C89, ASan + UBSan, MinGW)
working-directory: samples/audio/sinc_sibling
run: |
# Siblings share their parent's tables: a fresh stream either
# way, own state only, either free order.
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
. "$GITHUB_WORKSPACE/.github/workflows/scripts/run-parallel.sh"
make -j$(nproc) check SANITIZER=address,undefined
make clean
make TARGET=sibling_asan SANITIZER=address,undefined
make TARGET=sibling_mingw CC=x86_64-w64-mingw32-gcc
par "sinc_sibling_test (ASan)" ./sibling_asan
par "sinc_sibling_test (MinGW, wine)" env WINEDEBUG=-all \
timeout 300 wine ./sibling_mingw.exe
par_wait
rm -f sibling_asan sibling_mingw.exe
WINEDEBUG=-all timeout 300 make check CC=x86_64-w64-mingw32-gcc \
RUN="wine ./sinc_sibling_test.exe"
- name: Build and run mic_handshake_test (ASan + UBSan)
working-directory: samples/audio/mic_handshake
@@ -1332,7 +1228,6 @@ jobs:
- name: Build and run pipeline_rate_change_test (ASan + UBSan, mingw)
working-directory: samples/audio/pipeline_rate_change
run: |
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# A core rate change taken by the running driver: one device
# open, the tone at its pitch on both sides, the ring grown
# where the new rate needs it, time stretch refused.
@@ -1386,29 +1281,17 @@ jobs:
# holds it. With audio the only clock, rate control has to
# leave the ratio alone, inline and threaded, and still hold
# the fill when a present blocks behind the runloop's back.
# And neither leaving fast-forward nor resuming from a pause
# may hold the core while a queue plays out, threaded or
# inline (#19940).
# Plain, not sanitized: it is the clock that is measured,
# and a sanitizer's slowdown is a host that starves the
# consumer whatever the cap does. Underruns with the cap are
# retried, since a host that takes the consumer off its core
# shows the same with the cap off; only a cap that never runs
# clean fails.
# Its lanes run in real time on next to no CPU, so they run
# at once, one setting each: the step takes as long as the
# longest setting, about 12 s, not the longest case.
. "$GITHUB_WORKSPACE/.github/workflows/scripts/run-parallel.sh"
make clean && make -j$(nproc)
test -x pipeline_clocked_test
for lane in audio_paced_16 audio_paced_32 audio_paced_64 \
setpoint_16 setpoint_32 setpoint_64 \
rate_control_32 rate_control_64 sync_off \
ff_exit_1 ff_exit_2 ff_exit_3 ff_exit_4 ff_exit_5; do
par "pipeline_clocked_test (fill cap: $lane)" \
env PACED_ONLY=$lane timeout 300 ./pipeline_clocked_test 3
done
par_wait
PACED_ONLY=1 timeout 600 ./pipeline_clocked_test 3
echo "[pass] pipeline_clocked_test (fill cap)"
- name: Build and run resampler option tests (C89, ASan + UBSan)
working-directory: samples/audio/resampler_options
run: |
+1 -35
View File
@@ -42,7 +42,7 @@ jobs:
name: Build and run samples/cores
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential pkg-config ffmpeg libavcodec-dev libavformat-dev libavutil-dev libswscale-dev libswresample-dev libv4l-dev libasound2-dev ccache libavdevice-dev libavfilter-dev libpipewire-0.3-dev mesa-vulkan-drivers
APT_PKGS: build-essential pkg-config ffmpeg libavcodec-dev libavformat-dev libavutil-dev libswscale-dev libswresample-dev libv4l-dev libasound2-dev ccache libavdevice-dev libavfilter-dev libpipewire-0.3-dev
timeout-minutes: 25
steps:
@@ -71,18 +71,6 @@ jobs:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: Select software Vulkan for CPU fixtures
run: |
set -eu
for icd in /usr/share/vulkan/icd.d/lvp_icd*.json; do
if [ -f "$icd" ]; then
printf 'VK_ICD_FILENAMES=%s\n' "$icd" >> "$GITHUB_ENV"
exit 0
fi
done
echo "Lavapipe ICD is missing" >&2
exit 1
- name: Link with lld
run: sh .github/workflows/scripts/use-lld.sh
@@ -153,28 +141,6 @@ jobs:
timeout 60 ./pipewire_poll_test
echo "[pass] pipewire_poll_test (ASan)"
- name: FFmpeg hardware-context replacement (plain, ASan + UBSan)
working-directory: samples/cores/ffmpeg_hw_context
run: |
set -eu
make clean
make check
make clean
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1:print_stacktrace=1 \
make check SANITIZER=address,undefined
- name: FFmpeg subtitle hand-off to the renderer (plain, ASan + UBSan, TSan)
working-directory: samples/cores/ffmpeg_ass_events
run: |
set -eu
make clean
make check
make clean
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1:print_stacktrace=1 \
make check SANITIZER=address,undefined
make clean
TSAN_OPTIONS=halt_on_error=1 make check SANITIZER=thread
- name: Build and run ffmpeg_sweep_test (plain, ASan + UBSan, TSan)
shell: bash
working-directory: samples/cores/ffmpeg_sweep
+10 -120
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-formats.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-formats.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -32,12 +20,12 @@ concurrency:
cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
jobs:
formats-core:
name: Core format decoders and containers
samples-formats:
name: Build and run samples/formats
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential ffmpeg clang ccache
timeout-minutes: 30
timeout-minutes: 10
steps:
- name: Checkout
@@ -85,15 +73,6 @@ jobs:
ccache -M 250M
ccache -z
- name: HEVC hidden pictures and prior-output discard
run: make -C libretro-common/samples/formats/h265 output-flags-check SANITIZER=address,undefined
- name: HEVC parameter replacement and output ownership (TSan)
run: TSAN_OPTIONS=halt_on_error=1 make -C libretro-common/samples/formats/h265 -B output-flags-check SANITIZER=thread
- name: MP4 hidden-picture timestamps, seeks and partial input
run: make -C libretro-common/samples/formats/vp9 mp4-h26x-check SANITIZER=address,undefined
- name: Build and run dts_lpcm_test (plain, ASan + UBSan)
shell: bash
working-directory: samples/formats/dts_lpcm
@@ -253,6 +232,13 @@ jobs:
make av1_params_test SANITIZER=address,undefined
python3 av1_fixtures.py
- name: VP9 sessions and WebM GPU dispatch (ASan + UBSan)
working-directory: libretro-common/samples/formats/vp9
run: |
make check stream-check pixel-check SANITIZER=address,undefined
make stack-check CC=gcc
make stack-check CC=clang
- name: Build and run video_hdr_fp16_test (ASan + UBSan + LSan)
shell: bash
working-directory: samples/formats/video_hdr_fp16
@@ -298,99 +284,3 @@ jobs:
with:
path: ~/.ccache
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ github.sha }}
vp9-matroska:
name: VP9 and Matroska codec conformance
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential ffmpeg clang ccache
timeout-minutes: 20
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install dependencies
timeout-minutes: 20
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: Link with lld
run: sh .github/workflows/scripts/use-lld.sh
- name: Restore ccache
uses: actions/cache/restore@v4
with:
path: ~/.ccache
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ github.sha }}
restore-keys: |
ccache-${{ github.workflow }}-${{ github.job }}-
- name: Enable ccache
run: |
set -eu
export CCACHE_DIR="$HOME/.ccache"
echo "CCACHE_DIR=$CCACHE_DIR" >> "$GITHUB_ENV"
echo "/usr/lib/ccache" >> "$GITHUB_PATH"
ccache -M 250M
ccache -z
- name: VP9 sessions and WebM GPU dispatch (ASan + UBSan)
working-directory: libretro-common/samples/formats/vp9
run: |
make check stream-check h26x-check h26x-color-check pixel-check SANITIZER=address,undefined
make stack-check CC=gcc
make stack-check CC=clang
H26X_TEST_THREADS=4 make h26x-check h26x-color-check SANITIZER=address,undefined
- name: Matroska concurrent decode and output ownership (TSan)
working-directory: libretro-common/samples/formats/vp9
run: |
make -B rwebm_h26x_stream_test rwebm_h26x_hw_test SANITIZER=thread
H26X_TEST_THREADS=4 TSAN_OPTIONS=halt_on_error=1 make h26x-check SANITIZER=thread
- name: ccache statistics
if: ${{ !cancelled() }}
continue-on-error: true
run: ccache -sv
- name: Save ccache
# Only master's pushes keep a cache: pull requests restore
# master's, so one push does not evict the next one's.
if: success() && github.event_name == 'push' && github.ref == 'refs/heads/master'
uses: actions/cache/save@v4
with:
path: ~/.ccache
key: ccache-${{ github.workflow }}-${{ github.job }}-${{ github.sha }}
samples-formats:
name: Build and run samples/formats
runs-on: ubuntu-latest
needs: [formats-core, vp9-matroska]
if: always()
timeout-minutes: 1
steps:
- name: Require both format suites
env:
FORMATS_RESULT: ${{ needs.formats-core.result }}
CODECS_RESULT: ${{ needs.vp9-matroska.result }}
run: |
test "$FORMATS_RESULT" = success
test "$CODECS_RESULT" = success
File diff suppressed because it is too large. Load diff
+10 -271
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-input.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-input.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -263,19 +251,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 timeout 60 ./connection_gate_test
make clean
- name: Build and run gekko_hid_test (ASan + UBSan, TSan)
shell: bash
working-directory: samples/input/gekko_hid
run: |
set -eu
# The Wii's USB HID driver taking pads away against os/gekko
# stand-ins; check also requires a driver that cancels a
# reader only once to fail.
make clean && ASAN_OPTIONS=detect_leaks=1 timeout 120 make check SANITIZER=address,undefined
make clean && make -j$(nproc) all SANITIZER=thread
TSAN_OPTIONS=halt_on_error=1 timeout 60 ./gekko_hid_test
make clean
- name: Build and run hidraw_hid_test (ASan + UBSan)
shell: bash
working-directory: samples/input/hidraw_hid
@@ -430,48 +405,6 @@ jobs:
make clean
echo "[pass] android_key_state_test (ASan)"
- name: Build and run android_poll_changes_test (ASan + UBSan)
shell: bash
working-directory: samples/input/android_poll_changes
run: |
set -eu
# What one Android input poll applies. The input queue is
# read on a thread of its own, so a poll is handed every
# event since the last, and a key, a finger or a mouse
# button can go down and back up in between. Pins that such a
# press is shown for one poll, that the order is kept, that
# a repeat never holds anything back, and that rows,
# devices, fingers, buttons and hats are told apart. A drain that
# applies everything it has is put back and asserted to be
# caught.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 60 ./android_poll_changes_test
make clean
echo "[pass] android_poll_changes_test (ASan)"
- name: Build and run android_input_ring_test (ASan + UBSan, TSan, mingw-w64)
shell: bash
working-directory: samples/input/android_input_ring
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The Android input reader's ring: each event a record of the
# size it needs, written where the poll applies it. Pins that
# the poll reads the reader's bytes in place, that no record
# crosses the ring's end over many laps, that a stick's moves
# merge only while unpublished, and that on two threads every
# record arrives once, whole and in order.
make clean && make all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 120 ./android_input_ring_test
make clean && make all SANITIZER=thread
TSAN_OPTIONS=halt_on_error=1 timeout 300 ./android_input_ring_test
make clean && make CC=x86_64-w64-mingw32-gcc
WINEDEBUG=-all timeout 180 wine ./android_input_ring_test.exe
make clean
echo "[pass] android_input_ring_test (ASan, TSan, Wine)"
- name: Build and run output_store_test (ASan + UBSan, TSan)
shell: bash
working-directory: samples/input/output_store
@@ -547,71 +480,10 @@ jobs:
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make -C samples/input/hotkey_menu clean check SANITIZER=address,undefined
make -C samples/input/hotkey_menu clean check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make -C samples/input/hotkey_menu clean
- name: Build and run pointer_second_test (ASan + UBSan, mingw + Wine)
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# A core's pointer read where the input driver has a second
# list (Android's second display): its fingers go after the
# overlay's, after none while the overlay blocks the pointer,
# else after the driver's main list; a driver with no second
# list answers with its main list alone. The test runs
# input_state_device() extracted from input_driver.c.
make -C samples/input/pointer_second clean check SANITIZER=address,undefined
make -C samples/input/pointer_second clean check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make -C samples/input/pointer_second clean
- name: Build and run android_focus_test (ASan + UBSan, mingw + Wine)
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# RetroArch's focus on Android from its Activity's window.
make -C samples/input/android_focus clean check SANITIZER=address,undefined
make -C samples/input/android_focus clean check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make -C samples/input/android_focus clean
- name: Build and run android_second_surface_test (ASan + UBSan, mingw + Wine)
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The second display's surface going: surfaceDestroyed never
# waits for the renderer, and the next poll lets it go.
make -C samples/frontend/android_second_surface clean check SANITIZER=address,undefined
make -C samples/frontend/android_second_surface clean check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make -C samples/frontend/android_second_surface clean
- name: Build and run mapped_port_test and mapped_port_openxr_test (ASan + UBSan, mingw + Wine)
shell: bash
working-directory: samples/input/mapped_port
run: |
set -euo pipefail
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# input/input_driver.c's Mapped Port sharing and Plays As
# against a stand-in frontend. Users mapped to one core port:
# its rumble, the menu, the hotkeys; controllers placed by
# their own player, sharing it, and their own hotkey buttons;
# the headset's controllers as player 1's; built with and
# without OpenXR.
make clean && make SANITIZER=address,undefined all
for t in mapped_port_test mapped_port_openxr_test; do
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
./$t | tee -a mapped_port.log
done
grep -q "^PASS mapped_port_test$" mapped_port.log
grep -q "^PASS mapped_port_openxr_test$" mapped_port.log
make clean
make CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine check
make clean
rm -f mapped_port.log
- name: Build and run key_lane_test (plain, ASan + UBSan, TSan)
shell: bash
working-directory: samples/input/key_lane
@@ -704,87 +576,6 @@ jobs:
make clean
echo "[pass] device_registry_test (ASan)"
- name: Build and run input_group_test (ASan + UBSan)
shell: bash
working-directory: samples/input/input_group
run: |
set -eu
# Device groups: a controller that reaches the OS as several
# input devices, read as one pad. Pins that the Android
# driver's rule table takes the devices its old chain of
# special cases took, in the same order; that either join
# order gives one pad; that a member leaving keeps it and the
# lead leaving hands the slot on; that two groups stand at
# once; and that a button that only joins is nothing alone.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 60 ./input_group_test
make clean
echo "[pass] input_group_test (ASan)"
- name: Build and run linux_pad_members_test (ASan + UBSan)
shell: bash
working-directory: samples/input/linux_pad_members
run: |
set -eu
# A pad's other nodes under its HID device - motion sensors,
# touchpad, hidraw - and the role the udev driver gives each:
# tagged nodes first, untagged ones tried for the sensors in
# order (a Wii Remote's), the touchpad never as the sensors,
# the pad's own node never, the hidraw node only for a pad
# that reads its reports.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 60 ./linux_pad_members_test
make clean
echo "[pass] linux_pad_members_test (ASan)"
- name: Build and run ignore_devices_test (ASan + UBSan)
shell: bash
working-directory: samples/input/ignore_devices
run: |
set -eu
# SDL_GAMECONTROLLER_IGNORE_DEVICES as the joypad drivers read
# it: the controllers Steam Input stands in for, left to it so
# that a pad is not read twice. The list as Steam writes it,
# and as SDL reads it - spaces, case, no 0x, a malformed entry
# passed over.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 60 ./ignore_devices_test
make clean
echo "[pass] ignore_devices_test (ASan)"
- name: Build and run overlay_contact_test (ASan + UBSan)
shell: bash
working-directory: samples/input/overlay_contact
run: |
set -eu
# A finger's contact on an overlay D-pad or face-button area:
# each tip of the ellipse the touchscreen reports presses the
# way it lies, sized per axis, with a dead zone at the middle;
# with no size, the way the centre lies.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
timeout 60 ./overlay_contact_test
make clean
echo "[pass] overlay_contact_test (ASan)"
- name: Build and run win_pad_ident_test (ASan + UBSan)
shell: bash
working-directory: samples/input/win_pad_ident
run: |
set -eu
# Which of Windows' views reads a controller, held to a table
# of real ones - Xbox pads on USB, Bluetooth and Bluetooth LE,
# paths in either case, DualShock 4 and DualSense on cable and
# Bluetooth at once, WinUSB pads, Steam Input's - under every
# Windows joypad driver: one port each.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 60 ./win_pad_ident_test
make clean
echo "[pass] win_pad_ident_test (ASan)"
- name: Build and run device_pool_test (ASan + UBSan)
shell: bash
working-directory: samples/input/device_pool
@@ -879,7 +670,6 @@ jobs:
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 ./winraw_mouse_buttons_test
make clean SANITIZER=thread && make -j$(nproc) all SANITIZER=thread
@@ -893,7 +683,6 @@ jobs:
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 ./connect_parity_test
make clean CC=x86_64-w64-mingw32-gcc LDFLAGS=-static && make -j$(nproc) all CC=x86_64-w64-mingw32-gcc LDFLAGS=-static
@@ -905,7 +694,6 @@ jobs:
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 ./sensor_snap_test
make clean SANITIZER=thread && make -j$(nproc) all SANITIZER=thread
@@ -919,7 +707,6 @@ jobs:
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean all check
make clean
make SANITIZER=address,undefined check
@@ -955,10 +742,13 @@ jobs:
run: |
set -eu
# input/drivers/winraw_input.c with its keyboard and mouse
# read in bulk by the poll. The real driver under Wine on a
# virtual display, with the focused window made and pumped by
# a second thread as the video thread does, and the driver
# started from that thread: init makes no window and the first poll does, on the polling
# read in bulk by the poll (the default;
# RETROARCH_RAWINPUT_POLL=0 turns it off). The real
# driver under Wine on a virtual display, with the focused
# window made and pumped by a second thread as the video
# thread does, and the driver started from that thread. With
# the switch off the driver is as it was. With it on: init
# makes no window and the first poll does, on the polling
# thread; six keys injected with SendInput() while nothing
# pumps are read by one bulk read, none as a message, none
# left in the queue, and come out of the poll as six key
@@ -1122,7 +912,6 @@ jobs:
working-directory: samples/input/net_retropad_repeat
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The Remote RetroPad core sends a control's state when it
# changes, by UDP. The real core is driven by a frontend of
# a few callbacks and its messages read back over loopback:
@@ -1143,7 +932,6 @@ jobs:
working-directory: samples/input/output_writer
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
timeout 30 make check
make clean SANITIZER=thread && make -j$(nproc) all SANITIZER=thread
@@ -1171,55 +959,6 @@ jobs:
timeout 120 ./udev_rumble_test
make clean
echo "[pass] udev_rumble_test"
- name: Build and run sensor_subdevice_test (ASan + UBSan)
shell: bash
working-directory: samples/input/sensor_subdevice
run: |
set -eu
# A core's sensor calls for a controller's sub-device (the
# Nunchuk, a left Joy-Con) through the frontend's wrappers as
# they ship: passed on with the index once enabled, refused
# when no driver has it, the controller's own unchanged.
make clean && make SANITIZER=address,undefined
UBSAN_OPTIONS=halt_on_error=1 timeout 60 ./sensor_subdevice_test
make clean
echo "[pass] sensor_subdevice_test"
- name: Build and run dingux_rumble_test (ASan + UBSan, then TSan)
shell: bash
working-directory: samples/input/dingux_rumble
run: |
set -eu
# The Dingux joypad driver's vibration motor, through evdev
# and the output writer: the first node that plays a sine is
# taken, the strengths and gain are written as they change and
# not again, a motor slow to take an upload does not hold the
# call, and stopping the driver lets the motor go.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
timeout 120 ./dingux_rumble_test
timeout 120 ./dingux_rumble_test_nothreads
make clean SANITIZER=thread && make -j$(nproc) all SANITIZER=thread
timeout 120 ./dingux_rumble_test
make clean
echo "[pass] dingux_rumble_test"
- name: Build and run udev_player_lights_test (ASan + UBSan, then TSan)
shell: bash
working-directory: samples/input/udev_player_lights
run: |
set -eu
# The udev joypad driver lights each pad's player through its
# LED class devices, found under the pad in a directory laid
# out as /sys is: a DualSense's five and not its light bar, a
# DualShock 4's light bar by colour, a DualShock 3's, an Xbox
# 360 pad's ring and not a receiver's four; out when no port
# reads it, unless it was never lit. Written by the rumble
# writer's thread, and without threads by the caller.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 timeout 60 ./udev_player_lights_test
ASAN_OPTIONS=detect_leaks=1 timeout 60 ./udev_player_lights_test_nothreads
make clean SANITIZER=thread && make -j$(nproc) all SANITIZER=thread
timeout 60 ./udev_player_lights_test
make clean
echo "[pass] udev_player_lights_test"
- name: Build and run udev_ds3_pressure_test (ASan + UBSan)
shell: bash
working-directory: samples/input/udev_ds3_pressure
@@ -1298,7 +1037,6 @@ jobs:
working-directory: samples/input/xinput_rumble
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# The XInput joypad driver writes rumble from a thread of its
# own. The real driver is given an XInputSetState that takes
# 60 ms: the call returns at once, the latest strength is the
@@ -1350,8 +1088,9 @@ jobs:
set -eu
# input/drivers_joypad/winraw_joypad.c with its controllers
# read by the poll. The real driver under Wine, started from
# a second thread as it is from the video thread: init makes
# no window and the first poll
# a second thread as it is from the video thread: with
# RETROARCH_RAWINPUT_POLL=0 init makes the window as it
# always did; otherwise init makes none and the first poll
# does, on the polling thread, marking it as one whose pump
# leaves raw input alone, with one bulk read a poll; a device
# change waiting for the window is taken by the poll;
@@ -4,43 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/network/cheevos_login/**'
- 'samples/network/gdrive_backup/**'
- 'samples/network/net_http_semantics/**'
- 'samples/network/nfs_backup/**'
- 'samples/network/s3_backup/**'
- 'samples/network/smb_backup/**'
- 'samples/network/webdav_backup/**'
- 'samples/network/webdav_options/**'
- 'samples/network/webdav_reauth/**'
- '.github/workflows/Linux-samples-network.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/network/cheevos_login/**'
- 'samples/network/gdrive_backup/**'
- 'samples/network/net_http_semantics/**'
- 'samples/network/nfs_backup/**'
- 'samples/network/s3_backup/**'
- 'samples/network/smb_backup/**'
- 'samples/network/webdav_backup/**'
- 'samples/network/webdav_options/**'
- 'samples/network/webdav_reauth/**'
- '.github/workflows/Linux-samples-network.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -6,12 +6,6 @@ on:
- master
paths:
- 'record/**'
- 'libretro-common/net/net_rtmp*'
- 'libretro-common/include/net/net_rtmp*'
- 'libretro-common/formats/flv/**'
- 'libretro-common/include/formats/rflv_mux.h'
- 'libretro-common/samples/net/rtmp/**'
- 'libretro-common/samples/formats/flv/**'
- 'gfx/common/videotoolbox_encode*.h'
- 'libretro-common/queues/**'
- 'libretro-common/include/retro_spsc.h'
@@ -23,12 +17,6 @@ on:
- master
paths:
- 'record/**'
- 'libretro-common/net/net_rtmp*'
- 'libretro-common/include/net/net_rtmp*'
- 'libretro-common/formats/flv/**'
- 'libretro-common/include/formats/rflv_mux.h'
- 'libretro-common/samples/net/rtmp/**'
- 'libretro-common/samples/formats/flv/**'
- 'gfx/common/videotoolbox_encode*.h'
- 'libretro-common/queues/**'
- 'libretro-common/include/retro_spsc.h'
@@ -136,7 +124,6 @@ jobs:
working-directory: samples/record/file_win32
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make check SANITIZER=address,undefined
make clean && make check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make clean
@@ -146,36 +133,14 @@ jobs:
working-directory: samples/record/mp4_mux
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make -j$(nproc) check SANITIZER=address,undefined
make clean && make -j$(nproc) check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make clean
- name: Native FLV mux (ASan + UBSan, mingw-w64)
shell: bash
working-directory: libretro-common/samples/formats/flv
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make check stream-check SANITIZER=address,undefined
make clean && make check stream-check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make clean
- name: RTMP protocol and sockets (ASan + UBSan, mingw-w64)
shell: bash
working-directory: libretro-common/samples/net/rtmp
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make check peer-check SANITIZER=address,undefined
make clean && make check peer-check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make clean
- name: GPU PCM output pipeline (ASan + UBSan, TSan, mingw-w64)
working-directory: samples/record/gpu_av_output
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make -j$(nproc) check SANITIZER=address,undefined
make clean && make thread_test session_test SANITIZER=thread
TSAN_OPTIONS=halt_on_error=1 timeout 120 ./thread_test
@@ -191,10 +156,6 @@ jobs:
make clean && make dispatch_test session_integration SANITIZER=thread
TSAN_OPTIONS=halt_on_error=1 timeout 120 ./dispatch_test
TSAN_OPTIONS=halt_on_error=1 timeout 120 ./session_integration
# one Wine server for the three tests: one each, a test that
# starts as the last server leaves is cut off before main()
wineserver -p
trap 'wineserver -k || true' EXIT
make clean && make check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make clean
@@ -202,7 +163,6 @@ jobs:
working-directory: samples/record/nvenc_frontend
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make check SANITIZER=address,undefined
make clean && make check CC=x86_64-w64-mingw32-gcc EXE=.exe RUNNER=wine
make clean
@@ -213,7 +173,6 @@ jobs:
working-directory: samples/record/videotoolbox_encode
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make check thread_test worker_thread_test audio_thread_test av_session_thread_test SANITIZER=address,undefined
./thread_test
./worker_thread_test
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-settings.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-samples-settings.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -32,54 +20,6 @@ concurrency:
cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
jobs:
ps3-user-paths:
name: PS3 per-user directories
runs-on: ubuntu-latest
timeout-minutes: 15
env:
APT_PKGS: gcc-mingw-w64-x86-64 wine64
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install dependencies
timeout-minutes: 15
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- name: Regression test
working-directory: samples/frontend/ps3_user_paths
run: |
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
# Each console user's own directory, the shared USRDIR layout
# when it cannot be used, a user's first boot copying the
# shared data, and one copy per imported configuration.
make clean
make -j$(nproc) SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 ./ps3_user_paths_test
make clean
make -j$(nproc) CC=x86_64-w64-mingw32-gcc TARGET=ps3_user_paths_test.exe
WINEDEBUG=-all timeout 300 wine ./ps3_user_paths_test.exe
make clean TARGET=ps3_user_paths_test.exe
samples-settings:
name: Build and run samples/settings
runs-on: ubuntu-latest
@@ -190,17 +130,6 @@ jobs:
# dropped that setting and saved the command-line value.
make clean && make check SANITIZER=address,undefined
- name: Build and run float_rows_test (ASan + UBSan)
shell: bash
working-directory: samples/settings/float_rows
run: |
set -eu
# Built without the menu: the float settings that are not the
# menu's (aspect ratio, refresh rate, fast-forward ratio, ...)
# must still be loaded and saved, and no setting of any kind
# may be listed twice.
make clean && make check SANITIZER=address,undefined
- name: ccache statistics
if: ${{ !cancelled() }}
continue-on-error: true
-203
View File
@@ -4,97 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'libretro-common/samples/encodings/rbzip2/**'
- 'samples/menu/dirwalk/**'
- 'samples/playlist/playlist_parity_test.c'
- 'samples/tasks/autodetect_handoff/**'
- 'samples/tasks/bluetooth_scan/**'
- 'samples/tasks/bps_patch/**'
- 'samples/tasks/bsv_checkpoint/**'
- 'samples/tasks/bsv_replay/**'
- 'samples/tasks/bsv_replay_init/**'
- 'samples/tasks/bsv_statestream/**'
- 'samples/tasks/cloudsync/**'
- 'samples/tasks/content_prefetch/**'
- 'samples/tasks/core_backup/**'
- 'samples/tasks/core_updater/**'
- 'samples/tasks/database/**'
- 'samples/tasks/decompress/**'
- 'samples/tasks/file_transfer/**'
- 'samples/tasks/http/**'
- 'samples/tasks/http_emscripten/**'
- 'samples/tasks/image_decode_slice/**'
- 'samples/tasks/input_remap/**'
- 'samples/tasks/natt_desc/**'
- 'samples/tasks/netplay_nat/**'
- 'samples/tasks/ordering/**'
- 'samples/tasks/overlay/**'
- 'samples/tasks/patch_stream/**'
- 'samples/tasks/pl_thumbnail/**'
- 'samples/tasks/playlist_manager/**'
- 'samples/tasks/save_state/**'
- 'samples/tasks/turbo_bind/**'
- 'samples/tasks/video_shader_parse/**'
- 'samples/tasks/wait_timeout/**'
- 'samples/tasks/watchdog/**'
- 'samples/tasks/wifi_tasks/**'
- 'samples/playlist/**'
- 'samples/ui_companion_log_stub.c'
- '.github/workflows/Linux-samples-tasks.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'libretro-common/samples/encodings/rbzip2/**'
- 'samples/menu/dirwalk/**'
- 'samples/playlist/playlist_parity_test.c'
- 'samples/tasks/autodetect_handoff/**'
- 'samples/tasks/bluetooth_scan/**'
- 'samples/tasks/bps_patch/**'
- 'samples/tasks/bsv_checkpoint/**'
- 'samples/tasks/bsv_replay/**'
- 'samples/tasks/bsv_replay_init/**'
- 'samples/tasks/bsv_statestream/**'
- 'samples/tasks/cloudsync/**'
- 'samples/tasks/content_prefetch/**'
- 'samples/tasks/core_backup/**'
- 'samples/tasks/core_updater/**'
- 'samples/tasks/database/**'
- 'samples/tasks/decompress/**'
- 'samples/tasks/file_transfer/**'
- 'samples/tasks/http/**'
- 'samples/tasks/http_emscripten/**'
- 'samples/tasks/image_decode_slice/**'
- 'samples/tasks/input_remap/**'
- 'samples/tasks/natt_desc/**'
- 'samples/tasks/netplay_nat/**'
- 'samples/tasks/ordering/**'
- 'samples/tasks/overlay/**'
- 'samples/tasks/patch_stream/**'
- 'samples/tasks/pl_thumbnail/**'
- 'samples/tasks/playlist_manager/**'
- 'samples/tasks/save_state/**'
- 'samples/tasks/turbo_bind/**'
- 'samples/tasks/video_shader_parse/**'
- 'samples/tasks/wait_timeout/**'
- 'samples/tasks/watchdog/**'
- 'samples/tasks/wifi_tasks/**'
- 'samples/playlist/**'
- 'samples/ui_companion_log_stub.c'
- '.github/workflows/Linux-samples-tasks.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -337,7 +249,6 @@ jobs:
working-directory: samples/tasks/cloudsync
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean SANITIZER=address,undefined && make -j$(nproc) cloudsync_commit_test SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 ./cloudsync_commit_test
make clean SANITIZER=thread && make -j$(nproc) cloudsync_commit_test SANITIZER=thread
@@ -573,21 +484,6 @@ jobs:
timeout 120 ./bsv_replay_init_test
echo "[pass] bsv_replay_init_test (STATESTREAM, ASan + UBSan)"
- name: Build and run netplay BSV recording tests
shell: bash
working-directory: samples/tasks/bsv_replay_init
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make clean && make -j$(nproc) NETPLAY=1 SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1:allocator_may_return_null=1 \
timeout 120 ./bsv_replay_init_test
make clean && make -j$(nproc) NETPLAY=1 STATESTREAM=1 SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1:allocator_may_return_null=1 \
timeout 120 ./bsv_replay_init_test
make clean && make -j$(nproc) NETPLAY=1 CC=x86_64-w64-mingw32-gcc LDFLAGS=-static
WINEDEBUG=-all timeout 120 wine ./bsv_replay_init_test.exe
- name: Build and run bsv_statestream_test (plain, ASan + UBSan)
shell: bash
working-directory: samples/tasks/bsv_statestream
@@ -1210,53 +1106,6 @@ jobs:
make clean
echo "[pass] database_scan_test (ASan)"
- name: Build and run database_scan_test (TSan, no threads, no readers)
shell: bash
working-directory: samples/tasks/database
run: |
set -eu
# The scan's reader tasks under TSan, with a stub SMB backend
# so they take smb:// paths; then the same checks
# in a build without threads, with the budget test too, and in
# one whose readers are compiled in but never start.
make clean SANITIZER=thread && make -j$(nproc) database_scan_test SANITIZER=thread \
SCAN_DEFINES=-DHAVE_SMBCLIENT
scan_root="$(mktemp -d)"
TSAN_OPTIONS=halt_on_error=1 timeout 900 ./database_scan_test "$scan_root"
rm -rf "${scan_root:?}"
make clean && make -j$(nproc) database_scan_test scan_begin_budget_test HAVE_THREADS=0
scan_root="$(mktemp -d)"
timeout 900 ./database_scan_test "$scan_root"
rm -rf "${scan_root:?}"
budget_root="$(mktemp -d)"
TMPDIR="$budget_root" timeout 600 ./scan_begin_budget_test
rm -rf "${budget_root:?}"
make clean && make -j$(nproc) database_scan_test SANITIZER=address,undefined \
SCAN_DEFINES=-DSCAN_READERS_MAX=0
scan_root="$(mktemp -d)"
ASAN_OPTIONS=detect_leaks=1:detect_stack_use_after_return=1 \
UBSAN_OPTIONS=print_stacktrace=1 timeout 900 \
./database_scan_test "$scan_root"
rm -rf "${scan_root:?}"
make clean
echo "[pass] database_scan_test (TSan, HAVE_THREADS=0, SCAN_READERS_MAX=0)"
- name: Build and run core_info_cache_test (ASan + UBSan)
shell: bash
working-directory: samples/tasks/database
run: |
set -eu
# core_info.cache: an info file added after its core was
# cached is read, a rewrite keeps the entries served from the
# cache whole, and an unchanged core set rewrites nothing.
make clean SANITIZER=address,undefined && make -j$(nproc) core_info_cache_test SANITIZER=address,undefined
root="$(mktemp -d)"
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 120 ./core_info_cache_test "$root"
rm -rf "${root:?}"
make clean
echo "[pass] core_info_cache_test (ASan)"
- name: Build and run pl_manager_budget_test (plain, ASan + UBSan, TSan)
shell: bash
working-directory: samples/tasks/playlist_manager
@@ -1397,24 +1246,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 timeout 60 ./bluetooth_scan_test
echo "[pass] bluetooth_scan_test"
- name: Build and run wifi_tasks_test (ASan + UBSan, TSan)
shell: bash
working-directory: samples/tasks/wifi_tasks
run: |
set -eu
# The Wi-Fi tasks on the real threaded task queue, with a
# driver whose scan takes a while. Connect, Disconnect and the
# Wi-Fi Enabled toggle pushed during the networks list's
# periodic scan were turned away; pins that they are held and
# run after it in order, one on the driver at a time, and that
# only a scan behind a scan is refused.
make clean SANITIZER=address,undefined && make -j$(nproc) all SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
timeout 60 ./wifi_tasks_test
make clean SANITIZER=thread && make -j$(nproc) all SANITIZER=thread
TSAN_OPTIONS=halt_on_error=1 timeout 60 ./wifi_tasks_test
echo "[pass] wifi_tasks_test"
- name: Build and run wait_timeout_test (plain, ASan + UBSan, TSan)
shell: bash
working-directory: samples/tasks/wait_timeout
@@ -1476,26 +1307,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 ./task_ordering_test
make clean >/dev/null
- name: Build and run autodetect_handoff_test (plain, ASan + UBSan, TSan)
shell: bash
working-directory: samples/tasks/autodetect_handoff
run: |
set -eu
# Autoconfig reports from a driver's own thread are made on
# the main thread, in order, where the queue's answer is exact.
make clean >/dev/null
make all -j$(nproc)
./autodetect_handoff_test
make clean >/dev/null
make all SANITIZER=address,undefined -j$(nproc)
ASAN_OPTIONS=detect_leaks=1:detect_stack_use_after_return=1 \
UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
./autodetect_handoff_test
make clean >/dev/null
make all SANITIZER=thread -j$(nproc)
TSAN_OPTIONS=halt_on_error=1 ./autodetect_handoff_test
make clean >/dev/null
- name: Build and run task_watchdog_test (plain, ASan + UBSan, TSan)
shell: bash
working-directory: samples/tasks/watchdog
@@ -1882,20 +1693,6 @@ jobs:
TSAN_OPTIONS=halt_on_error=1 timeout 300 \
./save_state_io_test conc
echo "[pass] save_state_io_test (TSan)"
# The same oracle with HAVE_COMPRESSION, as the frontend
# ships it, states going through rzip. The lane that needs
# it runs only here: a save over a slot keeps the file that
# was there for undo, and an undo puts that file back byte
# for byte - compressed or not, whatever the setting has
# become - rather than inflating it on every save and
# deflating it afresh on undo.
make clean RZIP=1 && make -j$(nproc) all RZIP=1 SANITIZER=address,undefined
ASAN_OPTIONS=detect_leaks=1:detect_stack_use_after_return=1 \
UBSAN_OPTIONS=print_stacktrace=1 timeout 300 \
./save_state_io_test_rzip
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=print_stacktrace=1 \
timeout 300 ./save_state_io_test_rzip conc
echo "[pass] save_state_io_test_rzip (ASan)"
- name: ccache statistics
if: ${{ !cancelled() }}
+1 -13
View File
@@ -18,21 +18,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-tsan-harness.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-tsan-harness.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -49,7 +37,7 @@ jobs:
timeout-minutes: 45
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
# Line tables are all a sanitizer report needs. configure and
# make take these in place of DEBUG=1's -O0 -g, adding their own.
CFLAGS: -O0 -g1
-12
View File
@@ -12,21 +12,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-tsan-samples.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-tsan-samples.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -27,25 +27,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-tsan-threaded-video.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-tsan-threaded-video.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -60,7 +44,7 @@ jobs:
name: Build with TSan and run with threaded video
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
timeout-minutes: 45
steps:
+14 -107
View File
@@ -74,35 +74,14 @@ name: CI Vulkan/GL/D3D11 [idle waits + driver harness]
# 8. SDL3 views: the views e2e cases on the SDL3 driver, against an SDL3
# built from a pinned release with its renderer, the tree configured
# with SDL3 in place of SDL2.
#
# 9. HDR10 frame: the shipping frontend from the validation build, on
# lavapipe under an Xvfb of depth 30, through a layer that pairs the
# surface's 10-bit format with the HDR10 colour space
# (samples/gfx/vulkan_hdr_ui_pass), so the driver takes its HDR path
# with no HDR display: a shader preset with the menu, the statistics
# and an OSD message over it, and the controls without. The UI
# layer's render pass was left open under the composite whenever a
# preset and any UI met; no lane here ran HDR, so nothing saw it.
on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-vulkan-validation.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux-vulkan-validation.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -139,20 +118,6 @@ jobs:
set -eu
tools/check.sh tools/vulkan_idle_wait_check.c
- name: Vulkan NULL-submit check, self-test
if: ${{ !cancelled() }}
shell: bash
run: |
set -eu
tools/check.sh tools/vulkan_null_submit_check.c --selftest
- name: Vulkan NULL-submit check, tree check
if: ${{ !cancelled() }}
shell: bash
run: |
set -eu
tools/check.sh tools/vulkan_null_submit_check.c
- name: D3D12 wait allowlist, self-test
if: ${{ !cancelled() }}
shell: bash
@@ -185,7 +150,7 @@ jobs:
name: Threaded-video harness on Vulkan (lavapipe, validation layer)
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev libgl1-mesa-dri libgl-dev imagemagick libsdl2-dev ccache
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev libgl1-mesa-dri libgl-dev imagemagick libsdl2-dev ccache
timeout-minutes: 75
steps:
@@ -236,12 +201,11 @@ jobs:
- name: Configure
# Non-Qt, as the harness requires (with Qt, main() lives in
# ui_qt.o). Select SDL2 for the views cases below; other defaults
# keep every Vulkan path a release build has.
# ui_qt.o). Everything else at its default so the Vulkan driver
# is built with every path a release build has.
run: |
./configure --disable-qt --enable-sdl2 --disable-sdl3
./configure --disable-qt
grep -q '^HAVE_VULKAN = 1' config.mk
grep -q '^HAVE_SDL2 = 1' config.mk
- name: Build with VULKAN_DEBUG=1
# VULKAN_DEBUG enables VK_LAYER_KHRONOS_validation and the
@@ -291,12 +255,6 @@ jobs:
# each device: the driver must not suballocate from a buffer
# it could not map.
SAN=none VK_DEBUG=1 GFX_INSTRUMENT=1 CYCLES=1 make -C samples/gfx/threaded_video check-vulkan-mapfail
# And on a unified-memory device whose cached memory is not
# coherent, with linear images bound past offset 0: the
# driver's hand-written flushes and invalidates run, which
# no desktop driver's memory makes it do, and every range
# must lie inside its mapping.
SAN=none VK_DEBUG=1 GFX_INSTRUMENT=1 CYCLES=1 make -C samples/gfx/threaded_video check-vulkan-noncoherent
# And with the harness core as a Vulkan hardware core, which
# runs its own lanes alone: the core's image must not be drawn
# from once the core has destroyed it - at a content close,
@@ -314,19 +272,7 @@ jobs:
# anything the driver or the filter chain does that leans on
# an optional extension is a validation error here and nowhere
# else. The filter chain's mirror-clamp samplers were.
# It passes the required extensions, so none are added.
HARNESS_CORE_HW_VULKAN=2 FORBID_LOG='left out required device extensions' \
SAN=none VK_DEBUG=1 GFX_INSTRUMENT=1 CYCLES=1 make -C samples/gfx/threaded_video check-vulkan
make -C samples/gfx/threaded_video clean
# And as one whose create_device leaves the required extensions
# out (Flycast): the frontend must add them and say so, also
# when the core resolves vkCreateDevice through the
# vkGetInstanceProcAddr it looked up itself.
HARNESS_CORE_HW_VULKAN=2 HARNESS_CORE_IGNORE_REQUIRED_EXTS=1 EXPECT_LOG='left out required device extensions' \
SAN=none VK_DEBUG=1 GFX_INSTRUMENT=1 CYCLES=1 make -C samples/gfx/threaded_video check-vulkan
make -C samples/gfx/threaded_video clean
HARNESS_CORE_HW_VULKAN=2 HARNESS_CORE_IGNORE_REQUIRED_EXTS=2 EXPECT_LOG='left out required device extensions' \
SAN=none VK_DEBUG=1 GFX_INSTRUMENT=1 CYCLES=1 make -C samples/gfx/threaded_video check-vulkan
HARNESS_CORE_HW_VULKAN=2 SAN=none VK_DEBUG=1 GFX_INSTRUMENT=1 CYCLES=1 make -C samples/gfx/threaded_video check-vulkan
make -C samples/gfx/threaded_video clean
# And as a core that caches its context across a video reinit
# (Azahar): the instance comes back from the cache with what
@@ -352,17 +298,6 @@ jobs:
python3 samples/cores/video_views/e2e/run.py ./retroarch \
"$RUNNER_TEMP/views-e2e" gl glcore vulkan sdl2
- name: HDR10 frame paths under the validation layer (lavapipe, fake HDR10 surface)
shell: bash
run: |
set -eu
# Each case selects an HDR10 swapchain or fails, and must take
# the HDR game pass and composite it names; any validation
# error fails it. Logs stay in the temp dir named below.
export VK_DRIVER_FILES=/usr/share/vulkan/icd.d/lvp_icd.json
python3 samples/gfx/vulkan_hdr_ui_pass/run.py --retroarch ./retroarch \
--log-dir "$RUNNER_TEMP/vulkan-hdr-ui-pass"
- name: ccache statistics
if: ${{ !cancelled() }}
continue-on-error: true
@@ -381,7 +316,7 @@ jobs:
name: Threaded-video harness on Vulkan built with OpenXR (lavapipe, validation layer)
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev ccache
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev ccache
timeout-minutes: 45
steps:
@@ -540,7 +475,7 @@ jobs:
timeout-minutes: 60
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev ccache
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev ccache
# Line tables are all a sanitizer report needs. configure and
# make take these in place of DEBUG=1's -O0 -g, adding their own.
CFLAGS: -O0 -g1
@@ -640,7 +575,7 @@ jobs:
timeout-minutes: 60
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev ccache
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libvulkan-dev mesa-vulkan-drivers vulkan-validationlayers vulkan-tools libasound2-dev ccache
# Line tables are all a sanitizer report needs. configure and
# make take these in place of DEBUG=1's -O0 -g, adding their own.
CFLAGS: -O0 -g1
@@ -736,7 +671,7 @@ jobs:
name: Threaded-video harness on ${{ matrix.drivers }} (llvmpipe, ${{ matrix.api }}, ${{ matrix.san }})
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype-dev libgl-dev libglx-dev libegl-dev libgles-dev libgl1-mesa-dri libglx-mesa0 mesa-utils libasound2-dev ccache
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libxcb1-dev libxinerama-dev libxrandr-dev libxxf86vm-dev libxv-dev xvfb x11-utils zlib1g-dev libfreetype6-dev libgl-dev libglx-dev libegl-dev libgles-dev libgl1-mesa-dri libglx-mesa0 mesa-utils libasound2-dev ccache
timeout-minutes: 60
strategy:
fail-fast: false
@@ -902,7 +837,7 @@ jobs:
# retry fetches only the rest, one file at a time after a
# growing wait so a shared runner's rate limit can clear.
p=$MINGW_PACKAGE_PREFIX
pkgs="base-devel git $p-cc $p-gdb $p-python $p-ffmpeg"
pkgs="base-devel git $p-cc $p-gdb"
for i in 1 2 3 4 5; do
pacman -S --noconfirm --needed $pkgs && exit 0
[ $i = 5 ] && break
@@ -916,7 +851,7 @@ jobs:
shell: msys2 {0}
run: |
set -eu
./configure --disable-qt --disable-ffmpeg --disable-webmplayer --disable-imageviewer
./configure --disable-qt
grep -q '^HAVE_D3D11 = 1' config.mk
grep -q '^HAVE_D3D12 = 1' config.mk
make -j"$(nproc)"
@@ -928,41 +863,14 @@ jobs:
set -eu
samples/gfx/threaded_video/build.sh
HARNESS_CORE_XRGB8888=${{ matrix.core_xrgb8888 || '' }} \
SAN=none DRIVER=${{ matrix.driver }} CYCLES=1 GDB=on-failure make -C samples/gfx/threaded_video check-driver
SAN=none DRIVER=${{ matrix.driver }} CYCLES=1 GDB=1 make -C samples/gfx/threaded_video check-driver
make -C samples/gfx/threaded_video clean
- name: Preserve failed Windows driver harness log
if: failure()
uses: actions/upload-artifact@v4
with:
name: threaded-video-${{ matrix.driver }}-failure
path: |
samples/gfx/threaded_video/check.log
samples/gfx/threaded_video/debugger.log
if-no-files-found: ignore
- name: RGUI GPU subtitle output on ${{ matrix.driver }}
shell: msys2 {0}
run: |
set -eu
ffmpeg -v error -y -f lavfi -i testsrc2=size=320x240:rate=30 -f lavfi -i sine=frequency=440:sample_rate=48000 -t 3 -c:v libx264 -preset ultrafast -pix_fmt yuv420p -c:a aac -shortest samples/menu/rgui_media/fixture.mp4
python3 -c "from pathlib import Path; Path('samples/menu/rgui_media/fixture.srt').write_text('1\n00:00:00,000 --> 00:10:00,000\nSubtitle sidecar\nUTF-8 \u00e9\n\n', encoding='utf-8'); Path('samples/menu/rgui_media/fixture.en.srt').write_text('1\n00:00:00,000 --> 00:10:00,000\nEnglish track\n', encoding='utf-8')"
capture="$(cygpath -m "$RUNNER_TEMP/rgui-subtitles-${{ matrix.driver }}")"
mkdir -p "$capture"
MEDIA_TEST_CAPTURE_DIR="$capture" MEDIA_TEST_SUBTITLE_CONTEXT=1 \
python3 samples/menu/rgui_media/run.py --driver rgui --video-driver ${{ matrix.driver }} --gpu-surface --subtitles samples/menu/rgui_media/fixture.mp4
- name: RGUI GPU folder playback and settings on ${{ matrix.driver }}
shell: msys2 {0}
run: |
set -eu
python3 samples/menu/rgui_media/run.py --driver rgui --video-driver ${{ matrix.driver }} --gpu-surface --refresh-pixels samples/menu/rgui_media/fixture.mp4
python3 samples/menu/rgui_media/run.py --driver rgui --video-driver ${{ matrix.driver }} --gpu-surface --continuous-error samples/menu/rgui_media/fixture.mp4
views-sdl3:
name: Views on SDL3, end to end (Xvfb, llvmpipe)
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential ninja-build cmake xvfb x11-utils imagemagick libx11-dev libxext-dev libxrandr-dev libxi-dev libxss-dev libxcursor-dev libxfixes-dev libxkbcommon-dev libgl1-mesa-dri libgl-dev libegl-dev zlib1g-dev libfreetype-dev libasound2-dev
APT_PKGS: build-essential ninja-build cmake xvfb x11-utils imagemagick libx11-dev libxext-dev libxrandr-dev libxi-dev libxss-dev libxcursor-dev libxfixes-dev libxkbcommon-dev libgl1-mesa-dri libgl-dev libegl-dev zlib1g-dev libfreetype6-dev libasound2-dev
timeout-minutes: 45
steps:
@@ -1052,7 +960,7 @@ jobs:
name: Views on SDL 1.2, XShm and XVideo, end to end (Xvfb, sdl12-compat)
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential gdb xvfb x11-utils imagemagick openbox libx11-dev libxext-dev libxv-dev libsdl1.2-dev libgl1-mesa-dri libgl-dev zlib1g-dev libfreetype-dev libasound2-dev
APT_PKGS: build-essential xvfb x11-utils imagemagick openbox libx11-dev libxext-dev libxv-dev libsdl1.2-dev libgl1-mesa-dri libgl-dev zlib1g-dev libfreetype6-dev libasound2-dev
timeout-minutes: 45
steps:
@@ -1100,7 +1008,6 @@ jobs:
shell: bash
run: |
set -eu
python3 samples/cores/video_views/e2e/test_wm_ready.py
# The CPU drivers' views: each view scaled straight out of the
# frame into the window's surface or image, the anaglyph and
# interlaced canvas blended on the CPU, views read exactly out
-8
View File
@@ -6,9 +6,7 @@ on:
paths:
- 'cores/libretro-media/**'
- 'samples/cores/webm_player/**'
- 'samples/gfx/d3d11_video_decode/**'
- 'libretro-common/samples/formats/audio_transfer/**'
- 'libretro-common/samples/formats/audio_transfer_wma/**'
- 'libretro-common/formats/**'
- 'libretro-common/include/formats/**'
- '.github/workflows/Linux-webm-player.yml'
@@ -17,9 +15,7 @@ on:
paths:
- 'cores/libretro-media/**'
- 'samples/cores/webm_player/**'
- 'samples/gfx/d3d11_video_decode/**'
- 'libretro-common/samples/formats/audio_transfer/**'
- 'libretro-common/samples/formats/audio_transfer_wma/**'
- 'libretro-common/formats/**'
- 'libretro-common/include/formats/**'
- '.github/workflows/Linux-webm-player.yml'
@@ -73,8 +69,6 @@ jobs:
make -j2 check AUDIO=0 SAMPLE_OBJDIR=obj-noaudio TARGET=webm_player_noaudio SANITIZER=address,undefined
make -j2 check MP4=0 SAMPLE_OBJDIR=obj-webm TARGET=webm_player_webm SANITIZER=address,undefined
make -j2 check THREADS=0 SAMPLE_OBJDIR=obj-nothreads TARGET=webm_player_nothreads SANITIZER=address,undefined
make -j2 check-wma SANITIZER=address,undefined SAMPLE_OBJDIR=obj-wma
make -j2 check-wma WMA=0 SANITIZER=address,undefined SAMPLE_OBJDIR=obj-wma-disabled
env:
ASAN_OPTIONS: detect_leaks=1
UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
@@ -82,6 +76,4 @@ jobs:
working-directory: samples/cores/webm_player
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
make -j2 check CC=x86_64-w64-mingw32-gcc OS=Windows_NT EXE=.exe SAMPLE_OBJDIR=obj-win RUNNER=wine
make -j2 check-wma CC=x86_64-w64-mingw32-gcc OS=Windows_NT EXE=.exe SAMPLE_OBJDIR=obj-win RUNNER=wine
+2 -23
View File
@@ -3,19 +3,7 @@ name: CI Linux (i686)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Linux.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -31,14 +19,11 @@ concurrency:
jobs:
build:
# The 32-bit xenial image resolves no host on an Ubuntu 26.04 runner,
# public resolvers or not: since ubuntu-latest moved, its runs stop at
# checkout. The other container jobs, all 64-bit, are unaffected.
runs-on: ubuntu-24.04
runs-on: ubuntu-latest
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-i386-ubuntu:xenial-gcc9
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- name: Check Out Repo
@@ -59,12 +44,6 @@ jobs:
make -j$(getconf _NPROCESSORS_ONLN) clean
make -j$(getconf _NPROCESSORS_ONLN) info all
- name: Hidden symbol check
run: |
# libretro-common's MD5 and krb5 keep their system namesakes'
# names; exported, libssl and cores bind to them.
.github/workflows/scripts/hidden-symbols-check.sh
- name: Stack frame sweep
run: |
set -eu
+15 -31
View File
@@ -3,23 +3,7 @@ name: CI Windows (MSVC)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/MSVC.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/MSVC.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -41,14 +25,14 @@ jobs:
timeout-minutes: 90
strategy:
matrix:
version: [2022-UWP, 2019, 2022]
version: [UWP, 2019, 2022]
configuration: [Debug, Release]
platform: [x64]
exclude:
- version: 2022-UWP
- version: UWP
configuration: Debug
include:
- version: 2022-UWP
- version: UWP
configuration: ReleaseAngle
platform: x64
# Qt and Cg builds are excluded for now
@@ -59,7 +43,7 @@ jobs:
uses: microsoft/setup-msbuild@v1
- name: Compile RA
working-directory: "${{github.workspace}}/pkg/msvc"
working-directory: "${{github.workspace}}/pkg/msvc${{ matrix.version == 'UWP' && '-uwp' || ''}}"
run: |
msbuild -p:"Configuration=${{matrix.configuration}}" -p:"Platform=${{matrix.platform}}" .\RetroArch-msvc${{matrix.version}}.sln
@@ -73,24 +57,24 @@ jobs:
with:
name: retroarch-${{matrix.version}}-${{matrix.configuration}}-${{matrix.platform}}-${{ steps.slug.outputs.sha8 }}
path: |
${{ !endsWith(matrix.version, 'UWP') }}:
${{ matrix.version != 'UWP' }}:
pkg/msvc/${{matrix.platform}}/${{matrix.configuration}}/RetroArch-msvc${{matrix.version}}.exe
${{ endsWith(matrix.version, 'UWP') }}:
pkg/msvc/AppPackages/RetroArch-msvc${{matrix.version}}
${{ matrix.version == 'UWP' }}:
pkg/msvc-uwp/AppPackages/RetroArch-msvcUWP
msvc2026:
runs-on: windows-2025
timeout-minutes: 90
strategy:
matrix:
version: [2026-UWP, 2026]
version: [UWP, 2026]
configuration: [Debug, Release]
platform: [x64]
exclude:
- version: 2026-UWP
- version: UWP
configuration: Debug
include:
- version: 2026-UWP
- version: UWP
configuration: ReleaseAngle
platform: x64
# Qt and Cg builds are excluded for now
@@ -101,7 +85,7 @@ jobs:
uses: microsoft/setup-msbuild@v3
- name: Compile RA
working-directory: "${{github.workspace}}/pkg/msvc"
working-directory: "${{github.workspace}}/pkg/msvc${{ matrix.version == 'UWP' && '-uwp' || ''}}"
run: |
msbuild -p:"Configuration=${{matrix.configuration}}" -p:"Platform=${{matrix.platform}}" .\RetroArch-msvc${{matrix.version}}.sln
@@ -112,9 +96,9 @@ jobs:
- uses: actions/upload-artifact@v4
with:
name: retroarch-${{matrix.version}}-${{matrix.configuration}}-${{matrix.platform}}-${{ steps.slug.outputs.sha8 }}
name: retroarch-${{matrix.version}}-vs2026-${{matrix.configuration}}-${{matrix.platform}}-${{ steps.slug.outputs.sha8 }}
path: |
${{ !endsWith(matrix.version, 'UWP') }}:
${{ matrix.version != 'UWP' }}:
pkg/msvc/${{matrix.platform}}/${{matrix.configuration}}/RetroArch-msvc${{matrix.version}}.exe
${{ endsWith(matrix.version, 'UWP') }}:
pkg/msvc/AppPackages/RetroArch-msvc${{matrix.version}}
${{ matrix.version == 'UWP' }}:
pkg/msvc-uwp/AppPackages/RetroArch-msvcUWP
-28
View File
@@ -3,19 +3,7 @@ name: CI Windows (MSYS2)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/MSYS2.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/MSYS2.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -95,22 +83,6 @@ jobs:
QB_JOBS=${{ matrix.qb_jobs }} ./configure
make -j"$(nproc)" info all
- name: Native modal message pump regression
shell: msys2 {0}
run: |
set -eu
flags=''
if cc --version | grep -qi clang; then flags="-Wno-c99-extensions -Wno-c11-extensions"; fi
cc $flags -std=c89 -pedantic -Wall -Wextra -Werror -Wno-unused-function -Wframe-larger-than=4096 -Ilibretro-common/include samples/gfx/win32_window_proc/modal_frame_test.c -o modal_frame_test.exe -lgdi32 -luser32
rc=0
./modal_frame_test.exe || rc=$?
if [ "$rc" = 77 ] && [ "${{ matrix.sys }}" = CLANGARM64 ]; then
echo "::notice::Modal continuity unavailable; checking safe fallback"
./modal_frame_test.exe --fallback
else
test "$rc" = 0
fi
- name: Collect DLLs and binaries
shell: msys2 {0}
run: |
+1 -17
View File
@@ -18,23 +18,7 @@ name: CI macOS PowerPC (cross)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/MacOS-PPC-Cross.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/MacOS-PPC-Cross.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -56,7 +40,7 @@ jobs:
timeout-minutes: 60
container:
image: ghcr.io/variantxyz/gcc-powerpc-apple-darwin8:build-gcc-14.2-MacOSXSDK10.5
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
strategy:
fail-fast: false
matrix:
@@ -1,99 +0,0 @@
name: CI macOS task queue samples
# The task_queue samples run on Linux and under Wine in
# Linux-libretro-common-samples.yml, which never builds the GCD runner
# Apple builds use. This runs each one with Apple clang on the threaded
# runner, and those with a GCD=1 build again on GCD: plain, under
# ASan+UBSan and under TSan.
on:
push:
branches: [master]
paths:
- 'libretro-common/queues/task_queue.c'
- 'libretro-common/include/queues/**'
- 'libretro-common/rthreads/**'
- 'libretro-common/include/rthreads/**'
- 'libretro-common/include/retro_atomic.h'
- 'libretro-common/include/retro_timers.h'
- 'libretro-common/include/features/features_cpu.h'
- 'libretro-common/include/time/rtime.h'
- 'libretro-common/features/**'
- 'libretro-common/time/rtime.c'
- 'libretro-common/samples/queues/task_queue_*/**'
- 'libretro-common/samples/sample_objdir.mk'
- '.github/workflows/MacOS-task-queue-samples.yml'
pull_request:
paths:
- 'libretro-common/queues/task_queue.c'
- 'libretro-common/include/queues/**'
- 'libretro-common/rthreads/**'
- 'libretro-common/include/rthreads/**'
- 'libretro-common/include/retro_atomic.h'
- 'libretro-common/include/retro_timers.h'
- 'libretro-common/include/features/features_cpu.h'
- 'libretro-common/include/time/rtime.h'
- 'libretro-common/features/**'
- 'libretro-common/time/rtime.c'
- 'libretro-common/samples/queues/task_queue_*/**'
- 'libretro-common/samples/sample_objdir.mk'
- '.github/workflows/MacOS-task-queue-samples.yml'
workflow_dispatch:
permissions:
contents: read
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
jobs:
task-queue-macos:
name: task_queue samples on macOS, threaded and GCD
runs-on: macos-latest
timeout-minutes: 20
steps:
- uses: actions/checkout@v6
- name: Build and run the task_queue samples
shell: bash
working-directory: libretro-common/samples/queues
env:
TSAN_OPTIONS: halt_on_error=1 second_deadlock_stack=1
UBSAN_OPTIONS: halt_on_error=1:print_stacktrace=1
run: |
set -u
set -o pipefail
# macOS has no timeout(1): perl's alarm bounds each run.
fails=0
runs=0
for d in task_queue_*; do
t=$(sed -nE 's/^TARGET[[:space:]]*:?=[[:space:]]*//p' "$d/Makefile")
runners=0
if grep -qF 'ifeq ($(GCD),1)' "$d/Makefile"; then
runners="0 1"
fi
for g in $runners; do
for san in '' address,undefined thread; do
label="$t, GCD=$g, ${san:-plain}"
printf '\n[build] %s\n' "$label"
if ! ( cd "$d" && make clean >/dev/null && make all GCD=$g SANITIZER=$san ); then
printf '::error title=macOS build failed::%s does not build\n' "$label"
fails=$((fails+1))
continue
fi
printf '[run] %s\n' "$label"
if ( cd "$d" && perl -e 'alarm shift; exec @ARGV or die "exec $ARGV[0]: $!\n"' 300 "./$t" ); then
printf '[pass] %s\n' "$label"
runs=$((runs+1))
else
rc=$?
printf '::error title=Test failed on macOS::%s exited with status %d\n' "$label" "$rc"
fails=$((fails+1))
fi
done
done
( cd "$d" && make clean >/dev/null )
done
printf '\n Ran: %d\n Failed: %d\n' "$runs" "$fails"
[[ $fails -eq 0 ]]
@@ -8,7 +8,6 @@ on:
- 'libretro-common/formats/h265/rh265_sps_crop.c'
- 'libretro-common/include/formats/rh265_sps_crop.h'
- 'record/drivers/record_metal.*'
- 'record/drivers/record_avfoundation*'
- 'record/record_driver.*'
- 'gfx/drivers/metal.m'
- 'Makefile.common'
@@ -33,7 +32,6 @@ on:
- 'libretro-common/formats/h265/rh265_sps_crop.c'
- 'libretro-common/include/formats/rh265_sps_crop.h'
- 'record/drivers/record_metal.*'
- 'record/drivers/record_avfoundation*'
- 'record/record_driver.*'
- 'gfx/drivers/metal.m'
- 'Makefile.common'
@@ -68,8 +66,6 @@ jobs:
- name: Portable ownership and failure contracts
working-directory: samples/record/videotoolbox_encode
run: make check thread_test worker_thread_test audio_thread_test av_session_thread_test && ./thread_test && ./worker_thread_test && ./audio_thread_test && ./av_session_thread_test
- name: Native AAC property ABI and advertised rates
run: make -C samples/record/videotoolbox_encode native-audio-check
- name: Native hardware encoder and independent pixels
run: |
rc=0
+62 -24
View File
@@ -6,46 +6,56 @@ on:
paths:
- '.github/workflows/MacOS-videotoolbox-hevc.yml'
- 'samples/gfx/videotoolbox_hevc/**'
- 'samples/gfx/videotoolbox_vp9/**'
- 'samples/gfx/videotoolbox_av1/**'
- 'gfx/common/videotoolbox_av1*.h'
- 'gfx/common/videotoolbox_vp9*.h'
- 'gfx/common/vp9_color.h'
- 'libretro-common/include/formats/rvp9*.h'
- 'libretro-common/include/formats/rwebm*.h'
- 'libretro-common/formats/vp9/**'
- 'libretro-common/formats/webm/**'
- 'samples/gfx/metal_frame/**'
- 'gfx/common/videotoolbox_hevc*.h'
- 'gfx/common/metal_frame*.h'
- 'gfx/common/metal_hevc_driver.h'
- 'gfx/common/metal_vp9_driver.h'
- 'gfx/common/metal_video_decoder_driver.h'
- 'gfx/common/metal_decoder_snapshot.h'
- 'gfx/common/videotoolbox_vp9*.h'
- 'samples/gfx/videotoolbox_vp9/**'
- 'libretro-common/formats/vp9/**'
- 'libretro-common/formats/mp4/rmp4_video.c'
- 'libretro-common/formats/webm/rwebm_video.c'
- 'gfx/drivers/metal.m'
- 'gfx/drivers/metal.h'
- 'gfx/drivers/metal_shaders/Shaders.metal'
- 'gfx/video_driver.h'
- 'gfx/video_defines.h'
- 'libretro-common/formats/h265/**'
- 'libretro-common/formats/video_player.c'
- 'libretro-common/samples/formats/video_player/**'
- 'libretro-common/rthreads/**'
- 'libretro-common/include/**'
pull_request:
paths:
- '.github/workflows/MacOS-videotoolbox-hevc.yml'
- 'samples/gfx/videotoolbox_hevc/**'
- 'samples/gfx/videotoolbox_vp9/**'
- 'samples/gfx/videotoolbox_av1/**'
- 'gfx/common/videotoolbox_av1*.h'
- 'gfx/common/videotoolbox_vp9*.h'
- 'gfx/common/vp9_color.h'
- 'libretro-common/include/formats/rvp9*.h'
- 'libretro-common/include/formats/rwebm*.h'
- 'libretro-common/formats/vp9/**'
- 'libretro-common/formats/webm/**'
- 'samples/gfx/metal_frame/**'
- 'gfx/common/videotoolbox_hevc*.h'
- 'gfx/common/metal_frame*.h'
- 'gfx/common/metal_hevc_driver.h'
- 'gfx/common/metal_vp9_driver.h'
- 'gfx/common/metal_video_decoder_driver.h'
- 'gfx/common/metal_decoder_snapshot.h'
- 'gfx/common/videotoolbox_vp9*.h'
- 'samples/gfx/videotoolbox_vp9/**'
- 'libretro-common/formats/vp9/**'
- 'libretro-common/formats/mp4/rmp4_video.c'
- 'libretro-common/formats/webm/rwebm_video.c'
- 'gfx/drivers/metal.m'
- 'gfx/drivers/metal.h'
- 'gfx/drivers/metal_shaders/Shaders.metal'
- 'gfx/video_driver.h'
- 'gfx/video_defines.h'
- 'libretro-common/formats/h265/**'
- 'libretro-common/formats/video_player.c'
- 'libretro-common/samples/formats/video_player/**'
- 'libretro-common/rthreads/**'
- 'libretro-common/include/**'
workflow_dispatch:
@@ -59,6 +69,44 @@ jobs:
timeout-minutes: 10
steps:
- uses: actions/checkout@v6
- name: Player cold hardware startup and cancellation
run: |
for threads in 0 1; do
make -C libretro-common/samples/formats/video_player clean all THREADS="$threads" SANITIZER=address,undefined
libretro-common/samples/formats/video_player/video_player_test
done
- name: VideoToolbox VP9 configuration conformance (no device claim)
run: |
make -C samples/gfx/videotoolbox_vp9 check CC=clang SANITIZER=address,undefined
CC=clang python3 samples/gfx/videotoolbox_vp9/run.py --native
- name: VideoToolbox VP9 native pixels, Metal playback and retained output
run: |
rc=0
CC=clang python3 samples/gfx/videotoolbox_vp9/run.py --native --pixels --pipeline || rc=$?
if [ "$rc" = 77 ]; then
echo "::warning::VP9 hardware or Metal device unavailable; native VP9 playback acceptance remains incomplete"
exit 0
fi
exit "$rc"
- name: VideoToolbox AV1 configuration and ownership (no decoder device claim)
run: |
make -C samples/gfx/videotoolbox_av1 check CC=clang SANITIZER=address,undefined
CC=clang python3 samples/gfx/videotoolbox_av1/run.py --native-format
- name: VideoToolbox AV1 hardware pixels, keyframe seeks and retained images
run: |
if ! command -v ffmpeg >/dev/null ||
! ffmpeg -hide_banner -encoders 2>/dev/null | grep ' libaom-av1 ' >/dev/null; then
brew install ffmpeg-full
export PATH="$(brew --prefix ffmpeg-full)/bin:$PATH"
fi
ffmpeg -hide_banner -encoders 2>/dev/null | grep ' libaom-av1 '
rc=0
CC=clang python3 samples/gfx/videotoolbox_av1/run.py --native-pixels --pipeline || rc=$?
if [ "$rc" = 77 ]; then
echo "::warning::AV1 hardware unavailable; native AV1 decode acceptance remains incomplete"
exit 0
fi
exit "$rc"
- name: VideoToolbox HEVC hardware decode and pixel ownership
run: |
rc=0
@@ -68,16 +116,6 @@ jobs:
exit 0
fi
exit "$rc"
- name: VideoToolbox VP9 hardware decode, MP4/WebM and Metal pixels
if: ${{ !cancelled() }}
run: |
rc=0
python3 samples/gfx/videotoolbox_vp9/run.py --native --pipeline || rc=$?
if [ "$rc" = 77 ]; then
echo "::warning::VP9 hardware decode or Metal unavailable; native acceptance did not complete"
exit 0
fi
exit "$rc"
- name: Metal movie import, history and GPU pixel acceptance
if: ${{ !cancelled() }}
run: python3 samples/gfx/metal_frame/run.py --native
-12
View File
@@ -3,19 +3,7 @@ name: CI macOS
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/MacOS.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/MacOS.yml'
# ci_paths: end
permissions:
contents: read
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI Miyoo ARM32
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Miyoo.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Miyoo.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-dingux:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
@@ -33,21 +33,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Msg-Hash-Packed-Check.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Msg-Hash-Packed-Check.yml'
# ci_paths: end
workflow_dispatch:
permissions:
@@ -124,9 +112,6 @@ jobs:
# format argument today and twenty-nine of them are not MSG_*.
tools/check.sh tools/msg_hash_format_check.c
- name: Internal headers survive translation conversion
run: python3 tools/intl_conversion_check.py
- name: Label macros current
shell: bash
run: |
-12
View File
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Overlap-Copy-Check.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Overlap-Copy-Check.yml'
# ci_paths: end
workflow_dispatch:
permissions:
-133
View File
@@ -1,133 +0,0 @@
name: CI PS2 runtime
# Runs PS2 builds of samples/frontend/ps2_whole_file under Play!'s
# headless AutoTest (null GS), so file I/O is exercised on the console's
# own runtime - ps2sdk's libcglue and fileXio over the host: device -
# rather than a host libc standing in for it. The ELF is built in the
# same image as the PS2 release build; AutoTest is built from a pinned
# Play! commit and cached on it.
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/frontend/ps2_whole_file/**'
- '.github/workflows/PS2-runtime.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- 'samples/frontend/ps2_whole_file/**'
- '.github/workflows/PS2-runtime.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
permissions:
contents: read
env:
ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
# Play! commit AutoTest is built from; move deliberately.
PLAY_REF: 1f27232772e484bfb79364b751b84f41f4c87481
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
jobs:
build:
runs-on: ubuntu-latest
timeout-minutes: 15
container:
image: reallibretroretroarch/libretro-build-ps2:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
steps:
- uses: actions/checkout@v4
- name: Build ps2_whole_file
working-directory: samples/frontend/ps2_whole_file
run: make PS2=1
- uses: actions/upload-artifact@v4
with:
name: ps2-runtime-elfs
path: samples/frontend/ps2_whole_file/ps2_whole_file_test.elf
run:
needs: build
runs-on: ubuntu-latest
timeout-minutes: 45
env:
APT_PKGS: cmake ninja-build zlib1g-dev libbz2-dev libssl-dev
steps:
- uses: actions/checkout@v5
- uses: actions/checkout@v5
with:
repository: jpd002/Play-
ref: ${{ env.PLAY_REF }}
submodules: recursive
path: Play
- name: Apt cache key
id: apt
run: sh .github/workflows/scripts/apt-cache-key.sh "$APT_PKGS"
- name: Restore apt cache
uses: actions/cache/restore@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
restore-keys: ${{ steps.apt.outputs.prefix }}
- name: Install build dependencies
timeout-minutes: 10
run: sh .github/workflows/scripts/apt-install.sh $APT_PKGS
- name: Save apt cache
if: env.APT_CACHE_SAVE == '1'
uses: actions/cache/save@v4
with:
path: ~/.apt-cache
key: ${{ steps.apt.outputs.key }}
- uses: actions/cache@v4
with:
path: Play/build
key: play-autotest-${{ runner.os }}-${{ env.PLAY_REF }}
- name: Build AutoTest
run: |
cmake -S Play -B Play/build -G Ninja -DCMAKE_BUILD_TYPE=Release \
-DBUILD_PLAY=OFF -DBUILD_TESTS=ON
cmake --build Play/build --target autotest
- uses: actions/download-artifact@v4
with:
name: ps2-runtime-elfs
path: run
- name: Run under AutoTest
shell: bash
run: |
set -euo pipefail
# AutoTest runs every .elf in the directory and writes its EE
# stdout to <name>.result; it reports a pass only against a
# .reference file, so the verdict is the harness's own lines.
# host: maps to ~/.local/share/Play Data Files/vfs/host.
timeout 600 Play/build/tools/AutoTest/autotest run
cat run/ps2_whole_file_test.result
if grep -q '^FAIL' run/ps2_whole_file_test.result; then exit 1; fi
grep -qx 'ps2_whole_file_test: PASS' run/ps2_whole_file_test.result
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI PS2
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PS2.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PS2.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-ps2:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI PS3/PSL1GHT
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PS3-PSL1GHT.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PS3-PSL1GHT.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-psl1ght:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
-16
View File
@@ -3,23 +3,7 @@ name: CI PS4/ORBIS
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PS4-ORBIS.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PS4-ORBIS.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
+2 -18
View File
@@ -3,23 +3,7 @@ name: CI PSP
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PSP.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PSP.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,14 +23,14 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-psp:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
- name: Compile bootstrap
run: |
cd os/psp1/kernel_functions_prx
cd bootstrap/psp1/kernel_functions_prx
make -j$(getconf _NPROCESSORS_ONLN) clean
make -j$(getconf _NPROCESSORS_ONLN)
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI PSVita
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PSVita.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/PSVita.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-vita:latest-20260905
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
-8
View File
@@ -10,14 +10,6 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Prune-caches.yml'
# ci_paths: end
schedule:
- cron: '23 * * * *'
workflow_dispatch:
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI RS90 Odbeta MIPS32
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/RS90.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/RS90.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-dingux:odbeta
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
@@ -30,21 +30,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Removed-Member-Check.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Removed-Member-Check.yml'
# ci_paths: end
workflow_dispatch:
permissions:
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI RetroFW MIPS32
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/RetroFW.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/RetroFW.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-dingux:odbeta
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
@@ -4,21 +4,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Samples-Objdir-Check.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/Samples-Objdir-Check.yml'
# ci_paths: end
workflow_dispatch:
permissions:
+2 -8
View File
@@ -8,14 +8,6 @@ on:
push:
tags:
- "v*.*"
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/SourceRelease.yml'
# ci_paths: end
env:
ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
@@ -45,6 +37,8 @@ jobs:
mv * /tmp/$PKGNAME
mv /tmp/$PKGNAME .
rm -rf $PKGNAME/pkg || true
rm -rf $PKGNAME/deps/glslang/glslang/Test || true
rm -rf $PKGNAME/deps/SPIRV-Cross/reference || true
rm -rf $PKGNAME/gfx/include/userland || true
find $PKGNAME/ -type f -name '*.a' -delete || true
find $PKGNAME/ -type f -name '*.lib' -delete || true
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI Switch/libnx
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Switch-libnx.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Switch-libnx.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-libnx-devkitpro:v4-10-0
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: actions/checkout@v4
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI Wii
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Wii.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Wii.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: devkitpro/devkitppc:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: taiki-e/checkout-action@v1
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI WiiU
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/WiiU.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/WiiU.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-wiiu:latest
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: taiki-e/checkout-action@v1
-16
View File
@@ -3,23 +3,7 @@ name: CI Windows ARM64 (MSVC)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Windows-ARM64.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Windows-ARM64.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
release:
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI Windows i686 (MXE)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Windows-i686-MXE.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Windows-i686-MXE.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-mxe-win32-cross:gcc16
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: taiki-e/checkout-action@v1
+3 -2
View File
@@ -7,13 +7,14 @@ name: CI Windows raw input under Wine
# input driver and the raw input joypad driver, presses keys in its
# window and reads its log.
#
# It runs a small core that writes to the log what reaches it. Four
# It runs a small core that writes to the log what reaches it. Five
# scenarios, each: two keys, a fullscreen toggle (which restarts the
# GDI video driver), the two keys again, quit with Escape - and in each
# the core must have seen its button and its key events before the
# restart and after it. Read by the poll and kept across the restart
# (the default); restarted with the video driver
# (RETROARCH_INPUT_KEEP=0); threaded video off; and DirectInput.
# (RETROARCH_INPUT_KEEP=0); threaded video off; the raw driver as it
# was before any of this (RETROARCH_RAWINPUT_POLL=0); and DirectInput.
# In all of those the window is left up across both restarts and
# taken back; two more destroy it with the driver as before
# (RETROARCH_WINDOW_KEEP=0) and leave it up without taking it (=2).
-3
View File
@@ -112,7 +112,6 @@ jobs:
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
v="$RUNNER_TEMP/vkd3d"
git clone -q --depth 1 --branch vkd3d-2.1 \
https://gitlab.winehq.org/wine/vkd3d.git "$v"
@@ -174,8 +173,6 @@ jobs:
xvfb-run -a python3 samples/gfx/d3d_failure_paths/gpu.py
CC=x86_64-w64-mingw32-gcc RUNNER=wine REQUIRE_D3D11=1 \
xvfb-run -a python3 samples/gfx/d3d_failure_paths/lend_gpu.py
CC=x86_64-w64-mingw32-gcc RUNNER=wine REQUIRE_D3D11=1 \
xvfb-run -a python3 samples/gfx/d3d_failure_paths/sw_lend_gpu.py
- name: A core writing into the framebuffer d3d9_hlsl lends it (Wine)
shell: bash
+1 -14
View File
@@ -28,8 +28,6 @@ on:
- 'gfx/video_views_draw.h'
- 'gfx/video_driver.c'
- 'gfx/video_thread_wrapper.*'
- 'configuration.*'
- 'samples/settings/video_screens/**'
- 'samples/cores/video_views/**'
- '.github/workflows/Windows-wine-views.yml'
pull_request:
@@ -47,8 +45,6 @@ on:
- 'gfx/video_views_draw.h'
- 'gfx/video_driver.c'
- 'gfx/video_thread_wrapper.*'
- 'configuration.*'
- 'samples/settings/video_screens/**'
- 'samples/cores/video_views/**'
- '.github/workflows/Windows-wine-views.yml'
workflow_dispatch:
@@ -109,7 +105,6 @@ jobs:
shell: bash
run: |
set -eu
. "$GITHUB_WORKSPACE/.github/workflows/scripts/wine-server.sh"
v="$RUNNER_TEMP/vkd3d"
git clone -q --depth 1 --branch vkd3d-2.1 \
https://gitlab.winehq.org/wine/vkd3d.git "$v"
@@ -140,11 +135,10 @@ jobs:
set -eu
export CCACHE_DIR="$HOME/.ccache"
ccache -M 250M
# The screens' windows too, which video_screens_test runs.
./configure --host=x86_64-w64-mingw32 \
--disable-qt --disable-vulkan --disable-ffmpeg \
--disable-cheevos --disable-discord --enable-d3d8 \
--disable-sdl --disable-sdl2 --enable-video_windows
--disable-sdl --disable-sdl2
make -j$(nproc) CC="ccache x86_64-w64-mingw32-gcc" \
CXX="ccache x86_64-w64-mingw32-g++"
ccache -s
@@ -154,13 +148,6 @@ jobs:
done
make -C samples/cores/video_views DLL=1 CC=x86_64-w64-mingw32-gcc
- name: Build and run video_screens_test under Wine
shell: bash
run: |
set -eu
WINEDEBUG=-all xvfb-run -a python3 samples/settings/video_screens/build.py \
--output-dir "$RUNNER_TEMP/video-screens" --runner wine
- name: Views on GDI, D3D8, D3D9, D3D10, D3D11 and D3D12, end to end (Wine, Xvfb, llvmpipe, lavapipe)
shell: bash
run: |
+1 -17
View File
@@ -3,23 +3,7 @@ name: CI Windows x64 (MXE)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Windows-x64-MXE.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/Windows-x64-MXE.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
@@ -39,7 +23,7 @@ jobs:
timeout-minutes: 30
container:
image: reallibretroretroarch/libretro-build-mxe-win64-cross:gcc16
options: --user root --dns 1.1.1.1 --dns 8.8.8.8
options: --user root
steps:
- uses: taiki-e/checkout-action@v1
-12
View File
@@ -16,19 +16,7 @@ name: CI iOS 6 (armv7)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/iOS-Legacy.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/iOS-Legacy.yml'
# ci_paths: end
repository_dispatch:
types: [run_build]
-16
View File
@@ -3,23 +3,7 @@ name: CI iOS (13)
on:
push:
branches: [master]
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/iOS.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/iOS.yml'
# ci_paths: end
permissions:
contents: read
+1 -17
View File
@@ -6,25 +6,9 @@ on:
push:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/retroarch.yml'
# ci_paths: end
pull_request:
branches:
- master
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!samples/**'
- '!libretro-common/samples/**'
- '!.github/workflows/*.yml'
- '.github/workflows/retroarch.yml'
# ci_paths: end
permissions:
contents: read
@@ -40,7 +24,7 @@ jobs:
linux-c89: # Smoketest build using most restrictive compiler and default options
runs-on: ubuntu-latest
env:
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libvulkan-dev libpipewire-0.3-dev zlib1g-dev libfreetype-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev nvidia-cg-toolkit nvidia-cg-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
APT_PKGS: build-essential libxkbcommon-dev libx11-xcb-dev libvulkan-dev libpipewire-0.3-dev zlib1g-dev libfreetype6-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev nvidia-cg-toolkit nvidia-cg-dev libavcodec-dev libsdl2-dev libsdl-image1.2-dev libxml2-dev yasm
timeout-minutes: 30
steps:
- name: Checkout
+1 -4
View File
@@ -4,16 +4,13 @@
# entry, so the repository's cache holds each set once. A new runner
# image makes a new entry, seeded through the prefix by the last one's;
# apt-install.sh refreshes what no longer resolves.
# Off x86-64 the key also names the runner's architecture.
#
# apt-cache-key.sh "PACKAGE..." (writes key= and prefix= to
# GITHUB_OUTPUT)
set -eu
pkgs=$(printf '%s\n' $1 | sort -u | tr '\n' ' ')
hash=$(printf '%s' "$pkgs" | sha256sum | cut -c1-16)
arch=
[ "${RUNNER_ARCH:-X64}" = X64 ] || arch="$RUNNER_ARCH-"
prefix="apt-${ImageOS:-unknown}-$arch$hash-"
prefix="apt-${ImageOS:-unknown}-$hash-"
key="$prefix${ImageVersion:-unknown}"
echo "key=$key" >> "$GITHUB_OUTPUT"
echo "prefix=$prefix" >> "$GITHUB_OUTPUT"
+3 -23
View File
@@ -26,21 +26,6 @@ while [ $# -gt 0 ]; do
esac
done
[ $# -gt 0 ] || { echo "apt-install.sh: no packages"; exit 2; }
# Wine 10's packages keep wineserver in Wine's library directory with
# nothing on the PATH; the jobs start and stop it by name.
wineserver_on_path() {
command -v wineserver >/dev/null 2>&1 && return 0
for w in /usr/lib/x86_64-linux-gnu/wine/wineserver /usr/lib/wine/wineserver64 \
/usr/lib/wine/wineserver /usr/lib/aarch64-linux-gnu/wine/wineserver; do
if [ -x "$w" ]; then
sudo ln -sf "$w" /usr/local/bin/wineserver 2>/dev/null || true
return 0
fi
done
return 0
}
trap wineserver_on_path EXIT
pkgs="$*"
cache=${APT_CACHE:-$HOME/.apt-cache}
@@ -84,20 +69,15 @@ done
# Fetch first, under a bound: a download is safe to stop and resumes, an
# install is not. A mirror that stalls is left for the main archive.
main=archive.ubuntu.com/ubuntu
case $(dpkg --print-architecture) in
amd64|i386) ;;
*) main=ports.ubuntu.com/ubuntu-ports ;;
esac
for i in 1 2 3; do
sudo timeout 240 apt-get install -y --download-only $dirs $net $opts $pkgs \
&& break
[ $i = 3 ] && exit 1
echo "package download failed or stalled (attempt $i); retrying from ${main%%/*}"
echo "package download failed or stalled (attempt $i); retrying from archive.ubuntu.com"
for f in /etc/apt/sources.list /etc/apt/sources.list.d/*; do
[ -f "$f" ] || continue
sudo sed -i -e "s#mirror+file:/etc/apt/apt-mirrors.txt#http://$main/#g" \
-e "s#http://azure\.$main#http://$main#g" "$f"
sudo sed -i -e 's#mirror+file:/etc/apt/apt-mirrors.txt#http://archive.ubuntu.com/ubuntu/#g' \
-e 's#http://azure\.archive\.ubuntu\.com/ubuntu#http://archive.ubuntu.com/ubuntu#g' "$f"
done
sudo timeout 120 apt-get update -y $dirs $upd || true
done
+8 -153
View File
@@ -58,7 +58,6 @@ check() {
}
AUDIO="libretro-common/formats/audio_transfer.c libretro-common/audio/audio_mixer.c"
check "wma only" "-DHAVE_RWMA" $AUDIO
echo "== audio codec combinations =="
# the sets real platform makefiles select, plus each codec alone and none
@@ -183,14 +182,14 @@ console_set "switch tls" "-I$STUBS/libnx" "-DHAVE_LIBNX -DSWITCH
# The built-in NFS client, which the 3DS, Vita, Switch and Wii U
# build, under the defines their Makefiles set (RARCH_CONSOLE for the
# console sleep and the 3DS transfer cap, Vita's legacy socket layer):
# Wii U against its own os/wiiu/include, Vita against stubs of vitasdk's
# Wii U against its own wiiu/include, Vita against stubs of vitasdk's
# socket headers.
NFS_SET="libretro-common/net/net_nfs3.c libretro-common/vfs/vfs_implementation_nfs.c libretro-common/vfs/vfs_prefetch.c"
NFSD="-DHAVE_RETRONFS -DHAVE_NFSCLIENT"
console_set "3ds nfs" "-Itools/platform_stubs/ctr $NFSD" "-D_3DS -DARM11 -DRARCH_CONSOLE" $NFS_SET
console_set "vita nfs" "-Itools/platform_stubs/vita $NFSD" "-DVITA -DRARCH_CONSOLE -DHAVE_SOCKET_LEGACY" $NFS_SET
console_set "switch nfs" "-I$STUBS/libnx $NFSD" "-DHAVE_LIBNX -DSWITCH -D__SWITCH__ -DRARCH_CONSOLE" $NFS_SET
console_set "wiiu nfs" "-Ios/wiiu/include -Itools/platform_stubs/wiiu $NFSD" "-DWIIU -D__WUT__ -DHW_WUP -D__wiiu__ -DRARCH_CONSOLE" $NFS_SET
console_set "wiiu nfs" "-Iwiiu/include -Itools/platform_stubs/wiiu $NFSD" "-DWIIU -D__WUT__ -DHW_WUP -D__wiiu__ -DRARCH_CONSOLE" $NFS_SET
# The built-in SMB and Kerberos clients, which the 3DS, Vita and Switch
# build on their crypto (the Wii U has no kernel RNG for it to draw on).
SMB_SET="libretro-common/net/net_smb2.c libretro-common/net/net_krb5.c libretro-common/vfs/vfs_implementation_smb.c"
@@ -345,11 +344,7 @@ platform_video "dingux video" "-DDINGUX" "-I/usr/include/SDL" \
platform_video "rs90 video" "-DDINGUX -DRS90" "-I/usr/include/SDL" \
gfx/drivers/sdl_rs90_gfx.c /usr/include/SDL/SDL.h
platform_video "wiiu gx2 video" "-DWIIU $HOSTOFF" \
"-Ios/wiiu/include -Ios/wiiu" gfx/drivers/gx2_gfx.c ""
# The iosuhax client, devoptab and libfat sector interface that replaced
# deps/libiosuhax, against newlib's devoptab order.
platform_video "wiiu iosuhax" "-DWIIU -D__wiiu__ -DHAVE_IOSUHAX $HOSTOFF" \
"-Ios/wiiu/include -Itools/platform_stubs/wiiu" os/wiiu/fs/iosuhax.c ""
"-Iwiiu/include -Iwiiu" gfx/drivers/gx2_gfx.c ""
platform_video "hub75 video" "" "" gfx/drivers/hub75_gfx.c ""
platform_video "openvg video" "-DHAVE_VG -DHAVE_EGL" \
"-Itools/platform_stubs/openvg" gfx/drivers/vg.c ""
@@ -368,13 +363,6 @@ platform_video "dispmanx video" "-DHAVE_DISPMANX" "-I$STUBS/videocore" \
platform_video "oga video" "-DHAVE_ODROIDGO2" \
"-I$STUBS/rga -I/usr/include/libdrm" \
gfx/drivers/oga_gfx.c /usr/include/xf86drm.h
# Its GL context: the RGA rotate and page flip that libgo2 used to do,
# against the same librga stand-in.
platform_video "go2 drm context" \
"-DHAVE_ODROIDGO2 -DHAVE_KMS -DHAVE_EGL -DHAVE_OPENGLES -DHAVE_GLSL" \
"-I$STUBS/rga -I/usr/include/libdrm" \
gfx/drivers_context/drm_go2_ctx.c \
"/usr/include/xf86drm.h /usr/include/gbm.h /usr/include/EGL/egl.h"
# The Direct3D drivers, against the DirectX headers the tree vendors in
# gfx/include/dxsdk. Six drivers no other lane compiles, and they read
@@ -452,22 +440,6 @@ d3d_video "d3d11 video, no threads" "$D3DDEFS -DHAVE_D3D11 -UHAVE_THREADS" \
gfx/drivers/d3d11.c
d3d_video "d3d12 video, no threads" "$D3DDEFS -DHAVE_D3D12 -UHAVE_THREADS" \
gfx/drivers/d3d12.c
d3d_video "d3d12 video, temporal upscaler" "$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER" \
gfx/drivers/d3d12.c
d3d_video "d3d12 NGX backend" "$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER" \
gfx/common/d3d12_ngx.c
d3d_video "d3d12 NGX backend, no threads" \
"$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER -UHAVE_THREADS" gfx/common/d3d12_ngx.c
d3d_video "d3d12 upscaler dispatch" "$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER" \
gfx/common/d3d12_upscaler.c
d3d_video "d3d12 FSR backend" "$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER" \
gfx/common/d3d12_ffx.c
d3d_video "d3d12 FSR backend, no threads" \
"$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER -UHAVE_THREADS" gfx/common/d3d12_ffx.c
d3d_video "d3d12 XeSS backend" "$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER" \
gfx/common/d3d12_xess.c
d3d_video "d3d12 XeSS backend, no threads" \
"$D3DDEFS -DHAVE_D3D12 -DHAVE_TEMPORAL_UPSCALER -UHAVE_THREADS" gfx/common/d3d12_xess.c
# With the MP4 previews: frames from rh264's D3D11 video backend,
# imported by D3D11 and D3D12 through shared handles and fences (11.4
# interfaces from the bundled headers), and the backend itself.
@@ -624,7 +596,7 @@ check "gl2: GLES3 on KMS" \
check "gl2: desktop on KMS" \
"$GLDEFS -DHAVE_EGL -DHAVE_KMS $GLINC $KMSINC" \
gfx/drivers/gl2.c gfx/common/egl_gbm_frames.c
GL3DEFS="-DHAVE_OPENGL -DHAVE_OPENGL_CORE -DHAVE_SLANG -DHAVE_RSLC -DHAVE_REWIND -DHAVE_OVERLAY"
GL3DEFS="-DHAVE_OPENGL -DHAVE_OPENGL_CORE -DHAVE_SLANG -DHAVE_GLSLANG -DHAVE_SPIRV_CROSS -DHAVE_REWIND -DHAVE_OVERLAY -Ideps/SPIRV-Cross"
check "gl3: desktop" \
"$GL3DEFS $GLINC" gfx/drivers/gl3.c
check "gl3: GLES3" \
@@ -831,7 +803,7 @@ check "psp: psp_joypad" "$PSP_DEFS $CDECL" input/drivers_joypad/psp_joypa
check "orbis: ps4_audio" "$HOSTOFF -Itools/platform_stubs/orbis -DORBIS $CDECL" audio/drivers/ps4_audio.c
check "qnx: alsa_qsa" "$HOSTOFF -Itools/platform_stubs/qnx -D__QNX__ $CDECL" audio/drivers/alsa_qsa.c
check "android: vfs saf" "$HOSTOFF -Itools/platform_stubs/android -DANDROID $CDECL" libretro-common/vfs/vfs_implementation_saf.c
check "android: play delivery" "$HOSTOFF -Itools/platform_stubs/android -DANDROID $CDECL" os/android/play_feature_delivery.c
check "android: play delivery" "$HOSTOFF -Itools/platform_stubs/android -DANDROID $CDECL" play_feature_delivery/play_feature_delivery.c
# the Android build carries the built-in NFS client and its backend
# (HAVE_RETRONFS in pkg/android/phoenix-common/jni/Android.mk) and the
# prefetcher both network backends read through
@@ -916,32 +888,6 @@ salamander_link "salamander link: rtime.c" \
"$HOSTOFF -UHAVE_THREADS -Itools/platform_stubs/vita -DVITA -DIS_SALAMANDER -DRARCH_CONSOLE" \
libretro-common/time/rtime.c
# Every launcher's whole libretro-common list, read from its Makefile,
# linked with frontend_salamander.c and a host frontend driver: a unit
# in a list that calls into one the list leaves out fails the link the
# way that launcher's would.
salamander_objs() {
case "$1" in
Makefile.wiiu)
sed -n '/^ifeq ($(SALAMANDER_BUILD),1)/,/^else/p' "$1" ;;
*) cat "$1" ;;
esac | grep -oE '(libretro-common/[A-Za-z0-9_/]+|verbosity)\.o' \
| sed 's/\.o$/.c/' | sort -u
}
for mk in Makefile.*.salamander Makefile.wiiu; do
if ! out=$($CC $WARN $INC $BASE -UHAVE_THREADS -DIS_SALAMANDER \
-DRARCH_CONSOLE -DHAVE_MAIN -o /tmp/salamander_link_check \
tools/platform_stubs/salamander_frontend.c \
frontend/frontend_salamander.c $(salamander_objs "$mk") 2>&1); then
echo "FAIL salamander link: $mk object set"
show_out "$out"
fail=1
else
echo "ok salamander link: $mk object set"
fi
rm -f /tmp/salamander_link_check
done
# runloop.c under Android: runloop_idle_wait's looper branch, and every
# other ANDROID block in the file, compiled against hermetic NDK stubs
# (jni, looper, native_activity, sensor, configuration, window) with
@@ -980,12 +926,6 @@ check "AV1 hardware registry: threads" "-DHAVE_RAV1" libretro-common/formats/av1
check_nothreads "no threads: AV1 hardware registry" "-DHAVE_RAV1" libretro-common/formats/av1/rav1_hw.c
check "vp9/h265/video streams: threads" "-DHAVE_RVP9 -DHAVE_RVP8 -DHAVE_RWEBM -DHAVE_RMP4 -DHAVE_RH264 -DHAVE_RH265" libretro-common/formats/vp9/rvp9.c libretro-common/formats/h265/rh265.c libretro-common/formats/webm/rwebm_video.c libretro-common/formats/mp4/rmp4_video.c libretro-common/formats/image/image_blit_bands.c
check_nothreads "no threads: vp9/h265/video streams" "-DHAVE_RVP9 -DHAVE_RVP8 -DHAVE_RWEBM -DHAVE_RMP4 -DHAVE_RH264 -DHAVE_RH265" libretro-common/formats/vp9/rvp9.c libretro-common/formats/h265/rh265.c libretro-common/formats/webm/rwebm_video.c libretro-common/formats/mp4/rmp4_video.c libretro-common/formats/image/image_blit_bands.c
check "Matroska AVC/HEVC without MP4 or VP9" "-DHAVE_RWEBM" \
libretro-common/formats/h264/rh264.c libretro-common/formats/h265/rh265.c \
libretro-common/formats/webm/rwebm_video.c libretro-common/formats/image_transfer.c
check_nothreads "no threads: Matroska AVC/HEVC without MP4 or VP9" "-DHAVE_RWEBM" \
libretro-common/formats/h264/rh264.c libretro-common/formats/h265/rh265.c \
libretro-common/formats/webm/rwebm_video.c libretro-common/formats/image_transfer.c
check "gfx_surface: threads" "$GLINC" gfx/gfx_surface.c gfx/gfx_thumbnail.c gfx/gfx_surface_player.c libretro-common/formats/video_player.c
check_nothreads "no threads: gfx_surface" "$GLINC" gfx/gfx_surface.c gfx/gfx_thumbnail.c gfx/gfx_surface_player.c libretro-common/formats/video_player.c
check_nothreads "no threads: gl2" "$GLDEFS $GLINC" gfx/drivers/gl2.c
@@ -1147,20 +1087,12 @@ GFXDEFS="-DHAVE_RGUI -DHAVE_OVERLAY -DHAVE_GFX_WIDGETS"
VK_H=/usr/include/vulkan/vulkan.h
platform_video "vulkan back end" "$GFXDEFS -DHAVE_VULKAN" "" \
gfx/drivers/vulkan.c "$VK_H"
check "Vulkan Video: Matroska without MP4" "-DHAVE_VULKAN -DHAVE_RWEBM -DHAVE_DYLIB -Igfx/include" \
gfx/common/vulkan_common.c gfx/common/vulkan_video_decode.c
check "Vulkan Video: AV1 disabled" "-DHAVE_VULKAN -DHAVE_RMP4 -DHAVE_DYLIB -Igfx/include" gfx/common/vulkan_common.c gfx/common/vulkan_video_decode.c
check "Vulkan Video: AV1 enabled, VP9 disabled" "-DHAVE_VULKAN -DHAVE_RMP4 -DHAVE_RAV1 -DHAVE_DYLIB -Igfx/include" gfx/common/vulkan_common.c gfx/common/vulkan_video_decode.c
platform_video "vulkan shader back end" "$GFXDEFS -DHAVE_VULKAN" "" \
gfx/drivers_shader/shader_vulkan.c "$VK_H"
check "cg shader back end" "$GFXDEFS -DHAVE_CG -DHAVE_OPENGL" \
gfx/drivers_shader/shader_gl_cg.c
for api in OPENGLES2 OPENGLES3; do
defs="$GFXDEFS -DHAVE_CG -DHAVE_OPENGL -DHAVE_OPENGLES -DHAVE_$api"
check "cg shader back end: $api" "$defs" gfx/drivers_shader/shader_gl_cg.c
d3d_video "cg shader back end: $api mingw" "$defs -Igfx/include/ANGLE" \
gfx/drivers_shader/shader_gl_cg.c
done
check "framebuffer back ends" "$GFXDEFS" \
gfx/drivers/fpga_gfx.c gfx/drivers/hub75_gfx.c gfx/drivers/sunxi_gfx.c
X11_H=/usr/include/X11/Xlib.h
@@ -1185,7 +1117,7 @@ check "runahead: both" "$RADEFS -DHAVE_DYNAMIC -DHAVE_DYLIB" runahea
# the stand-ins do not declare is an error: a new Metal call needs its
# declaration added there.
if command -v clang > /dev/null 2>&1; then
for metal_features in "" "-DHAVE_RMP4 -DHAVE_THREADS" "-DHAVE_RWEBM -DHAVE_THREADS"; do
for metal_features in "" "-DHAVE_RMP4 -DHAVE_THREADS"; do
for metal_ownership in "" "-fobjc-arc"; do
if ! out=$(clang -x objective-c -fobjc-runtime=macosx-10.13 -fblocks $metal_ownership \
-fsyntax-only -Wall -Wno-unused-function -Werror=objc-method-access \
@@ -1271,7 +1203,7 @@ font_layout "font layout: ps2" "" \
-Wno-declaration-after-statement" \
gfx/drivers/ps2_gfx.c
font_layout "font layout: gx2" "" \
"-DWIIU $HOSTOFF -Ios/wiiu/include -Ios/wiiu -Wno-declaration-after-statement" \
"-DWIIU $HOSTOFF -Iwiiu/include -Iwiiu -Wno-declaration-after-statement" \
gfx/drivers/gx2_gfx.c
font_layout "font layout: glcore" "" \
"-DHAVE_OPENGL -DHAVE_OPENGL_CORE -DHAVE_SLANG" gfx/drivers/gl3.c
@@ -1305,88 +1237,11 @@ UNITY_DIR=$(mktemp -d)
printf '#include "gfx/drivers/gl2.c"\n#include "gfx/drivers/gl3.c"\n#include "gfx/drivers/vulkan.c"\n' \
> "$UNITY_DIR/unity_gfx.c"
check "unity: gl2 + gl3 + vulkan in one translation unit" \
"-Igfx/include -DHAVE_OPENGL -DHAVE_OPENGL_CORE -DHAVE_GLSL -DHAVE_VULKAN -DHAVE_SLANG -DHAVE_SHADERPIPELINE -DHAVE_RSLC -DHAVE_GFX_WIDGETS -DHAVE_OVERLAY -DHAVE_X11" \
"-Igfx/include -DHAVE_OPENGL -DHAVE_OPENGL_CORE -DHAVE_GLSL -DHAVE_VULKAN -DHAVE_SLANG -DHAVE_SHADERPIPELINE -DHAVE_SPIRV_CROSS -DHAVE_GFX_WIDGETS -DHAVE_OVERLAY -DHAVE_X11" \
"$UNITY_DIR/unity_gfx.c"
rm -rf "$UNITY_DIR"
check "image YUV: PS2 C89" "-DPS2 -DRARCH_CONSOLE $HOSTOFF -std=c89" \
libretro-common/formats/image/image_yuv_blit.c
echo "== screens' own windows: with HAVE_VIDEO_WINDOWS =="
# Android builds the screens' windows and a desktop build does not, so
# no other lane compiles the drivers' window code or the frontend's
# with it; and without threads, as a --disable-threads build would.
WINDEFS="-DHAVE_VIDEO_WINDOWS -DHAVE_EGL"
WINTU="gfx/video_driver.c gfx/video_thread_wrapper.c input/input_driver.c \
configuration.c menu/menu_setting.c menu/menu_displaylist.c \
gfx/common/egl_common.c gfx/video_windows.c"
check "windows: frontend" "$UIDEFS $WINDEFS -DHAVE_OPENGL -DHAVE_OVERLAY" $WINTU
check_nothreads "windows: frontend, no threads" \
"$UIDEFS $WINDEFS -DHAVE_OPENGL -DHAVE_OVERLAY" \
$(echo "$WINTU" | sed 's|gfx/video_thread_wrapper.c||')
check "windows: gl2 GLES2" \
"$GLDEFS -DHAVE_OPENGLES -DHAVE_OPENGLES2 $WINDEFS $GLINC" gfx/drivers/gl2.c
check "windows: gl2 GLES3" \
"$GLDEFS -DHAVE_OPENGLES -DHAVE_OPENGLES3 $WINDEFS $GLINC" gfx/drivers/gl2.c
check "windows: gl2 desktop" "$GLDEFS $WINDEFS $GLINC" gfx/drivers/gl2.c
check_nothreads "windows: gl2, no threads" "$GLDEFS $WINDEFS $GLINC" \
gfx/drivers/gl2.c
platform_video "windows: vulkan back end" \
"$GFXDEFS -DHAVE_VULKAN -DHAVE_VIDEO_WINDOWS" "" gfx/drivers/vulkan.c "$VK_H"
check "windows: vulkan second output" \
"-DHAVE_VULKAN -DHAVE_DYLIB -DHAVE_VIDEO_WINDOWS -Igfx/include" \
gfx/common/vulkan_common.c
# PlayStation clang declares in immintrin.h only the intrinsics of the
# ISAs the whole build enables, so a kernel built under a per-function
# target("avx2") or target("avx512f") that the host compiles cleanly
# does not exist there: the PS4 has AVX alone, the PS5 AVX2 and no
# AVX-512. Every unit carrying a per-function target or 256/512-bit
# intrinsics is found by content rather than listed, so a new one is
# checked the day it lands, and compiled (not only parsed) for each
# console's own target triple, which brings that console's __SCE__ and
# CPU baseline. Host libc headers stand in for the SDK's.
echo "== playstation x86 SIMD units =="
SIMD_PAT='target\("(avx|fma|sse4|bmi|f16c)|_mm256_|_mm512_'
if git rev-parse --git-dir > /dev/null 2>&1; then
SIMD_TU=$(git grep -lE "$SIMD_PAT" -- '*.c' ':!deps/' ':!samples/' \
':!libretro-common/samples/' ':!tools/' ':!pkg/' ':!os/' ':!wiiu/')
else
SIMD_TU=$(grep -rlE --include='*.c' "$SIMD_PAT" . \
| sed 's|^\./||' \
| grep -vE '^(deps|samples|libretro-common/samples|tools|pkg|os|wiiu)/')
fi
SCE_CC=${SCE_CC:-clang}
SCE_SYS="-isystem /usr/include"
[ -d /usr/include/x86_64-linux-gnu ] \
&& SCE_SYS="$SCE_SYS -isystem /usr/include/x86_64-linux-gnu"
SCE_DEFS="-DRARCH_INTERNAL -DHAVE_THREADS -DHAVE_REWIND -DHAVE_CHEATS -D_BSD_SOURCE"
for sce in "ps4 x86_64-scei-ps4 -DORBIS -Itools/platform_stubs/orbis" \
"ps5 x86_64-sie-ps5"; do
set -- $sce
sce_name=$1; sce_triple=$2; shift 2
sce_extra="$*"
if ! command -v "$SCE_CC" > /dev/null 2>&1 \
|| ! "$SCE_CC" --target=$sce_triple -x c -c -o /dev/null /dev/null \
> /dev/null 2>&1; then
echo "skip $sce_name: SIMD units (no clang for $sce_triple)"
continue
fi
bad=0
for tu in $SIMD_TU; do
if ! out=$("$SCE_CC" --target=$sce_triple $SCE_SYS $HOSTOFF $INC \
$SCE_DEFS $sce_extra \
-O2 -Wall -Werror=implicit-function-declaration \
-c -o /dev/null "$tu" 2>&1); then
echo "FAIL $sce_name: SIMD units"
echo " $tu"
show_out "$out"
fail=1; bad=1
fi
done
[ "$bad" = 1 ] \
|| echo "ok $sce_name: SIMD units ($(echo $SIMD_TU | wc -w) files)"
done
exit $fail
@@ -1,38 +0,0 @@
#!/bin/sh
# Definitions that share their names with system libraries must stay
# hidden. Exported, they win the lookup: libssl's MD5_Init lands in
# libretro-common's copy, whose MD5_CTX is a different size, and so do
# the MD5 calls of a core bundling LibreSSL. Whether the executable
# exports them depends on what it links, so this reads the objects,
# where the visibility is set no matter what the link pulls in.
#
# Reads the release objects, so run it after a plain `make`.
set -e
cd "$(dirname "$0")/../../.."
OBJDIR=${OBJDIR:-obj-unix/release}
LRC="$OBJDIR/libretro-common"
fail=0
objs="$LRC/utils/md5.o"
if grep -q '^HAVE_RETROSMB = 1' config.mk 2>/dev/null; then
objs="$objs $LRC/net/net_krb5.o"
fi
for o in $objs; do
if [ ! -f "$o" ]; then
echo "FAIL: $o not built (run make first)"
fail=1
continue
fi
# Num Value Size Type Bind Vis Ndx Name
exported=$(readelf -sW "$o" | awk '$4 == "FUNC" && $5 == "GLOBAL" && $6 != "HIDDEN" && $7 != "UND" { print $8 }')
if [ -n "$exported" ]; then
echo "FAIL: $o exports:" $exported
fail=1
else
echo "ok: $o"
fi
done
exit $fail
@@ -1,9 +1,6 @@
# function size stack-frame (release build, x86-64 GCC 15, Ubuntu 26.04)
# function size stack-frame (release build, x86-64 GCC)
# Driver Pacing release/marker dispatch adds code; the stack guard stays put.
# sample_batch settles pending pause and reset requests on the submitting thread.
# Measured again under GCC 15 when ubuntu-latest moved to 26.04: from the same
# source it emits 12-22% more code than GCC 13 did for three of these.
runloop_iterate 8026 120
video_driver_frame 8191 3992
video_thread_frame 4825 200
audio_driver_sample_batch 623 24
runloop_iterate 6527 88
video_driver_frame 9447 4008
video_thread_frame 3873 152
audio_driver_sample_batch 394 24
-35
View File
@@ -1,35 +0,0 @@
# Sourced by a step: runs commands at the same time, for tests that wait
# on a real clock and use next to no CPU, so the step takes as long as
# the longest of them rather than all of them in a row.
#
# par "name" command args... start one, its output kept apart
# par_wait wait for all; print each one's output in
# the order started, and fail the step if
# any of them failed
par_names=""
par_pids=""
par_dir=$(mktemp -d)
par() {
name="$1"; shift
"$@" > "$par_dir/$(echo "$name" | tr ' /' '__').log" 2>&1 &
par_pids="$par_pids $!"
par_names="$par_names|$name"
}
par_wait() {
bad=0
set -- $par_pids
old_ifs=$IFS; IFS='|'; names=${par_names#|}; IFS=$old_ifs
while [ $# -gt 0 ]; do
name=${names%%|*}; names=${names#*|}
if wait "$1"; then status=pass; else status=FAIL; bad=1; fi
echo "== $name"
cat "$par_dir/$(echo "$name" | tr ' /' '__').log"
echo "[$status] $name"
shift
done
rm -rf "$par_dir"
par_names=""; par_pids=""; par_dir=$(mktemp -d)
return $bad
}
@@ -1,79 +0,0 @@
#!/bin/sh
# Checks webos-deps.sh against a stub gh: transient API failures are
# retried, a lasting outage falls back to the cache, and a cached tag
# downloads nothing.
set -eu
script=$(cd "$(dirname "$0")" && pwd)/webos-deps.sh
t=$(mktemp -d)
trap 'rm -rf "$t"' EXIT
mkdir -p "$t/bin"
cat > "$t/bin/gh" <<'EOF'
#!/bin/sh
n=$(cat "$STUB/count" 2>/dev/null || echo 0)
echo $((n + 1)) > "$STUB/count"
if [ "$n" -lt "$STUB_FAIL" ]; then
echo "HTTP 500" >&2
exit 1
fi
case $2 in
view) echo v2 ;;
download)
echo "$2 $3" >> "$STUB/downloads"
while [ $# -gt 0 ]; do
case $1 in
-p) p=$2; shift ;;
-D) d=$2; shift ;;
esac
shift
done
mkdir -p "$d"
echo x > "$d/$(echo "$p" | sed 's/\*/1.0/')"
;;
esac
EOF
chmod +x "$t/bin/gh"
export PATH="$t/bin:$PATH" STUB="$t" WEBOS_DEPS_DELAY=0 WEBOS_DEPS_TRIES=3
fail=0
run() {
rm -f "$t/count" "$t/downloads"
STUB_FAIL=$1 WEBOS_DEPS="$t/deps" sh "$script" fetch > "$t/log" 2>&1
}
check() {
if eval "$2"; then
echo "ok $1"
else
echo "FAIL $1"
cat "$t/log"
fail=1
fi
}
run 2 && rc=0 || rc=$?
check "transient failures are retried" \
'[ $rc = 0 ] && [ "$(cat $t/deps/cscd98_buildroot-nc4/TAG)" = v2 ]'
run 0 && rc=0 || rc=$?
check "cached tag downloads nothing" '[ $rc = 0 ] && [ ! -e $t/downloads ]'
echo v1 > "$t/deps/webosbrew_ares-cli-rs/TAG"
run 1000 && rc=0 || rc=$?
check "outage falls back to the cache" \
'[ $rc = 0 ] && grep -q "using cached v1" $t/log'
rm -rf "$t/deps"
run 1000 && rc=0 || rc=$?
check "outage without a cache fails" '[ $rc != 0 ]'
rm -f "$t/count"
key=$(STUB_FAIL=1000 sh "$script" key 2> "$t/log")
check "key is unresolved during an outage" '[ "$key" = unresolved ]'
rm -f "$t/count"
key=$(STUB_FAIL=0 sh "$script" key)
check "key names the latest releases" \
'[ ${#key} = 16 ] && [ "$key" != unresolved ]'
exit $fail
-92
View File
@@ -1,92 +0,0 @@
#!/bin/sh
# Fetches the webOS packaging tools and NDKs from their latest releases.
#
# webos-deps.sh key print the cache key of the latest releases
# webos-deps.sh fetch fill WEBOS_DEPS with them
#
# WEBOS_DEPS (default /tmp/webos-deps) holds one directory per release
# repository, with the asset and its tag; actions/cache keeps it. The
# GitHub API fails now and then (HTTP 500), so each call is retried, and
# when it keeps failing the assets the cache already has are used.
set -eu
dir=${WEBOS_DEPS:-/tmp/webos-deps}
delay=${WEBOS_DEPS_DELAY:-15}
tries=${WEBOS_DEPS_TRIES:-5}
deps() {
cat <<'EOF'
webosbrew/ares-cli-rs ares-package_*_amd64.deb
webosbrew/dev-toolbox-cli webosbrew-toolbox-gen-manifest_*_amd64.deb
openlgtv/buildroot-nc4 arm-webos-linux-gnueabi_sdk-buildroot-x86_64.tar.gz
cscd98/buildroot-nc4 aarch64-webos-linux-gnu_sdk-buildroot-x86_64.tar.gz
EOF
}
retry() {
n=1
until "$@" < /dev/null; do
[ "$n" -lt "$tries" ] || return 1
echo "webos-deps.sh: attempt $n of $tries failed; retrying" >&2
sleep $((delay * n))
n=$((n + 1))
done
}
latest_tag() {
retry gh release view -R "$1" --json tagName -q .tagName
}
have() {
for f in "$1"/$2; do
[ -s "$f" ] && return 0
done
return 1
}
case ${1:-} in
key)
tags=
while read -r repo pattern; do
tag=$(latest_tag "$repo") || { echo unresolved; exit 0; }
tags="$tags $repo@$tag"
done <<EOF
$(deps)
EOF
echo "$tags" | sha1sum | cut -c1-16
;;
fetch)
mkdir -p "$dir"
while read -r repo pattern; do
d=$dir/$(echo "$repo" | tr / _)
if tag=$(latest_tag "$repo"); then
if [ "$(cat "$d/TAG" 2>/dev/null)" = "$tag" ] && have "$d" "$pattern"; then
echo "webos-deps.sh: $repo $tag cached"
continue
fi
rm -rf "$d.new"
if retry gh release download "$tag" -R "$repo" -p "$pattern" \
-D "$d.new" --clobber && have "$d.new" "$pattern"; then
echo "$tag" > "$d.new/TAG"
rm -rf "$d"
mv "$d.new" "$d"
echo "webos-deps.sh: $repo $tag downloaded"
continue
fi
rm -rf "$d.new"
fi
if have "$d" "$pattern"; then
echo "::warning::$repo unreachable; using cached $(cat "$d/TAG" 2>/dev/null || echo release)"
else
echo "::error::$repo unreachable and not cached"
exit 1
fi
done <<EOF
$(deps)
EOF
;;
*)
echo "usage: webos-deps.sh key|fetch" >&2
exit 2
;;
esac
-18
View File
@@ -1,18 +0,0 @@
# Sourced by a step that runs Windows programs under Wine, and needs no
# display: one Wine server for the whole step, ended when the step ends.
# Left to itself each program starts a server that leaves after it, and
# a program started as the last one is leaving is cut off before main()
# ("wine client error:0: recvmsg: Connection reset by peer").
# Wine's services start with a server's first program and hold that
# program's output for as long as they live, which is now the step: a
# step piping a test into tee would wait for them. So they are started
# here, with no output to hold. A server already running for the prefix
# is used as it is, and left running. Sets the step's EXIT trap.
if command -v wineserver >/dev/null 2>&1; then
mkdir -p "${WINEPREFIX:-$HOME/.wine}"
if wineserver -p 2>/dev/null; then
trap 'wineserver -k || true' EXIT
WINEDEBUG=-all "$(command -v wine64 || command -v wine)" cmd /c exit \
</dev/null >/dev/null 2>&1 || true
fi
fi
+51 -65
View File
@@ -6,19 +6,7 @@ on:
- '*'
branches:
- '*'
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/webOS.yml'
# ci_paths: end
pull_request:
# ci_paths: generated by tools/ci_paths.py, do not edit
paths:
- '**'
- '!.github/workflows/*.yml'
- '.github/workflows/webOS.yml'
# ci_paths: end
release:
types: [ published ]
repository_dispatch:
@@ -40,39 +28,21 @@ jobs:
- name: Link with lld
run: sh .github/workflows/scripts/use-lld.sh
- name: Test webOS dependency fetcher
run: sh .github/workflows/scripts/webos-deps-test.sh
- name: Resolve webOS tools and NDKs
id: webos-deps
env:
GH_TOKEN: ${{ github.token }}
run: echo "key=$(sh .github/workflows/scripts/webos-deps.sh key)" >> "$GITHUB_OUTPUT"
- name: Restore webOS tools and NDKs
id: webos-deps-cache
uses: actions/cache/restore@v4
- name: Download ares-cli-rs
uses: robinraju/release-downloader@v1
with:
path: /tmp/webos-deps
key: webos-deps-${{ steps.webos-deps.outputs.key }}
restore-keys: |
webos-deps-
repository: "webosbrew/ares-cli-rs"
latest: true
fileName: "ares-package_*_amd64.deb"
out-file-path: "temp"
- name: Fetch webOS tools and NDKs
if: steps.webos-deps-cache.outputs.cache-hit != 'true'
env:
GH_TOKEN: ${{ github.token }}
run: sh .github/workflows/scripts/webos-deps.sh fetch
- name: Save webOS tools and NDKs
if: >-
steps.webos-deps-cache.outputs.cache-hit != 'true' &&
steps.webos-deps.outputs.key != 'unresolved' &&
github.event_name == 'push' && github.ref == 'refs/heads/master'
uses: actions/cache/save@v4
- name: Download Manifest Generator
uses: robinraju/release-downloader@v1
with:
path: /tmp/webos-deps
key: webos-deps-${{ steps.webos-deps.outputs.key }}
repository: "webosbrew/dev-toolbox-cli"
latest: true
fileName: "webosbrew-toolbox-gen-manifest_*_amd64.deb"
out-file-path: "temp"
- name: Update packages
timeout-minutes: 5
@@ -89,16 +59,32 @@ jobs:
run: |
sudo apt-get -yq install \
-o Acquire::Retries=3 -o Acquire::http::Timeout=30 \
/tmp/webos-deps/webosbrew_ares-cli-rs/ares-package_*_amd64.deb \
/tmp/webos-deps/webosbrew_dev-toolbox-cli/webosbrew-toolbox-gen-manifest_*.deb
./temp/ares-package_*_amd64.deb \
./temp/webosbrew-toolbox-gen-manifest_*.deb
- name: Download webOS (arm) NDK
uses: robinraju/release-downloader@v1
with:
repository: "openlgtv/buildroot-nc4"
latest: true
fileName: "arm-webos-linux-gnueabi_sdk-buildroot-x86_64.tar.gz"
out-file-path: "/tmp"
- name: Download webOS (aarch64) NDK
uses: robinraju/release-downloader@v1
with:
repository: "cscd98/buildroot-nc4"
latest: true
fileName: "aarch64-webos-linux-gnu_sdk-buildroot-x86_64.tar.gz"
out-file-path: "/tmp"
- name: Extract webOS NDKs
shell: bash
working-directory: /tmp
run: |
tar xzf /tmp/webos-deps/openlgtv_buildroot-nc4/arm-webos-linux-gnueabi_sdk-buildroot-x86_64.tar.gz
tar xzf arm-webos-linux-gnueabi_sdk-buildroot-x86_64.tar.gz
./arm-webos-linux-gnueabi_sdk-buildroot/relocate-sdk.sh
tar xzf /tmp/webos-deps/cscd98_buildroot-nc4/aarch64-webos-linux-gnu_sdk-buildroot-x86_64.tar.gz
tar xzf aarch64-webos-linux-gnu_sdk-buildroot-x86_64.tar.gz
./aarch64-webos-linux-gnu_sdk-buildroot/relocate-sdk.sh
- name: Load RARCH_VERSION from version.all
@@ -171,9 +157,9 @@ jobs:
bash .github/workflows/scripts/ccache-make.sh -f Makefile.webos ipk PACKAGE_NAME=${PACKAGE_NAME} ADD_SDL2_LIB=1 \
SDL2_PREBUILT_ARCHIVE="file:///tmp/sdl2-prebuilt/${SDL2_NAME}" \
-j"$(getconf _NPROCESSORS_ONLN)"
mkdir -p pkg/webos/arm
mv pkg/webos/com.retroarch.webos_${RARCH_VERSION}_arm.ipk \
pkg/webos/arm/com.retroarch.webos-legacy-gles2-no-wayland_${RARCH_VERSION}_arm.ipk
mkdir -p webos/arm
mv webos/com.retroarch.webos_${RARCH_VERSION}_arm.ipk \
webos/arm/com.retroarch.webos-legacy-gles2-no-wayland_${RARCH_VERSION}_arm.ipk
env:
DEBUG: ${{ github.event_name == 'release' && '0' || '1' }}
SDL2_NAME: ${{ steps.sdl2.outputs.name }}
@@ -182,7 +168,7 @@ jobs:
uses: actions/upload-artifact@v7
with:
name: com.retroarch.webos-legacy-gles2-no-wayland_${{ env.RARCH_VERSION }}_${{ github.sha }}_arm.ipk
path: pkg/webos/arm/com.retroarch.webos-legacy-gles2-no-wayland_${{ env.RARCH_VERSION }}_arm.ipk
path: webos/arm/com.retroarch.webos-legacy-gles2-no-wayland_${{ env.RARCH_VERSION }}_arm.ipk
archive: false
- name: Compile RA (default)
@@ -196,9 +182,9 @@ jobs:
SDL2_PREBUILT_ARCHIVE="file:///tmp/sdl2-prebuilt/${SDL2_NAME}" \
HAVE_XKBCOMMON=1 HAVE_USERLAND=1 HAVE_EGL=1 HAVE_WAYLAND=1 \
HAVE_OPENGLES3=1 HAVE_OPENGLES3_1=1 HAVE_OPENGLES3_2=1 -j"$(getconf _NPROCESSORS_ONLN)"
mkdir -p pkg/webos/arm
mv pkg/webos/com.retroarch.webos_${RARCH_VERSION}_arm.ipk \
pkg/webos/arm/com.retroarch.webos_${RARCH_VERSION}_arm.ipk
mkdir -p webos/arm
mv webos/com.retroarch.webos_${RARCH_VERSION}_arm.ipk \
webos/arm/com.retroarch.webos_${RARCH_VERSION}_arm.ipk
env:
DEBUG: ${{ github.event_name == 'release' && '0' || '1' }}
SDL2_NAME: ${{ steps.sdl2.outputs.name }}
@@ -207,16 +193,16 @@ jobs:
uses: actions/upload-artifact@v7
with:
name: com.retroarch.webos_${{ env.RARCH_VERSION }}_${{ github.sha }}_arm.ipk
path: pkg/webos/arm/com.retroarch.webos_${{ env.RARCH_VERSION }}_arm.ipk
path: webos/arm/com.retroarch.webos_${{ env.RARCH_VERSION }}_arm.ipk
archive: false
- name: Generate Manifest (default only)
if: github.repository == 'webosbrew/Retroarch'
shell: bash
run: |
webosbrew-gen-manifest -o pkg/webos/${PACKAGE_NAME}.manifest.json \
-p pkg/webos/arm/${PACKAGE_NAME}_${RARCH_VERSION}_arm.ipk \
-i https://github.com/libretro/RetroArch/raw/master/pkg/webos/icon160.png \
webosbrew-gen-manifest -o webos/${PACKAGE_NAME}.manifest.json \
-p webos/arm/${PACKAGE_NAME}_${RARCH_VERSION}_arm.ipk \
-i https://github.com/webosbrew/RetroArch/raw/webos/webos/icon160.png \
-l https://github.com/webosbrew/RetroArch
- name: Compile RA (aarch64)
@@ -232,9 +218,9 @@ jobs:
HAVE_OPENGLES3=1 HAVE_OPENGLES3_1=1 HAVE_OPENGLES3_2=1 \
HAVE_WAYLAND_BACKPORT=0 HAVE_64TO32BIT_BRIDGE=1 SET_ELF_INTERPRETER=1 HAVE_UDEV=1 \
ARES_PACKAGE_ARGS="-A arm" -j"$(getconf _NPROCESSORS_ONLN)"
mkdir -p pkg/webos/aarch64
mv pkg/webos/com.retroarch.webos_${{ env.RARCH_VERSION }}_arm.ipk \
pkg/webos/aarch64/com.retroarch.webos_${{ env.RARCH_VERSION }}_aarch64.ipk
mkdir -p webos/aarch64
mv webos/com.retroarch.webos_${{ env.RARCH_VERSION }}_arm.ipk \
webos/aarch64/com.retroarch.webos_${{ env.RARCH_VERSION }}_aarch64.ipk
env:
DEBUG: ${{ github.event_name == 'release' && '0' || '1' }}
@@ -256,7 +242,7 @@ jobs:
uses: actions/upload-artifact@v7
with:
name: com.retroarch.webos_${{ env.RARCH_VERSION }}_${{ github.sha }}_aarch64.ipk
path: pkg/webos/aarch64/com.retroarch.webos_${{ env.RARCH_VERSION }}_aarch64.ipk
path: webos/aarch64/com.retroarch.webos_${{ env.RARCH_VERSION }}_aarch64.ipk
archive: false
- name: Release
@@ -270,7 +256,7 @@ jobs:
omitBody: true
omitPrereleaseDuringUpdate: true
artifacts: |
pkg/webos/arm/com.retroarch.webos_${{ env.RARCH_VERSION }}_arm.ipk
pkg/webos/arm/com.retroarch.webos-legacy-gles2-no-wayland_${{ env.RARCH_VERSION }}_arm.ipk
pkg/webos/aarch64/com.retroarch.webos_${{ env.RARCH_VERSION }}_aarch64.ipk
pkg/webos/${{ env.PACKAGE_NAME }}.manifest.json
webos/arm/com.retroarch.webos_${{ env.RARCH_VERSION }}_arm.ipk
webos/arm/com.retroarch.webos-legacy-gles2-no-wayland_${{ env.RARCH_VERSION }}_arm.ipk
webos/aarch64/com.retroarch.webos_${{ env.RARCH_VERSION }}_aarch64.ipk
webos/${{ env.PACKAGE_NAME }}.manifest.json
+7 -25
View File
@@ -45,7 +45,8 @@ Debug
Release
ipch
*.user
/os/gekko/rvl/app_booter/app_booter.bin
/bootstrap/gx/wii/app_booter/app_booter.bin
/wii/app_booter/app_booter.bin
*.zip
RetroArch-w32/
RetroArch-w64/
@@ -124,8 +125,7 @@ shaders/shaders_slang
*.depend
*.rpx
*.last
os/wiiu/wut/elf2rpl/elf2rpl
os/wiiu/wut/elf2rpl/elf2rpl.exe
wiiu/wut/elf2rpl/elf2rpl
/pkg/wiiu/retroarch
/pkg/wiiu/wiiu
/pkg/wiiu/rpx
@@ -281,7 +281,6 @@ gfx/common/wayland/wlr-output-management-unstable-v1.h
# samples/: built harness executables and objects. Each directory's
# test is <dir>_test; nothing built there is source.
samples/**/*_test
libretro-common/test/formats/rxml_oom_test
samples/**/*_test_*
samples/audio/stretch/stretch_bench
samples/gfx/rslc_corpus/rslc_corpus_dump
@@ -319,7 +318,6 @@ samples/gfx/font_lifecycle/chain
samples/gfx/font_lifecycle/frame
samples/gfx/font_lifecycle/vg
samples/gfx/font_lifecycle/sdl2
samples/gfx/font_lifecycle/omap
samples/gfx/slang_cache/mapped
samples/gfx/slang_cache/read
samples/tasks/database/database_task
@@ -330,10 +328,6 @@ samples/gfx/threaded_video/fake_rebar_layer.json
# Generated by samples/gfx/wayland_drm_lease from the bundled protocol
# XML; the client half of the same pair lands in gfx/common/wayland.
samples/gfx/wayland_drm_lease/drm-lease-v1-client-protocol.h
# The golden-hash tests, one per video filter, named golden_<filter>
# beside their recorded golden_<filter>.h tables.
samples/gfx/filter_golden/golden_*
!samples/gfx/filter_golden/golden_*.h
samples/gfx/wayland_drm_lease/drm-lease-v1-server-protocol.h
samples/gfx/wayland_drm_lease/drm-lease-v1-protocol.c
@@ -351,6 +345,7 @@ param.sfo
*.self
*.vpk
/.vs
/deps/SPIRV-Cross/out/build/x64-Debug
# Visual Studio Code
.vscode/
@@ -378,23 +373,10 @@ samples/audio/embedded_alsa/ealsa_abi.h
__pycache__/
*.pyc
samples/audio/asio_clock/asio_clock_driver.h
samples/audio/asio_teardown/asio_teardown_driver.h
samples/gfx/integer_scale_axis/integer_scale_driver.h
samples/gfx/coord_array/coord_array_driver.h
samples/gfx/integer_scale_axis/integer_scale_axis_test
samples/gfx/set_rotation_deferred/set_rotation_driver.h
# os/wiiu/slang host tool
/os/wiiu/slang/slang-cafe
/os/wiiu/slang/slang-cafe.exe
samples/gfx/vulkan_upscaler/Zdir/
samples/gfx/vulkan_upscaler/Zdir_fsr/
samples/gfx/vulkan_upscaler/Zdir_xess/
samples/gfx/vulkan_upscaler/Zdir_none/
samples/gfx/d3d12_upscaler/Zdir/
samples/gfx/d3d12_upscaler/Zdir_fsr/
samples/gfx/d3d12_upscaler/Zdir_xess/
samples/gfx/d3d12_upscaler/Zdir_none/
samples/record/ffmpeg_pipeline/record_finalize_fragment.c
samples/record/ffmpeg_pipeline/record_start_fragment.c
samples/input/sensor_subdevice/core_sensor_fragment.c
# wiiu/slang host tool
/wiiu/slang/slang-cafe
/wiiu/slang/slang-cafe.exe
+4 -20
View File
@@ -50,6 +50,7 @@ build-retroarch-windows-x64:
--enforcedir /usr/lib/mxe/usr/x86_64-w64-mingw32.shared/qt5/plugins/styles/
--copy
--objdump x86_64-w64-mingw32.shared-objdump"
- "cp -f nvdaControllerClient64.dll ${MEDIA_PATH}/${CI_PROJECT_NAME}/redist/nvdaControllerClient64.dll"
- "rm -f ${MEDIA_PATH}/${CI_PROJECT_NAME}/redist/opengl32.dll"
build-retroarch-windows-i686:
@@ -698,23 +699,6 @@ build-retroarch-android-playstore-plus:
cp -r ./* .retroarch-precompiled/
mv .retroarch-precompiled/ retroarch-precompiled/
build-retroarch-android-quest-aarch64:
image: $CI_SERVER_HOST:5050/libretro-infrastructure/libretro-build-android:latest
stage: build
artifacts:
paths:
- retroarch-precompiled/
expire_in: 10 min
script:
- |
set -e
cd pkg/android/phoenix
./gradlew assembleQuestRelease
cd -
mkdir .retroarch-precompiled
cp -r ./* .retroarch-precompiled/
mv .retroarch-precompiled/ retroarch-precompiled/
build-static-retroarch-libnx-aarch64:
image: $CI_SERVER_HOST:5050/libretro-infrastructure/libretro-build-libnx-devkitpro:v4-10-0
stage: prepare-for-static-cores
@@ -771,7 +755,7 @@ build-static-retroarch-psp:
- build-static-retroarch-dummy-psp
script:
# We need to boostrap before compile
- "(cd os/psp1/kernel_functions_prx/ && make && cd -)"
- "(cd bootstrap/psp1/kernel_functions_prx/ && make && cd -)"
# Allow failure since we don't have a core
- "make -f Makefile.psp1 -j$NUMPROC ||:"
- "mkdir .retroarch-precompiled"
@@ -793,9 +777,9 @@ build-static-retroarch-dummy-psp:
expire_in: 10 min
dependencies: []
script:
- "(cd os/psp1/kernel_functions_prx/ && make && cd -)"
- "(cd bootstrap/psp1/kernel_functions_prx/ && make && cd -)"
- "make -f Makefile.psp1.salamander -j$NUMPROC"
- "make -C os/psp1/kernel_functions_prx/"
- "make -C bootstrap/psp1/kernel_functions_prx/"
- "mkdir -p ${MEDIA_PATH}/${CI_PROJECT_NAME}/pkg"
- "cp -f pkg/psp1/ICON0.PNG ${MEDIA_PATH}/${CI_PROJECT_NAME}/pkg"
- "cp -f pkg/psp1/PIC1.PNG ${MEDIA_PATH}/${CI_PROJECT_NAME}/pkg"
Loaded 100 of 6830 files, more files were not shown because too many files have changed in this diff. Show more