/************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * Copyright 2008 by Sun Microsystems, Inc. * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: bitmapdevice.cxx,v $ * $Revision: 1.31 $ * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 3 * only, as published by the Free Software Foundation. * * OpenOffice.org is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License version 3 for more details * (a copy is included in the LICENSE file that accompanied this code). * * You should have received a copy of the GNU Lesser General Public License * version 3 along with OpenOffice.org. If not, see * * for a copy of the LGPLv3 License. * ************************************************************************/ #include "basebmp/bitmapdevice.hxx" #include "basebmp/compositeiterator.hxx" #include "basebmp/iteratortraits.hxx" #include "basebmp/accessor.hxx" #include "basebmp/accessortraits.hxx" #include "basebmp/accessoradapters.hxx" #include "basebmp/colorblendaccessoradapter.hxx" #include "basebmp/color.hxx" #include "basebmp/colormisc.hxx" #include "basebmp/colortraits.hxx" #include "basebmp/greylevelformats.hxx" #include "basebmp/paletteformats.hxx" #include "basebmp/rgbmaskpixelformats.hxx" #include "basebmp/rgb24pixelformats.hxx" #include "basebmp/scanlineformats.hxx" #include "basebmp/fillimage.hxx" #include "basebmp/scaleimage.hxx" #include "basebmp/clippedlinerenderer.hxx" #include "basebmp/polypolygonrenderer.hxx" #include "basebmp/genericcolorimageaccessor.hxx" #include "basebmp/tools.hxx" #include "intconversion.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace vigra { /// componentwise xor of an RGBValue (missing from rgbvalue.hxx) template< class Value, unsigned int RedIndex, unsigned int BlueIndex, unsigned int GreenIndex > inline RGBValue operator^( RGBValue const& lhs, RGBValue const& rhs ) { RGBValue res( lhs[0] ^ rhs[0], lhs[1] ^ rhs[1], lhs[2] ^ rhs[2]); return res; } } namespace basebmp { namespace { /** Create the type for an accessor that takes the (mask,bitmap) input value generated from a JoinImageAccessorAdapter, and pipe that through a mask functor. @tpl DestAccessor Destination bitmap accessor @tpl JoinedAccessor Input accessor, is expected to generate a std::pair as the value type @tpl MaskFunctorMode Either FastMask or NoFastMask, depending on whether the mask is guaranteed to contain only 0s and 1s. */ template< class DestAccessor, class JoinedAccessor, bool polarity, typename MaskFunctorMode > struct masked_input_splitting_accessor { typedef BinarySetterFunctionAccessorAdapter< DestAccessor, BinaryFunctorSplittingWrapper< typename outputMaskFunctorSelector< typename JoinedAccessor::value_type::first_type, typename JoinedAccessor::value_type::second_type, polarity, MaskFunctorMode >::type > > type; }; // Actual BitmapDevice implementation (templatized by accessor and iterator) //-------------------------------------------------------------------------- /** Implementation of the BitmapDevice interface @tpl DestIterator Iterator to access bitmap memory @tpl RawAccessor Raw accessor, to access pixel values directly @tpl AccessorSelector Accessor adapter selector, which, when applying the nested template metafunction wrap_accessor to one of the raw bitmap accessors, yields a member type named 'type', which is a wrapped accessor that map color values. @tpl Masks Traits template, containing nested traits clipmask_format_traits and alphamask_format_traits, which determine what specialized formats are to be used for clip and alpha masks. With those mask formats, clipping and alpha blending is handled natively. */ template< class DestIterator, class RawAccessor, class AccessorSelector, class Masks > class BitmapRenderer : public BitmapDevice { public: typedef DestIterator dest_iterator_type; typedef RawAccessor raw_accessor_type; typedef AccessorSelector accessor_selector; typedef typename Masks::clipmask_format_traits::iterator_type mask_iterator_type; typedef typename Masks::clipmask_format_traits::raw_accessor_type mask_rawaccessor_type; typedef typename Masks::clipmask_format_traits::accessor_selector mask_accessorselector_type; typedef typename Masks::alphamask_format_traits::iterator_type alphamask_iterator_type; typedef typename Masks::alphamask_format_traits::raw_accessor_type alphamask_rawaccessor_type; typedef typename Masks::alphamask_format_traits::accessor_selector alphamask_accessorselector_type; typedef typename AccessorSelector::template wrap_accessor< raw_accessor_type >::type dest_accessor_type; typedef AccessorTraits< dest_accessor_type > accessor_traits; typedef CompositeIterator2D< dest_iterator_type, mask_iterator_type > composite_iterator_type; typedef CompositeIterator2D< vigra::Diff2D, vigra::Diff2D > generic_composite_iterator_type; typedef BitmapRenderer mask_bitmap_type; typedef BitmapRenderer alphamask_bitmap_type; // ------------------------------------------------------- typedef AccessorTraits< raw_accessor_type > raw_accessor_traits; typedef typename uInt32Converter< typename raw_accessor_type::value_type>::to to_uint32_functor; // ------------------------------------------------------- typedef typename raw_accessor_traits::xor_accessor raw_xor_accessor_type; typedef AccessorTraits raw_xor_accessor_traits; typedef typename accessor_selector::template wrap_accessor< raw_xor_accessor_type >::type xor_accessor_type; typedef AccessorTraits xor_accessor_traits; // ------------------------------------------------------- typedef typename raw_accessor_traits::template masked_accessor< mask_rawaccessor_type, dest_iterator_type, mask_iterator_type, Masks::clipmask_polarity>::type raw_maskedaccessor_type; typedef typename accessor_selector::template wrap_accessor< raw_maskedaccessor_type >::type masked_accessor_type; typedef typename AccessorTraits< raw_maskedaccessor_type>::xor_accessor raw_maskedxor_accessor_type; typedef typename accessor_selector::template wrap_accessor< raw_maskedxor_accessor_type >::type masked_xoraccessor_type; // ------------------------------------------------------- // ((iter,mask),mask) special case (e.g. for clipped // drawMaskedColor()) typedef AccessorTraits< raw_maskedaccessor_type > raw_maskedaccessor_traits; typedef typename raw_maskedaccessor_traits::template masked_accessor< mask_rawaccessor_type, composite_iterator_type, mask_iterator_type, Masks::clipmask_polarity>::type raw_maskedmask_accessor_type; typedef CompositeIterator2D< composite_iterator_type, mask_iterator_type> composite_composite_mask_iterator_type; // ------------------------------------------------------- typedef ConstantColorBlendSetterAccessorAdapter< dest_accessor_type, typename alphamask_rawaccessor_type::value_type, Masks::alphamask_polarity> colorblend_accessor_type; typedef AccessorTraits colorblend_accessor_traits; typedef typename colorblend_accessor_traits::template masked_accessor< mask_rawaccessor_type, dest_iterator_type, mask_iterator_type, Masks::clipmask_polarity>::type masked_colorblend_accessor_type; // ------------------------------------------------------- typedef ConstantColorBlendSetterAccessorAdapter< dest_accessor_type, Color, Masks::alphamask_polarity> colorblend_generic_accessor_type; typedef AccessorTraits colorblend_generic_accessor_traits; typedef typename colorblend_generic_accessor_traits::template masked_accessor< mask_rawaccessor_type, dest_iterator_type, mask_iterator_type, Masks::clipmask_polarity>::type masked_colorblend_generic_accessor_type; // ------------------------------------------------------- typedef JoinImageAccessorAdapter< dest_accessor_type, mask_rawaccessor_type > joined_image_accessor_type; typedef JoinImageAccessorAdapter< GenericColorImageAccessor, GenericColorImageAccessor > joined_generic_image_accessor_type; // ------------------------------------------------------- dest_iterator_type maBegin; typename accessor_traits::color_lookup maColorLookup; to_uint32_functor maToUInt32Converter; dest_accessor_type maAccessor; colorblend_accessor_type maColorBlendAccessor; colorblend_generic_accessor_type maGenericColorBlendAccessor; raw_accessor_type maRawAccessor; xor_accessor_type maXorAccessor; raw_xor_accessor_type maRawXorAccessor; masked_accessor_type maMaskedAccessor; masked_colorblend_accessor_type maMaskedColorBlendAccessor; masked_colorblend_generic_accessor_type maGenericMaskedColorBlendAccessor; masked_xoraccessor_type maMaskedXorAccessor; raw_maskedaccessor_type maRawMaskedAccessor; raw_maskedxor_accessor_type maRawMaskedXorAccessor; raw_maskedmask_accessor_type maRawMaskedMaskAccessor; // ------------------------------------------------------- BitmapRenderer( const basegfx::B2IRange& rBounds, sal_Int32 nScanlineFormat, sal_Int32 nScanlineStride, sal_uInt8* pFirstScanline, dest_iterator_type begin, raw_accessor_type rawAccessor, dest_accessor_type accessor, const RawMemorySharedArray& rMem, const PaletteMemorySharedVector& rPalette ) : BitmapDevice( rBounds, nScanlineFormat, nScanlineStride, pFirstScanline, rMem, rPalette ), maBegin( begin ), maColorLookup(), maToUInt32Converter(), maAccessor( accessor ), maColorBlendAccessor( accessor ), maGenericColorBlendAccessor( accessor ), maRawAccessor( rawAccessor ), maXorAccessor( accessor ), maRawXorAccessor( rawAccessor ), maMaskedAccessor( accessor ), maMaskedColorBlendAccessor( maColorBlendAccessor ), maGenericMaskedColorBlendAccessor( maGenericColorBlendAccessor ), maMaskedXorAccessor( accessor ), maRawMaskedAccessor( rawAccessor ), maRawMaskedXorAccessor( rawAccessor ), maRawMaskedMaskAccessor( rawAccessor ) {} private: boost::shared_ptr getCompatibleBitmap( const BitmapDeviceSharedPtr& bmp ) const { return boost::dynamic_pointer_cast< BitmapRenderer >( bmp ); } virtual bool isCompatibleBitmap( const BitmapDeviceSharedPtr& bmp ) const { // TODO(P1): dynamic_cast usually called twice for // compatible formats return getCompatibleBitmap(bmp).get() != NULL; } boost::shared_ptr getCompatibleClipMask( const BitmapDeviceSharedPtr& bmp ) const { boost::shared_ptr pMask( boost::dynamic_pointer_cast( bmp )); if( !pMask ) return pMask; if( pMask->getSize() != getSize() ) pMask.reset(); return pMask; } virtual bool isCompatibleClipMask( const BitmapDeviceSharedPtr& bmp ) const { // TODO(P1): dynamic_cast usually called twice for // compatible formats return boost::dynamic_pointer_cast( bmp ).get() != NULL; } boost::shared_ptr getCompatibleAlphaMask( const BitmapDeviceSharedPtr& bmp ) const { return boost::dynamic_pointer_cast( bmp ); } virtual bool isCompatibleAlphaMask( const BitmapDeviceSharedPtr& bmp ) const { // TODO(P1): dynamic_cast usually called twice for // compatible formats return getCompatibleAlphaMask( bmp ).get() != NULL; } virtual void clear_i( Color fillColor, const basegfx::B2IRange& rBounds ) { fillImage(destIterRange(maBegin, maRawAccessor, rBounds), maColorLookup( maAccessor, fillColor) ); } virtual void setPixel_i( const basegfx::B2IPoint& rPt, Color pixelColor, DrawMode drawMode ) { const DestIterator pixel( maBegin + vigra::Diff2D(rPt.getX(), rPt.getY()) ); if( drawMode == DrawMode_XOR ) maXorAccessor.set( pixelColor, pixel ); else maAccessor.set( pixelColor, pixel ); } virtual void setPixel_i( const basegfx::B2IPoint& rPt, Color pixelColor, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { boost::shared_ptr pMask( getCompatibleClipMask(rClip) ); OSL_ASSERT( pMask ); const vigra::Diff2D offset(rPt.getX(), rPt.getY()); const composite_iterator_type aIter( maBegin + offset, pMask->maBegin + offset ); if( drawMode == DrawMode_XOR ) maMaskedXorAccessor.set( pixelColor, aIter ); else maMaskedAccessor.set( pixelColor, aIter ); } virtual Color getPixel_i(const basegfx::B2IPoint& rPt ) { const DestIterator pixel( maBegin + vigra::Diff2D(rPt.getX(), rPt.getY()) ); return maAccessor(pixel); } virtual sal_uInt32 getPixelData_i( const basegfx::B2IPoint& rPt ) { const DestIterator pixel( maBegin + vigra::Diff2D(rPt.getX(), rPt.getY()) ); return maToUInt32Converter(maRawAccessor(pixel)); } template< typename Iterator, typename Col, typename RawAcc > void implRenderLine2( const basegfx::B2IPoint& rPt1, const basegfx::B2IPoint& rPt2, const basegfx::B2IRange& rBounds, Col col, const Iterator& begin, const RawAcc& rawAcc ) { renderClippedLine( rPt1, rPt2, rBounds, col, begin, rawAcc ); } template< typename Iterator, typename Accessor, typename RawAcc > void implRenderLine( const basegfx::B2IPoint& rPt1, const basegfx::B2IPoint& rPt2, const basegfx::B2IRange& rBounds, Color col, const Iterator& begin, const Accessor& acc, const RawAcc& rawAcc ) { implRenderLine2( rPt1,rPt2,rBounds, maColorLookup( acc, col ), begin, rawAcc ); } template< typename Iterator, typename RawAcc, typename XorAcc > void implDrawLine( const basegfx::B2IPoint& rPt1, const basegfx::B2IPoint& rPt2, const basegfx::B2IRange& rBounds, Color col, const Iterator& begin, const RawAcc& rawAcc, const XorAcc& xorAcc, DrawMode drawMode ) { if( drawMode == DrawMode_XOR ) implRenderLine( rPt1, rPt2, rBounds, col, begin, maAccessor, xorAcc ); else implRenderLine( rPt1, rPt2, rBounds, col, begin, maAccessor, rawAcc ); } virtual void drawLine_i(const basegfx::B2IPoint& rPt1, const basegfx::B2IPoint& rPt2, const basegfx::B2IRange& rBounds, Color lineColor, DrawMode drawMode ) { implDrawLine(rPt1,rPt2,rBounds,lineColor, maBegin, maRawAccessor,maRawXorAccessor,drawMode); } composite_iterator_type getMaskedIter( const BitmapDeviceSharedPtr& rClip ) const { boost::shared_ptr pMask( getCompatibleClipMask(rClip) ); OSL_ASSERT( pMask ); return composite_iterator_type( maBegin, pMask->maBegin ); } virtual void drawLine_i(const basegfx::B2IPoint& rPt1, const basegfx::B2IPoint& rPt2, const basegfx::B2IRange& rBounds, Color lineColor, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { implDrawLine(rPt1,rPt2,rBounds,lineColor, getMaskedIter(rClip), maRawMaskedAccessor, maRawMaskedXorAccessor,drawMode); } template< typename Iterator, typename RawAcc > void implDrawPolygon( const basegfx::B2DPolygon& rPoly, const basegfx::B2IRange& rBounds, Color col, const Iterator& begin, const RawAcc& acc ) { basegfx::B2DPolygon aPoly( rPoly ); if( rPoly.areControlPointsUsed() ) aPoly = basegfx::tools::adaptiveSubdivideByCount( rPoly ); const typename dest_iterator_type::value_type colorIndex( maColorLookup( maAccessor, col)); const sal_uInt32 nVertices( aPoly.count() ); for( sal_uInt32 i=1; i 1 && aPoly.isClosed() ) implRenderLine2( basegfx::fround(aPoly.getB2DPoint(nVertices-1)), basegfx::fround(aPoly.getB2DPoint(0)), rBounds, colorIndex, begin, acc ); } virtual void drawPolygon_i(const basegfx::B2DPolygon& rPoly, const basegfx::B2IRange& rBounds, Color lineColor, DrawMode drawMode ) { if( drawMode == DrawMode_XOR ) implDrawPolygon( rPoly, rBounds, lineColor, maBegin, maRawXorAccessor ); else implDrawPolygon( rPoly, rBounds, lineColor, maBegin, maRawAccessor ); } virtual void drawPolygon_i(const basegfx::B2DPolygon& rPoly, const basegfx::B2IRange& rBounds, Color lineColor, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( drawMode == DrawMode_XOR ) implDrawPolygon( rPoly, rBounds, lineColor, getMaskedIter(rClip), maRawMaskedXorAccessor ); else implDrawPolygon( rPoly, rBounds, lineColor, getMaskedIter(rClip), maRawMaskedAccessor ); } template< typename Iterator, typename RawAcc > void implFillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly, Color col, const Iterator& begin, const RawAcc& acc, const basegfx::B2IRange& rBounds ) { basegfx::B2DPolyPolygon aPoly( rPoly ); if( rPoly.areControlPointsUsed() ) aPoly = basegfx::tools::adaptiveSubdivideByCount( rPoly ); renderClippedPolyPolygon( begin, acc, maColorLookup( maAccessor, col), rBounds, aPoly ); } virtual void fillPolyPolygon_i(const basegfx::B2DPolyPolygon& rPoly, Color fillColor, DrawMode drawMode, const basegfx::B2IRange& rBounds ) { if( drawMode == DrawMode_XOR ) implFillPolyPolygon( rPoly, fillColor, maBegin, maRawXorAccessor, rBounds ); else implFillPolyPolygon( rPoly, fillColor, maBegin, maRawAccessor, rBounds ); } virtual void fillPolyPolygon_i(const basegfx::B2DPolyPolygon& rPoly, Color fillColor, DrawMode drawMode, const basegfx::B2IRange& rBounds, const BitmapDeviceSharedPtr& rClip ) { if( drawMode == DrawMode_XOR ) implFillPolyPolygon( rPoly, fillColor, getMaskedIter(rClip), maRawMaskedXorAccessor, rBounds ); else implFillPolyPolygon( rPoly, fillColor, getMaskedIter(rClip), maRawMaskedAccessor, rBounds ); } template< typename Iterator, typename RawAcc > void implDrawBitmap(const BitmapDeviceSharedPtr& rSrcBitmap, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, const Iterator& begin, const RawAcc& acc) { boost::shared_ptr pSrcBmp( getCompatibleBitmap(rSrcBitmap) ); OSL_ASSERT( pSrcBmp ); scaleImage( srcIterRange(pSrcBmp->maBegin, pSrcBmp->maRawAccessor, rSrcRect), destIterRange(begin, acc, rDstRect), rSrcBitmap.get() == this ); } template< typename Iterator, typename Acc > void implDrawBitmapGeneric(const BitmapDeviceSharedPtr& rSrcBitmap, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, const Iterator& begin, const Acc& acc) { GenericColorImageAccessor aSrcAcc( rSrcBitmap ); scaleImage( srcIterRange(vigra::Diff2D(), aSrcAcc, rSrcRect), destIterRange(begin, acc, rDstRect)); } virtual void drawBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode ) { if( isCompatibleBitmap( rSrcBitmap ) ) { if( drawMode == DrawMode_XOR ) implDrawBitmap(rSrcBitmap, rSrcRect, rDstRect, maBegin, maRawXorAccessor); else implDrawBitmap(rSrcBitmap, rSrcRect, rDstRect, maBegin, maRawAccessor); } else { if( drawMode == DrawMode_XOR ) implDrawBitmapGeneric(rSrcBitmap, rSrcRect, rDstRect, maBegin, maXorAccessor); else implDrawBitmapGeneric(rSrcBitmap, rSrcRect, rDstRect, maBegin, maAccessor); } } virtual void drawBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( isCompatibleBitmap( rSrcBitmap ) ) { if( drawMode == DrawMode_XOR ) implDrawBitmap(rSrcBitmap, rSrcRect, rDstRect, getMaskedIter(rClip), maRawMaskedXorAccessor); else implDrawBitmap(rSrcBitmap, rSrcRect, rDstRect, getMaskedIter(rClip), maRawMaskedAccessor); } else { if( drawMode == DrawMode_XOR ) implDrawBitmapGeneric(rSrcBitmap, rSrcRect, rDstRect, getMaskedIter(rClip), maMaskedXorAccessor); else implDrawBitmapGeneric(rSrcBitmap, rSrcRect, rDstRect, getMaskedIter(rClip), maMaskedAccessor); } } virtual void drawMaskedColor_i(Color aSrcColor, const BitmapDeviceSharedPtr& rAlphaMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IPoint& rDstPoint ) { boost::shared_ptr pMask( getCompatibleClipMask(rAlphaMask) ); boost::shared_ptr pAlpha( getCompatibleAlphaMask(rAlphaMask) ); if( pAlpha ) { maColorBlendAccessor.setColor( aSrcColor ); vigra::copyImage( srcIterRange(pAlpha->maBegin, pAlpha->maRawAccessor, rSrcRect), destIter(maBegin, maColorBlendAccessor, rDstPoint) ); } else if( pMask ) { const composite_iterator_type aBegin( maBegin + vigra::Diff2D(rDstPoint.getX(), rDstPoint.getY()), pMask->maBegin + topLeft(rSrcRect) ); fillImage(aBegin, aBegin + vigra::Diff2D(rSrcRect.getWidth(), rSrcRect.getHeight()), maRawMaskedAccessor, maColorLookup( maAccessor, aSrcColor) ); } else { GenericColorImageAccessor aSrcAcc( rAlphaMask ); maGenericColorBlendAccessor.setColor( aSrcColor ); vigra::copyImage( srcIterRange(vigra::Diff2D(), aSrcAcc, rSrcRect), destIter(maBegin, maGenericColorBlendAccessor, rDstPoint) ); } } virtual void drawMaskedColor_i(Color aSrcColor, const BitmapDeviceSharedPtr& rAlphaMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IPoint& rDstPoint, const BitmapDeviceSharedPtr& rClip ) { boost::shared_ptr pMask( getCompatibleClipMask(rAlphaMask) ); boost::shared_ptr pAlpha( getCompatibleAlphaMask(rAlphaMask) ); if( pAlpha ) { const composite_iterator_type aBegin( getMaskedIter(rClip) ); maMaskedColorBlendAccessor.get1stWrappedAccessor().setColor( aSrcColor ); vigra::copyImage( srcIterRange(pAlpha->maBegin, pAlpha->maRawAccessor, rSrcRect), destIter(aBegin, maMaskedColorBlendAccessor, rDstPoint) ); } else if( pMask ) { boost::shared_ptr pClipMask( getCompatibleClipMask(rClip) ); OSL_ASSERT( pClipMask ); // setup a ((iter,mask),clipMask) composite composite // iterator, to pass both masks (clip and alpha mask) // to the algorithm const composite_composite_mask_iterator_type aBegin( composite_iterator_type( maBegin + vigra::Diff2D(rDstPoint.getX(), rDstPoint.getY()), pMask->maBegin + topLeft(rSrcRect)), pClipMask->maBegin + vigra::Diff2D(rDstPoint.getX(), rDstPoint.getY()) ); fillImage(aBegin, aBegin + vigra::Diff2D(rSrcRect.getWidth(), rSrcRect.getHeight()), maRawMaskedMaskAccessor, maColorLookup( maAccessor, aSrcColor) ); } else { GenericColorImageAccessor aSrcAcc( rAlphaMask ); const composite_iterator_type aBegin( getMaskedIter(rClip) ); maGenericMaskedColorBlendAccessor.get1stWrappedAccessor().setColor( aSrcColor ); vigra::copyImage( srcIterRange(vigra::Diff2D(), aSrcAcc, rSrcRect), destIter(aBegin, maGenericMaskedColorBlendAccessor, rDstPoint) ); } } template< typename Iterator, typename Acc > void implDrawMaskedBitmap(const BitmapDeviceSharedPtr& rSrcBitmap, const BitmapDeviceSharedPtr& rMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, const Iterator& begin, const Acc& acc) { boost::shared_ptr pSrcBmp( getCompatibleBitmap(rSrcBitmap) ); boost::shared_ptr pMask( getCompatibleClipMask(rMask) ); OSL_ASSERT( pMask && pSrcBmp ); scaleImage( srcIterRange(composite_iterator_type( pSrcBmp->maBegin, pMask->maBegin), joined_image_accessor_type( pSrcBmp->maAccessor, pMask->maRawAccessor), rSrcRect), destIterRange(begin, typename masked_input_splitting_accessor< Acc, joined_image_accessor_type, Masks::clipmask_polarity, FastMask >::type(acc), rDstRect), rSrcBitmap.get() == this); } template< typename Iterator, typename Acc > void implDrawMaskedBitmapGeneric(const BitmapDeviceSharedPtr& rSrcBitmap, const BitmapDeviceSharedPtr& rMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, const Iterator& begin, const Acc& acc) { GenericColorImageAccessor aSrcAcc( rSrcBitmap ); GenericColorImageAccessor aMaskAcc( rMask ); const vigra::Diff2D aTopLeft(rSrcRect.getMinX(), rSrcRect.getMinY()); const vigra::Diff2D aBottomRight(rSrcRect.getMaxX(), rSrcRect.getMaxY()); scaleImage( vigra::make_triple( generic_composite_iterator_type( aTopLeft,aTopLeft), generic_composite_iterator_type( aBottomRight,aBottomRight), joined_generic_image_accessor_type( aSrcAcc, aMaskAcc)), destIterRange(begin, typename masked_input_splitting_accessor< Acc, joined_generic_image_accessor_type, Masks::clipmask_polarity, NoFastMask >::type(acc), rDstRect)); } virtual void drawMaskedBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap, const BitmapDeviceSharedPtr& rMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode ) { if( isCompatibleClipMask(rMask) && isCompatibleBitmap(rSrcBitmap) ) { if( drawMode == DrawMode_XOR ) implDrawMaskedBitmap(rSrcBitmap, rMask, rSrcRect, rDstRect, maBegin, maXorAccessor); else implDrawMaskedBitmap(rSrcBitmap, rMask, rSrcRect, rDstRect, maBegin, maAccessor); } else { if( drawMode == DrawMode_XOR ) implDrawMaskedBitmapGeneric(rSrcBitmap, rMask, rSrcRect, rDstRect, maBegin, maXorAccessor); else implDrawMaskedBitmapGeneric(rSrcBitmap, rMask, rSrcRect, rDstRect, maBegin, maAccessor); } } virtual void drawMaskedBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap, const BitmapDeviceSharedPtr& rMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( isCompatibleClipMask(rMask) && isCompatibleBitmap(rSrcBitmap) ) { if( drawMode == DrawMode_XOR ) implDrawMaskedBitmap(rSrcBitmap, rMask, rSrcRect, rDstRect, getMaskedIter(rClip), maMaskedXorAccessor); else implDrawMaskedBitmap(rSrcBitmap, rMask, rSrcRect, rDstRect, getMaskedIter(rClip), maMaskedAccessor); } else { if( drawMode == DrawMode_XOR ) implDrawMaskedBitmapGeneric(rSrcBitmap, rMask, rSrcRect, rDstRect, getMaskedIter(rClip), maMaskedXorAccessor); else implDrawMaskedBitmapGeneric(rSrcBitmap, rMask, rSrcRect, rDstRect, getMaskedIter(rClip), maMaskedAccessor); } } }; } // namespace struct ImplBitmapDevice { /** Bitmap memory plus deleter. Always points to the start of the mem */ RawMemorySharedArray mpMem; /// Palette memory plus deleter (might be NULL) PaletteMemorySharedVector mpPalette; /** Bounds of the device. maBounds.getWidth()/getHeight() yield the true size of the device (i.e. the rectangle given by maBounds covers the device area under the excluding-bottommost-and-rightmost-pixels fill rule) */ basegfx::B2IRange maBounds; /** Bounds of the device. maBounds.getWidth()/getHeight() yield the true size of the device minus 1 (i.e. the rectangle given by maBounds covers the device area under the including-the-bottommost-and-rightmost-pixels fill rule). The member is used to clip line stroking against the device bounds. */ basegfx::B2IRange maLineClipRect; /// Scanline format, as provided at the constructor sal_Int32 mnScanlineFormat; /// Scanline stride. Negative for bottom-to-top formats sal_Int32 mnScanlineStride; /// raw ptr to 0th scanline. used for cloning a generic renderer sal_uInt8* mpFirstScanline; /** (Optional) device sharing the same memory, and used for input clip masks/alpha masks/bitmaps that don't match our exact bitmap format. This is to avoid the combinatorical explosion when dealing with n bitmap formats, which could be combined with n clip masks, alpha masks and bitmap masks (yielding a total of n^4 combinations). Since each BitmapRenderer is specialized for one specific combination of said formats, a lot of duplicate code would be generated, most of which probably never used. Therefore, only the most common combinations are specialized templates, the remainder gets handled by this generic renderer (via runtime polymorphism). */ BitmapDeviceSharedPtr mpGenericRenderer; }; BitmapDevice::BitmapDevice( const basegfx::B2IRange& rBounds, sal_Int32 nScanlineFormat, sal_Int32 nScanlineStride, sal_uInt8* pFirstScanline, const RawMemorySharedArray& rMem, const PaletteMemorySharedVector& rPalette ) : mpImpl( new ImplBitmapDevice ) { mpImpl->mpMem = rMem; mpImpl->mpPalette = rPalette; mpImpl->maBounds = rBounds; mpImpl->maLineClipRect = basegfx::B2IRange( rBounds.getMinX(), rBounds.getMinY(), rBounds.getMaxX()-1, rBounds.getMaxY()-1 ); mpImpl->mnScanlineFormat = nScanlineFormat; mpImpl->mnScanlineStride = nScanlineStride; mpImpl->mpFirstScanline = pFirstScanline; } BitmapDevice::~BitmapDevice() { // outline, because of internal ImplBitmapDevice } basegfx::B2IVector BitmapDevice::getSize() const { return basegfx::B2IVector( mpImpl->maBounds.getMaxX() - mpImpl->maBounds.getMinX(), mpImpl->maBounds.getMaxY() - mpImpl->maBounds.getMinY() ); } bool BitmapDevice::isTopDown() const { return mpImpl->mnScanlineStride >= 0; } sal_Int32 BitmapDevice::getScanlineFormat() const { return mpImpl->mnScanlineFormat; } sal_Int32 BitmapDevice::getScanlineStride() const { return mpImpl->mnScanlineStride < 0 ? -mpImpl->mnScanlineStride : mpImpl->mnScanlineStride; } RawMemorySharedArray BitmapDevice::getBuffer() const { return mpImpl->mpMem; } PaletteMemorySharedVector BitmapDevice::getPalette() const { return mpImpl->mpPalette; } const sal_Int32 BitmapDevice::getPaletteEntryCount() const { return mpImpl->mpPalette ? mpImpl->mpPalette->size() : 0; } void BitmapDevice::clear( Color fillColor ) { clear_i( fillColor, mpImpl->maBounds ); } void BitmapDevice::setPixel( const basegfx::B2IPoint& rPt, Color lineColor, DrawMode drawMode ) { if( mpImpl->maLineClipRect.isInside(rPt) ) setPixel_i(rPt,lineColor,drawMode); } void BitmapDevice::setPixel( const basegfx::B2IPoint& rPt, Color lineColor, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( !rClip ) { setPixel(rPt,lineColor,drawMode); return; } if( mpImpl->maLineClipRect.isInside(rPt) ) { if( isCompatibleClipMask( rClip ) ) setPixel_i(rPt,lineColor,drawMode,rClip); else getGenericRenderer()->setPixel( rPt, lineColor, drawMode, rClip ); } } Color BitmapDevice::getPixel( const basegfx::B2IPoint& rPt ) { if( mpImpl->maLineClipRect.isInside(rPt) ) return getPixel_i(rPt); return Color(); } sal_uInt32 BitmapDevice::getPixelData( const basegfx::B2IPoint& rPt ) { if( mpImpl->maLineClipRect.isInside(rPt) ) return getPixelData_i(rPt); return 0; } void BitmapDevice::drawLine( const basegfx::B2IPoint& rPt1, const basegfx::B2IPoint& rPt2, Color lineColor, DrawMode drawMode ) { drawLine_i( rPt1, rPt2, mpImpl->maLineClipRect, lineColor, drawMode ); } void BitmapDevice::drawLine( const basegfx::B2IPoint& rPt1, const basegfx::B2IPoint& rPt2, Color lineColor, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( !rClip ) { drawLine(rPt1,rPt2,lineColor,drawMode); return; } if( isCompatibleClipMask( rClip ) ) drawLine_i( rPt1, rPt2, mpImpl->maLineClipRect, lineColor, drawMode, rClip ); else getGenericRenderer()->drawLine( rPt1, rPt2, lineColor, drawMode, rClip ); } void BitmapDevice::drawPolygon( const basegfx::B2DPolygon& rPoly, Color lineColor, DrawMode drawMode ) { const sal_uInt32 numVertices( rPoly.count() ); if( numVertices ) drawPolygon_i( rPoly, mpImpl->maLineClipRect, lineColor, drawMode ); } void BitmapDevice::drawPolygon( const basegfx::B2DPolygon& rPoly, Color lineColor, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( !rClip ) { drawPolygon(rPoly,lineColor,drawMode); return; } const sal_uInt32 numVertices( rPoly.count() ); if( numVertices ) if( isCompatibleClipMask( rClip ) ) drawPolygon_i( rPoly, mpImpl->maLineClipRect, lineColor, drawMode, rClip ); else getGenericRenderer()->drawPolygon( rPoly, lineColor, drawMode, rClip ); } void BitmapDevice::fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly, Color fillColor, DrawMode drawMode ) { fillPolyPolygon_i( rPoly, fillColor, drawMode, mpImpl->maBounds ); } void BitmapDevice::fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly, Color fillColor, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( !rClip ) { fillPolyPolygon(rPoly,fillColor,drawMode); return; } if( isCompatibleClipMask( rClip ) ) fillPolyPolygon_i( rPoly, fillColor, drawMode, mpImpl->maBounds, rClip ); else getGenericRenderer()->fillPolyPolygon( rPoly, fillColor, drawMode, rClip ); } namespace { void assertImagePoint( const basegfx::B2IPoint& rPt, const basegfx::B2IRange& rPermittedRange ) { (void)rPt; (void)rPermittedRange; OSL_ASSERT( rPermittedRange.isInside(rPt) ); } void assertImageRange( const basegfx::B2IRange& rRange, const basegfx::B2IRange& rPermittedRange ) { #if OSL_DEBUG_LEVEL > 0 basegfx::B2IRange aRange( rRange ); aRange.intersect( rPermittedRange ); OSL_ASSERT( aRange == rRange ); #else (void)rRange; (void)rPermittedRange; #endif } // TODO(Q3): Move canvas/canvastools.hxx clipBlit() down // to basegfx, and use here! bool clipAreaImpl( ::basegfx::B2IRange& io_rSourceArea, ::basegfx::B2IPoint& io_rDestPoint, const ::basegfx::B2IRange& rSourceBounds, const ::basegfx::B2IRange& rDestBounds ) { const ::basegfx::B2IPoint aSourceTopLeft( io_rSourceArea.getMinimum() ); ::basegfx::B2IRange aLocalSourceArea( io_rSourceArea ); // clip source area (which must be inside rSourceBounds) aLocalSourceArea.intersect( rSourceBounds ); if( aLocalSourceArea.isEmpty() ) return false; // calc relative new source area points (relative to orig // source area) const ::basegfx::B2IVector aUpperLeftOffset( aLocalSourceArea.getMinimum()-aSourceTopLeft ); const ::basegfx::B2IVector aLowerRightOffset( aLocalSourceArea.getMaximum()-aSourceTopLeft ); ::basegfx::B2IRange aLocalDestArea( io_rDestPoint + aUpperLeftOffset, io_rDestPoint + aLowerRightOffset ); // clip dest area (which must be inside rDestBounds) aLocalDestArea.intersect( rDestBounds ); if( aLocalDestArea.isEmpty() ) return false; // calc relative new dest area points (relative to orig // source area) const ::basegfx::B2IVector aDestUpperLeftOffset( aLocalDestArea.getMinimum()-io_rDestPoint ); const ::basegfx::B2IVector aDestLowerRightOffset( aLocalDestArea.getMaximum()-io_rDestPoint ); io_rSourceArea = ::basegfx::B2IRange( aSourceTopLeft + aDestUpperLeftOffset, aSourceTopLeft + aDestLowerRightOffset ); io_rDestPoint = aLocalDestArea.getMinimum(); return true; } // TODO(Q3): Move canvas/canvastools.hxx clipBlit() down // to basegfx, and use here! bool clipAreaImpl( ::basegfx::B2IRange& io_rDestArea, ::basegfx::B2IRange& io_rSourceArea, const ::basegfx::B2IRange& rDestBounds, const ::basegfx::B2IRange& rSourceBounds ) { // extract inherent scale const double nScaleX( io_rDestArea.getWidth() / (double)io_rSourceArea.getWidth() ); const double nScaleY( io_rDestArea.getHeight() / (double)io_rSourceArea.getHeight() ); // extract range origins const basegfx::B2IPoint aDestTopLeft( io_rDestArea.getMinimum() ); const ::basegfx::B2IPoint aSourceTopLeft( io_rSourceArea.getMinimum() ); ::basegfx::B2IRange aLocalSourceArea( io_rSourceArea ); // clip source area (which must be inside rSourceBounds) aLocalSourceArea.intersect( rSourceBounds ); if( aLocalSourceArea.isEmpty() ) return false; // calc relative new source area points (relative to orig // source area) const ::basegfx::B2IVector aUpperLeftOffset( aLocalSourceArea.getMinimum()-aSourceTopLeft ); const ::basegfx::B2IVector aLowerRightOffset( aLocalSourceArea.getMaximum()-aSourceTopLeft ); ::basegfx::B2IRange aLocalDestArea( basegfx::fround(aDestTopLeft.getX() + nScaleX*aUpperLeftOffset.getX()), basegfx::fround(aDestTopLeft.getY() + nScaleY*aUpperLeftOffset.getY()), basegfx::fround(aDestTopLeft.getX() + nScaleX*aLowerRightOffset.getX()), basegfx::fround(aDestTopLeft.getY() + nScaleY*aLowerRightOffset.getY()) ); // clip dest area (which must be inside rDestBounds) aLocalDestArea.intersect( rDestBounds ); if( aLocalDestArea.isEmpty() ) return false; // calc relative new dest area points (relative to orig // source area) const ::basegfx::B2IVector aDestUpperLeftOffset( aLocalDestArea.getMinimum()-aDestTopLeft ); const ::basegfx::B2IVector aDestLowerRightOffset( aLocalDestArea.getMaximum()-aDestTopLeft ); io_rSourceArea = ::basegfx::B2IRange( basegfx::fround(aSourceTopLeft.getX() + aDestUpperLeftOffset.getX()/nScaleX), basegfx::fround(aSourceTopLeft.getY() + aDestUpperLeftOffset.getY()/nScaleY), basegfx::fround(aSourceTopLeft.getX() + aDestLowerRightOffset.getX()/nScaleX), basegfx::fround(aSourceTopLeft.getY() + aDestLowerRightOffset.getY()/nScaleY) ); io_rDestArea = aLocalDestArea; // final source area clip (chopping round-offs) io_rSourceArea.intersect( rSourceBounds ); if( io_rSourceArea.isEmpty() ) return false; return true; } } void BitmapDevice::drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode ) { const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() ); const basegfx::B2IRange aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() ); basegfx::B2IRange aSrcRange( rSrcRect ); basegfx::B2IRange aDestRange( rDstRect ); if( clipAreaImpl( aDestRange, aSrcRange, mpImpl->maBounds, aSrcBounds )) { assertImageRange(aDestRange,mpImpl->maBounds); assertImageRange(aSrcRange,aSrcBounds); drawBitmap_i( rSrcBitmap, aSrcRange, aDestRange, drawMode ); } } void BitmapDevice::drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( !rClip ) { drawBitmap(rSrcBitmap,rSrcRect,rDstRect,drawMode); return; } const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() ); const basegfx::B2IRange aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() ); basegfx::B2IRange aSrcRange( rSrcRect ); basegfx::B2IRange aDestRange( rDstRect ); if( clipAreaImpl( aDestRange, aSrcRange, mpImpl->maBounds, aSrcBounds )) { assertImageRange(aDestRange,mpImpl->maBounds); assertImageRange(aSrcRange,aSrcBounds); if( isCompatibleClipMask( rClip ) ) { drawBitmap_i( rSrcBitmap, aSrcRange, aDestRange, drawMode, rClip ); } else { getGenericRenderer()->drawBitmap( rSrcBitmap, rSrcRect, rDstRect, drawMode, rClip ); } } } void BitmapDevice::drawMaskedColor( Color aSrcColor, const BitmapDeviceSharedPtr& rAlphaMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IPoint& rDstPoint ) { const basegfx::B2IVector& rSrcSize( rAlphaMask->getSize() ); const basegfx::B2IRange aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() ); basegfx::B2IRange aSrcRange( rSrcRect ); basegfx::B2IPoint aDestPoint( rDstPoint ); if( clipAreaImpl( aSrcRange, aDestPoint, aSrcBounds, mpImpl->maBounds )) { assertImagePoint(aDestPoint,mpImpl->maBounds); assertImageRange(aSrcRange,aSrcBounds); if( rAlphaMask.get() == this ) { // src == dest, copy rAlphaMask beforehand // --------------------------------------------------- const basegfx::B2ITuple aSize( aSrcRange.getWidth(), aSrcRange.getHeight() ); BitmapDeviceSharedPtr pAlphaCopy( cloneBitmapDevice( aSize, shared_from_this()) ); basegfx::B2ITuple aGcc3WorkaroundTemporary; const basegfx::B2IRange aAlphaRange( aGcc3WorkaroundTemporary, aSize ); pAlphaCopy->drawBitmap(rAlphaMask, aSrcRange, aAlphaRange, DrawMode_PAINT); drawMaskedColor_i( aSrcColor, pAlphaCopy, aAlphaRange, aDestPoint ); } else { drawMaskedColor_i( aSrcColor, rAlphaMask, aSrcRange, aDestPoint ); } } } void BitmapDevice::drawMaskedColor( Color aSrcColor, const BitmapDeviceSharedPtr& rAlphaMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IPoint& rDstPoint, const BitmapDeviceSharedPtr& rClip ) { if( !rClip ) { drawMaskedColor(aSrcColor,rAlphaMask,rSrcRect,rDstPoint); return; } const basegfx::B2IVector& rSrcSize( rAlphaMask->getSize() ); const basegfx::B2IRange aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() ); basegfx::B2IRange aSrcRange( rSrcRect ); basegfx::B2IPoint aDestPoint( rDstPoint ); if( clipAreaImpl( aSrcRange, aDestPoint, aSrcBounds, mpImpl->maBounds )) { assertImagePoint(aDestPoint,mpImpl->maBounds); assertImageRange(aSrcRange,aSrcBounds); if( isCompatibleClipMask( rClip ) ) { if( rAlphaMask.get() == this ) { // src == dest, copy rAlphaMask beforehand // --------------------------------------------------- const basegfx::B2ITuple aSize( aSrcRange.getWidth(), aSrcRange.getHeight() ); BitmapDeviceSharedPtr pAlphaCopy( cloneBitmapDevice( aSize, shared_from_this()) ); basegfx::B2ITuple aGcc3WorkaroundTemporary; const basegfx::B2IRange aAlphaRange( aGcc3WorkaroundTemporary, aSize ); pAlphaCopy->drawBitmap(rAlphaMask, aSrcRange, aAlphaRange, DrawMode_PAINT); drawMaskedColor_i( aSrcColor, pAlphaCopy, aAlphaRange, aDestPoint, rClip ); } else { drawMaskedColor_i( aSrcColor, rAlphaMask, aSrcRange, aDestPoint, rClip ); } } else { getGenericRenderer()->drawMaskedColor( aSrcColor, rAlphaMask, rSrcRect, rDstPoint, rClip ); } } } void BitmapDevice::drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap, const BitmapDeviceSharedPtr& rMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode ) { OSL_ASSERT( rMask->getSize() == rSrcBitmap->getSize() ); const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() ); const basegfx::B2IRange aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() ); basegfx::B2IRange aSrcRange( rSrcRect ); basegfx::B2IRange aDestRange( rDstRect ); if( clipAreaImpl( aDestRange, aSrcRange, mpImpl->maBounds, aSrcBounds )) { assertImageRange(aDestRange,mpImpl->maBounds); assertImageRange(aSrcRange,aSrcBounds); drawMaskedBitmap_i( rSrcBitmap, rMask, aSrcRange, aDestRange, drawMode ); } } void BitmapDevice::drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap, const BitmapDeviceSharedPtr& rMask, const basegfx::B2IRange& rSrcRect, const basegfx::B2IRange& rDstRect, DrawMode drawMode, const BitmapDeviceSharedPtr& rClip ) { if( !rClip ) { drawMaskedBitmap(rSrcBitmap,rMask,rSrcRect,rDstRect,drawMode); return; } OSL_ASSERT( rMask->getSize() == rSrcBitmap->getSize() ); const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() ); const basegfx::B2IRange aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() ); basegfx::B2IRange aSrcRange( rSrcRect ); basegfx::B2IRange aDestRange( rDstRect ); if( clipAreaImpl( aDestRange, aSrcRange, mpImpl->maBounds, aSrcBounds )) { assertImageRange(aDestRange,mpImpl->maBounds); assertImageRange(aSrcRange,aSrcBounds); if( isCompatibleClipMask( rClip ) ) { drawMaskedBitmap_i( rSrcBitmap, rMask, aSrcRange, aDestRange, drawMode, rClip ); } else { getGenericRenderer()->drawMaskedBitmap( rSrcBitmap, rMask, rSrcRect, rDstRect, drawMode, rClip ); } } } //---------------------------------------------------------------------------------- /** Standard clip and alpha masks */ struct StdMasks { typedef PixelFormatTraits_GREY1_MSB clipmask_format_traits; typedef PixelFormatTraits_GREY8 alphamask_format_traits; /// Clipmask: 0 means opaque static const bool clipmask_polarity = false; /// Alpha mask: 0 means fully transparent static const bool alphamask_polarity = true; }; #if 0 /** Clip and alpha masks for the generic renderer (of course, those need to be generic, too) */ struct MaskTraitsGeneric { typedef PixelFormatTraits_GenericInteger clipmask_format_traits; typedef PixelFormatTraits_GenericInteger alphamask_format_traits; }; #endif //---------------------------------------------------------------------------------- // Some compilers don't like the nested template wrap_accessor // reference in the parameter list - being slightly less type safe, // then. #ifndef BASEBMP_NO_NESTED_TEMPLATE_PARAMETER /// Produces a specialized renderer for the given pixel format template< class FormatTraits, class MaskTraits > BitmapDeviceSharedPtr createRenderer( const basegfx::B2IRange& rBounds, sal_Int32 nScanlineFormat, sal_Int32 nScanlineStride, sal_uInt8* pFirstScanline, typename FormatTraits::raw_accessor_type const& rRawAccessor, typename FormatTraits::accessor_selector::template wrap_accessor< typename FormatTraits::raw_accessor_type>::type const& rAccessor, boost::shared_array< sal_uInt8 > pMem, const PaletteMemorySharedVector& pPal ) #else template< class FormatTraits, class MaskTraits, class Accessor > BitmapDeviceSharedPtr createRenderer( const basegfx::B2IRange& rBounds, sal_Int32 nScanlineFormat, sal_Int32 nScanlineStride, sal_uInt8* pFirstScanline, typename FormatTraits::raw_accessor_type const& rRawAccessor, Accessor const& rAccessor, boost::shared_array< sal_uInt8 > pMem, const PaletteMemorySharedVector& pPal ) #endif { typedef typename FormatTraits::iterator_type Iterator; typedef BitmapRenderer< Iterator, typename FormatTraits::raw_accessor_type, typename FormatTraits::accessor_selector, MaskTraits > Renderer; return BitmapDeviceSharedPtr( new Renderer( rBounds, nScanlineFormat, nScanlineStride, pFirstScanline, Iterator( reinterpret_cast( pFirstScanline), nScanlineStride), rRawAccessor, rAccessor, pMem, pPal )); } /// Create standard grey level palette PaletteMemorySharedVector createStandardPalette( const PaletteMemorySharedVector& pPal, sal_Int32 nNumEntries ) { if( pPal || nNumEntries <= 0 ) return pPal; boost::shared_ptr< std::vector > pLocalPal( new std::vector(nNumEntries) ); const sal_Int32 nIncrement( 0x00FFFFFF/nNumEntries ); --nNumEntries; for( sal_Int32 i=0, c=0; iat(i) = Color(0xFF000000 | c); pLocalPal->at(nNumEntries) = Color(0xFFFFFFFF); return pLocalPal; } template< class FormatTraits, class MaskTraits > BitmapDeviceSharedPtr createRenderer( const basegfx::B2IRange& rBounds, sal_Int32 nScanlineFormat, sal_Int32 nScanlineStride, sal_uInt8* pFirstScanline, boost::shared_array< sal_uInt8 > pMem, const PaletteMemorySharedVector& pPal ) { return createRenderer(rBounds, nScanlineFormat, nScanlineStride, pFirstScanline, typename FormatTraits::raw_accessor_type(), typename FormatTraits::accessor_selector::template wrap_accessor< typename FormatTraits::raw_accessor_type>::type(), pMem, pPal); } template< class FormatTraits, class MaskTraits > BitmapDeviceSharedPtr createRenderer( const basegfx::B2IRange& rBounds, sal_Int32 nScanlineFormat, sal_Int32 nScanlineStride, sal_uInt8* pFirstScanline, boost::shared_array< sal_uInt8 > pMem, PaletteMemorySharedVector pPal, int nBitsPerPixel ) { pPal = createStandardPalette(pPal, 1UL << nBitsPerPixel); OSL_ASSERT(pPal); return createRenderer(rBounds, nScanlineFormat, nScanlineStride, pFirstScanline, typename FormatTraits::raw_accessor_type(), typename FormatTraits::accessor_selector::template wrap_accessor< typename FormatTraits::raw_accessor_type>::type( &pPal->at(0), pPal->size()), pMem, pPal); } //---------------------------------------------------------------------------------- // TODO(Q3): consolidate with canvas/canvastools.hxx! Best move this // to o3tl or sal/bithacks.hxx ... /** Compute the next highest power of 2 of a 32-bit value Code devised by Sean Anderson, in good ole HAKMEM tradition. @return 1 << (lg(x - 1) + 1) */ inline sal_uInt32 nextPow2( sal_uInt32 x ) { --x; x |= x >> 1; x |= x >> 2; x |= x >> 4; x |= x >> 8; x |= x >> 16; return ++x; } //---------------------------------------------------------------------------------- namespace { BitmapDeviceSharedPtr createBitmapDeviceImpl( const basegfx::B2IVector& rSize, bool bTopDown, sal_Int32 nScanlineFormat, boost::shared_array< sal_uInt8 > pMem, PaletteMemorySharedVector pPal, const basegfx::B2IRange* pSubset ) { if( nScanlineFormat <= Format::NONE || nScanlineFormat > Format::MAX ) return BitmapDeviceSharedPtr(); static const sal_uInt8 bitsPerPixel[] = { 0, // NONE 1, // ONE_BIT_MSB_GREY 1, // ONE_BIT_LSB_GREY 1, // ONE_BIT_MSB_PAL 1, // ONE_BIT_LSB_PAL 4, // FOUR_BIT_MSB_GREY 4, // FOUR_BIT_LSB_GREY 4, // FOUR_BIT_MSB_PAL 4, // FOUR_BIT_LSB_PAL 8, // EIGHT_BIT_PAL 8, // EIGHT_BIT_GREY 16, // SIXTEEN_BIT_LSB_TC_MASK 16, // SIXTEEN_BIT_MSB_TC_MASK 24, // TWENTYFOUR_BIT_TC_MASK 32, // THIRTYTWO_BIT_TC_MASK 32, // THIRTYTWO_BIT_TC_MASK_ARGB }; sal_Int32 nScanlineStride(0); // round up to full 8 bit, divide by 8 nScanlineStride = (rSize.getX()*bitsPerPixel[nScanlineFormat] + 7) >> 3; // rounded up to next full power-of-two number of bytes const sal_uInt32 bytesPerPixel = nextPow2( (bitsPerPixel[nScanlineFormat] + 7) >> 3); // now make nScanlineStride a multiple of bytesPerPixel nScanlineStride = (nScanlineStride + bytesPerPixel - 1) / bytesPerPixel * bytesPerPixel; // factor in bottom-up scanline order case nScanlineStride *= bTopDown ? 1 : -1; const std::size_t nMemSize( (nScanlineStride < 0 ? -nScanlineStride : nScanlineStride)*rSize.getY() ); if( !pMem ) { pMem.reset( reinterpret_cast(rtl_allocateMemory( nMemSize )), &rtl_freeMemory ); rtl_zeroMemory(pMem.get(),nMemSize); } sal_uInt8* pFirstScanline = nScanlineStride < 0 ? pMem.get() + nMemSize + nScanlineStride : pMem.get(); // shrink render area to given subset, if given basegfx::B2IRange aBounds(0,0,rSize.getX(),rSize.getY()); if( pSubset ) aBounds.intersect( *pSubset ); switch( nScanlineFormat ) { // ---------------------------------------------------------------------- // one bit formats case Format::ONE_BIT_MSB_GREY: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); case Format::ONE_BIT_LSB_GREY: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); case Format::ONE_BIT_MSB_PAL: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal, bitsPerPixel[nScanlineFormat] ); case Format::ONE_BIT_LSB_PAL: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal, bitsPerPixel[nScanlineFormat] ); // ---------------------------------------------------------------------- // four bit formats case Format::FOUR_BIT_MSB_GREY: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); case Format::FOUR_BIT_LSB_GREY: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); case Format::FOUR_BIT_MSB_PAL: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal, bitsPerPixel[nScanlineFormat] ); case Format::FOUR_BIT_LSB_PAL: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal, bitsPerPixel[nScanlineFormat] ); // ---------------------------------------------------------------------- // eight bit formats case Format::EIGHT_BIT_GREY: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); case Format::EIGHT_BIT_PAL: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal, bitsPerPixel[nScanlineFormat] ); // ---------------------------------------------------------------------- // sixteen bit formats case Format::SIXTEEN_BIT_LSB_TC_MASK: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); case Format::SIXTEEN_BIT_MSB_TC_MASK: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); // ---------------------------------------------------------------------- // twentyfour bit formats case Format::TWENTYFOUR_BIT_TC_MASK: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); // ---------------------------------------------------------------------- // thirtytwo bit formats case Format::THIRTYTWO_BIT_TC_MASK: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); case Format::THIRTYTWO_BIT_TC_MASK_ARGB: return createRenderer( aBounds, nScanlineFormat, nScanlineStride, pFirstScanline, pMem, pPal ); } // TODO(F3): other formats not yet implemented return BitmapDeviceSharedPtr(); } } // namespace BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, bool bTopDown, sal_Int32 nScanlineFormat ) { return createBitmapDeviceImpl( rSize, bTopDown, nScanlineFormat, boost::shared_array< sal_uInt8 >(), PaletteMemorySharedVector(), NULL ); } BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, bool bTopDown, sal_Int32 nScanlineFormat, const PaletteMemorySharedVector& rPalette ) { return createBitmapDeviceImpl( rSize, bTopDown, nScanlineFormat, boost::shared_array< sal_uInt8 >(), rPalette, NULL ); } BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, bool bTopDown, sal_Int32 nScanlineFormat, const RawMemorySharedArray& rMem, const PaletteMemorySharedVector& rPalette ) { return createBitmapDeviceImpl( rSize, bTopDown, nScanlineFormat, rMem, rPalette, NULL ); } BitmapDeviceSharedPtr subsetBitmapDevice( const BitmapDeviceSharedPtr& rProto, const basegfx::B2IRange& rSubset ) { return createBitmapDeviceImpl( rProto->getSize(), rProto->isTopDown(), rProto->getScanlineFormat(), rProto->getBuffer(), rProto->getPalette(), &rSubset ); } BitmapDeviceSharedPtr cloneBitmapDevice( const basegfx::B2IVector& rSize, const BitmapDeviceSharedPtr& rProto ) { return createBitmapDeviceImpl( rSize, rProto->isTopDown(), rProto->getScanlineFormat(), boost::shared_array< sal_uInt8 >(), rProto->getPalette(), NULL ); } //---------------------------------------------------------------------------------- /// Clone our device, with GenericImageAccessor to handle all formats BitmapDeviceSharedPtr BitmapDevice::getGenericRenderer() const { #if 0 // xxx TODO typedef BitmapRenderer< PixelFormatTraits_GenericInteger::iterator_type, PixelFormatTraits_GenericInteger::raw_accessor_type, PixelFormatTraits_GenericInteger::accessor_selector, MaskTraitsGeneric > Renderer; if( !mpImpl->mpGenericRenderer ) { mpImpl->mpGenericRenderer.reset( new Renderer( mpImpl->maBounds, isTopDown(), getScanlineFormat(), getScanlineStride(), mpImpl->mpFirstScanline, PixelFormatTraits_GenericInteger::iterator_type(), GenericIntegerImageRawAccessor( const_cast(this)->shared_from_this()), GenericIntegerImageAccessor( const_cast(this)->shared_from_this()), getBuffer(), getPalette() )); } #endif return mpImpl->mpGenericRenderer; } } // namespace basebmp