summaryrefslogtreecommitdiffstats
path: root/opensuse/core/qt3/0007-qpixmap_constants.patch
diff options
context:
space:
mode:
Diffstat (limited to 'opensuse/core/qt3/0007-qpixmap_constants.patch')
-rw-r--r--opensuse/core/qt3/0007-qpixmap_constants.patch384
1 files changed, 384 insertions, 0 deletions
diff --git a/opensuse/core/qt3/0007-qpixmap_constants.patch b/opensuse/core/qt3/0007-qpixmap_constants.patch
new file mode 100644
index 000000000..65f9cd64b
--- /dev/null
+++ b/opensuse/core/qt3/0007-qpixmap_constants.patch
@@ -0,0 +1,384 @@
+qt-bugs@ issue : 11790 (part of)
+applied: no
+author: Lubos Lunak <[email protected]>
+
+See 0005-qpixmap_mitshm.patch for details.
+
+
+--- src/kernel/qpixmap_x11.cpp
++++ src/kernel/qpixmap_x11.cpp
+@@ -1123,9 +1123,6 @@ bool QPixmap::convertFromImage( const QI
+ return FALSE;
+ int bppc = xi->bits_per_pixel;
+
+- if ( bppc > 8 && xi->byte_order == LSBFirst )
+- bppc++;
+-
+ bool contig_bits = n_bits(red_mask) == rbits &&
+ n_bits(green_mask) == gbits &&
+ n_bits(blue_mask) == bbits;
+@@ -1174,32 +1171,70 @@ bool QPixmap::convertFromImage( const QI
+ }
+ init=TRUE;
+ }
++
++ enum { BPP8,
++ BPP16_8_3_M3, BPP16_7_2_M3, BPP16_MSB, BPP16_LSB,
++ BPP24_MSB, BPP24_LSB,
++ BPP32_16_8_0, BPP32_MSB, BPP32_LSB
++ } mode = BPP8;
+
+- for ( uint y=0; y<h; y++ ) {
+- uchar* src = image.scanLine( y );
+- uchar* dst = newbits + xi->bytes_per_line*y;
+- QRgb* p = (QRgb *)src;
++ if ( bppc > 8 && xi->byte_order == LSBFirst )
++ bppc++;
+
+-#define GET_RGB \
+- int r = qRed ( *p ); \
+- int g = qGreen( *p ); \
+- int b = qBlue ( *p++ ); \
+- r = red_shift > 0 \
+- ? r << red_shift : r >> -red_shift; \
+- g = green_shift > 0 \
+- ? g << green_shift : g >> -green_shift; \
+- b = blue_shift > 0 \
+- ? b << blue_shift : b >> -blue_shift;
++ int wordsize;
++ bool bigendian;
++ qSysInfo( &wordsize, &bigendian );
++ bool same_msb_lsb = ( xi->byte_order == MSBFirst ) == ( bigendian );
++
++ if( bppc == 8 ) // 8 bit
++ mode = BPP8;
++ else if( bppc == 16 || bppc == 17 ) { // 16 bit MSB/LSB
++ if( red_shift == 8 && green_shift == 3 && blue_shift == -3
++ && !d8 && same_msb_lsb )
++ mode = BPP16_8_3_M3;
++ else if( red_shift == 7 && green_shift == 2 && blue_shift == -3
++ && !d8 && same_msb_lsb )
++ mode = BPP16_7_2_M3;
++ else
++ mode = bppc == 17 ? BPP16_LSB : BPP16_MSB;
++ } else if( bppc == 24 || bppc == 25 ) { // 24 bit MSB/LSB
++ mode = bppc == 25 ? BPP24_LSB : BPP24_MSB;
++ } else if( bppc == 32 || bppc == 33 ) { // 32 bit MSB/LSB
++ if( red_shift == 16 && green_shift == 8 && blue_shift == 0
++ && !d8 && same_msb_lsb )
++ mode = BPP32_16_8_0;
++ else
++ mode = bppc == 33 ? BPP32_LSB : BPP32_MSB;
++ } else
++ qFatal("Logic error 3");
+
+ #define GET_PIXEL \
+ int pixel; \
+ if ( d8 ) pixel = pix[*src++]; \
+ else { \
+- GET_RGB \
+- pixel = (b & blue_mask)|(g & green_mask) | (r & red_mask) \
++ int r = qRed ( *p ); \
++ int g = qGreen( *p ); \
++ int b = qBlue ( *p++ ); \
++ r = red_shift > 0 \
++ ? r << red_shift : r >> -red_shift; \
++ g = green_shift > 0 \
++ ? g << green_shift : g >> -green_shift; \
++ b = blue_shift > 0 \
++ ? b << blue_shift : b >> -blue_shift; \
++ pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask) \
+ | ~(blue_mask | green_mask | red_mask); \
+ }
+
++// optimized case - no d8 case, shift only once instead of twice, mask only once instead of twice,
++// use direct values instead of variables, and use only one statement
++// (*p >> 16), (*p >> 8 ) and (*p) are qRed(),qGreen() and qBlue() without masking
++// shifts have to be passed including the shift operator (e.g. '>>3'), because of the direction
++#define GET_PIXEL_OPT(red_shift,green_shift,blue_shift,red_mask,green_mask,blue_mask) \
++ int pixel = ((( *p >> 16 ) red_shift ) & red_mask ) \
++ | ((( *p >> 8 ) green_shift ) & green_mask ) \
++ | ((( *p ) blue_shift ) & blue_mask ); \
++ ++p;
++
+ #define GET_PIXEL_DITHER_TC \
+ int r = qRed ( *p ); \
+ int g = qGreen( *p ); \
+@@ -1220,91 +1255,177 @@ bool QPixmap::convertFromImage( const QI
+ ? g << green_shift : g >> -green_shift; \
+ b = blue_shift > 0 \
+ ? b << blue_shift : b >> -blue_shift; \
+- int pixel = (b & blue_mask)|(g & green_mask) | (r & red_mask);
++ int pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask);
+
+- if ( dither_tc ) {
+- uint x;
+- switch ( bppc ) {
+- case 16: // 16 bit MSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL_DITHER_TC
+- *dst++ = (pixel >> 8);
+- *dst++ = pixel;
+- }
++// again, optimized case
++// can't be optimized that much :(
++#define GET_PIXEL_DITHER_TC_OPT(red_shift,green_shift,blue_shift,red_mask,green_mask,blue_mask, \
++ rbits,gbits,bbits) \
++ const int thres = D[x%16][y%16]; \
++ int r = qRed ( *p ); \
++ if ( r <= (255-(1<<(8-rbits))) && ((r<<rbits) & 255) \
++ > thres) \
++ r += (1<<(8-rbits)); \
++ int g = qGreen( *p ); \
++ if ( g <= (255-(1<<(8-gbits))) && ((g<<gbits) & 255) \
++ > thres) \
++ g += (1<<(8-gbits)); \
++ int b = qBlue ( *p++ ); \
++ if ( b <= (255-(1<<(8-bbits))) && ((b<<bbits) & 255) \
++ > thres) \
++ b += (1<<(8-bbits)); \
++ int pixel = (( r red_shift ) & red_mask ) \
++ | (( g green_shift ) & green_mask ) \
++ | (( b blue_shift ) & blue_mask );
++
++#define CYCLE(body) \
++ for ( uint y=0; y<h; y++ ) { \
++ uchar* src = image.scanLine( y ); \
++ uchar* dst = newbits + xi->bytes_per_line*y; \
++ QRgb* p = (QRgb *)src; \
++ body \
++ }
++
++ if ( dither_tc ) {
++ switch ( mode ) {
++ case BPP16_8_3_M3:
++ CYCLE(
++ Q_INT16* dst16 = (Q_INT16*)dst;
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL_DITHER_TC_OPT(<<8,<<3,>>3,0xf800,0x7e0,0x1f,5,6,5)
++ *dst16++ = pixel;
++ }
++ )
+ break;
+- case 17: // 16 bit LSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL_DITHER_TC
+- *dst++ = pixel;
+- *dst++ = pixel >> 8;
+- }
++ case BPP16_7_2_M3:
++ CYCLE(
++ Q_INT16* dst16 = (Q_INT16*)dst;
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL_DITHER_TC_OPT(<<7,<<2,>>3,0x7c00,0x3e0,0x1f,5,5,5)
++ *dst16++ = pixel;
++ }
++ )
++ break;
++ case BPP16_MSB: // 16 bit MSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL_DITHER_TC
++ *dst++ = (pixel >> 8);
++ *dst++ = pixel;
++ }
++ )
++ break;
++ case BPP16_LSB: // 16 bit LSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL_DITHER_TC
++ *dst++ = pixel;
++ *dst++ = pixel >> 8;
++ }
++ )
+ break;
+ default:
+ qFatal("Logic error");
+ }
+- } else {
+- uint x;
+- switch ( bppc ) {
+- case 8: // 8 bit
+- for ( x=0; x<w; x++ ) {
+- int pixel = pix[*src++];
+- *dst++ = pixel;
+- }
++ } else {
++ switch ( mode ) {
++ case BPP8: // 8 bit
++ CYCLE(
++ Q_UNUSED(p);
++ for ( uint x=0; x<w; x++ ) {
++ int pixel = pix[*src++];
++ *dst++ = pixel;
++ }
++ )
+ break;
+- case 16: // 16 bit MSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL
+- *dst++ = (pixel >> 8);
+- *dst++ = pixel;
+- }
++ case BPP16_8_3_M3:
++ CYCLE(
++ Q_INT16* dst16 = (Q_INT16*)dst;
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL_OPT(<<8,<<3,>>3,0xf800,0x7e0,0x1f)
++ *dst16++ = pixel;
++ }
++ )
+ break;
+- case 17: // 16 bit LSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL
+- *dst++ = pixel;
+- *dst++ = pixel >> 8;
+- }
++ case BPP16_7_2_M3:
++ CYCLE(
++ Q_INT16* dst16 = (Q_INT16*)dst;
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL_OPT(<<7,<<2,>>3,0x7c00,0x3e0,0x1f)
++ *dst16++ = pixel;
++ }
++ )
+ break;
+- case 24: // 24 bit MSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL
+- *dst++ = pixel >> 16;
+- *dst++ = pixel >> 8;
+- *dst++ = pixel;
+- }
++ case BPP16_MSB: // 16 bit MSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL
++ *dst++ = (pixel >> 8);
++ *dst++ = pixel;
++ }
++ )
+ break;
+- case 25: // 24 bit LSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL
+- *dst++ = pixel;
+- *dst++ = pixel >> 8;
+- *dst++ = pixel >> 16;
+- }
++ case BPP16_LSB: // 16 bit LSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL
++ *dst++ = pixel;
++ *dst++ = pixel >> 8;
++ }
++ )
+ break;
+- case 32: // 32 bit MSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL
+- *dst++ = pixel >> 24;
+- *dst++ = pixel >> 16;
+- *dst++ = pixel >> 8;
+- *dst++ = pixel;
+- }
++ case BPP24_MSB: // 24 bit MSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL
++ *dst++ = pixel >> 16;
++ *dst++ = pixel >> 8;
++ *dst++ = pixel;
++ }
++ )
+ break;
+- case 33: // 32 bit LSB
+- for ( x=0; x<w; x++ ) {
+- GET_PIXEL
+- *dst++ = pixel;
+- *dst++ = pixel >> 8;
+- *dst++ = pixel >> 16;
+- *dst++ = pixel >> 24;
+- }
++ case BPP24_LSB: // 24 bit LSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL
++ *dst++ = pixel;
++ *dst++ = pixel >> 8;
++ *dst++ = pixel >> 16;
++ }
++ )
+ break;
+- default:
+- qFatal("Logic error 2");
+- }
+- }
+- }
+- xi->data = (char *)newbits;
++ case BPP32_16_8_0:
++ CYCLE(
++ memcpy( dst, p, w * 4 );
++ )
++ break;
++ case BPP32_MSB: // 32 bit MSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL
++ *dst++ = pixel >> 24;
++ *dst++ = pixel >> 16;
++ *dst++ = pixel >> 8;
++ *dst++ = pixel;
++ }
++ )
++ break;
++ case BPP32_LSB: // 32 bit LSB
++ CYCLE(
++ for ( uint x=0; x<w; x++ ) {
++ GET_PIXEL
++ *dst++ = pixel;
++ *dst++ = pixel >> 8;
++ *dst++ = pixel >> 16;
++ *dst++ = pixel >> 24;
++ }
++ )
++ break;
++ default:
++ qFatal("Logic error 2");
++ }
++ }
++ xi->data = (char *)newbits;
+ }
+
+ if ( d == 8 && !trucol ) { // 8 bit pixmap
+@@ -1554,15 +1675,24 @@ bool QPixmap::convertFromImage( const QI
+
+ if (image.depth() == 32) {
+ const int *iptr = (const int *) image.bits();
+- int max = w * h;
+- while (max--)
+- *aptr++ = *iptr++ >> 24; // squirt
++ if( axi->bytes_per_line == (int)w ) {
++ int max = w * h;
++ while (max--)
++ *aptr++ = *iptr++ >> 24; // squirt
++ } else {
++ for (uint i = 0; i < h; ++i ) {
++ for (uint j = 0; j < w; ++j )
++ *aptr++ = *iptr++ >> 24; // squirt
++ aptr += ( axi->bytes_per_line - w );
++ }
++ }
+ } else if (image.depth() == 8) {
+ const QRgb * const rgb = image.colorTable();
+ for (uint y = 0; y < h; ++y) {
+ const uchar *iptr = image.scanLine(y);
+ for (uint x = 0; x < w; ++x)
+ *aptr++ = qAlpha(rgb[*iptr++]);
++ aptr += ( axi->bytes_per_line - w );
+ }
+ }
+
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-04 21:03:13 +0000