| 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 <bernd.kuhls@t-online.de> |
| |
| 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 <string.h> |
| #include <squish.h> |
| #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} |