Rendering text with SDL2, problems updating texture / output

Question

I have recently started using SDL2 in a C++ project, which is mainly used as a training project so I can learn using SDL2. One of the things I tried, was to write a simple label class. The Idea is that the label is created with given position and dimensions at start. Then when I call my 'setText()' function, the text would be rendered and shown on window. At first I used this approach:

// get a surface from given text    
m_surf = TTF_RenderText_Solid(m_font, txt.c_str(), fgCol);
// get a texture from the previous surface  
m_texture = SDL_CreateTextureFromSurface(r, m_surf);
// render it in 'r' which is the window renderer
SDL_RenderCopy(r, m_texture, NULL, &rect);

This works for me. So I thought to remove the overhead of creating textures every time text changes, then destroy them, and use SDL_UpdateTexture() . Well, this never worked! It always produces a corrupt output on screen, even though the call is successful:

// Once at ctor create a texture
m_texture = SDL_CreateTexture(r, SDL_PIXELFORMAT_RGBA32,SDL_TEXTUREACCESS_STATIC, rect.w, rect.h);
// ...
// later update when setText() is called get a surface from given text and update texture   
m_surf = TTF_RenderText_Solid(m_font, txt.c_str(), fgCol);
rc = SDL_UpdateTexture(m_texture,  NULL, m_surf->pixels, m_surf->pitch);

My first thought was that it's something wrong with the pixel formatting... so I also used a format convert before updating: m_surf = SDL_ConvertSurfaceFormat(ts, SDL_PIXELFORMAT_RGBA32, 0); where 'ts' is a temp surface where the text was rendered, and constant SDL_PIXELFORMAT_RGBA32 is same as the one I used to create the m_texture.

here is what I get on window when using 'SDL_UpdateTexture()'

Any Ideas ?

Thank you, Alex

Code Snip: I have written a compact piece of code that is related to reproduce problem

// label class declaration
class label
{
    friend class panel;
    public:
        label(SDL_Window* const w, TTF_Font* const fnt, SDL_Rect rect);
        ~label();

        int draw(SDL_Rect& rect);
        int draw(SDL_Rect& rect,const std::string& txt, SDL_Color fgCol, int quality);

    private:
    std::string     m_txt;
    TTF_Font* const m_font = nullptr;
    SDL_Surface     *m_surf = nullptr;
    SDL_Texture     *m_texture = nullptr;
    SDL_Rect        m_rect{0,0,0,0};
    SDL_Renderer    *m_ren;
    SDL_Window      *m_wnd;
    Uint32          m_pixForm;
};

// label class constructor
label::label(SDL_Window* const w, TTF_Font* const fnt, SDL_Rect rect):m_wnd(w),m_font(fnt),m_surf (nullptr), m_rect(rect)
{
// save window info locally for label object
    m_ren =SDL_GetRenderer(m_wnd);
    m_pixForm =SDL_GetWindowPixelFormat(m_wnd);
    m_texture = SDL_CreateTexture(m_ren, m_pixForm,SDL_TEXTUREACCESS_STATIC, rect.w, rect.h);
    m_surf = nullptr;
    std::cout << "PixelFormat " << m_pixForm << " : " << SDL_GetPixelFormatName(m_pixForm) <<  std::endl;
}

// label class methods to render/draw text on screen
int label::setText(const std::string& txt, SDL_Color fgCol, int quality=0)
{
    int w,h;
    SDL_Surface *ts;
    if(m_surf!=nullptr)SDL_FreeSurface(m_surf);
    switch(quality)
    {
        case 1:
        {
            ts = TTF_RenderText_Shaded(m_font, txt.c_str(), fgCol, SDL_Color{0,0,0,0});
            break;
        }
        case 2:
        {
            ts = TTF_RenderText_Blended(m_font,txt.c_str(), fgCol);
            break;
        }
        default:
        {
            ts = TTF_RenderText_Solid(m_font, txt.c_str(), fgCol);
            break;
        }
    }
    std::cout << "Before pixFormat ts " << SDL_GetPixelFormatName(ts->format->format)<< std::endl;
    m_surf =  SDL_ConvertSurfaceFormat(ts, m_pixForm, 0);
    std::cout << "After pixFormat surf : " <<  SDL_GetPixelFormatName(m_surf->format->format) << " ts " << SDL_GetPixelFormatName(ts->format->format)<< std::endl;
    SDL_FreeSurface(ts);
    TTF_SizeText(m_font, txt.c_str(), &w, &h);
    std::cout << "Set text '" << txt << "' w: " << w << " h: " << h << std::endl;
}

int label::draw(SDL_Rect& rect)
{
    // HERE is the one that draw the noise on screen!
    {
        int rc;
        rc = SDL_UpdateTexture(m_texture,  NULL, m_surf->pixels, m_surf->pitch);
        if(rc)
        {
            std::cout << "Error updating texture " << rc <<std::endl;
            return(rc);
        }
    }
    // if it is replaced with the following it works:
    /*
    {
        if(m_texture!=nullptr)SDL_DestroyTexture(m_texture);
        m_texture = SDL_CreateTextureFromSurface(r, m_surf);
    }
    */

    SDL_RenderCopy(m_ren, m_texture, NULL, &rect);
}

int label::draw(SDL_Rect& rect,const std::string& txt, SDL_Color fgCol, int q)
{
    setText(txt,fgCol,q);
    draw(rect);
}

// main functiom. Init SDL, create window, create label and draw it:
int main( int argc, char * argv[] )
{
    SDL_Window *wnd ;
    SDL_Renderer *wrend;
    int i;

    wnd = SDL_CreateWindow("TestWin",SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,500,300,0);
    wrend = SDL_CreateRenderer(wnd,-1,SDL_RENDERER_ACCELERATED);
    SDL_SetRenderDrawBlendMode(wrend,SDL_BLENDMODE_ADD);
    SDL_SetRenderDrawColor(wrend,0,0,0,255);
    SDL_RenderClear(wrend);

    SDL_Color fcol{255,255,0,128};
    SDL_Rect lblBox;
    lblBox.h = 120;
    lblBox.w = 280;
    lblBox.x = 1;
    lblBox.y = 1;

    label lbl(wnd, getCurrentFont(), lblBox); // create a label (getCurrentFont returns a valid TTF_Font pointer)
    lbl.draw(lblBox,std::string("Text Test"), fcol, 2);
    SDL_RenderPresent(wrend);
    SDL_ShowWindow(wnd);
    // .. more code here
}

Answer 1

I tested your code on MacOS Catalina and last version of SDL2 and SDL2_ttf and had segmentation fault .

After debugging I found that in label::setText() you use a quality parameter and if you pass quality=2 (to use the function TTF_RenderText_Blended() ), you will end up with a segmentation fault or garbage pixels.

But functions TTF_RenderText_Shaded() and TTF_RenderText_Solid() work well, I think this is directly linked to the fact that with TTF_RenderText_Blended( ) you have transparency in your surface.

Edit:
After digging a bit more I solved the segmentation fault I had previously by replacing the NULL value for the rect in line :

 rc = SDL_UpdateTexture(m_texture,  NULL, m_surf->pixels, m_surf->pitch);

by the size of m_surf:

SDL_Rect SurfRect;

SurfRect.x = 0;
SurfRect.y = 0;
SurfRect.w = m_surf->w;
SurfRect.h = m_surf->h;
...
rc = SDL_UpdateTexture(m_texture, SurfRect, m_surf->pixels, m_surf->pitch);

Edit 2 : I directly look into the source file of the SDL2 to understand what was the difference between my tests and the code done internally by the function SDL_CreateTexture() and you have to add these lines :

int rc = SDL_UpdateTexture(m_texture, &SurfRect, m_surf->pixels, m_surf->pitch);
{
    Uint8 r, g, b, a;
    SDL_BlendMode blendMode;
    SDL_GetSurfaceColorMod(m_surf, &r, &g, &b);
    SDL_SetTextureColorMod(m_texture, r, g, b);

    SDL_GetSurfaceAlphaMod(m_surf, &a);
    SDL_SetTextureAlphaMod(m_texture, a);

    if (SDL_HasColorKey(m_surf)) {
        /* We converted to a texture with alpha format */
        SDL_SetTextureBlendMode(m_texture, SDL_BLENDMODE_BLEND);
    } else {
        SDL_GetSurfaceBlendMode(m_surf, &blendMode);
        SDL_SetTextureBlendMode(m_texture, blendMode);
    }
}

Find here my raw debug file (this isn't pretty)