Guru3D RTSS Rivatuner Statistics Server Download 7.3.0 Final

Version 7.3.0 final release

• Scanline sync no longer stops working in OpenGL applications when OSD support is disabled at application profile level
• Fixed Vulkan device and instance handle leak in Vulkan bootstrap layer
• Fixed crash on capturing screenshots in Cyberpunk 2077 when scRGB HDR mode is enabled
• Improved compatibility with Vulkan applications using multiple Vulkan instances and devices
• Various Vulkan bootstrap layer and Vulkan overlay renderer cleanups aimed to improve compatibility with Vulkan validation layer
• Added alternate asynchronous On-Screen Display renderer for Vulkan applications presenting frames from compute queue (id Tech 6 and newer engine games like Doom 2016 and Dooom Eternal). The implementation is using original AMD’s high performance concept of asynchronous offscreen overlay rendering and the principle of asynchronous combining with framebuffer directly from compute pipeline with compute shader without stalling compute/graphics pipelines. PresentFromCompute entry in global profile template is set to 1 by default now and it enables new asynchronous implementation. The previous synchronous and more performance consuming implementation is also available and can be enabled by setting PresentFromCompute to 2. It is recommended to enable the previous synchronous implementation for performance comparisons only and for estimating difference in performance hit between new and old implementations
• Improved compatibility with multithreaded Direct3D1x applications, using multiple Direct3D devices and swapchains and concurrently presenting frames on them from different threads (e.g. Windows Terminal)
• Various compatibility improvements in the hook engine:
  • Now any application may manifest itself as incompatible with RivaTuner Statistics Server overlay/hooks either via declaring special named exported variable (recommended and preferred way for EXE-level implementation) or via setting process environment variable (alternate way for DLL-level implementation). So the applications incompatible with RivaTuner Statistics Server may prevent its API hooking functionality with just a couple lines of code at compile time without need to add exclusion profile for it from RivaTuner Statistics Server side
  • Added user extendable profile mapper to profile loader. The mapper is allowing RivaTuner Statistics Server to map multiple executable names matching with specified wildcard (e.g. vegas130.exe, vegas140.exe and so on for different versions of Sony Vegas) to a single profile file, so it is no longer necessary to create exclusion profiles for each version of such application independently
  • Added user extendable injection ignore triggers list. Similar to injection delay triggers list, injection ignore triggers list allows defining the set of DLL modules, which will prevent RivaTuner Statistics Server from injecting target process when any of such modules is detected in the process context. This feature is aimed to exclude applications using typical GPU accelerated GUI libraries from hooking. The list currently includes WPF framework libraries (PresentationFramework.dll and PresentationFramework.NI.dll), so all WPF applications are excluded from hooking now
  • Improved 32-bit runtime disassembler provides better compatibility with 32-bit applications when stealth mode is enabled
  • Added Direct3D12 hooking support for Direct3D12 runtime changes introduced with KB4598291
  • Improved RivaTuner Statistics Server host API:
    • New localization API is allowing the plugins to use host multilanguage translation functionality for localizing the plugin’s GUI
    • New On-Screen Display preview API is allowing the plugins to render On-Screen Display on top of Direct3D frambuffer specified by caller and report back each rendered layer’s screen position and extent. On-Screen Display preview API can be used to implement visual On-Screen Display editing functionality
    • Added helper PickColor API function, allowing the plugins to use advanced host color picker dialog window
    • Improved On-Screen Display hypertext formatting implementation:
      • Various fixes in alignment, dynamic tabbing, positioning and backspace tags parsing implementation
      • Added layer definition tags. Each layer defined inside the hypertext is treated by parser as an independent block of text and new On-Screen Display preview API is able to report each rendered layer’s screen position and extent independently. Please take a note that layer definition tags also affect text extent calculation, so embedded objects with zero height and width defined inside the layer are covering just their layer area instead of whole On-Screen Display area
      • Added extent override tags support. By default the layer extent is defined by hypertext content, but you may force the layer extent to be greater than actual content extent with new extent override tag. The tag also allows aligning the layer content by left/right/top/bottom or centering it horizontally/vertically
      • Added image loading tags support. The tags are allowing the parser to load and embed a custom PNG image into On-Screen Display font texture
      • Added image embedding tags support. The tags are allowing you to render a part of On-Screen Display font texture image into hypertext. This allows you to display custom logos or animated image sequences into On-Screen Display
      • Added defaults override tags support. The tags are aimed to be used in pairs, to start and stop defaults override blocks inside the hypertext. The first tag starts the block, stores default hypertext formatting attributes (text color, size and so on) and saves currently applied hypertext formatting attributes as new defaults. This way user defined defaults are being applied with default text color or size tags inside defaults override block. The next tag ends the block and restores previously saved default hypertext formatting attributes
      • Changed embedded object size interpretation. Now positive size values are treated as zoomed pixels instead of fixed pixels
      • Added new <EXE> hypertext tag, allowing displaying hooked process executable name in On-Screen Display
      • Added range autoscaling flag support for embedded graphs
      • Added new type of plugins: client plugins. RivaTuner Statistics Server is designed to act as a server process, which is running passively and providing different functionality (On-Screen Display rendering, screen and video capture, benchmarking etc) to multiple client applications connected to it (e.g. MSI Afterburner). GUI for such functionality is normally located at client application side. New client plugins allow integrating GUI for such functionality directly into RivaTuner Statistics Server, without the need to run additional client applications, so new client plugins architecture is intended for those who prefer to use RivaTuner Statistics Server as a standalone solution without MSI Afterburner. SDK is now including the following open source client plugins:
        • HotkeyHandler plugin is a built in hotkey processor, which is providing and demonstrating implementation of the following functionality:
          • Low-latency DirectInput based hotkey handler, similar to MSI Afterburner’s internal one
          • Full set of standard hotkey based functionality, available in MSI Afterburner client and based on RivaTuner Statistics Server API. This includes On-Screen Display visibility control, framerate limiter activation/deactivation, screen capture, video capture and benchmarking functionality. Now all those features can be also used in standalone RivaTuner Statistics Server usage scenario
          • Up to 4 additional general-purpose programmable profile modifier hotkeys.  You may bind almost any profile modification related actions to those hotkeys, e.g.  increase of decrease framerate limit, toggle between multiple predefined framerate limits, increase or decrease scanline index for  scanline sync mode, zoom OSD in/out, enable or disable global hooks and many more
• OverlayEditor plugin is advanced visual hypertext editor, providing you more than any currently existing overlay can do. There were a lot of fair and independent commercial overlay reviews recently, claiming that it is absolutely impossible to develop visual overlay editing in free applications and that feature wise all free overlays are second tier products comparing to commercial ones. We decided to take it as a challenge, burst that marketing bubble and provide the plugin with such functionality free of charge to anyone who still believes in free system software distribution principles like us. So this plugin was developed from scratch in just a few weeks. It comes with fully open source code included in SDK, so you can peek inside and improve it or just see if such kind of functionality is really a rocket science development:
  • Unified and extremely flexible overlay layout editing GUI, which can be used in combo with any major and most popular hardware monitoring cores available on the market: HwINFO64, AIDA64 or MSI Afterburner. Do you wish to attach something else, e.g. GPU-Z? That’s not a problem, it can be easily done by any beginner developer in just a few hours because the plugin is completely open source. Your overlay layout can be easily adapted to any hardware monitoring data provider application and it will look exactly the same and stay exactly the same feature rich. With such modular architecture overlay rendering and editing application is completely decoupled from hardware monitoring core so it is extremely easy to troubleshoot hardware monitoring related compatibility issues and switch to a different hardware monitoring data provider application. Such modular architecture is a pro, not a con
  • The plugin provides internal data sources, which are measured by RivaTuner Statistics Server itself (e.g. framerate, frametime, minimum/maximum/average/1%/0.1% low framerates for benchmark mode). Such data sources can be used in overlay layout as is, without running any additional hardware monitoring data provider application in background
  • The plugin provides internal HAL (Hardware Abstraction Layer) and minimalistic built-in hardware monitoring core based on it. The HAL provides basic CPU and RAM usage related data sources and architecture specific GPU related monitoring data sources (such as graphics engine usage, videomemory usage, graphics processor and videomemory clocks, temperatures, power consumption, fan speeds and so on) available on modern discrete AMD and NVIDIA GPUs and integrated Intel GPUs. Internal HAL do not rely on low-level access to hardware in any form, it uses only native GPU monitoring functionality embedded in OS and GPU display drivers: NVAPI for modern NVIDIA GPUs, AMD ADL for modern AMD GPUs and D3DKMT for Intel iGPUs and legacy GPUs. Such approach don not break our main principle of decoupling overlay from hardware monitoring application, so HAL data sources have close to zero chances to affect hardware compatibility and they can be safely used in conjunction with any external data provider application of your choice
  • The plugin provides internal ping monitoring data source, implementation is a direct clone of MSI Afterburner’s ping monitoring plugin. Ping monitoring is not natively available in HwINFO64 or AIDA64, so this internal data source is aimed to help those who plan to use this plugin without MSI Afterburner in combo with HwINFO64 or AIDA64
  • The plugin provides an ability to import data sources from Windows performance counters, implementation is a direct clone of MSI Afterburner’s PerfConter plugin. Windows performance counters provide you built-in monitoring of HDD usage and read/write speeds, network interface download and upload rates, a lot of detailed global and per-process CPU, memory and pagefile related metrics as well as hundreds of other performance counters visible to OS
  • The plugin provides MSI Afterburner styled correction formulas for all external data sources. Which means that you can transform data received from external hardware monitoring data provider applications in any form, for example convert memory usage from megabytes to gigabytes and many more
  • The plugin provides layer based overlay layout representation, which is typical for graphics editors. Such architecture suits best for creating more complex and artistic On-Screen Display layouts, but requires a bit more time and efforts
  • Each layer is independently formatted and positioned hypertext block, which can display both static and dynamic hypertext. In addition to standard customization of each layer’s hypertext formatting attributes (text and background color, font size, subscript or superscript text size, text alignment etc), you can also embed the following objects directly into hypertext of each layer:
    • Rich set of different macro definitions, displaying system time in different formats, programmable timers, your PC hardware specs and of course current values of internal plugin data sources (e.g. framerate or frametime) of external data sources exported from different hardware monitoring applications (e.g. GPU temperature exported from MSI Afterburner)
    • Traditional, diagram or barchart styled graphs attached to any data source, either internal or external one
    • Static images, displaying your hardware manufacturer logos and so in
    • Dynamic animated images, changing depending on data source connected to animation input. This way you can create absolutely uniquely looking graphics indicators in your overlay layouts, e.g. round progress indicators, gauges etc
    • You’re not limited to embed just a single object per layer. This means that for example you may create a layer containing all CPU load barchart graphs and make them share the same settings template, which makes it much easier to modify such overlay layouts
    • Complete freedom of choice, you can still customize On-Screen Display layout via built-in GUI of MSI Afterburner, HwINFO64 or AIDA64. Use new plugin only if you need it and wish to create something more complex than native MSI Afterburner or HwINFO64 On-Screen Display layout
    • Added asynchronous process specific performance counters access interface.  The interface is integrated into hooks library, which is running inside protected process context and may report hooked process specific RAM and VRAM usages to client applications
    • Added new open source DesktopOverlayHost tool to SDK. DesktopOverlayHost is a simple blank borderless 3D window with adjustable size, position, transparency and chroma keying support. You can use it as a platform for displaying any 3D API hook based overlay right on top of your Windows desktop. Implementation is overlay vendor agnostic, so you can use it with RivaTuner Statistics Server, as well as with other third party overlays like EVGA Precision X1 and so on
    • Added ShowForegroundStat profile switch, which is allowing any 3D application to display foreground 3D process framerate and frametime statistics instead of application’s own ones. This switch is used by new DesktopOverlayHost tool profile to let it to display foreground 3D process statistics on desktop
    • Added RenderDelay profile compatibility switch, allowing delaying On-Screen Display initialization and rendering for some applications when it is necessary (e.g. Resident Evil 3 in Direct3D11 mode when HDR mode is enabled)
    • FCAT overlay update rate is no longer limited to overlay content update rate in offscreen overlay rendering mode
    • Added new hypertext tags for displaying process specific 1% low and 0.1% low framerate graphs. Now multiple simultaneously running 3D applications can display their own independent 1% low and 0.1% low framerate graphs instead of foreground 3D application’s 1% low and 0.1% low framerate graphs in the previous version
    • Improved 1% low and 0.1% low framerate graphs rendering implementation for graph and diagram rendering modes. The graphs showing the history of 1% low and 0.1% low framerate changes has no statistical sense, so now RivaTuner Statistics Server is showing you more informative dynamic histogram of sorted and the most slowest immediate framerates with highlighted 1% or 0.1% areas on it. For barchart rendering mode 1% low and 0.1% framerate graphs still display the current value like before
    • Added new “moving bar” rendering mode for FCAT overlay. New mode is aimed to simplify visual identification of tearline position and it can be used when calibrating Scanline Sync settings
    • Added new “Frametime calculation point” option to “General” application properties. This option is aimed to help those who try to directly compare frame rendering start timestamp based frametimes with frame presentation timestamp based frametimes. Please refer to new option context help to get more detailed info
    • Added new “Percentile calculation mode” option to “General” application properties. This option is aimed to help those who try to compare different implementations of 1% low and 0.1% low framerate metrics in different applications. Please refer to new option context help to get more detailed info
    • Added new “Framerate limiting mode” option to “General” application properties. Two alternate framerate limiting modes selectable with this option (“front edge sync” and “back edge sync”) are intended to be used in conjunction with scanline sync mode. Using those options in tandem allows enabling so called hybrid scanline sync mode. In this case actual target scanline synchronization is performed just once for initial tearline positioning then tearline position can be steered with high precision system clock. This option can also help those who try to compare flatness of frametime graphs measured at different points (frame start vs frame presentation timestamp based)
    • Added 3 more decimal digits to fractional framerate limit adjustment control. Extended framerate limit adjustment precision can be necessary for new hybrid scanline sync mode, where the previous 0.001 FPS adjustment precision can be insufficient
    • Added fractional frametime limit adjustment support. Extended frametime limit adjustment precision can be necessary for new hybrid scanline sync mode, where the previous 1 microsecond adjustment precision can be insufficient
    • Now you may hold <Alt> and click framerate limit adjustment control to set framerate limit to your refresh rate
    • Now up/down spin buttons associated with framerate limit adjustment control tune the limit in minimum adjustment step instead of fixed 1 FPS step (e.g. in 0.1 FPS step if single decimal digit after comma is specified)
    • Added power user controllable passive wait stage to framerate limiter’s busy waiting loop. It is aimed to help those who is ready to sacrifice timing precision in favor of lower CPU load
    • Improved power user oriented scanline sync info panel. New performance counters are aimed to improve the process of scanline sync calibration and help you to diagnose tearline jittering. The following new performance counters have been added to it:
      • Sync start – index of scanline where 3D application called 3D API frame presentation function and scanline sync engine started the process of waiting for the target scanline
      • Sync end – index of scanline where scanline sync engine ended the process of waiting for target scanline. Ideally it must be as close to expected target scanline as it is possible
      • Present – index of scanline where 3D API frame presentation function was actually called after performing scanline synchronization. For normal scanline sync modes it is pretty close to the previous performance counter. For hybrid scanline sync mode it can drift depending on your framerate limit, if it doesn’t match with your display refresh rate
      • Present latency – time spent inside 3D API frame presentation call
      • Updated hardware encoding plugins:
        • All hardware encoding plugins are using new host localization API, so all plugins support multilanguage settings GUI
        • Updated Intel QuickSync H.264 encoder plugin. Now you may manually select target display device in the plugin’s settings. Please take a note that manual device selection can be required on Intel DCH drivers to address problems with wrong automatic Intel iGPU device selection, which could prevent the encoder from working properly
        • Added alternate and user configurable CPU yielding implementation to busy wait loops used in both framerate limiter and scanline sync implementations. Alternate CPU yielding implementation is used by default now, it can improve previously existing and close to ideal framepacing accuracy even further under heavy CPU load conditions due to minimizing context switching related timing penalties
        • Added alternate named pipe interface for streaming frametime statistics to third party applications in real time
        • Updated profiles list