From 642b86aa541aa977143ac5a084550f3390423926 Mon Sep 17 00:00:00 2001
From: David Tardon <dtardon@redhat.com>
Date: Thu, 22 Nov 2012 09:41:19 +0100
Subject: fix 3D 'fade' transitions

* canvas bitmaps created without transparency get an appropriate color
  space
* implement a color space for OpenGL RGBA to use instead of
  canvas::tools::getStdColorSpace(), which apparently uses VCL's
  interpretation of alpha (alpha == 0xff means full transparency,
  alpha == 0 full opacity).

Change-Id: I97f30533206b75132abd0bb0d290a279f15ae8a9
---
 .../OGLTrans/unx/OGLTrans_TransitionerImpl.cxx     | 367 ++++++++++++++++++++-
 1 file changed, 365 insertions(+), 2 deletions(-)

(limited to 'slideshow')

diff --git a/slideshow/source/engine/OGLTrans/unx/OGLTrans_TransitionerImpl.cxx b/slideshow/source/engine/OGLTrans/unx/OGLTrans_TransitionerImpl.cxx
index 67db2632c10c..03e7c4c26407 100644
--- a/slideshow/source/engine/OGLTrans/unx/OGLTrans_TransitionerImpl.cxx
+++ b/slideshow/source/engine/OGLTrans/unx/OGLTrans_TransitionerImpl.cxx
@@ -33,6 +33,8 @@
 #include <com/sun/star/rendering/IntegerBitmapLayout.hpp>
 #include <com/sun/star/rendering/ColorComponentTag.hpp>
 #include <com/sun/star/rendering/ColorSpaceType.hpp>
+#include <com/sun/star/rendering/RenderingIntent.hpp>
+#include <com/sun/star/util/Endianness.hpp>
 #include <com/sun/star/animations/TransitionType.hpp>
 #include <com/sun/star/animations/TransitionSubType.hpp>
 #include <com/sun/star/presentation/XTransitionFactory.hpp>
@@ -50,7 +52,11 @@
 #include <comphelper/servicedecl.hxx>
 
 #include <canvas/canvastools.hxx>
+
+#include <tools/diagnose_ex.h>
 #include <tools/gen.hxx>
+
+#include <vcl/canvastools.hxx>
 #include <vcl/window.hxx>
 #include <vcl/syschild.hxx>
 
@@ -915,6 +921,360 @@ void OGLTransitionerImpl::createTexture( unsigned int* texID,
     SAL_WARN_IF(!glIsTexture(*texID), "slideshow.opengl", "Can't generate Leaving slide textures in OpenGL");
 }
 
+namespace
+{
+    class OGLColorSpace : public cppu::WeakImplHelper1< com::sun::star::rendering::XIntegerBitmapColorSpace >
+    {
+    private:
+        uno::Sequence< sal_Int8 >  maComponentTags;
+        uno::Sequence< sal_Int32 > maBitCounts;
+
+        virtual ::sal_Int8 SAL_CALL getType(  ) throw (uno::RuntimeException)
+        {
+            return rendering::ColorSpaceType::RGB;
+        }
+        virtual uno::Sequence< ::sal_Int8 > SAL_CALL getComponentTags(  ) throw (uno::RuntimeException)
+        {
+            return maComponentTags;
+        }
+        virtual ::sal_Int8 SAL_CALL getRenderingIntent(  ) throw (uno::RuntimeException)
+        {
+            return rendering::RenderingIntent::PERCEPTUAL;
+        }
+        virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties(  ) throw (uno::RuntimeException)
+        {
+            return uno::Sequence< beans::PropertyValue >();
+        }
+        virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >& deviceColor,
+                                                                    const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
+                                                                                                                                                uno::RuntimeException)
+        {
+            // TODO(P3): if we know anything about target
+            // colorspace, this can be greatly sped up
+            uno::Sequence<rendering::ARGBColor> aIntermediate(
+                convertToARGB(deviceColor));
+            return targetColorSpace->convertFromARGB(aIntermediate);
+        }
+        virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const double*  pIn( deviceColor.getConstArray() );
+            const sal_Size nLen( deviceColor.getLength() );
+            ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                    "number of channels no multiple of 4",
+                                    static_cast<rendering::XColorSpace*>(this), 0);
+
+            uno::Sequence< rendering::RGBColor > aRes(nLen/4);
+            rendering::RGBColor* pOut( aRes.getArray() );
+            for( sal_Size i=0; i<nLen; i+=4 )
+            {
+                *pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]);
+                pIn += 4;
+            }
+            return aRes;
+        }
+        virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const double*  pIn( deviceColor.getConstArray() );
+            const sal_Size nLen( deviceColor.getLength() );
+            ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                    "number of channels no multiple of 4",
+                                    static_cast<rendering::XColorSpace*>(this), 0);
+
+            uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
+            rendering::ARGBColor* pOut( aRes.getArray() );
+            for( sal_Size i=0; i<nLen; i+=4 )
+            {
+                *pOut++ = rendering::ARGBColor(pIn[3],pIn[0],pIn[1],pIn[2]);
+                pIn += 4;
+            }
+            return aRes;
+        }
+        virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const double*  pIn( deviceColor.getConstArray() );
+            const sal_Size nLen( deviceColor.getLength() );
+            ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                    "number of channels no multiple of 4",
+                                    static_cast<rendering::XColorSpace*>(this), 0);
+
+            uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
+            rendering::ARGBColor* pOut( aRes.getArray() );
+            for( sal_Size i=0; i<nLen; i+=4 )
+            {
+                *pOut++ = rendering::ARGBColor(pIn[3],pIn[3]*pIn[0],pIn[3]*pIn[1],pIn[3]*pIn[2]);
+                pIn += 4;
+            }
+            return aRes;
+        }
+        virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const rendering::RGBColor* pIn( rgbColor.getConstArray() );
+            const sal_Size             nLen( rgbColor.getLength() );
+
+            uno::Sequence< double > aRes(nLen*4);
+            double* pColors=aRes.getArray();
+            for( sal_Size i=0; i<nLen; ++i )
+            {
+                *pColors++ = pIn->Red;
+                *pColors++ = pIn->Green;
+                *pColors++ = pIn->Blue;
+                *pColors++ = 1.0;
+                ++pIn;
+            }
+            return aRes;
+        }
+        virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
+            const sal_Size              nLen( rgbColor.getLength() );
+
+            uno::Sequence< double > aRes(nLen*4);
+            double* pColors=aRes.getArray();
+            for( sal_Size i=0; i<nLen; ++i )
+            {
+                *pColors++ = pIn->Red;
+                *pColors++ = pIn->Green;
+                *pColors++ = pIn->Blue;
+                *pColors++ = pIn->Alpha;
+                ++pIn;
+            }
+            return aRes;
+        }
+        virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
+            const sal_Size              nLen( rgbColor.getLength() );
+
+            uno::Sequence< double > aRes(nLen*4);
+            double* pColors=aRes.getArray();
+            for( sal_Size i=0; i<nLen; ++i )
+            {
+                *pColors++ = pIn->Red/pIn->Alpha;
+                *pColors++ = pIn->Green/pIn->Alpha;
+                *pColors++ = pIn->Blue/pIn->Alpha;
+                *pColors++ = pIn->Alpha;
+                ++pIn;
+            }
+            return aRes;
+        }
+
+        // XIntegerBitmapColorSpace
+        virtual ::sal_Int32 SAL_CALL getBitsPerPixel(  ) throw (uno::RuntimeException)
+        {
+            return 32;
+        }
+        virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts(  ) throw (uno::RuntimeException)
+        {
+            return maBitCounts;
+        }
+        virtual ::sal_Int8 SAL_CALL getEndianness(  ) throw (uno::RuntimeException)
+        {
+            return util::Endianness::LITTLE;
+        }
+        virtual uno::Sequence<double> SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
+                                                                                const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
+                                                                                                                                                        uno::RuntimeException)
+        {
+            if( dynamic_cast<OGLColorSpace*>(targetColorSpace.get()) )
+            {
+                const sal_Int8* pIn( deviceColor.getConstArray() );
+                const sal_Size  nLen( deviceColor.getLength() );
+                ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                        "number of channels no multiple of 4",
+                                        static_cast<rendering::XColorSpace*>(this), 0);
+
+                uno::Sequence<double> aRes(nLen);
+                double* pOut( aRes.getArray() );
+                for( sal_Size i=0; i<nLen; i+=4 )
+                {
+                    *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
+                    *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
+                    *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
+                    *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
+                }
+                return aRes;
+            }
+            else
+            {
+                // TODO(P3): if we know anything about target
+                // colorspace, this can be greatly sped up
+                uno::Sequence<rendering::ARGBColor> aIntermediate(
+                    convertIntegerToARGB(deviceColor));
+                return targetColorSpace->convertFromARGB(aIntermediate);
+            }
+        }
+        virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
+                                                                                    const uno::Reference< rendering::XIntegerBitmapColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
+                                                                                                                                                                        uno::RuntimeException)
+        {
+            if( dynamic_cast<OGLColorSpace*>(targetColorSpace.get()) )
+            {
+                // it's us, so simply pass-through the data
+                return deviceColor;
+            }
+            else
+            {
+                // TODO(P3): if we know anything about target
+                // colorspace, this can be greatly sped up
+                uno::Sequence<rendering::ARGBColor> aIntermediate(
+                    convertIntegerToARGB(deviceColor));
+                return targetColorSpace->convertIntegerFromARGB(aIntermediate);
+            }
+        }
+        virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const sal_Int8* pIn( deviceColor.getConstArray() );
+            const sal_Size  nLen( deviceColor.getLength() );
+            ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                    "number of channels no multiple of 4",
+                                    static_cast<rendering::XColorSpace*>(this), 0);
+
+            uno::Sequence< rendering::RGBColor > aRes(nLen/4);
+            rendering::RGBColor* pOut( aRes.getArray() );
+            for( sal_Size i=0; i<nLen; i+=4 )
+            {
+                *pOut++ = rendering::RGBColor(
+                    vcl::unotools::toDoubleColor(pIn[0]),
+                    vcl::unotools::toDoubleColor(pIn[1]),
+                    vcl::unotools::toDoubleColor(pIn[2]));
+                pIn += 4;
+            }
+            return aRes;
+        }
+
+        virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const sal_Int8* pIn( deviceColor.getConstArray() );
+            const sal_Size  nLen( deviceColor.getLength() );
+            ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                    "number of channels no multiple of 4",
+                                    static_cast<rendering::XColorSpace*>(this), 0);
+
+            uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
+            rendering::ARGBColor* pOut( aRes.getArray() );
+            for( sal_Size i=0; i<nLen; i+=4 )
+            {
+                *pOut++ = rendering::ARGBColor(
+                    vcl::unotools::toDoubleColor(pIn[3]),
+                    vcl::unotools::toDoubleColor(pIn[0]),
+                    vcl::unotools::toDoubleColor(pIn[1]),
+                    vcl::unotools::toDoubleColor(pIn[2]));
+                pIn += 4;
+            }
+            return aRes;
+        }
+
+        virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const sal_Int8* pIn( deviceColor.getConstArray() );
+            const sal_Size  nLen( deviceColor.getLength() );
+            ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                    "number of channels no multiple of 4",
+                                    static_cast<rendering::XColorSpace*>(this), 0);
+
+            uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
+            rendering::ARGBColor* pOut( aRes.getArray() );
+            for( sal_Size i=0; i<nLen; i+=4 )
+            {
+                const sal_Int8 nAlpha( pIn[3] );
+                *pOut++ = rendering::ARGBColor(
+                    vcl::unotools::toDoubleColor(nAlpha),
+                    vcl::unotools::toDoubleColor(nAlpha*pIn[0]),
+                    vcl::unotools::toDoubleColor(nAlpha*pIn[1]),
+                    vcl::unotools::toDoubleColor(nAlpha*pIn[2]));
+                pIn += 4;
+            }
+            return aRes;
+        }
+
+        virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const rendering::RGBColor* pIn( rgbColor.getConstArray() );
+            const sal_Size             nLen( rgbColor.getLength() );
+
+            uno::Sequence< sal_Int8 > aRes(nLen*4);
+            sal_Int8* pColors=aRes.getArray();
+            for( sal_Size i=0; i<nLen; ++i )
+            {
+                *pColors++ = vcl::unotools::toByteColor(pIn->Red);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Green);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
+                *pColors++ = 255;
+                ++pIn;
+            }
+            return aRes;
+        }
+
+        virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
+            const sal_Size              nLen( rgbColor.getLength() );
+
+            uno::Sequence< sal_Int8 > aRes(nLen*4);
+            sal_Int8* pColors=aRes.getArray();
+            for( sal_Size i=0; i<nLen; ++i )
+            {
+                *pColors++ = vcl::unotools::toByteColor(pIn->Red);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Green);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Alpha);
+                ++pIn;
+            }
+            return aRes;
+        }
+
+        virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+        {
+            const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
+            const sal_Size              nLen( rgbColor.getLength() );
+
+            uno::Sequence< sal_Int8 > aRes(nLen*4);
+            sal_Int8* pColors=aRes.getArray();
+            for( sal_Size i=0; i<nLen; ++i )
+            {
+                *pColors++ = vcl::unotools::toByteColor(pIn->Red/pIn->Alpha);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Green/pIn->Alpha);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Blue/pIn->Alpha);
+                *pColors++ = vcl::unotools::toByteColor(pIn->Alpha);
+                ++pIn;
+            }
+            return aRes;
+        }
+
+    public:
+        OGLColorSpace() :
+            maComponentTags(4),
+            maBitCounts(4)
+        {
+            sal_Int8*  pTags = maComponentTags.getArray();
+            sal_Int32* pBitCounts = maBitCounts.getArray();
+            pTags[0] = rendering::ColorComponentTag::RGB_RED;
+            pTags[1] = rendering::ColorComponentTag::RGB_GREEN;
+            pTags[2] = rendering::ColorComponentTag::RGB_BLUE;
+            pTags[3] = rendering::ColorComponentTag::ALPHA;
+
+            pBitCounts[0] =
+            pBitCounts[1] =
+            pBitCounts[2] =
+            pBitCounts[3] = 8;
+        }
+    };
+
+    struct OGLColorSpaceHolder : public rtl::StaticWithInit<uno::Reference<rendering::XIntegerBitmapColorSpace>, OGLColorSpaceHolder>
+    {
+        uno::Reference<rendering::XIntegerBitmapColorSpace> operator()()
+        {
+            return new OGLColorSpace();
+        }
+    };
+
+    uno::Reference<rendering::XIntegerBitmapColorSpace>
+    getOGLColorSpace()
+    {
+        return OGLColorSpaceHolder::get();
+    }
+}
+
 void OGLTransitionerImpl::impl_createTexture(
                      bool useMipmap,
                      uno::Sequence<sal_Int8>& data,
@@ -926,7 +1286,7 @@ void OGLTransitionerImpl::impl_createTexture(
         uno::Sequence<sal_Int8> tempBytes(
             SlideBitmapLayout.ColorSpace->convertToIntegerColorSpace(
                 data,
-                canvas::tools::getStdColorSpace()));
+                getOGLColorSpace()));
         gluBuild2DMipmaps(GL_TEXTURE_2D,
                           4,
                           SlideSize.Width,
@@ -1085,7 +1445,10 @@ const OGLFormat* OGLTransitionerImpl::chooseFormats()
                     }
                     break;
                 case 32:
-                    pDetectedFormat = &lcl_ARGB32[nComponentOrderIndex];
+                    if ( nNumComponents == 4 )
+                    {
+                        pDetectedFormat = &lcl_ARGB32[nComponentOrderIndex];
+                    }
                     break;
             }
         }
-- 
cgit