SDL2：快速像素操作

Posted 2023-04-14

【中文标题】SDL2：快速像素操作

【英文标题】：SDL2: Fast Pixel Manipulation

【发布时间】：2016-01-23 02:36:38

【问题描述】：

我想在显示器上绘制在某些参数后经常变化的像素。例如。如果红色和绿色像素碰撞，它们都会消失，等等。

在每一帧中，我必须处理大约 100 - 1000 个像素。我在这里有一个多线程方法，它不会给我 30FPS（我想要的）。目前我在 RAM 中存储了一个像素数组，其中包含所有像素并有一个SDL_Surface。当数组中的一个像素发生变化时，它也会在 Surface 中发生变化，然后在所有操作完成后被 blitted 到屏幕上。我目前的方法太慢了，我考虑了如何提高速度。

我目前的想法是：

使用 OpenGL 直接在 GPU 上进行像素操作，一些论坛告诉我这比我目前的方法慢得多，因为“这不是 GPU 的工作方式” 不要存储像素阵列，直接在 RAM 中存储 BMP，对其进行操作，然后将其移动到 SDL_Surface 或 SDL_Texture

还有其他方法可以快速操作像素吗？

【问题讨论】：

我认为像素操作本身并不是低 FPS 的原因。如果您随机更改屏幕上的每个像素（不仅仅是其中的 1K），您应该可以达到 30FPS 以上。 Here 表示您应该使用 SDL_Texture 来提高性能。你试过吗？你是否已经分析了你的代码？

我有一个SDL_Texture 和TEXTURE_STREAMING，然后锁定纹理，对获得的像素阵列进行操作，完成后解锁。

只有分析才能知道瓶颈在哪里

但在我再次实施我的方法之前，我想知道是否有人知道魔法;)。但后来我只是对它进行基准测试。谢谢！

使用 SDL_RenderDrawPoint?

【参考方案1】：

SDL_CreateTexture() w/SDL_TEXTUREACCESS_STREAMING + SDL_UpdateTexture() 似乎在正确的像素格式下工作得很好。

在我的系统上使用默认渲染器：

Renderer name: direct3d
Texture formats:
SDL_PIXELFORMAT_ARGB8888
SDL_PIXELFORMAT_YV12
SDL_PIXELFORMAT_IYUV

（虽然opengl 的信息是一样的：）

Renderer name: opengl
Texture formats:
SDL_PIXELFORMAT_ARGB8888
SDL_PIXELFORMAT_YV12
SDL_PIXELFORMAT_IYUV

SDL_PIXELFORMAT_ARGB8888 给我 ~1ms/frame:

// g++ main.cpp `pkg-config --cflags --libs sdl2`
#include <SDL.h>
#include <iostream>
#include <iomanip>
#include <vector>
#include <cstring>

int main( int argc, char** argv )

    SDL_Init( SDL_INIT_EVERYTHING );

    SDL_Window* window = SDL_CreateWindow
        (
        "SDL2",
        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
        600, 600,
        SDL_WINDOW_SHOWN
        );

    SDL_Renderer* renderer = SDL_CreateRenderer
        (
        window,
        -1,
        SDL_RENDERER_ACCELERATED
        );

    SDL_RendererInfo info;
    SDL_GetRendererInfo( renderer, &info );
    std::cout << "Renderer name: " << info.name << std::endl;
    std::cout << "Texture formats: " << std::endl;
    for( Uint32 i = 0; i < info.num_texture_formats; i++ )
    
        std::cout << SDL_GetPixelFormatName( info.texture_formats[i] ) << std::endl;
    

    const unsigned int texWidth = 1024;
    const unsigned int texHeight = 1024;
    SDL_Texture* texture = SDL_CreateTexture
        (
        renderer,
        SDL_PIXELFORMAT_ARGB8888,
        SDL_TEXTUREACCESS_STREAMING,
        texWidth, texHeight
        );

    std::vector< unsigned char > pixels( texWidth * texHeight * 4, 0 );

    SDL_Event event;
    bool running = true;
    bool useLocktexture = false;
    
    unsigned int frames = 0;
    Uint64 start = SDL_GetPerformanceCounter();

    while( running )
    

        SDL_SetRenderDrawColor( renderer, 0, 0, 0, SDL_ALPHA_OPAQUE );
        SDL_RenderClear( renderer );

        while( SDL_PollEvent( &event ) )
        
            if( ( SDL_QUIT == event.type ) ||
                ( SDL_KEYDOWN == event.type && SDL_SCANCODE_ESCAPE == event.key.keysym.scancode ) )
            
                running = false;
                break;
            
            if( SDL_KEYDOWN == event.type && SDL_SCANCODE_L == event.key.keysym.scancode )
            
                useLocktexture = !useLocktexture;
                std::cout << "Using " << ( useLocktexture ? "SDL_LockTexture() + memcpy()" : "SDL_UpdateTexture()" ) << std::endl;
            
        
        
        // splat down some random pixels
        for( unsigned int i = 0; i < 1000; i++ )
        
            const unsigned int x = rand() % texWidth;
            const unsigned int y = rand() % texHeight;

            const unsigned int offset = ( texWidth * 4 * y ) + x * 4;
            pixels[ offset + 0 ] = rand() % 256;        // b
            pixels[ offset + 1 ] = rand() % 256;        // g
            pixels[ offset + 2 ] = rand() % 256;        // r
            pixels[ offset + 3 ] = SDL_ALPHA_OPAQUE;    // a
        

        if( useLocktexture )
        
            unsigned char* lockedPixels = nullptr;
            int pitch = 0;
            SDL_LockTexture
                (
                texture,
                NULL,
                reinterpret_cast< void** >( &lockedPixels ),
                &pitch
                );
            std::memcpy( lockedPixels, pixels.data(), pixels.size() );
            SDL_UnlockTexture( texture );
        
        else
        
            SDL_UpdateTexture
                (
                texture,
                NULL,
                pixels.data(),
                texWidth * 4
                );
        

        SDL_RenderCopy( renderer, texture, NULL, NULL );
        SDL_RenderPresent( renderer );
        
        frames++;
        const Uint64 end = SDL_GetPerformanceCounter();
        const static Uint64 freq = SDL_GetPerformanceFrequency();
        const double seconds = ( end - start ) / static_cast< double >( freq );
        if( seconds > 2.0 )
        
            std::cout
                << frames << " frames in "
                << std::setprecision(1) << std::fixed << seconds << " seconds = "
                << std::setprecision(1) << std::fixed << frames / seconds << " FPS ("
                << std::setprecision(3) << std::fixed << ( seconds * 1000.0 ) / frames << " ms/frame)"
                << std::endl;
            start = end;
            frames = 0;
        
    

    SDL_DestroyRenderer( renderer );
    SDL_DestroyWindow( window );
    SDL_Quit();

    return 0;

确保您没有启用 vsync（在驱动程序中强制执行、运行合成器等），否则 所有您的帧时间将约为 16 毫秒（或任何您的显示刷新设置为）。

【讨论】：

请问你用的是什么系统？在带有英特尔 HD 2000 的 i5 上，我在带有 GTX 560 的 i7 2600k 上每帧大约 10 毫秒，我得到 3 毫秒。两者都运行gentoo linux。谢谢！

@Nidhoegger：i7 2600 @ 3.4GHz，Win7 和 AMD FirePro V4800。

@Nidhoegger：SDL_GetRendererInfo() 转储在您的系统上显示什么？

和你的一样（openGL）。我在 Linux 上，但纹理格式相同（ARGB8888、YV12、IYUV）。如果帧时间来自我的多显示器设置，我正在探索 atm。也许 nVidia 驱动程序没有我想象的那么好（专有的，不是新的）

您的方法是否比简单地填充“SDL_Point”数组然后使用 SDL_RenderDrawPoints 从中绘制更快？