Foobar2000:Components/Coverflow (foo coverflow)

Coverflow
Coverflow Example (Spiral)
Developer(s)	da yuyu
Repository	github
Release information
Initial release
Stable release	1.18.3 (August 25, 2024)
Preview release
foobar2000 compatibility
Architecture	{{{foobar2000_architecture}}}
Minimum version	2
Maximum version
UI module(s)	Default UI, Columns UI
Additional information
Use	UI
License	GPL v2
Discussion thread	{{{discussion_thread}}}
View all components

Description

This is a coverflow plugin for foobar2000. This plugin provides a UI panel that displays a 3d rendering of the albums in your media library. It is further development of Chronial's Coverflow

Requirements

Tablacus Script control is required for 64-bit functionality. Please install it first.

Preferences

Cover Display tab

JScript reference

Note on compatibility with Chronial's Coverflow cover display scripts

Add this code block at the end of Chronial's Coverflow scripts:

function enableCoverTitle() { return true; }

function enableCoverPngAlpha() { return true; }

function enableCarousel(){ return true }

Performance tab

Chronflow Preferences page showing the "Performance" tab.

To understand the effect of the settings in the performance tab it is important to know the basic architecture of the plugin: The plugin has two threads - one thread to render the image and one thread to cache the cover textures.
The image will only be rendered when it is needed - eg. when you restore the foobar window, new textures have been loaded or an animation is shown. While foobar is minimized or completely hidden behind any windows the renderer will do nothing at all and so also cause no load for your cpu.
The texture loading thread loads the covers from you hard-disk into memory so the renderer can display them. This is done in an asynchronous manner (you can see this by scrolling very fast - the covers move faster than the loader can load them -> you see the "hourglass cover"). Once the texture cache is filled, the loader sleeps until you move the covers again. See #Texture Cache for further details.

Rendering Quality

These Settings influence the quality of the generated image.

Note: Changes to the multisampling settings will only take effect after the panel is restarted (either hide and show it or restart foobar2000).

Texture Cache

Each time you move the display to a new cover, the texture loader makes sure that at least cache size*0.9 covers around the selected cover are loaded.
The covers are loaded into GPU memory, so this also the limiting element for your cache. Remember that there are multiple other applications that use your GPU and all share its memory. So setting the texture cache too large will influence video playback, other multimedia applications as well as games.
The texture loading process works this way: the background loader loads the image into memory and resizes it to the maximum texture size, then the image is moved into GPU memory and compressed. This is called uploading. During the uploading the renderer has to pause, and as the uploading can take rather long (we only have 13ms to render a frame at 60fps) it is only done when there is no animation displayed or when a preloaded image comes into view.

Cache Size

The number of covers that will be cached. This should always be larger than the number of covers displayed at once, because otherwise there will be uploading at nearly every frame what might slow down you rendering severely. But setting this to high might be too much for your GPU memory, thus slowing down you whole system.

Maximum Texture Size

The maximum sidelength for the textures. All covers will be shrinked to fit in a square with this sidelength. Decreasing this setting will lower the needed GPU memory as well as the upload time. Note that, depending on your GPU this might be rounded down to the next power of two. You have to reload the texture cache for this to take effect (do this by pressing ctrl+F5 in the panel).

You should try to set this to the size the covers actually have inside the panel. This can heavily increase texture quality, since the shrinking done during loading produces way better quality than shrinking done during rendering

Enable Texture Compression

This will quite heavily reduce the amount of GPU memory used by the covers (on my system it went down to 1/6), but will also increase the texture uploading time.

Texture Loading Thread Priority

You can decrease the priority of the texture loading. You can try to change this when you experience slow rendering, but the default should be alright in most cases.

Empty cache when window is minimized

This will cause the texture cache to be cleared when you minimize the foobar window. This makes it available for games or video display, but when you restore the foobar window, the covers will have to be loaded again.

VSync

You can choose between 3 different Settings for VSync:

No Vsync + try to hit VBlank with Sleep()

This is actually no VSync, but the framerate is limited by the renderer sleeping some time between each frame. This has the lowest CPU usage of the 3 options, but you do not get the benefits of VSync -> you might experience tearing. You should try this setting and if you do not see any annoying tearing you should stick with it, since it delivers best performance.

Vsync + try to hit VBlank with Sleep()

This enables VSync, but since some GPUs (mine for example) cause 100% CPU usage while waiting for VBlank (the moment at which you monitor has finished displaying the old picture), the renderer tries to sleep some time here to reduce CPU usage. This can cause a severe CPU usage reduction against pure VSync - at my system it dropped from 100% to 20%. But if another process takes too much time the renderer might miss VBlank, causing quite a drop in framerate.

Vsync only

Just activates VSync. If VSync is well implemented by your GPU (it is not by NVidia GPUs), this will give you high framerate, good CPU usage and no tearing. If it is not well implemented you will get high framerate and no tearing but 100% cpu usage during animation.

Note that the Sleep() modes need to know your display's refresh rate. If you have a multi-monitor system with different refresh rates among the monitors and foobar not running on the primary display, the plugin might not be able to guess the right refresh rate.

Benchmarking

Display speed information (fps, ms per frame)

This displays information about the rendering speed in the panel. The panel has to be large enough for it to be visible, otherwise it won't be drawn. The information displayed is to be interpreted in the following way:

• fps: displays the average FPS (averaged over 30 frames)
• min: displays the fps for the one frame of the last 30 frames that took the longest to display
• cpu-ms/f: this number shows the amount of time the plugin spend to generate the information for the frame and pass it to the GPU. upload duration is also added to this number. It's rather difficult to interpret this number, but if it is way lower than (1000ms/refresh rate) and your fps are lower than your fps, there is quite probably something wrong with the VSync Sleep()
• max: same as for frames, but for the cpu-ms/f

External links

• Discussion topic on hydrogenaudio
• Download
• Repository