My application exits when trying to load as wallpaper

[Pancakeman49]

I've made a C++ application that creates a rolling waveform visualizer. By its self it works fine and importing into lively also works for the preview but the second lively tries to make it the wallpaper, it exits with either 1 or -1 and somehow leaves the application running in the background. (I assume its the audio capture thread somehow even tho I've set it to get killed when the main window gets destroyed)
I really would like to know what are the requirements for Lively to run an exe as the wallpaper.

When importing the application, preview works:

But when its loaded it exits and somehow still is in task manager.

And since for some reason i cant attach the .cpp file here is the full code:

// wasapi_loopback_visualizer_cleaned.cpp
#define UNICODE
#define _UNICODE

#include <windows.h>
#include <mmdeviceapi.h>
#include <audioclient.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <thread>
#include <mutex>
#include <atomic>
#include <gdiplus.h>

#pragma comment(lib, "Ole32.lib")
#pragma comment(lib, "Gdiplus.lib")

const int WINDOW_WIDTH  = 1280;
const int WINDOW_HEIGHT = 720;
const int BUFFER_SIZE   = 4096;

// --- Global State ---
HWND g_hwnd = nullptr;
HBITMAP g_hBitmap = nullptr;
HDC g_hMemDC = nullptr;
Gdiplus::Graphics* g_pGraphics = nullptr;
Gdiplus::Pen* g_pPen = nullptr;

std::vector<float> g_waveformBuffer(BUFFER_SIZE, 0.0f);
size_t g_bufferOffset = 0;
std::mutex g_bufferMutex;
std::atomic<bool> g_running(true);
ULONG_PTR g_gdiplusToken = 0;

bool g_inSizeMove = false;
void DrawWaveform();

// --- Window Procedure ---
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
        case WM_DESTROY:
            g_running = false;
            PostQuitMessage(0);
            return 0;

        case WM_PAINT: {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            if (g_hBitmap && g_hMemDC) {
                RECT rc;
                GetClientRect(hwnd, &rc);
                BitBlt(hdc, 0, 0, rc.right - rc.left, rc.bottom - rc.top, g_hMemDC, 0, 0, SRCCOPY);
            }
            EndPaint(hwnd, &ps);
            return 0;
        }

        case WM_SIZE: {
            int width = LOWORD(lParam);
            int height = HIWORD(lParam);
            if (g_hBitmap) DeleteObject(g_hBitmap);
            if (g_hMemDC) DeleteDC(g_hMemDC);

            HDC hdc = GetDC(hwnd);
            g_hBitmap = CreateCompatibleBitmap(hdc, width, height);
            g_hMemDC = CreateCompatibleDC(hdc);
            SelectObject(g_hMemDC, g_hBitmap);
            ReleaseDC(hwnd, hdc);

            delete g_pGraphics;
            g_pGraphics = new Gdiplus::Graphics(g_hMemDC);
            return 0;
        }
        
        case WM_NCHITTEST: {
            LRESULT hit = DefWindowProc(hwnd, msg, wParam, lParam); //for dragable window
            return (hit == HTCLIENT) ? HTCAPTION : hit;
        }
        

        case WM_ENTERSIZEMOVE:
            g_inSizeMove = true;
            SetTimer(hwnd, 1, 6, nullptr); // ~165 FPS
            return 0;

        case WM_EXITSIZEMOVE:
            g_inSizeMove = false;
            KillTimer(hwnd, 1);
            InvalidateRect(hwnd, nullptr, FALSE);
            return 0;

        case WM_TIMER:
            if (g_inSizeMove) {
                DrawWaveform(); // render manually while resizing/moving
                UpdateWindow(hwnd);
            }
            return 0;

        default:
            return DefWindowProc(hwnd, msg, wParam, lParam);
    }
}

// --- Initialize Window ---
bool InitializeWindow(HINSTANCE hInstance) {
    WNDCLASS wc = {0};
    wc.lpfnWndProc   = WndProc;
    wc.hInstance     = hInstance;
    wc.lpszClassName = L"AudioVisualizerClass";
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);

    if (!RegisterClass(&wc)) return false;

    g_hwnd = CreateWindowEx(
        WS_EX_APPWINDOW,
        L"AudioVisualizerClass",
        L"Desktop Audio Visualizer",
        WS_OVERLAPPEDWINDOW,
        100, 100,
        WINDOW_WIDTH, WINDOW_HEIGHT,
        nullptr, nullptr, hInstance, nullptr
    );
    if (!g_hwnd) return false;

    ShowWindow(g_hwnd, SW_SHOW);
    UpdateWindow(g_hwnd);

    HDC hdc = GetDC(g_hwnd);
    g_hBitmap = CreateCompatibleBitmap(hdc, WINDOW_WIDTH, WINDOW_HEIGHT);
    g_hMemDC  = CreateCompatibleDC(hdc);
    SelectObject(g_hMemDC, g_hBitmap);
    ReleaseDC(g_hwnd, hdc);

    Gdiplus::GdiplusStartupInput gdiplusStartupInput;
    Gdiplus::GdiplusStartup(&g_gdiplusToken, &gdiplusStartupInput, nullptr);

    g_pGraphics = new Gdiplus::Graphics(g_hMemDC);
    g_pPen = new Gdiplus::Pen(Gdiplus::Color(255, 0, 255), 1.0f);

    return true;
}

// --- Draw waveform ---
void DrawWaveform() {
    if (!g_pGraphics || !g_pPen) return;

    RECT rc;
    GetClientRect(g_hwnd, &rc);
    int width = rc.right - rc.left;
    int height = rc.bottom - rc.top;

    g_pGraphics->Clear(Gdiplus::Color(0, 0, 0));

    std::vector<Gdiplus::PointF> points;
    points.reserve(BUFFER_SIZE);

    std::lock_guard<std::mutex> lock(g_bufferMutex);
    for (size_t i = 0; i < BUFFER_SIZE; ++i) {
        size_t idx = (g_bufferOffset + i) % BUFFER_SIZE;
        float value = std::clamp(g_waveformBuffer[idx], -1.0f, 1.0f);
        float x = static_cast<float>(i) / BUFFER_SIZE * width;
        float y = (1.0f - (value + 1.0f) / 2.0f) * height;
        points.emplace_back(x, y);
    }

    if (!points.empty())
        g_pGraphics->DrawLines(g_pPen, points.data(), static_cast<INT>(points.size()));

    InvalidateRect(g_hwnd, nullptr, FALSE);
}

// --- Update visualization buffer ---
void UpdateVisualization(float* audioData, UINT32 numFrames, int nChannels) {
    std::lock_guard<std::mutex> lock(g_bufferMutex);
    for (UINT32 i = 0; i < numFrames; ++i) {
        float sample = 0.0f;
        for (int c = 0; c < nChannels; ++c)
            sample += audioData[i * nChannels + c];
        sample /= nChannels;
        g_waveformBuffer[g_bufferOffset] = std::clamp(sample, -1.0f, 1.0f);
        g_bufferOffset = (g_bufferOffset + 1) % BUFFER_SIZE;
    }
}

// --- Audio capture thread ---
void AudioCaptureThread() {
    HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
    if (FAILED(hr)) return;

    IMMDeviceEnumerator* pEnumerator = nullptr;
    IMMDevice* pDevice = nullptr;
    IAudioClient* pAudioClient = nullptr;
    IAudioCaptureClient* pCaptureClient = nullptr;
    WAVEFORMATEX* pwfx = nullptr;
    HANDLE hEvent = nullptr;
    std::vector<float> tempBuffer(BUFFER_SIZE, 0.0f);

    hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), nullptr, CLSCTX_ALL,
                          __uuidof(IMMDeviceEnumerator), (void**)&pEnumerator);
    if (FAILED(hr)) goto cleanup;

    hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pDevice);
    if (FAILED(hr)) goto cleanup;

    hr = pDevice->Activate(__uuidof(IAudioClient), CLSCTX_ALL, nullptr, (void**)&pAudioClient);
    if (FAILED(hr)) goto cleanup;

    hr = pAudioClient->GetMixFormat(&pwfx);
    if (FAILED(hr)) goto cleanup;

    hEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
    if (!hEvent) goto cleanup;

    hr = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED,
                                  AUDCLNT_STREAMFLAGS_LOOPBACK | AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
                                  0, 0, pwfx, nullptr);
    if (FAILED(hr)) goto cleanup;

    pAudioClient->SetEventHandle(hEvent);
    hr = pAudioClient->GetService(__uuidof(IAudioCaptureClient), (void**)&pCaptureClient);
    if (FAILED(hr)) goto cleanup;



    hr = pAudioClient->Start();
    if (FAILED(hr)) goto cleanup;

   

    while (g_running) {
        DWORD waitResult = WaitForSingleObject(hEvent, 100);
        if (waitResult == WAIT_FAILED || !g_running) break;

        UINT32 packetFrames = 0;
        hr = pCaptureClient->GetNextPacketSize(&packetFrames);
        if (FAILED(hr)) break;

        while (packetFrames > 0 && g_running) {
            BYTE* pData = nullptr;
            UINT32 numFrames = 0;
            DWORD flags = 0;

            hr = pCaptureClient->GetBuffer(&pData, &numFrames, &flags, nullptr, nullptr);
            if (FAILED(hr)) break;

            if (flags & AUDCLNT_BUFFERFLAGS_SILENT)
                std::fill(tempBuffer.begin(), tempBuffer.begin() + numFrames * pwfx->nChannels, 0.0f);
            else {
                float* floatData = (pwfx->wFormatTag == WAVE_FORMAT_PCM)
                    ? nullptr
                    : reinterpret_cast<float*>(pData);
                if (pwfx->wFormatTag == WAVE_FORMAT_PCM && pwfx->wBitsPerSample == 16) {
                    short* shortData = reinterpret_cast<short*>(pData);
                    for (UINT32 i = 0; i < numFrames * pwfx->nChannels; ++i)
                        tempBuffer[i] = shortData[i] / 32768.0f;
                } else {
                    for (UINT32 i = 0; i < numFrames * pwfx->nChannels; ++i)
                        tempBuffer[i] = floatData[i];
                }
            }

            UpdateVisualization(tempBuffer.data(), numFrames, pwfx->nChannels);
            pCaptureClient->ReleaseBuffer(numFrames);
            hr = pCaptureClient->GetNextPacketSize(&packetFrames);
            if (FAILED(hr)) break;
        }
    }

cleanup:
    if (pAudioClient) pAudioClient->Stop();
    if (pCaptureClient) pCaptureClient->Release();
    if (pwfx) CoTaskMemFree(pwfx);
    if (pAudioClient) pAudioClient->Release();
    if (pDevice) pDevice->Release();
    if (pEnumerator) pEnumerator->Release();
    if (hEvent) CloseHandle(hEvent);
    CoUninitialize();
}

// --- Entry Point ---
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int) {
    if (!InitializeWindow(hInstance)) return -1;

    std::thread audioThread(AudioCaptureThread);

    MSG msg;
    while (g_running) {
        while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) g_running = false;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        DrawWaveform();
        std::this_thread::sleep_for(std::chrono::milliseconds(6));
    }

    if (audioThread.joinable()) audioThread.join();

    delete g_pPen;
    delete g_pGraphics;
    if (g_hMemDC) DeleteDC(g_hMemDC);
    if (g_hBitmap) DeleteObject(g_hBitmap);
    if (g_gdiplusToken) Gdiplus::GdiplusShutdown(g_gdiplusToken);

    return 0;
}

[rocksdanister]

Can you try creating the Window with WS_EX_LAYERED style ?

[Pancakeman49]

Tried it, didn't work still, application exits with either -1 or 1. I tried with WS_EX_LAYERED and also WS_POPUP and WS_TILED.
Also discovered something, the application instantly exits with -1 but also still exists in task manager, when ended in task manager the application exits with 1. Im assuming the UI thread exits with -1 and the audio thread exits with 1?

[rocksdanister]

Yeah taskmgr probably thread related.

This was the recent change with Windows 11:

lively/src/Lively/Lively/Core/WinDesktopCore.cs

Lines 130 to 147 in d27589c

	Microsoft:
	As Windows evolves to help deliver the best customer experiences, we have changed how the
	Background renders in Windows to enable new scenarios such as HDR Backgrounds as announced
	in Windows Insider.
	When the desktop is split out from the list view window (aka the "raised desktop") we no
	longer create multiple top-level HWNDs to support this scenario. Instead, the top-level
	"Progman" window is now created with WS_EX_NOREDIRECTIONBITMAP (so there is no GDI content
	for that window at all) and the shell DefView child window is a WS_EX_LAYERED child window.
	When the desktop is raised, we create a child WorkerW window that is z-ordered under the
	DefView that will render the wallpaper. The DefView window will draw mostly transparent with
	just the icons and text.
	If your application forces the "raised desktop" state, it will now need to create its own
	WS_EX_LAYERED child HWND that is z-ordered under the DefView window but above the WorkerW
	window. This window should likely be a SetLayeredWindowAttributes(bAlpha=0xFF) window so
	that you can do DX blt presents to it and not suffer performance issues.
	*/

but this is causing issues related to input and hangs for some users, so I am going to try something different.