Ticket #8934: pixelformat_v1.patch

common/system.h

@@ -31 +31 @@
 #include "common/noncopyable.h"
 #include "common/rect.h"
 
+#include "graphics/colormasks.h"
+
 namespace Audio {
         class Mixer;
 }
@@ -571 +573 @@
         virtual void hideOverlay() = 0;
 
         /**
+         * Returns the pixel format description of the overlay.
+         * @see Graphics::PixelFormat
+         */
+        virtual Graphics::PixelFormat getOverlayFormat() const = 0;
+
+        /**
          * Reset the overlay.
          *
          * After calling this method while the overlay mode is active, the user

common/system.cpp

@@ -62 +62 @@
 }
 
 OverlayColor OSystem::RGBToColor(uint8 r, uint8 g, uint8 b) {
-        return ::RGBToColor<ColorMasks<565> >(r, g, b);
+        return Graphics::RGBToColor<Graphics::ColorMasks<565> >(r, g, b);
 }
 
 void OSystem::colorToRGB(OverlayColor color, uint8 &r, uint8 &g, uint8 &b) {
-        ::colorToRGB<ColorMasks<565> >(color, r, g, b);
+        Graphics::colorToRGB<Graphics::ColorMasks<565> >(color, r, g, b);
 }
 
 OverlayColor OSystem::ARGBToColor(uint8 a, uint8 r, uint8 g, uint8 b) {

graphics/scaler.cpp

@@ -105 +105 @@
         gBitFormat = BitFormat;
 #ifndef DISABLE_HQ_SCALERS
         if (gBitFormat == 555)
-                InitLUT<ColorMasks<555> >();
+                InitLUT<Graphics::ColorMasks<555> >();
         if (gBitFormat == 565)
-                InitLUT<ColorMasks<565> >();
+                InitLUT<Graphics::ColorMasks<565> >();
 #endif
 }
 

graphics/scaler/thumbnail_intern.cpp

@@ -118 +118 @@
                         g = palette[((uint8*)screen->pixels)[y * screen->pitch + x] * 4 + 1];
                         b = palette[((uint8*)screen->pixels)[y * screen->pitch + x] * 4 + 2];
 
-                        ((uint16*)surf->pixels)[y * surf->w + x] = RGBToColor<ColorMasks<565> >(r, g, b);
+                        ((uint16*)surf->pixels)[y * surf->w + x] = Graphics::RGBToColor<Graphics::ColorMasks<565> >(r, g, b);
                 }
         }
 
@@ -209 +209 @@
                         g = palette[pixels[y * w + x] * 3 + 1];
                         b = palette[pixels[y * w + x] * 3 + 2];
 
-                        ((uint16 *)screen.pixels)[y * screen.w + x] = RGBToColor<ColorMasks<565> >(r, g, b);
+                        ((uint16 *)screen.pixels)[y * screen.w + x] = Graphics::RGBToColor<Graphics::ColorMasks<565> >(r, g, b);
                 }
         }
 

graphics/scaler/intern.h

@@ -30 +30 @@
 #include "graphics/colormasks.h"
 
 
-#define highBits        ColorMasks<bitFormat>::highBits
-#define lowBits         ColorMasks<bitFormat>::lowBits
-#define qhighBits       ColorMasks<bitFormat>::qhighBits
-#define qlowBits        ColorMasks<bitFormat>::qlowBits
-#define redblueMask     ColorMasks<bitFormat>::kRedBlueMask
-#define greenMask       ColorMasks<bitFormat>::kGreenMask
+#define highBits        Graphics::ColorMasks<bitFormat>::highBits
+#define lowBits         Graphics::ColorMasks<bitFormat>::lowBits
+#define qhighBits       Graphics::ColorMasks<bitFormat>::qhighBits
+#define qlowBits        Graphics::ColorMasks<bitFormat>::qlowBits
+#define redblueMask     Graphics::ColorMasks<bitFormat>::kRedBlueMask
+#define greenMask       Graphics::ColorMasks<bitFormat>::kGreenMask
 
 
 /**

graphics/colormasks.h

@@ -26 +26 @@
 #ifndef GRAPHICS_COLORMASKS_H
 #define GRAPHICS_COLORMASKS_H
 
+namespace Graphics {
+
 template<int bitFormat>
 struct ColorMasks {
 };
@@ -251 +253 @@
         b = ((color & T::kBlueMask) >> T::kBlueShift) << (8 - T::kBlueBits);
 }
 
+/**
+ * A pixel format description.
+ *
+ * Like ColorMasks it includes the given values to create colors from RGB
+ * values and to retrieve RGB values from colors.
+ *
+ * Unlike ColorMasks it is not dependend on knowing the exact pixel format
+ * on compile time.
+ *
+ * A minor difference between ColorMasks and PixelFormat is that ColorMasks
+ * stores the bit count per channel in 'kFooBits', while PixelFormat stores
+ * the loss compared to 8 bits per channel in '#Loss'.
+ */
+struct PixelFormat {
+        PixelFormat() {}
+
+        template<class Mask>
+        PixelFormat() {
+                bytesPerPixel = Mask::kBytesPerPixel;
+
+                rLoss = 8 - Mask::kRedBits;
+                gLoss = 8 - Mask::kGreenBits;
+                bLoss = 8 - Mask::kBlueBits;
+                aLoss = 8 - Mask::kAlphaBits;
+
+                rShift = Mask::kRedShift;
+                gShift = Mask::kGreenShift;
+                bShift = Mask::kBlueShift;
+                aShift = Mask::kAlphaShift;
+
+                rMask = Mask::kRedMask;
+                gMask = Mask::kGreenMask;
+                bMask = Mask::kBlueMask;
+                aMask = Mask::kAlphaMask;
+        }
+
+        byte bytesPerPixel; /**< Number of bytes used in the pixel format. */
+
+        byte rLoss, gLoss, bLoss, aLoss; /**< Precision loss of each color component. */
+        byte rShift, gShift, bShift, aShift; /**< Binary left shift of each color component in the pixel value. */
+
+        uint32 rMask, gMask, bMask, aMask; /**< Binary mask used to retrieve individual color values. */
+};
+
+inline uint32 RGBToColor(uint8 r, uint8 g, uint8 b, const PixelFormat &fmt) {
+        return fmt.aMask |
+                (((r >> fmt.rLoss) << fmt.rShift) & fmt.rMask) |
+                (((g >> fmt.gLoss) << fmt.gShift) & fmt.gMask) |
+                (((b >> fmt.bLoss) << fmt.bShift) & fmt.bMask);
+}
+
+inline uint32 ARGBToColor(uint8 a, uint8 r, uint8 g, uint8 b, const PixelFormat &fmt) {
+        return
+                (((a >> fmt.aLoss) << fmt.aShift) & fmt.aMask) |
+                (((r >> fmt.rLoss) << fmt.rShift) & fmt.rMask) |
+                (((g >> fmt.gLoss) << fmt.gShift) & fmt.gMask) |
+                (((b >> fmt.bLoss) << fmt.bShift) & fmt.bMask);
+}
+
+inline void colorToRGB(uint32 color, uint8 &r, uint8 &g, uint8 &b, const PixelFormat &fmt) {
+        r = ((color & fmt.rMask) >> fmt.rShift) << fmt.rLoss;
+        g = ((color & fmt.gMask) >> fmt.gShift) << fmt.gLoss;
+        b = ((color & fmt.bMask) >> fmt.bShift) << fmt.bLoss;
+}
+
+inline void colorToARGB(uint32 color, uint8 &a, uint8 &r, uint8 &g, uint8 &b, const PixelFormat &fmt) {
+        a = ((color & fmt.aMask) >> fmt.aShift) << fmt.aLoss;
+        r = ((color & fmt.rMask) >> fmt.rShift) << fmt.rLoss;
+        g = ((color & fmt.gMask) >> fmt.gShift) << fmt.gLoss;
+        b = ((color & fmt.bMask) >> fmt.bShift) << fmt.bLoss;
+}
+
+} // end of namespace Graphics
+
 #endif

backends/platform/sdl/graphics.cpp

@@ -396 +396 @@
         if (_overlayscreen == NULL)
                 error("allocating _overlayscreen failed");
 
+        _overlayFormat.bytesPerPixel = _overlayscreen->format->BytesPerPixel;
+
+        _overlayFormat.rMask = _overlayscreen->format->Rmask;
+        _overlayFormat.gMask = _overlayscreen->format->Gmask;
+        _overlayFormat.bMask = _overlayscreen->format->Bmask;
+        _overlayFormat.aMask = _overlayscreen->format->Amask;
+
+        _overlayFormat.rLoss = _overlayscreen->format->Rloss;
+        _overlayFormat.gLoss = _overlayscreen->format->Gloss;
+        _overlayFormat.bLoss = _overlayscreen->format->Bloss;
+        _overlayFormat.aLoss = _overlayscreen->format->Aloss;
+
+        _overlayFormat.rShift = _overlayscreen->format->Rshift;
+        _overlayFormat.gShift = _overlayscreen->format->Gshift;
+        _overlayFormat.bShift = _overlayscreen->format->Bshift;
+        _overlayFormat.aShift = _overlayscreen->format->Ashift;
+
         _tmpscreen2 = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth + 3, _overlayHeight + 3,
                                                 16,
                                                 _hwscreen->format->Rmask,

backends/platform/sdl/sdl.h

@@ -176 +176 @@
         void deleteMutex(MutexRef mutex);
 
         // Overlay
+        virtual Graphics::PixelFormat getOverlayFormat() const { return _overlayFormat; }
         virtual void showOverlay();
         virtual void hideOverlay();
         virtual void clearOverlay();
@@ -246 +247 @@
         SDL_Surface *_overlayscreen;
         int _overlayWidth, _overlayHeight;
         bool _overlayVisible;
+        Graphics::PixelFormat _overlayFormat;
 
         // Audio
         int _samplesPerSec;