C++11 + SDL2 + Windows：多线程程序在任何输入事件后挂起

问题描述 投票：0回答：1

我正在使用 C++11、MinGW 和 Windows API 开发屏幕捕获程序。 我正在尝试使用 SDL2 实时观看我的屏幕捕获程序如何工作。

窗口打开得很好，只要我只移动鼠标光标，程序似乎运行良好。 但是，如果我单击窗口、其菜单栏、窗口外部，或按任意键，SDL 窗口就会冻结。

我已经为事件设置了一些日志记录，以了解发生了什么。 除了按顺序 

SDL_WINDOW_FOCUS_GAINED
、
SDL_TEXTEDITING
和 
SDL_WINDOWEVENT_SHOWN
之外，我从未收到过任何事件。 所有这些都是一开始就收到的。

我尝试查找有关 SDL 事件处理的教程，因为这是我对问题根源的最佳猜测。 我发现的只是用于监视 

SDL_QUIT
的基本事件处理、基本的鼠标和键盘事件，以及 
SDL_WINDOWEVENT
上的一个似乎没有帮助的内容。 我没有深入了解这些事件的含义以及处理这些事件的最佳实践。 这可能并不重要，因为这可能不是问题的根源。 据我所知，SDL 正在发脾气，因为还有其他线程正在运行。

任何人都可以看到我的代码中挂起的任何原因并提供如何修复它的解释吗？

对我的程序结构的快速解释是为了涵盖我省略的代码。 

Captor
类启动并运行一个线程来抓取屏幕截图并传递给 
Encoder
。 
Encoder
启动数量可变的线程，这些线程从 
Captor
接收屏幕截图，对屏幕截图进行编码，然后将编码传递给 
Screen
。 传递机制是 
SynchronousQueue<T>
类，它提供配对方法 
put(const T&)
和 
T get()
来允许生产者和消费者使用资源进行同步；这些方法超时是为了让系统能够响应终止消息。

现在是源文件（希望没有太多膨胀）。 虽然我很感激有关如何提高应用程序性能的任何评论，但我的重点是使程序具有响应能力。

main.cpp

#include "RTSC.hpp"

int main(int argc, char** argv) {
    RTSC rtsc {
        (uint32_t) stoi(argv[1]),
        (uint32_t) stoi(argv[2]),
        (uint32_t) stoi(argv[3]),
        (uint32_t) stoi(argv[4]),
        (uint32_t) stoi(argv[5]),
        (uint32_t) stoi(argv[6])
    };

    while (rtsc.isRunning()) {
        SwitchToThread();
    }

    return 0;
}

RTSC.hpp

#ifndef RTSC_HPP
#define RTSC_HPP

#include "Captor.hpp"
#include "Encoder.hpp"
#include "Screen.hpp"

#include <iostream>
using namespace std;


class RTSC {
    private:
        Captor *captor;
        Encoder *encoder;

        SynchronousQueue<uint8_t*> imageQueue {1};
        SynchronousQueue<RegionList> regionQueue {1};

        Screen *screen;

    public:
        RTSC(
            uint32_t width,
            uint32_t height,
            uint32_t maxRegionCount,
            uint32_t threadCount,
            uint32_t divisionsAlongThreadWidth,
            uint32_t divisionsAlongThreadHeight
        ) {
            captor = new Captor(width, height, imageQueue);
            encoder = new Encoder(
                width,
                height,
                maxRegionCount,
                threadCount,
                divisionsAlongThreadWidth,
                divisionsAlongThreadHeight,
                imageQueue,
                regionQueue
            );

            screen = new Screen(
                width,
                height,
                width >> 1,
                height >> 1,
                regionQueue
            );

            captor->start();
        }

        ~RTSC() {
            delete screen;
            delete encoder;
            delete captor;
        }

        bool isRunning() const {
            return screen->isRunning();
        }
};

#endif

屏幕.hpp

#ifndef SCREEN_HPP
#define SCREEN_HPP

#include <atomic>
#include <SDL.h>
#include <windows.h>

#include "Region.hpp"
#include "SynchronousQueue.hpp"

using namespace std;

class Screen {
    private:
        atomic_bool running {false};
        HANDLE thread;
        SynchronousQueue<RegionList>* inputQueue;
        uint32_t inputHeight;
        uint32_t inputWidth;
        uint32_t screenHeight;
        uint32_t screenWidth;

        SDL_Renderer* renderer;
        SDL_Surface* surface;
        SDL_Texture* texture;
        SDL_Window* window;

        void run() {
            SDL_Event event;
            while (running) {
                while (SDL_PollEvent(&event)) {
                    switch (event.type) {
                        case SDL_QUIT:
                            running = false;
                            break;

                        case SDL_WINDOWEVENT:
                            switch (event.window.event) {
                                case SDL_WINDOWEVENT_CLOSE:
                                    running = false;
                                    break;

                        default:
                            break;
                    }
                }

                try {
                    RegionList rl = inputQueue->get();

                    SDL_RenderClear(renderer);

                    SDL_LockSurface(surface);
                    SDL_FillRect(surface, nullptr, 0);

                    for (uint32_t i = 0; i < rl.count; ++i) {
                        Region &r = rl.regions[i];

                        SDL_Rect rect {
                            (int) r.getX(),
                            (int) r.getY(),
                            (int) r.getWidth(),
                            (int) r.getHeight()
                        };
                        uint32_t color =
                            (r.getRed() << 16) +
                            (r.getGreen() << 8) +
                            r.getBlue();
                        SDL_FillRect(surface, &rect, color);
                    }

                    SDL_UnlockSurface(surface);
                    SDL_UpdateTexture(
                        texture,
                        nullptr,
                        surface->pixels,
                        surface->pitch
                    );
                    SDL_RenderCopyEx(
                        renderer,
                        texture,
                        nullptr,
                        nullptr,
                        0,
                        nullptr,
                        SDL_FLIP_VERTICAL
                    );
                } catch (exception &e) {}

                SDL_RenderPresent(renderer);
                SwitchToThread();
            }
        }

        static DWORD startThread(LPVOID self) {
            ((Screen*) self)->run();
            return (DWORD) 0;
        }

    public:
        Screen(
            uint32_t inputWidth,
            uint32_t inputHeight,
            uint32_t windowWidth,
            uint32_t windowHeight,
            SynchronousQueue<RegionList> &inputQueue
        ): inputQueue {&inputQueue}, inputHeight {inputHeight} {
            SDL_Init(SDL_INIT_VIDEO);

            window = SDL_CreateWindow(
                "RTSC",
                SDL_WINDOWPOS_CENTERED,
                SDL_WINDOWPOS_CENTERED,
                windowWidth,
                windowHeight,
                SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE |
                    SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS
            );

            renderer = SDL_CreateRenderer(window, -1, 0);

            surface = SDL_CreateRGBSurface(
                0,
                inputWidth,
                inputHeight,
                24,
                0xFF << 16,
                0xFF << 8,
                0xFF,
                0
            );

            texture = SDL_CreateTexture(
                renderer,
                surface->format->format,
                SDL_TEXTUREACCESS_STREAMING,
                inputWidth,
                inputHeight
            );

            running = true;
            thread = CreateThread(nullptr, 0, startThread, this, 0, nullptr);
        }

        ~Screen() {
            running = false;
            WaitForSingleObject(thread, INFINITE);
            CloseHandle(thread);

            SDL_FreeSurface(surface);
            SDL_DestroyRenderer(renderer);
            SDL_DestroyWindow(window);
            SDL_Quit();
        }

        bool isRunning() const {
            return running;
        }
};

#endif
c++ windows multithreading c++11 sdl-2
1个回答
6
投票

我没有在多线程环境中使用 SDL API 的经验，但这并不是一个大问题，您稍后会看到。我检查了您的代码，我认为您至少应该更改一件事。

  1. 通常，对于 GUI 系统（部分 SDL 也是 GUI 系统），您应该始终仅从主线程访问 gui，并期望 gui 事件来自主线程。大多数 GUI API 都是单线程的，如果这也适用于 SDL，我不会感到惊讶。请注意，许多 GUI 系统默认运行在进程的主线程上，并且您无法选择自己的线程。不要在工作线程上运行 Screen 类的代码，而是在主线程上运行它并从主线程进行每个 SDL API 调用。
  2. 如果您正在编写游戏或类似软件，那么（首先）将其编写为单线程。引擎的子系统（物理模拟、这个系统、游戏逻辑、渲染）应该在主线程（从主循环）上依次执行。如果您想利用在“另一个维度”中执行此操作的多线程：将某些子系统或较小的工作单元（如合并排序）转换为多线程，例如，物理系统任务通常可以分为几个小任务所以当主线程更新物理系统时，物理系统就会烧掉你所有的核心......

在主线程上完成大部分任务还有另一个优点：它使您的代码更容易移植到任何平台。或者，如果您编写代码以便它可以在单线程模式下执行，那么在许多情况下它可以使调试更容易，然后您还有一个“参考构建”来比较多线程构建与性能。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.