Add Kodi-specific patch Kodi 15.0 contains an updated version of libsquish: https://github.com/xbmc/xbmc/tree/master/tools/depends/native/libsquish-native The OpenElec project provides a separate tarball including the Kodi- specific patches: http://sources.openelec.tv/devel/libsquish-1.10-openelec.tar.gz This patch contains the relevant diff between upstream libsquish 1.13 and the OpenElec tarball. Signed-off-by: Bernd Kuhls diff -uwNr 1.13/squish.cpp libsquish-1.10-openelec/squish.cpp --- 1.13/squish.cpp 2015-04-30 12:48:49.000000000 +0200 +++ libsquish-1.10-openelec/squish.cpp 2015-01-09 10:58:43.000000000 +0100 @@ -23,6 +23,7 @@ -------------------------------------------------------------------------- */ +#include #include #include "colourset.h" #include "maths.h" @@ -39,7 +40,7 @@ // grab the flag bits int method = flags & ( kDxt1 | kDxt3 | kDxt5 ); int fit = flags & ( kColourIterativeClusterFit | kColourClusterFit | kColourRangeFit ); - int extra = flags & kWeightColourByAlpha; + int extra = flags & ( kWeightColourByAlpha | kSourceBGRA ); // set defaults if( method != kDxt3 && method != kDxt5 ) @@ -124,8 +125,30 @@ return blockcount*blocksize; } +void CopyRGBA( u8 const* source, u8* dest, int flags ) +{ + if (flags & kSourceBGRA) + { + // convert from bgra to rgba + dest[0] = source[2]; + dest[1] = source[1]; + dest[2] = source[0]; + dest[3] = source[3]; + } + else + { + for( int i = 0; i < 4; ++i ) + *dest++ = *source++; + } +} + void CompressImage( u8 const* rgba, int width, int height, void* blocks, int flags, float* metric ) { + CompressImage(rgba, width, height, width*4, blocks, flags, metric); +} + +void CompressImage( u8 const* rgba, int width, int height, int pitch, void* blocks, int flags, float* metric ) +{ // fix any bad flags flags = FixFlags( flags ); @@ -154,20 +177,14 @@ if( sx < width && sy < height ) { // copy the rgba value - u8 const* sourcePixel = rgba + 4*( width*sy + sx ); - for( int i = 0; i < 4; ++i ) - *targetPixel++ = *sourcePixel++; - + u8 const* sourcePixel = rgba + pitch*sy + 4*sx; + CopyRGBA(sourcePixel, targetPixel, flags); // enable this pixel mask |= ( 1 << ( 4*py + px ) ); } - else - { - // skip this pixel as its outside the image targetPixel += 4; } } - } // compress it into the output CompressMasked( sourceRgba, mask, targetBlock, flags, metric ); @@ -180,6 +197,11 @@ void DecompressImage( u8* rgba, int width, int height, void const* blocks, int flags ) { + DecompressImage( rgba, width, height, width*4, blocks, flags ); +} + +void DecompressImage( u8* rgba, int width, int height, int pitch, void const* blocks, int flags ) +{ // fix any bad flags flags = FixFlags( flags ); @@ -207,24 +229,132 @@ int sy = y + py; if( sx < width && sy < height ) { - u8* targetPixel = rgba + 4*( width*sy + sx ); + u8* targetPixel = rgba + pitch*sy + 4*sx; // copy the rgba value + CopyRGBA(sourcePixel, targetPixel, flags); + } + sourcePixel += 4; + } + } + + // advance + sourceBlock += bytesPerBlock; + } + } +} + +static double ErrorSq(double x, double y) +{ + return (x - y) * (x - y); +} + +static void ComputeBlockWMSE(u8 const *original, u8 const *compressed, unsigned int w, unsigned int h, double &cmse, double &amse) +{ + // Computes the MSE for the block and weights it by the variance of the original block. + // If the variance of the original block is less than 4 (i.e. a standard deviation of 1 per channel) + // then the block is close to being a single colour. Quantisation errors in single colour blocks + // are easier to see than similar errors in blocks that contain more colours, particularly when there + // are many such blocks in a large area (eg a blue sky background) as they cause banding. Given that + // banding is easier to see than small errors in "complex" blocks, we weight the errors by a factor + // of 5. This implies that images with large, single colour areas will have a higher potential WMSE + // than images with lots of detail. + + cmse = amse = 0; + unsigned int sum_p[4]; // per channel sum of pixels + unsigned int sum_p2[4]; // per channel sum of pixels squared + memset(sum_p, 0, sizeof(sum_p)); + memset(sum_p2, 0, sizeof(sum_p2)); + for( unsigned int py = 0; py < 4; ++py ) + { + for( unsigned int px = 0; px < 4; ++px ) + { + if( px < w && py < h ) + { + double pixelCMSE = 0; + for( int i = 0; i < 3; ++i ) + { + pixelCMSE += ErrorSq(original[i], compressed[i]); + sum_p[i] += original[i]; + sum_p2[i] += (unsigned int)original[i]*original[i]; + } + if( original[3] == 0 && compressed[3] == 0 ) + pixelCMSE = 0; // transparent in both, so colour is inconsequential + amse += ErrorSq(original[3], compressed[3]); + cmse += pixelCMSE; + sum_p[3] += original[3]; + sum_p2[3] += (unsigned int)original[3]*original[3]; + } + original += 4; + compressed += 4; + } + } + unsigned int variance = 0; for( int i = 0; i < 4; ++i ) - *targetPixel++ = *sourcePixel++; + variance += w*h*sum_p2[i] - sum_p[i]*sum_p[i]; + if( variance < 4 * w * w * h * h ) + { + amse *= 5; + cmse *= 5; } - else +} + +void ComputeMSE( u8 const *rgba, int width, int height, u8 const *dxt, int flags, double &colourMSE, double &alphaMSE ) { - // skip this pixel as its outside the image - sourcePixel += 4; + ComputeMSE(rgba, width, height, width*4, dxt, flags, colourMSE, alphaMSE); +} + +void ComputeMSE( u8 const *rgba, int width, int height, int pitch, u8 const *dxt, int flags, double &colourMSE, double &alphaMSE ) +{ + // fix any bad flags + flags = FixFlags( flags ); + colourMSE = alphaMSE = 0; + + // initialise the block input + squish::u8 const* sourceBlock = dxt; + int bytesPerBlock = ( ( flags & squish::kDxt1 ) != 0 ) ? 8 : 16; + + // loop over blocks + for( int y = 0; y < height; y += 4 ) + { + for( int x = 0; x < width; x += 4 ) + { + // decompress the block + u8 targetRgba[4*16]; + Decompress( targetRgba, sourceBlock, flags ); + u8 const* sourcePixel = targetRgba; + + // copy across to a similar pixel block + u8 originalRgba[4*16]; + u8* originalPixel = originalRgba; + + for( int py = 0; py < 4; ++py ) + { + for( int px = 0; px < 4; ++px ) + { + int sx = x + px; + int sy = y + py; + if( sx < width && sy < height ) + { + u8 const* targetPixel = rgba + pitch*sy + 4*sx; + CopyRGBA(targetPixel, originalPixel, flags); } + sourcePixel += 4; + originalPixel += 4; } } + // compute the weighted MSE of the block + double blockCMSE, blockAMSE; + ComputeBlockWMSE(originalRgba, targetRgba, std::min(4, width - x), std::min(4, height - y), blockCMSE, blockAMSE); + colourMSE += blockCMSE; + alphaMSE += blockAMSE; // advance sourceBlock += bytesPerBlock; } } + colourMSE /= (width * height * 3); + alphaMSE /= (width * height); } } // namespace squish diff -uwNr 1.13/squish.h libsquish-1.10-openelec/squish.h --- 1.13/squish.h 2015-04-30 12:55:27.000000000 +0200 +++ libsquish-1.10-openelec/squish.h 2015-01-09 10:58:43.000000000 +0100 @@ -57,7 +57,10 @@ kColourRangeFit = ( 1 << 4 ), //! Weight the colour by alpha during cluster fit (disabled by default). - kWeightColourByAlpha = ( 1 << 7 ) + kWeightColourByAlpha = ( 1 << 7 ), + + //! Source is BGRA rather than RGBA + kSourceBGRA = ( 1 << 9 ), }; // ----------------------------------------------------------------------------- @@ -194,6 +197,7 @@ @param rgba The pixels of the source. @param width The width of the source image. @param height The height of the source image. + @param pitch The pitch of the source image. @param blocks Storage for the compressed output. @param flags Compression flags. @param metric An optional perceptual metric. @@ -231,6 +235,7 @@ to allocate for the compressed output. */ void CompressImage( u8 const* rgba, int width, int height, void* blocks, int flags, float* metric = 0 ); +void CompressImage( u8 const* rgba, int width, int height, int pitch, void* blocks, int flags, float* metric = 0 ); // ----------------------------------------------------------------------------- @@ -239,6 +244,7 @@ @param rgba Storage for the decompressed pixels. @param width The width of the source image. @param height The height of the source image. + @param pitch The pitch of the decompressed pixels. @param blocks The compressed DXT blocks. @param flags Compression flags. @@ -254,6 +260,32 @@ Internally this function calls squish::Decompress for each block. */ void DecompressImage( u8* rgba, int width, int height, void const* blocks, int flags ); +void DecompressImage( u8* rgba, int width, int height, int pitch, void const* blocks, int flags ); + +// ----------------------------------------------------------------------------- + +/*! @brief Computes MSE of an compressed image in memory. + + @param rgba The original image pixels. + @param width The width of the source image. + @param height The height of the source image. + @param pitch The pitch of the source image. + @param dxt The compressed dxt blocks + @param flags Compression flags. + @param colourMSE The MSE of the colour values. + @param alphaMSE The MSE of the alpha values. + + The colour MSE and alpha MSE are computed across all pixels. The colour MSE is + averaged across all rgb values (i.e. colourMSE = sum sum_k ||dxt.k - rgba.k||/3) + + The flags parameter should specify either kDxt1, kDxt3 or kDxt5 compression, + however, DXT1 will be used by default if none is specified. All other flags + are ignored. + + Internally this function calls squish::Decompress for each block. +*/ +void ComputeMSE(u8 const *rgba, int width, int height, u8 const *dxt, int flags, double &colourMSE, double &alphaMSE); +void ComputeMSE(u8 const *rgba, int width, int height, int pitch, u8 const *dxt, int flags, double &colourMSE, double &alphaMSE); // ----------------------------------------------------------------------------- diff -uwNr 1.13/squish.pc.in libsquish-1.10-openelec/squish.pc.in --- 1.13/squish.pc 1970-01-01 01:00:00.000000000 +0100 +++ libsquish-1.10-openelec/squish.pc 2015-01-09 10:58:43.000000000 +0100 @@ -0,0 +1,13 @@ +prefix=/usr +exec_prefix=${prefix} +libdir=${prefix}/lib +sharedlibdir=${libdir} +includedir=${prefix}/include + +Name: squish +Description: squish DXT lib +Version: 1.1.3-kodi + +Requires: +Libs: -L${libdir} -L${sharedlibdir} -lsquish +Cflags: -I${includedir}