Head

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/resources/image/image.cpp	Lines:	64	173	37.0 %
Date:	2021-03-17	Branches:	17	102	16.7 %


/*
 *  The ManaPlus Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2010  The Mana Developers
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "resources/image/image.h"

#include "logger.h"

#ifdef USE_OPENGL
#include "resources/openglimagehelper.h"
#endif  // USE_OPENGL

#include "resources/memorymanager.h"
#include "resources/sdlimagehelper.h"

#include "resources/image/subimage.h"

#include "resources/resourcemanager/resourcemanager.h"

#include "utils/cast.h"
#include "utils/sdlcheckutils.h"

PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#ifdef USE_SDL2
#include <SDL2_rotozoom.h>
#else  // USE_SDL2
#include <SDL_rotozoom.h>
#endif  // USE_SDL2
PRAGMA48(GCC diagnostic pop)

#include "debug.h"

#ifdef UNITTESTS
Image::Image(const int width,
             const int height) :
    Resource(),
#ifdef USE_OPENGL
    mGLImage(0),
    mTexWidth(0),
    mTexHeight(0),
#endif  // USE_OPENGL
    mBounds(),
    mAlpha(1.0F),
    mSDLSurface(nullptr),
#ifdef USE_SDL2
    mTexture(nullptr),
#endif  // USE_SDL2
    mAlphaChannel(nullptr),
    mAlphaCache(),
    mLoaded(false),
    mHasAlphaChannel(false),
    mUseAlphaCache(false),
    mIsAlphaVisible(true),
    mIsAlphaCalculated(false)
{
    mBounds.x = 0;
    mBounds.y = 0;
    mBounds.w = width;
    mBounds.h = height;
}
#endif  // UNITTESTS

#ifdef USE_SDL2
Image::Image(SDL_Texture *restrict const image,
             const int width, const int height) :
    Resource(),
#ifdef USE_OPENGL
    mGLImage(0),
    mTexWidth(0),
    mTexHeight(0),
#endif  // USE_OPENGL
    mBounds(),
    mAlpha(1.0F),
    mSDLSurface(nullptr),
    mTexture(image),
    mAlphaChannel(nullptr),
    mAlphaCache(),
    mLoaded(false),
    mHasAlphaChannel(false),
    mUseAlphaCache(false),
    mIsAlphaVisible(true),
    mIsAlphaCalculated(false)
{
#ifdef DEBUG_IMAGES
    logger->log("created image: %p",
        static_cast<void*>(this));
#endif  // DEBUG_IMAGES

    mBounds.x = 0;
    mBounds.y = 0;

    if (mTexture)
    {
        mBounds.w = CAST_U16(width);
        mBounds.h = CAST_U16(height);

        mLoaded = true;
    }
    else
    {
        mBounds.w = 0;
        mBounds.h = 0;
    }
}
#endif  // USE_SDL2

Image::Image(SDL_Surface *restrict const image, const bool hasAlphaChannel0,
             uint8_t *restrict const alphaChannel) :
    Resource(),
#ifdef USE_OPENGL
    mGLImage(0),
    mTexWidth(0),
    mTexHeight(0),
#endif  // USE_OPENGL
    mBounds(),
    mAlpha(1.0F),
    mSDLSurface(image),
#ifdef USE_SDL2
    mTexture(nullptr),
#endif  // USE_SDL2
    mAlphaChannel(alphaChannel),
    mAlphaCache(),
    mLoaded(false),
    mHasAlphaChannel(hasAlphaChannel0),
    mUseAlphaCache(SDLImageHelper::mEnableAlphaCache),
    mIsAlphaVisible(hasAlphaChannel0),
    mIsAlphaCalculated(false)
{
#ifdef DEBUG_IMAGES
    logger->log("created image: %p", static_cast<void*>(this));
#endif  // DEBUG_IMAGES

    mBounds.x = 0;
    mBounds.y = 0;

    if (mSDLSurface != nullptr)
    {
        mBounds.w = CAST_U16(mSDLSurface->w);
        mBounds.h = CAST_U16(mSDLSurface->h);

        mLoaded = true;
    }
    else
    {
        mBounds.w = 0;
        mBounds.h = 0;
    }
}

#ifdef USE_OPENGL
Image::Image(const GLuint glimage, const int width, const int height,
             const int texWidth, const int texHeight) :
    Resource(),
    mGLImage(glimage),
    mTexWidth(texWidth),
    mTexHeight(texHeight),
    mBounds(),
    mAlpha(1.0F),
    mSDLSurface(nullptr),
#ifdef USE_SDL2
    mTexture(nullptr),
#endif  // USE_SDL2
    mAlphaChannel(nullptr),
    mAlphaCache(),
    mLoaded(false),
    mHasAlphaChannel(true),
    mUseAlphaCache(false),
    mIsAlphaVisible(true),
    mIsAlphaCalculated(false)
{
#ifdef DEBUG_IMAGES
    logger->log("created image: %p", static_cast<void*>(this));
#endif  // DEBUG_IMAGES

    mBounds.x = 0;
    mBounds.y = 0;
    mBounds.w = CAST_U16(width);
    mBounds.h = CAST_U16(height);

    if (mGLImage != 0U)
    {
        mLoaded = true;
    }
}
#endif  // USE_OPENGL

Image::~Image()
{
#ifdef DEBUG_IMAGES
    logger->log("delete image: %p", static_cast<void*>(this));
    logger->log("  %s, %s", mIdPath.c_str(), mSource.c_str());
#endif  // DEBUG_IMAGES

    unload();
}

void Image::SDLCleanCache()
{
    for (std::map<float, SDL_Surface*>::iterator
         i = mAlphaCache.begin(), i_end = mAlphaCache.end();
         i != i_end; ++i)
    {
        if (mSDLSurface != i->second)
            ResourceManager::scheduleDelete(i->second);
        i->second = nullptr;
    }
    mAlphaCache.clear();
}

void Image::unload()
{
    mLoaded = false;

    if (mSDLSurface != nullptr)
    {
        SDLCleanCache();
        // Free the image surface.
        MSDL_FreeSurface(mSDLSurface);
        mSDLSurface = nullptr;

        delete [] mAlphaChannel;
        mAlphaChannel = nullptr;
    }
#ifdef USE_SDL2
    if (mTexture)
    {
        SDL_DestroyTexture(mTexture);
        mTexture = nullptr;
    }
#endif  // USE_SDL2

#ifdef USE_OPENGL
    if (mGLImage != 0U)
    {
        glDeleteTextures(1, &mGLImage);
        mGLImage = 0;
#ifdef DEBUG_OPENGL_LEAKS
        if (textures_count > 0)
            textures_count --;
#endif  // DEBUG_OPENGL_LEAKS
    }
#endif  // USE_OPENGL
}

bool Image::hasAlphaChannel() const
{
    if (mLoaded)
        return mHasAlphaChannel;

#ifdef USE_OPENGL
    if (OpenGLImageHelper::mUseOpenGL != RENDER_SOFTWARE)
        return true;
#endif  // USE_OPENGL

    return false;
}

SDL_Surface *Image::getByAlpha(const float alpha)
{
    const std::map<float, SDL_Surface*>::const_iterator
        it = mAlphaCache.find(alpha);
    if (it != mAlphaCache.end())
        return (*it).second;
    return nullptr;
}

void Image::setAlpha(const float alpha)
{
    if (mAlpha == alpha || !ImageHelper::mEnableAlpha)
        return;

    if (alpha < 0.0F || alpha > 1.0F)
        return;

    if (mSDLSurface != nullptr)
    {
        if (mUseAlphaCache)
        {
            SDL_Surface *surface = getByAlpha(mAlpha);
            if (surface == nullptr)
            {
                if (mAlphaCache.size() > 100)
                {
#ifdef DEBUG_ALPHA_CACHE
                    logger->log("cleanCache");
                    for (std::map<float, SDL_Surface*>::const_iterator
                         i = mAlphaCache.begin(), i_end = mAlphaCache.end();
                         i != i_end; ++i)
                    {
                        logger->log("alpha: " + toString(i->first));
                    }
#endif  // DEBUG_ALPHA_CACHE

                    SDLCleanCache();
                }
                surface = mSDLSurface;
                if (surface != nullptr)
                    mAlphaCache[mAlpha] = surface;
            }
            else
            {
                logger->log("cache bug");
            }

            surface = getByAlpha(alpha);
            if (surface != nullptr)
            {
                if (mSDLSurface == surface)
                    logger->log("bug");
                mAlphaCache.erase(alpha);
                mSDLSurface = surface;
                mAlpha = alpha;
                return;
            }
            mSDLSurface = SDLImageHelper::SDLDuplicateSurface(mSDLSurface);
            if (mSDLSurface == nullptr)
                return;
        }

        mAlpha = alpha;

        if (!mHasAlphaChannel)
        {
#ifdef USE_SDL2
            SDL_SetSurfaceAlphaMod(mSDLSurface,
                CAST_U8(255 * mAlpha));
#else  // USE_SDL2

            // Set the alpha value this image is drawn at
            SDL_SetAlpha(mSDLSurface, SDL_SRCALPHA,
                CAST_U8(255 * mAlpha));
#endif  // USE_SDL2
        }
        else
        {
            if (SDL_MUSTLOCK(mSDLSurface))
                SDL_LockSurface(mSDLSurface);

            const int bx = mBounds.x;
            const int by = mBounds.y;
            const int bw = mBounds.w;
            const int bh = mBounds.h;
            const int bxw = bx + bw;
            const int sw = mSDLSurface->w;
            const int maxHeight = std::min(by + bh, mSDLSurface->h);
            const int maxWidth = std::min(bxw, sw);
            const int i1 = by * sw + bx;
            const SDL_PixelFormat * const fmt = mSDLSurface->format;
            const uint32_t amask = fmt->Amask;
            const uint32_t invMask = ~fmt->Amask;
            const uint8_t aloss = fmt->Aloss;
            const uint8_t ashift = fmt->Ashift;

            if ((bx == 0) && bxw == sw)
            {
                const int i2 = (maxHeight - 1) * sw + maxWidth - 1;
                for (int i = i1; i <= i2; i++)
                {
                    const uint8_t sourceAlpha = mAlphaChannel[i];
                    if (sourceAlpha > 0)
                    {
                        const uint8_t a = CAST_U8(
                            static_cast<float>(sourceAlpha) * mAlpha);

                        uint32_t c = (static_cast<uint32_t*>(
                            mSDLSurface->pixels))[i];
                        c &= invMask;
                        c |= ((a >> aloss) << ashift & amask);
                        (static_cast<uint32_t*>(mSDLSurface->pixels))[i] = c;
                    }
                }
            }
            else
            {
                for (int y = by; y < maxHeight; y ++)
                {
                    const int idx = y * sw;
                    const int x1 = idx + bx;
                    const int x2 = idx + maxWidth;
                    for (int i = x1; i < x2; i ++)
                    {
                        const uint8_t sourceAlpha = mAlphaChannel[i];
                        if (sourceAlpha > 0)
                        {
                            const uint8_t a = CAST_U8(
                                static_cast<float>(sourceAlpha) * mAlpha);

                            uint32_t c = (static_cast<uint32_t*>(
                                mSDLSurface->pixels))[i];
                            c &= invMask;
                            c |= ((a >> aloss) << ashift & amask);
                            (static_cast<uint32_t*>(
                                mSDLSurface->pixels))[i] = c;
                        }
                    }
                }
            }

            if (SDL_MUSTLOCK(mSDLSurface))
                SDL_UnlockSurface(mSDLSurface);
        }
    }
#ifdef USE_SDL2
    else if (mTexture)
    {
        mAlpha = alpha;
        SDL_SetTextureAlphaMod(mTexture,
            CAST_U8(255 * mAlpha));
    }
#endif  // USE_SDL2
    else
    {
        mAlpha = alpha;
    }
}

Image* Image::SDLgetScaledImage(const int width, const int height) const
{
    // No scaling on incorrect new values.
    if (width == 0 || height == 0)
        return nullptr;

    // No scaling when there is ... no different given size ...
    if (width == mBounds.w && height == mBounds.h)
        return nullptr;

    Image* scaledImage = nullptr;

    if (mSDLSurface != nullptr)
    {
        SDL_Surface *const scaledSurface = zoomSurface(mSDLSurface,
                    static_cast<double>(width) / mBounds.w,
                    static_cast<double>(height) / mBounds.h,
                    1);

        // The load function takes care of the SDL<->OpenGL implementation
        // and about freeing the given SDL_surface*.
        if (scaledSurface != nullptr)
        {
            scaledImage = imageHelper->loadSurface(scaledSurface);
            MSDL_FreeSurface(scaledSurface);
        }
    }
    return scaledImage;
}

Image *Image::getSubImage(const int x, const int y,
                          const int width, const int height)
{
    // Create a new clipped sub-image
#ifdef USE_OPENGL
    const RenderType mode = OpenGLImageHelper::mUseOpenGL;
    if (mode == RENDER_NORMAL_OPENGL ||
        mode == RENDER_SAFE_OPENGL ||
        mode == RENDER_GLES_OPENGL ||
        mode == RENDER_GLES2_OPENGL ||
        mode == RENDER_MODERN_OPENGL)
    {
        return new SubImage(this,
            mGLImage,
            x, y,
            width, height,
            mTexWidth, mTexHeight);
    }
#endif  // USE_OPENGL

#ifdef USE_SDL2
#ifndef USE_OPENGL
    const RenderType mode = ImageHelper::mUseOpenGL;
#endif  // USE_OPENGL

    if (mode == RENDER_SOFTWARE)
        return new SubImage(this, mSDLSurface, x, y, width, height);
    else
        return new SubImage(this, mTexture, x, y, width, height);
#else  // USE_SDL2

    return new SubImage(this, mSDLSurface, x, y, width, height);
#endif  // USE_SDL2
}

void Image::SDLTerminateAlphaCache()
{
    SDLCleanCache();
    mUseAlphaCache = false;
}

int Image::calcMemoryLocal() const
{
    // +++ this calculation can be wrong for SDL2
    int sz = static_cast<int>(sizeof(Image) +
        sizeof(std::map<float, SDL_Surface*>)) +
        Resource::calcMemoryLocal();
    if (mSDLSurface != nullptr)
    {
        sz += CAST_S32(mAlphaCache.size()) *
            MemoryManager::getSurfaceSize(mSDLSurface);
    }
    return sz;
}

#ifdef USE_OPENGL
void Image::decRef()
{
    if ((mGLImage != 0U) && mRefCount <= 1)
        OpenGLImageHelper::invalidate(mGLImage);
    Resource::decRef();
}
#endif  // USE_OPENGL


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* The ManaPlus Client
3			* Copyright (C) 2004-2009 The Mana World Development Team
4			* Copyright (C) 2009-2010 The Mana Developers
5			* Copyright (C) 2011-2019 The ManaPlus Developers
6			* Copyright (C) 2019-2021 Andrei Karas
7			*
8			* This file is part of The ManaPlus Client.
9			*
10			* This program is free software; you can redistribute it and/or modify
11			* it under the terms of the GNU General Public License as published by
12			* the Free Software Foundation; either version 2 of the License, or
13			* any later version.
14			*
15			* This program is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU General Public License for more details.
19			*
20			* You should have received a copy of the GNU General Public License
21			* along with this program. If not, see <http://www.gnu.org/licenses/>.
22			*/
23
24			#include "resources/image/image.h"
25
26			#include "logger.h"
27
28			#ifdef USE_OPENGL
29			#include "resources/openglimagehelper.h"
30			#endif // USE_OPENGL
31
32			#include "resources/memorymanager.h"
33			#include "resources/sdlimagehelper.h"
34
35			#include "resources/image/subimage.h"
36
37			#include "resources/resourcemanager/resourcemanager.h"
38
39			#include "utils/cast.h"
40			#include "utils/sdlcheckutils.h"
41
42			PRAGMA48(GCC diagnostic push)
43			PRAGMA48(GCC diagnostic ignored "-Wshadow")
44			#ifdef USE_SDL2
45			#include <SDL2_rotozoom.h>
46			#else // USE_SDL2
47			#include <SDL_rotozoom.h>
48			#endif // USE_SDL2
49			PRAGMA48(GCC diagnostic pop)
50
51			#include "debug.h"
52
53			#ifdef UNITTESTS
54		143	Image::Image(const int width,
55		143	const int height) :
56			Resource(),
57			#ifdef USE_OPENGL
58			mGLImage(0),
59			mTexWidth(0),
60			mTexHeight(0),
61			#endif // USE_OPENGL
62			mBounds(),
63			mAlpha(1.0F),
64			mSDLSurface(nullptr),
65			#ifdef USE_SDL2
66			mTexture(nullptr),
67			#endif // USE_SDL2
68			mAlphaChannel(nullptr),
69			mAlphaCache(),
70			mLoaded(false),
71			mHasAlphaChannel(false),
72			mUseAlphaCache(false),
73			mIsAlphaVisible(true),
74		429	mIsAlphaCalculated(false)
75			{
76			mBounds.x = 0;
77			mBounds.y = 0;
78		143	mBounds.w = width;
79		143	mBounds.h = height;
80		143	}
81			#endif // UNITTESTS
82
83			#ifdef USE_SDL2
84		1657	Image::Image(SDL_Texture *restrict const image,
85		1657	const int width, const int height) :
86			Resource(),
87			#ifdef USE_OPENGL
88			mGLImage(0),
89			mTexWidth(0),
90			mTexHeight(0),
91			#endif // USE_OPENGL
92			mBounds(),
93			mAlpha(1.0F),
94			mSDLSurface(nullptr),
95			mTexture(image),
96			mAlphaChannel(nullptr),
97			mAlphaCache(),
98			mLoaded(false),
99			mHasAlphaChannel(false),
100			mUseAlphaCache(false),
101			mIsAlphaVisible(true),
102		4971	mIsAlphaCalculated(false)
103			{
104			#ifdef DEBUG_IMAGES
105			logger->log("created image: %p",
106			static_cast<void*>(this));
107			#endif // DEBUG_IMAGES
108
109			mBounds.x = 0;
110			mBounds.y = 0;
111
112	✓✗	1657	if (mTexture)
113			{
114		1657	mBounds.w = CAST_U16(width);
115		1657	mBounds.h = CAST_U16(height);
116
117		1657	mLoaded = true;
118			}
119			else
120			{
121			mBounds.w = 0;
122			mBounds.h = 0;
123			}
124		1657	}
125			#endif // USE_SDL2
126
127		28043	Image::Image(SDL_Surface *restrict const image, const bool hasAlphaChannel0,
128		28043	uint8_t *restrict const alphaChannel) :
129			Resource(),
130			#ifdef USE_OPENGL
131			mGLImage(0),
132			mTexWidth(0),
133			mTexHeight(0),
134			#endif // USE_OPENGL
135			mBounds(),
136			mAlpha(1.0F),
137			mSDLSurface(image),
138			#ifdef USE_SDL2
139			mTexture(nullptr),
140			#endif // USE_SDL2
141			mAlphaChannel(alphaChannel),
142			mAlphaCache(),
143			mLoaded(false),
144			mHasAlphaChannel(hasAlphaChannel0),
145			mUseAlphaCache(SDLImageHelper::mEnableAlphaCache),
146			mIsAlphaVisible(hasAlphaChannel0),
147		84129	mIsAlphaCalculated(false)
148			{
149			#ifdef DEBUG_IMAGES
150			logger->log("created image: %p", static_cast<void*>(this));
151			#endif // DEBUG_IMAGES
152
153			mBounds.x = 0;
154			mBounds.y = 0;
155
156	✓✓	28043	if (mSDLSurface != nullptr)
157			{
158		2237	mBounds.w = CAST_U16(mSDLSurface->w);
159		2237	mBounds.h = CAST_U16(mSDLSurface->h);
160
161		2237	mLoaded = true;
162			}
163			else
164			{
165			mBounds.w = 0;
166			mBounds.h = 0;
167			}
168		28043	}
169
170			#ifdef USE_OPENGL
171			Image::Image(const GLuint glimage, const int width, const int height,
172			const int texWidth, const int texHeight) :
173			Resource(),
174			mGLImage(glimage),
175			mTexWidth(texWidth),
176			mTexHeight(texHeight),
177			mBounds(),
178			mAlpha(1.0F),
179			mSDLSurface(nullptr),
180			#ifdef USE_SDL2
181			mTexture(nullptr),
182			#endif // USE_SDL2
183			mAlphaChannel(nullptr),
184			mAlphaCache(),
185			mLoaded(false),
186			mHasAlphaChannel(true),
187			mUseAlphaCache(false),
188			mIsAlphaVisible(true),
189			mIsAlphaCalculated(false)
190			{
191			#ifdef DEBUG_IMAGES
192			logger->log("created image: %p", static_cast<void*>(this));
193			#endif // DEBUG_IMAGES
194
195			mBounds.x = 0;
196			mBounds.y = 0;
197			mBounds.w = CAST_U16(width);
198			mBounds.h = CAST_U16(height);
199
200			if (mGLImage != 0U)
201			{
202			mLoaded = true;
203			}
204			}
205			#endif // USE_OPENGL
206
207		91466	Image::~Image()
208			{
209			#ifdef DEBUG_IMAGES
210			logger->log("delete image: %p", static_cast<void*>(this));
211			logger->log(" %s, %s", mIdPath.c_str(), mSource.c_str());
212			#endif // DEBUG_IMAGES
213
214		29843	unload();
215		31780	}
216
217		28043	void Image::SDLCleanCache()
218			{
219	✗✓	28043	for (std::map<float, SDL_Surface*>::iterator
220		84129	i = mAlphaCache.begin(), i_end = mAlphaCache.end();
221			i != i_end; ++i)
222			{
223			if (mSDLSurface != i->second)
224			ResourceManager::scheduleDelete(i->second);
225			i->second = nullptr;
226			}
227		56086	mAlphaCache.clear();
228		28043	}
229
230		29843	void Image::unload()
231			{
232		29843	mLoaded = false;
233
234	✓✓	29843	if (mSDLSurface != nullptr)
235			{
236		137	SDLCleanCache();
237			// Free the image surface.
238		137	MSDL_FreeSurface(mSDLSurface);
239		137	mSDLSurface = nullptr;
240
241	✗✓	137	delete [] mAlphaChannel;
242		137	mAlphaChannel = nullptr;
243			}
244			#ifdef USE_SDL2
245	✓✓	29843	if (mTexture)
246			{
247		1657	SDL_DestroyTexture(mTexture);
248		1657	mTexture = nullptr;
249			}
250			#endif // USE_SDL2
251
252			#ifdef USE_OPENGL
253	✗✓	29843	if (mGLImage != 0U)
254			{
255			glDeleteTextures(1, &mGLImage);
256			mGLImage = 0;
257			#ifdef DEBUG_OPENGL_LEAKS
258			if (textures_count > 0)
259			textures_count --;
260			#endif // DEBUG_OPENGL_LEAKS
261			}
262			#endif // USE_OPENGL
263		29843	}
264
265		27906	bool Image::hasAlphaChannel() const
266			{
267	✓✗	27906	if (mLoaded)
268		27906	return mHasAlphaChannel;
269
270			#ifdef USE_OPENGL
271			if (OpenGLImageHelper::mUseOpenGL != RENDER_SOFTWARE)
272			return true;
273			#endif // USE_OPENGL
274
275			return false;
276			}
277
278			SDL_Surface *Image::getByAlpha(const float alpha)
279			{
280			const std::map<float, SDL_Surface*>::const_iterator
281			it = mAlphaCache.find(alpha);
282			if (it != mAlphaCache.end())
283			return (*it).second;
284			return nullptr;
285			}
286
287		5328	void Image::setAlpha(const float alpha)
288			{
289	✗✓✗✗	5328	if (mAlpha == alpha \|\| !ImageHelper::mEnableAlpha)
290			return;
291
292			if (alpha < 0.0F \|\| alpha > 1.0F)
293			return;
294
295			if (mSDLSurface != nullptr)
296			{
297			if (mUseAlphaCache)
298			{
299			SDL_Surface *surface = getByAlpha(mAlpha);
300			if (surface == nullptr)
301			{
302			if (mAlphaCache.size() > 100)
303			{
304			#ifdef DEBUG_ALPHA_CACHE
305			logger->log("cleanCache");
306			for (std::map<float, SDL_Surface*>::const_iterator
307			i = mAlphaCache.begin(), i_end = mAlphaCache.end();
308			i != i_end; ++i)
309			{
310			logger->log("alpha: " + toString(i->first));
311			}
312			#endif // DEBUG_ALPHA_CACHE
313
314			SDLCleanCache();
315			}
316			surface = mSDLSurface;
317			if (surface != nullptr)
318			mAlphaCache[mAlpha] = surface;
319			}
320			else
321			{
322			logger->log("cache bug");
323			}
324
325			surface = getByAlpha(alpha);
326			if (surface != nullptr)
327			{
328			if (mSDLSurface == surface)
329			logger->log("bug");
330			mAlphaCache.erase(alpha);
331			mSDLSurface = surface;
332			mAlpha = alpha;
333			return;
334			}
335			mSDLSurface = SDLImageHelper::SDLDuplicateSurface(mSDLSurface);
336			if (mSDLSurface == nullptr)
337			return;
338			}
339
340			mAlpha = alpha;
341
342			if (!mHasAlphaChannel)
343			{
344			#ifdef USE_SDL2
345			SDL_SetSurfaceAlphaMod(mSDLSurface,
346			CAST_U8(255 * mAlpha));
347			#else // USE_SDL2
348
349			// Set the alpha value this image is drawn at
350			SDL_SetAlpha(mSDLSurface, SDL_SRCALPHA,
351			CAST_U8(255 * mAlpha));
352			#endif // USE_SDL2
353			}
354			else
355			{
356			if (SDL_MUSTLOCK(mSDLSurface))
357			SDL_LockSurface(mSDLSurface);
358
359			const int bx = mBounds.x;
360			const int by = mBounds.y;
361			const int bw = mBounds.w;
362			const int bh = mBounds.h;
363			const int bxw = bx + bw;
364			const int sw = mSDLSurface->w;
365			const int maxHeight = std::min(by + bh, mSDLSurface->h);
366			const int maxWidth = std::min(bxw, sw);
367			const int i1 = by * sw + bx;
368			const SDL_PixelFormat * const fmt = mSDLSurface->format;
369			const uint32_t amask = fmt->Amask;
370			const uint32_t invMask = ~fmt->Amask;
371			const uint8_t aloss = fmt->Aloss;
372			const uint8_t ashift = fmt->Ashift;
373
374			if ((bx == 0) && bxw == sw)
375			{
376			const int i2 = (maxHeight - 1) * sw + maxWidth - 1;
377			for (int i = i1; i <= i2; i++)
378			{
379			const uint8_t sourceAlpha = mAlphaChannel[i];
380			if (sourceAlpha > 0)
381			{
382			const uint8_t a = CAST_U8(
383			static_cast<float>(sourceAlpha) * mAlpha);
384
385			uint32_t c = (static_cast<uint32_t*>(
386			mSDLSurface->pixels))[i];
387			c &= invMask;
388			c \|= ((a >> aloss) << ashift & amask);
389			(static_cast<uint32_t*>(mSDLSurface->pixels))[i] = c;
390			}
391			}
392			}
393			else
394			{
395			for (int y = by; y < maxHeight; y ++)
396			{
397			const int idx = y * sw;
398			const int x1 = idx + bx;
399			const int x2 = idx + maxWidth;
400			for (int i = x1; i < x2; i ++)
401			{
402			const uint8_t sourceAlpha = mAlphaChannel[i];
403			if (sourceAlpha > 0)
404			{
405			const uint8_t a = CAST_U8(
406			static_cast<float>(sourceAlpha) * mAlpha);
407
408			uint32_t c = (static_cast<uint32_t*>(
409			mSDLSurface->pixels))[i];
410			c &= invMask;
411			c \|= ((a >> aloss) << ashift & amask);
412			(static_cast<uint32_t*>(
413			mSDLSurface->pixels))[i] = c;
414			}
415			}
416			}
417			}
418
419			if (SDL_MUSTLOCK(mSDLSurface))
420			SDL_UnlockSurface(mSDLSurface);
421			}
422			}
423			#ifdef USE_SDL2
424			else if (mTexture)
425			{
426			mAlpha = alpha;
427			SDL_SetTextureAlphaMod(mTexture,
428			CAST_U8(255 * mAlpha));
429			}
430			#endif // USE_SDL2
431			else
432			{
433			mAlpha = alpha;
434			}
435			}
436
437			Image* Image::SDLgetScaledImage(const int width, const int height) const
438			{
439			// No scaling on incorrect new values.
440			if (width == 0 \|\| height == 0)
441			return nullptr;
442
443			// No scaling when there is ... no different given size ...
444			if (width == mBounds.w && height == mBounds.h)
445			return nullptr;
446
447			Image* scaledImage = nullptr;
448
449			if (mSDLSurface != nullptr)
450			{
451			SDL_Surface *const scaledSurface = zoomSurface(mSDLSurface,
452			static_cast<double>(width) / mBounds.w,
453			static_cast<double>(height) / mBounds.h,
454			1);
455
456			// The load function takes care of the SDL<->OpenGL implementation
457			// and about freeing the given SDL_surface*.
458			if (scaledSurface != nullptr)
459			{
460			scaledImage = imageHelper->loadSurface(scaledSurface);
461			MSDL_FreeSurface(scaledSurface);
462			}
463			}
464			return scaledImage;
465			}
466
467		27906	Image *Image::getSubImage(const int x, const int y,
468			const int width, const int height)
469			{
470			// Create a new clipped sub-image
471			#ifdef USE_OPENGL
472		27906	const RenderType mode = OpenGLImageHelper::mUseOpenGL;
473	✓✗	27906	if (mode == RENDER_NORMAL_OPENGL \|\|
474		27906	mode == RENDER_SAFE_OPENGL \|\|
475		27906	mode == RENDER_GLES_OPENGL \|\|
476	✗✓	55812	mode == RENDER_GLES2_OPENGL \|\|
477			mode == RENDER_MODERN_OPENGL)
478			{
479			return new SubImage(this,
480			mGLImage,
481			x, y,
482			width, height,
483			mTexWidth, mTexHeight);
484			}
485			#endif // USE_OPENGL
486
487			#ifdef USE_SDL2
488			#ifndef USE_OPENGL
489			const RenderType mode = ImageHelper::mUseOpenGL;
490			#endif // USE_OPENGL
491
492	✓✗	27906	if (mode == RENDER_SOFTWARE)
493	✓✗	27906	return new SubImage(this, mSDLSurface, x, y, width, height);
494			else
495			return new SubImage(this, mTexture, x, y, width, height);
496			#else // USE_SDL2
497
498			return new SubImage(this, mSDLSurface, x, y, width, height);
499			#endif // USE_SDL2
500			}
501
502		27906	void Image::SDLTerminateAlphaCache()
503			{
504		27906	SDLCleanCache();
505		27906	mUseAlphaCache = false;
506		27906	}
507
508			int Image::calcMemoryLocal() const
509			{
510			// +++ this calculation can be wrong for SDL2
511			int sz = static_cast<int>(sizeof(Image) +
512			sizeof(std::map<float, SDL_Surface*>)) +
513			Resource::calcMemoryLocal();
514			if (mSDLSurface != nullptr)
515			{
516			sz += CAST_S32(mAlphaCache.size()) *
517			MemoryManager::getSurfaceSize(mSDLSurface);
518			}
519			return sz;
520			}
521
522			#ifdef USE_OPENGL
523		40243	void Image::decRef()
524			{
525	✗✓✗✗	40243	if ((mGLImage != 0U) && mRefCount <= 1)
526			OpenGLImageHelper::invalidate(mGLImage);
527		40243	Resource::decRef();
528		40243	}
529			#endif // USE_OPENGL