We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

I haven't seen this before.  Any chance you can get a stack trace to find out where it's crashing?

For that code I can't get a stack trace to come up, but for the OO code which displays the same error, I get the following under codelite:

0  0x4fdf6040  ??
1  0x7e418734  USER32!GetDC
2  0x000103f8  ??
3  0x7e418816  USER32!GetDC
4  0x4fdf6040  ??
5  0x000103f8  ??
6  0x7e428ea0  USER32!DefWindowProcW
7  0x00000000  ??


However running it a second time gives me:
0  0x4fdf6040  ??    
1  0x7e418734  USER32!GetDC    
2  0x0006014e  ??    
3  0x0000007e  ??    
4  0x00000020  ??    
5  0x04000500  ??    
6  0x4fdf6040  ??    
7  0xdcbaabcd  ??    
8  0x00000000  ??    

Seems a bit random.


With the non-OO code above, sometimes I get a crash, sometimes I get a complete but a return code of -1073741819, depending on whether I clean and build etc.


The OO code if you need it - just a library/wrapper I'm working on:

//Using SDL and standard IO
#include "SDL.h"
#include "SDL_image.h"
#include <iostream>
#include <fstream>
#include <ctime>


class platforma_log
{
private:
	std::ofstream logfile;
    time_t logtime;
	struct tm *logtimestruct;
public:
	platforma_log();
	platforma_log(const char *logfile_name, bool append);
	~platforma_log();
	void write_time();
	bool is_initialised();

    template <typename logtemplate>
    friend platforma_log& operator << (platforma_log& log, const logtemplate& value);
	friend platforma_log& operator << (platforma_log& log, std::ostream& (*pf) (std::ostream&));
};


platforma_log::platforma_log()
{
	logfile.open("platforma_log.txt");

	if (!logfile.is_open())
	{
		std::cerr << "Platforma_log Constructor: Problem! Logfile 'platforma_log.txt' could not be created. Check path/locking." << std::endl;
	}
}


platforma_log::platforma_log(const char *logfile_name, bool append)
{
	if (append)
	{
		logfile.open(logfile_name, std::ofstream::out | std::ofstream::app);
	}
	else
	{
		logfile.open(logfile_name);
	}

	if (!logfile.is_open())
	{
		std::cerr << "Platforma_log Constructor: Problem! Logfile '" << logfile_name << "' could not be opened. Check filename/path/locking." << std::endl;
	}
}


platforma_log::~platforma_log()
{
	logfile.close();
}


void platforma_log::write_time()
{
	logtime = time(0);
	logtimestruct = localtime(& logtime);

	if (logfile.is_open())
	{
		logfile << (logtimestruct->tm_year + 1900) << '-' << (logtimestruct->tm_mon + 1) << '-' <<  logtimestruct->tm_mday << ", " << logtimestruct->tm_hour << ":" << logtimestruct->tm_min << " : " << std::endl;
	}
}


template <typename logtemplate>

platforma_log& operator << (platforma_log& log, logtemplate const & value)
{
	if (log.logfile.is_open())
	{
		log.logfile << value;
		log.logfile.flush();
	}
    return log;
}

platforma_log& operator << (platforma_log& log, std::ostream& (*pf) (std::ostream&))
{
	if (log.logfile.is_open())
	{
		log.logfile << pf;
		log.logfile.flush();
	}
	return log;
}

bool platforma_log::is_initialised()
{
	if (logfile.is_open())
	{
		return true;
	}
	else
	{
		return false;
	}
}



class platforma_window
{
	private:
		SDL_Window* p_window;
		SDL_Surface* p_window_surface;
	public:
		platforma_window(const char *window_title, unsigned int window_width, unsigned int window_height, bool fullscreen, platforma_log *log);
		~platforma_window();
		
		SDL_Window* get();
		SDL_Surface* get_surface();
		bool is_initialised();
};



platforma_window::platforma_window(const char *window_title, unsigned int window_width, unsigned int window_height, bool fullscreen, platforma_log *log)
{
	p_window = NULL;
	p_window_surface = NULL;
	
	if (log == NULL)
	{
		std::cerr << "Platforma_window constructor: Error: log is NULL. Quitting." << std::endl;
		return;
	}
	
	// Create a window, fallback to non-opengl if opengl not available, fallback to windowed if fullscreen specified but not available:
	Uint32 default_window_flags = SDL_WINDOW_SHOWN|SDL_WINDOW_INPUT_FOCUS;

	if (window_width != 0 && window_height != 0) 
	{
		if (fullscreen)
		{
			//Create window with opengl possible
			p_window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, default_window_flags|SDL_WINDOW_OPENGL|SDL_WINDOW_FULLSCREEN);
		
			if (p_window == NULL)
			{
				*log << "Platforma_window constructor: Window could not be created with opengl, trying without opengl. SDL_Error: " << SDL_GetError() << std::endl;

				// Try without opengl
				p_window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, default_window_flags|SDL_WINDOW_FULLSCREEN);
				
				if (p_window == NULL)
				{
					*log << "Platforma_window constructor: Window could not be created without opengl and fullscreen, trying without fullscreen. SDL_Error: " << SDL_GetError() << std::endl;

					// Try without opengl and fullscreen
					p_window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, default_window_flags);
				}
			}
		}
		else // no fullscreen
		{
			//Create window with opengl enabled
			p_window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, default_window_flags|SDL_WINDOW_OPENGL);

			if (p_window == NULL)
			{
				*log << "Platforma_window constructor: Non-fullscreen window could not be created with opengl, trying without opengl. SDL_Error: " << SDL_GetError() << std::endl;
			
				// Try without opengl
				p_window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, default_window_flags);
			}
		}
	}
	else // Assume fullscreen desktop mode (window height and width == 0).
	{
		p_window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, default_window_flags|SDL_WINDOW_OPENGL|SDL_WINDOW_FULLSCREEN_DESKTOP|SDL_WINDOW_BORDERLESS);
	
		if (p_window == NULL)
		{
			*log << "Platforma_window constructor: Fullscreen desktop window could not be created with opengl, trying without opengl. SDL_Error: " << SDL_GetError() << std::endl;
			
			// Try without opengl
			p_window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, default_window_flags|SDL_WINDOW_FULLSCREEN_DESKTOP|SDL_WINDOW_BORDERLESS);
		}
	}

	if (p_window == NULL)
	{
		*log << "Platforma_window constructor: Error! Window could not be created! SDL_Error:" << SDL_GetError();
	}
	else
	{
		//Get window surface
		p_window_surface = SDL_GetWindowSurface(p_window);
	}
}


platforma_window::~platforma_window()
{	
	SDL_DestroyWindow(p_window);
	p_window = NULL;
	p_window_surface = NULL;
}


SDL_Window* platforma_window::get()
{
	return p_window;
}


SDL_Surface* platforma_window::get_surface()
{
	return p_window_surface;
}


bool platforma_window::is_initialised()
{
	return (p_window != NULL);
}


class platforma_renderer
{
private:
	SDL_Renderer* p_renderer;
public:
	platforma_renderer(SDL_Window *window, unsigned int logical_width, unsigned int logical_height, platforma_log *p_log);
	~platforma_renderer();
		
	SDL_Renderer* get();
	bool is_initialised();
};


platforma_renderer::platforma_renderer(SDL_Window *window, unsigned int logical_width, unsigned int logical_height, platforma_log *log)
{
	p_renderer = NULL;

	if (log == NULL)
	{
		std::cerr << "Platforma_renderer constructor: Error: log is NULL. Quitting." << std::endl;
		return;
	}

	
	// Try for hardware acceleration, vsync, rendering to textures, fallback to software rendering without vsync if unavailable:
	p_renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC|SDL_RENDERER_TARGETTEXTURE);
	
	if (p_renderer == NULL)
	{
		*log << "Platforma_renderer constructor: Renderer could not be created, trying without texture rendering. SDL_Error:" << SDL_GetError() << std::endl;
	
		p_renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC);

		if (p_renderer == NULL)
		{
			*log << "Platforma_renderer constructor: Renderer could not be created, trying without VSYNC. SDL_Error:" << SDL_GetError() << std::endl;
		
			p_renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

			if (p_renderer == NULL)
			{
				*log << "Platforma_renderer constructor: Renderer could not be created, trying software with VSYNC. SDL_Error:" << SDL_GetError() << std::endl;
			
				p_renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE|SDL_RENDERER_PRESENTVSYNC);
		
				if (p_renderer == NULL)
				{
					*log << "Platforma_renderer constructor: Renderer could not be created, trying software without VSYNC. SDL_Error:" << SDL_GetError() << std::endl;
				
					p_renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);

					if (p_renderer == NULL)
					{
						*log << "Platforma_renderer constructor: Renderer could not be created! SDL_Error:" << SDL_GetError() << std::endl;
					}
				}
			}
		}
	}
	
	if (p_renderer != NULL)
	{
		SDL_SetHint("SDL_HINT_RENDER_SCALE_QUALITY", "linear");
		SDL_RenderSetLogicalSize(p_renderer, logical_width, logical_height);
		SDL_RenderClear(p_renderer);
	}
}


platforma_renderer::~platforma_renderer()
{
	// Destroy renderer
	SDL_DestroyRenderer(p_renderer);
	p_renderer = NULL;
}


SDL_Renderer* platforma_renderer::get()
{
	return p_renderer;
}


bool platforma_renderer::is_initialised()
{
	return (p_renderer != NULL);
}



class platforma_texture
{
private:
	SDL_Texture *p_texture;
	SDL_Renderer *p_renderer;
	int width, height;
	Uint32 format;
public:
	platforma_texture(SDL_Renderer *renderer, const char *image_filename, platforma_log *log);
	~platforma_texture();
	SDL_Texture * get();
	void get_dimensions(int &texture_width, int &texture_height);
	void get_format(Uint32 &format);
	bool is_initialised();
//	int copy(int x, int y, unsigned int width, unsigned width height)
};


platforma_texture::platforma_texture(SDL_Renderer *renderer, const char *image_filename, platforma_log *log)
{
	p_texture = NULL;
	width = 0;
	height = 0;
	format = 0;
	p_renderer = renderer;
	
	if (log == NULL)
	{
		std::cerr << "Platforma_texture constructor: Error: log is NULL. Quitting." << std::endl;
		return;
	}


	if (renderer == NULL)
	{
		*log << "Platforma_texture constructor: Error: renderer is NULL. Quitting." << std::endl;
		return;
	}


	p_texture = IMG_LoadTexture(p_renderer, image_filename);

	if(p_texture == NULL)
	{
		*log << "Platforma_texture constructor: Unable to load image file to texture! SDL Error: " << SDL_GetError() << std::endl;
	}
	else
	{
		SDL_QueryTexture(p_texture, &format, NULL, &width, &height);
	}
}


platforma_texture::~platforma_texture()
{
	if (p_texture != NULL)
	{
		SDL_DestroyTexture(p_texture);
		p_texture = NULL;
	}
}


SDL_Texture* platforma_texture::get()
{
	return p_texture;
}


void platforma_texture::get_dimensions(int &texture_width, int &texture_height)
{
	texture_width = width;
	texture_height = height;
}


void platforma_texture::get_format(Uint32 &texture_format)
{
	texture_format = format;
}


bool platforma_texture::is_initialised()
{
	return (p_texture != NULL);
}



class platforma
{
private:
	platforma_log *log; 	
	platforma_window *window;
	platforma_renderer *renderer;
	//platforma_sprites *sprites;
	bool initialised;
public:
	platforma(const char *window_name, unsigned int window_width, unsigned int window_height, unsigned int renderer_width, unsigned int renderer_height, bool fullscreen);
	~platforma();
	SDL_Window* get_window();
	SDL_Renderer* get_renderer();
	platforma_log* get_log();
	
	bool is_initialised();
};


platforma::platforma(const char *window_name, unsigned int window_width, unsigned int window_height, unsigned int renderer_width, unsigned int renderer_height, bool fullscreen)
{
	initialised = false;
	log = NULL;
	window = NULL;
	renderer = NULL;
	
	// Log already initialised, check if initialised correctly:
	log = new platforma_log;
	
	if (!log->is_initialised())
	{
		std::cerr << "Platforma Constructor: Log could not initialize! Quitting." << std::endl;
		return;
	}

	*log << "Platforma initialising. Date/time ";
	log->write_time();
	

	// Initialise SDL:
	if( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_EVENTS|SDL_INIT_TIMER) < 0 )
	{
		*log << "Platforma Constructor: SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl;
		return;
	}
	
	*log << "SDL video, audio, timer and events initialised." << std::endl;

	
	// Initialise SDL_IMG for use with PNGs only:
	if(IMG_Init(IMG_INIT_PNG) == 0)
	{
		*log << "Platforma Constructor: SDL_img PNG support could not initialize! Quitting." << std::endl;
		return;
	} 	

	*log << "SDL_img initialised with PNG support." << std::endl;


	// Initialise Window:
	window = new platforma_window(window_name, window_width, window_height, fullscreen, log);
	
	if (!window->is_initialised())
	{
		*log << "Platforma Constructor: Window could not initialize! SDL_Error: " << SDL_GetError() << ". Quitting." << std::endl;
		delete window;
		delete log;
		return;
	}
	
	*log << "SDL Window " << window_name << " created with dimensions" << window_width << "*" << window_height << "." << std::endl;
	
	
	// Initialise Renderer:
	renderer = new platforma_renderer(window->get(), renderer_width, renderer_height, log);
	
	if (!renderer->is_initialised())
	{
		*log << "Platforma Constructor: Renderer could not initialize! SDL_Error: " << SDL_GetError() << ". Quitting." << std::endl;
		delete renderer;
		delete window;
		delete log;
		return;
	}
	
	*log << "SDL Renderer created with logical dimensions" << renderer_width << "*" << renderer_height << "." << std::endl;


	// Initialise Sprites:

	// Platforma is correctly initialised:
	initialised = true;
}


platforma::~platforma()
{
	// Destroy Sprites:
	
	// Destroy Renderer:
	if (renderer != NULL)
	{
		delete renderer;
	}
	
	// Destroy Window:
	if (window != NULL)
	{
		delete window;
	}
	
	// Close log:
	if (log != NULL)
	{
		delete log;
	}
	
	// Destroy SDL:
	SDL_Quit();
}


SDL_Renderer* platforma::get_renderer()
{
	return renderer->get();
}

SDL_Window* platforma::get_window()
{
	return window->get();
}

platforma_log* platforma::get_log()
{
	return log;
}

bool platforma::is_initialised()
{
	return initialised;
}


int main( int argc, char* args[] )
{
	platforma *engine;
	engine = new platforma ("Platforma test", 640, 480, 600, 400, true);
	
	if (!engine->is_initialised())
	{
		return -1;
	}

	platforma_texture *thetexture1, *thetexture2;
	thetexture1 = new platforma_texture(engine->get_renderer(), "image2.png", engine->get_log());
	thetexture2 = new platforma_texture(engine->get_renderer(), "image.png", engine->get_log());

	//Load media
	if(!thetexture1->is_initialised() || !thetexture2->is_initialised())
	{
		std::cerr << "Failed to load media!" << std::endl;
		return -1;
	}

	//Apply the image
	SDL_RenderCopy(engine->get_renderer(), thetexture2->get(), NULL, NULL);

	//Apply the image
	SDL_RenderCopy(engine->get_renderer(), thetexture1->get(), NULL, NULL);

	//Update the surface
	SDL_RenderPresent(engine->get_renderer());

	//Wait two seconds
	SDL_Delay( 2000 );
	
	delete thetexture2;
	delete thetexture1;
	delete engine;

	//Quit SDL subsystems
	SDL_Quit();

	return 0;
}

Just tried with 2.01, same issue. Still crashes on true fullscreen, 100% fine on windowed or fullscreen desktop.

Correction - this IS fixed in 2.01, I forgot to replace the sdl dll in the project directory.