vcl/quartz/salbmp.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "basebmp/scanlineformats.hxx"
  22 #include "basebmp/color.hxx"
  23
  24 #include "basegfx/vector/b2ivector.hxx"
  25
  26 #include "tools/color.hxx"
  27
  28 #include "vcl/bitmap.hxx"
  29 #include "vcl/salbtype.hxx"
  30
  31 #include "quartz/salbmp.h"
  32
  33 #ifdef MACOSX
  34 #include "aqua/saldata.hxx"
  35 #else
  36 #include "saldatabasic.hxx"
  37 #endif
  38
  39 #include "bmpfast.hxx"
  40
  41 static const unsigned long k16BitRedColorMask   = 0x00007c00;
  42 static const unsigned long k16BitGreenColorMask = 0x000003e0;
  43 static const unsigned long k16BitBlueColorMask  = 0x0000001f;
  44
  45 static const unsigned long k32BitRedColorMask   = 0x00ff0000;
  46 static const unsigned long k32BitGreenColorMask = 0x0000ff00;
  47 static const unsigned long k32BitBlueColorMask  = 0x000000ff;
  48
  49 // =======================================================================
  50
  51 static bool isValidBitCount( sal_uInt16 nBitCount )
  52 {
  53     return (nBitCount == 1) || (nBitCount == 4) || (nBitCount == 8) || (nBitCount == 16) || (nBitCount == 24) || (nBitCount == 32);
  54 }
  55
  56 // =======================================================================
  57
  58 QuartzSalBitmap::QuartzSalBitmap()
  59 : mxGraphicContext( NULL )
  60 , mxCachedImage( NULL )
  61 , mnBits(0)
  62 , mnWidth(0)
  63 , mnHeight(0)
  64 , mnBytesPerRow(0)
  65 {
  66 }
  67
  68 // ------------------------------------------------------------------
  69
  70 QuartzSalBitmap::~QuartzSalBitmap()
  71 {
  72     Destroy();
  73 }
  74
  75 // ------------------------------------------------------------------
  76
  77 bool QuartzSalBitmap::Create( CGLayerRef xLayer, int nBitmapBits,
  78     int nX, int nY, int nWidth, int nHeight, bool /*bMirrorVert*/ )
  79 {
  80     DBG_ASSERT( xLayer, "QuartzSalBitmap::Create() from non-layered context" );
  81
  82     // sanitize input parameters
  83     if( nX < 0 )
  84         nWidth += nX, nX = 0;
  85     if( nY < 0 )
  86         nHeight += nY, nY = 0;
  87     const CGSize aLayerSize = CGLayerGetSize( xLayer );
  88     if( nWidth >= (int)aLayerSize.width - nX )
  89         nWidth = (int)aLayerSize.width - nX;
  90     if( nHeight >= (int)aLayerSize.height - nY )
  91         nHeight = (int)aLayerSize.height - nY;
  92     if( (nWidth < 0) || (nHeight < 0) )
  93         nWidth = nHeight = 0;
  94
  95     // initialize properties
  96     mnWidth  = nWidth;
  97     mnHeight = nHeight;
  98     mnBits   = nBitmapBits ? nBitmapBits : 32;
  99
 100     // initialize drawing context
 101     CreateContext();
 102
 103     // copy layer content into the bitmap buffer
 104     const CGPoint aSrcPoint = { static_cast<CGFloat>(-nX), static_cast<CGFloat>(-nY) };
 105     ::CGContextDrawLayerAtPoint( mxGraphicContext, aSrcPoint, xLayer );
 106     return true;
 107 }
 108
 109 // ------------------------------------------------------------------
 110
 111 bool QuartzSalBitmap::Create( const Size& rSize, sal_uInt16 nBits, const BitmapPalette& rBitmapPalette )
 112 {
 113     if( !isValidBitCount( nBits ) )
 114         return false;
 115     maPalette = rBitmapPalette;
 116     mnBits = nBits;
 117     mnWidth = rSize.Width();
 118     mnHeight = rSize.Height();
 119     return AllocateUserData();
 120 }
 121
 122 // ------------------------------------------------------------------
 123
 124 bool QuartzSalBitmap::Create( const SalBitmap& rSalBmp )
 125 {
 126     return Create( rSalBmp, rSalBmp.GetBitCount() );
 127 }
 128
 129 // ------------------------------------------------------------------
 130
 131 bool QuartzSalBitmap::Create( const SalBitmap& rSalBmp, SalGraphics* pGraphics )
 132 {
 133     return Create( rSalBmp, pGraphics ? pGraphics->GetBitCount() : rSalBmp.GetBitCount() );
 134 }
 135
 136 // ------------------------------------------------------------------
 137
 138 bool QuartzSalBitmap::Create( const SalBitmap& rSalBmp, sal_uInt16 nNewBitCount )
 139 {
 140     const QuartzSalBitmap& rSourceBitmap = static_cast<const QuartzSalBitmap&>(rSalBmp);
 141
 142     if( isValidBitCount( nNewBitCount ) &&  rSourceBitmap.maUserBuffer.get() )
 143     {
 144         mnBits = nNewBitCount;
 145         mnWidth = rSourceBitmap.mnWidth;
 146         mnHeight = rSourceBitmap.mnHeight;
 147         maPalette = rSourceBitmap.maPalette;
 148
 149         if( AllocateUserData() )
 150         {
 151             ConvertBitmapData( mnWidth, mnHeight, mnBits, mnBytesPerRow, maPalette, maUserBuffer.get(), rSourceBitmap.mnBits, rSourceBitmap.mnBytesPerRow, rSourceBitmap.maPalette, rSourceBitmap.maUserBuffer.get() );
 152             return true;
 153         }
 154     }
 155     return false;
 156 }
 157
 158 // ------------------------------------------------------------------
 159
 160 bool QuartzSalBitmap::Create( const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XBitmapCanvas > /*xBitmapCanvas*/, Size& /*rSize*/, bool /*bMask*/ )
 161 {
 162     return false;
 163 }
 164
 165 // ------------------------------------------------------------------
 166
 167 void QuartzSalBitmap::Destroy()
 168 {
 169     DestroyContext();
 170     maUserBuffer.reset();
 171 }
 172
 173 // ------------------------------------------------------------------
 174
 175 void QuartzSalBitmap::DestroyContext()
 176 {
 177     CGImageRelease( mxCachedImage );
 178     mxCachedImage = NULL;
 179
 180     if( mxGraphicContext )
 181     {
 182         CGContextRelease( mxGraphicContext );
 183         mxGraphicContext = NULL;
 184         maContextBuffer.reset();
 185     }
 186 }
 187
 188 // ------------------------------------------------------------------
 189
 190 bool QuartzSalBitmap::CreateContext()
 191 {
 192     DestroyContext();
 193
 194     // prepare graphics context
 195     // convert image from user input if available
 196     const bool bSkipConversion = !maUserBuffer;
 197     if( bSkipConversion )
 198         AllocateUserData();
 199
 200     // default to RGBA color space
 201     CGColorSpaceRef aCGColorSpace = GetSalData()->mxRGBSpace;
 202     CGBitmapInfo aCGBmpInfo = kCGImageAlphaNoneSkipFirst;
 203
 204     // convert data into something accepted by CGBitmapContextCreate()
 205     size_t bitsPerComponent = (mnBits == 16) ? 5 : 8;
 206     sal_uInt32 nContextBytesPerRow = mnBytesPerRow;
 207     if( (mnBits == 16) || (mnBits == 32) )
 208     {
 209         // no conversion needed for truecolor
 210         maContextBuffer = maUserBuffer;
 211     }
 212     else if( (mnBits == 8) && maPalette.IsGreyPalette() )
 213     {
 214         // no conversion needed for grayscale
 215         maContextBuffer = maUserBuffer;
 216         aCGColorSpace = GetSalData()->mxGraySpace;
 217         aCGBmpInfo = kCGImageAlphaNone;
 218         bitsPerComponent = mnBits;
 219     }
 220     // TODO: is special handling for 1bit input buffers worth it?
 221     else
 222     {
 223         // convert user data to 32 bit
 224         nContextBytesPerRow = mnWidth << 2;
 225         try
 226         {
 227             maContextBuffer.reset( new sal_uInt8[ mnHeight * nContextBytesPerRow ] );
 228
 229             if( !bSkipConversion )
 230                 ConvertBitmapData( mnWidth, mnHeight,
 231                                32, nContextBytesPerRow, maPalette, maContextBuffer.get(),
 232                                mnBits, mnBytesPerRow, maPalette, maUserBuffer.get() );
 233         }
 234         catch( const std::bad_alloc& )
 235         {
 236             mxGraphicContext = 0;
 237         }
 238     }
 239
 240     if( maContextBuffer.get() )
 241     {
 242         mxGraphicContext = ::CGBitmapContextCreate( maContextBuffer.get(), mnWidth, mnHeight,
 243             bitsPerComponent, nContextBytesPerRow, aCGColorSpace, aCGBmpInfo );
 244     }
 245
 246     if( !mxGraphicContext )
 247         maContextBuffer.reset();
 248
 249     return mxGraphicContext != NULL;
 250 }
 251
 252 // ------------------------------------------------------------------
 253
 254 bool QuartzSalBitmap::AllocateUserData()
 255 {
 256     Destroy();
 257
 258     if( mnWidth && mnHeight )
 259     {
 260         mnBytesPerRow =  0;
 261
 262         switch( mnBits )
 263         {
 264         case 1:     mnBytesPerRow = (mnWidth + 7) >> 3; break;
 265         case 4:     mnBytesPerRow = (mnWidth + 1) >> 1; break;
 266         case 8:     mnBytesPerRow = mnWidth; break;
 267         case 16:    mnBytesPerRow = mnWidth << 1; break;
 268         case 24:    mnBytesPerRow = (mnWidth << 1) + mnWidth; break;
 269         case 32:    mnBytesPerRow = mnWidth << 2; break;
 270         default:
 271             OSL_FAIL("vcl::QuartzSalBitmap::AllocateUserData(), illegal bitcount!");
 272         }
 273     }
 274
 275     try
 276     {
 277         if( mnBytesPerRow )
 278             maUserBuffer.reset( new sal_uInt8[mnBytesPerRow * mnHeight] );
 279     }
 280     catch( const std::bad_alloc& )
 281     {
 282         OSL_FAIL( "vcl::QuartzSalBitmap::AllocateUserData: bad alloc" );
 283         maUserBuffer.reset( NULL );
 284         mnBytesPerRow = 0;
 285     }
 286
 287     return maUserBuffer.get() != 0;
 288 }
 289
 290 // ------------------------------------------------------------------
 291
 292 class ImplPixelFormat
 293 {
 294 protected:
 295     sal_uInt8* pData;
 296 public:
 297     static ImplPixelFormat* GetFormat( sal_uInt16 nBits, const BitmapPalette& rPalette );
 298
 299     virtual void StartLine( sal_uInt8* pLine ) { pData = pLine; }
 300     virtual void SkipPixel( sal_uInt32 nPixel ) = 0;
 301     virtual ColorData ReadPixel() = 0;
 302     virtual void WritePixel( ColorData nColor ) = 0;
 303     virtual ~ImplPixelFormat() { }
 304 };
 305
 306 class ImplPixelFormat32 : public ImplPixelFormat
 307 // currently ARGB-format for 32bit depth
 308 {
 309 public:
 310     virtual void SkipPixel( sal_uInt32 nPixel )
 311     {
 312         pData += nPixel << 2;
 313     }
 314     virtual ColorData ReadPixel()
 315     {
 316         const ColorData c = RGB_COLORDATA( pData[1], pData[2], pData[3] );
 317         pData += 4;
 318         return c;
 319     }
 320     virtual void WritePixel( ColorData nColor )
 321     {
 322         *pData++ = 0;
 323         *pData++ = COLORDATA_RED( nColor );
 324         *pData++ = COLORDATA_GREEN( nColor );
 325         *pData++ = COLORDATA_BLUE( nColor );
 326     }
 327 };
 328
 329 class ImplPixelFormat24 : public ImplPixelFormat
 330 // currently BGR-format for 24bit depth
 331 {
 332 public:
 333     virtual void SkipPixel( sal_uInt32 nPixel )
 334     {
 335         pData += (nPixel << 1) + nPixel;
 336     }
 337     virtual ColorData ReadPixel()
 338     {
 339         const ColorData c = RGB_COLORDATA( pData[2], pData[1], pData[0] );
 340         pData += 3;
 341         return c;
 342     }
 343     virtual void WritePixel( ColorData nColor )
 344     {
 345         *pData++ = COLORDATA_BLUE( nColor );
 346         *pData++ = COLORDATA_GREEN( nColor );
 347         *pData++ = COLORDATA_RED( nColor );
 348     }
 349 };
 350
 351 class ImplPixelFormat16 : public ImplPixelFormat
 352 // currently R5G6B5-format for 16bit depth
 353 {
 354 protected:
 355     sal_uInt16* pData16;
 356 public:
 357
 358     virtual void StartLine( sal_uInt8* pLine )
 359     {
 360         pData16 = (sal_uInt16*)pLine;
 361     }
 362     virtual void SkipPixel( sal_uInt32 nPixel )
 363     {
 364         pData += nPixel;
 365     }
 366     virtual ColorData ReadPixel()
 367     {
 368         const ColorData c = RGB_COLORDATA( (*pData & 0x7c00) >> 7, (*pData & 0x03e0) >> 2 , (*pData & 0x001f) << 3 );
 369         pData++;
 370         return c;
 371     }
 372     virtual void WritePixel( ColorData nColor )
 373     {
 374         *pData++ =  ((COLORDATA_RED( nColor ) & 0xf8 ) << 7 ) ||
 375                     ((COLORDATA_GREEN( nColor ) & 0xf8 ) << 2 ) ||
 376                     ((COLORDATA_BLUE( nColor ) & 0xf8 ) >> 3 );
 377     }
 378 };
 379
 380 class ImplPixelFormat8 : public ImplPixelFormat
 381 {
 382 private:
 383     const BitmapPalette& mrPalette;
 384
 385 public:
 386     ImplPixelFormat8( const BitmapPalette& rPalette )
 387     : mrPalette( rPalette )
 388     {
 389     }
 390     virtual void SkipPixel( sal_uInt32 nPixel )
 391     {
 392         pData += nPixel;
 393     }
 394     virtual ColorData ReadPixel()
 395     {
 396         return mrPalette[ *pData++ ].operator Color().GetColor();
 397     }
 398     virtual void WritePixel( ColorData nColor )
 399     {
 400         const BitmapColor aColor( COLORDATA_RED( nColor ), COLORDATA_GREEN( nColor ), COLORDATA_BLUE( nColor ) );
 401         *pData++ = static_cast< sal_uInt8 >( mrPalette.GetBestIndex( aColor ) );
 402     }
 403 };
 404
 405 class ImplPixelFormat4 : public ImplPixelFormat
 406 {
 407 private:
 408     const BitmapPalette& mrPalette;
 409     sal_uInt32 mnX;
 410     sal_uInt32 mnShift;
 411
 412 public:
 413     ImplPixelFormat4( const BitmapPalette& rPalette )
 414     : mrPalette( rPalette )
 415     {
 416     }
 417     virtual void SkipPixel( sal_uInt32 nPixel )
 418     {
 419         mnX += nPixel;
 420         if( (nPixel & 1) )
 421             mnShift ^= 4;
 422     }
 423     virtual void StartLine( sal_uInt8* pLine )
 424     {
 425         pData = pLine;
 426         mnX = 0;
 427         mnShift = 4;
 428     }
 429     virtual ColorData ReadPixel()
 430     {
 431         const BitmapColor& rColor = mrPalette[( pData[mnX >> 1] >> mnShift) & 0x0f];
 432         mnX++;
 433         mnShift ^= 4;
 434         return rColor.operator Color().GetColor();
 435     }
 436     virtual void WritePixel( ColorData nColor )
 437     {
 438         const BitmapColor aColor( COLORDATA_RED( nColor ), COLORDATA_GREEN( nColor ), COLORDATA_BLUE( nColor ) );
 439         pData[mnX>>1] &= (0xf0 >> mnShift);
 440         pData[mnX>>1] |= (static_cast< sal_uInt8 >( mrPalette.GetBestIndex( aColor ) ) & 0x0f);
 441         mnX++;
 442         mnShift ^= 4;
 443     }
 444 };
 445
 446 class ImplPixelFormat1 : public ImplPixelFormat
 447 {
 448 private:
 449     const BitmapPalette& mrPalette;
 450     sal_uInt32 mnX;
 451
 452 public:
 453     ImplPixelFormat1( const BitmapPalette& rPalette )
 454     : mrPalette( rPalette )
 455     {
 456     }
 457     virtual void SkipPixel( sal_uInt32 nPixel )
 458     {
 459         mnX += nPixel;
 460     }
 461     virtual void StartLine( sal_uInt8* pLine )
 462     {
 463         pData = pLine;
 464         mnX = 0;
 465     }
 466     virtual ColorData ReadPixel()
 467     {
 468         const BitmapColor& rColor = mrPalette[ (pData[mnX >> 3 ] >> ( 7 - ( mnX & 7 ) )) & 1];
 469         mnX++;
 470         return rColor.operator Color().GetColor();
 471     }
 472     virtual void WritePixel( ColorData nColor )
 473     {
 474         const BitmapColor aColor( COLORDATA_RED( nColor ), COLORDATA_GREEN( nColor ), COLORDATA_BLUE( nColor ) );
 475         if( mrPalette.GetBestIndex( aColor ) & 1 )
 476             pData[ mnX >> 3 ] |= 1 << ( 7 - ( mnX & 7 ) );
 477         else
 478             pData[ mnX >> 3 ] &= ~( 1 << ( 7 - ( mnX & 7 ) ) );
 479         mnX++;
 480     }
 481 };
 482
 483 ImplPixelFormat* ImplPixelFormat::GetFormat( sal_uInt16 nBits, const BitmapPalette& rPalette )
 484 {
 485     switch( nBits )
 486     {
 487     case 1: return new ImplPixelFormat1( rPalette );
 488     case 4: return new ImplPixelFormat4( rPalette );
 489     case 8: return new ImplPixelFormat8( rPalette );
 490     case 16: return new ImplPixelFormat16;
 491     case 24: return new ImplPixelFormat24;
 492     case 32: return new ImplPixelFormat32;
 493     }
 494
 495     return 0;
 496 }
 497
 498 void QuartzSalBitmap::ConvertBitmapData( sal_uInt32 nWidth, sal_uInt32 nHeight,
 499                                        sal_uInt16 nDestBits, sal_uInt32 nDestBytesPerRow, const BitmapPalette& rDestPalette, sal_uInt8* pDestData,
 500                                        sal_uInt16 nSrcBits, sal_uInt32 nSrcBytesPerRow, const BitmapPalette& rSrcPalette, sal_uInt8* pSrcData )
 501
 502 {
 503     if( (nDestBytesPerRow == nSrcBytesPerRow) && (nDestBits == nSrcBits) && ((nSrcBits != 8) || (rDestPalette.operator==( rSrcPalette ))) )
 504     {
 505         // simple case, same format, so just copy
 506         memcpy( pDestData, pSrcData, nHeight * nDestBytesPerRow );
 507         return;
 508     }
 509
 510     // try accelerated conversion if possible
 511     // TODO: are other truecolor conversions except BGR->ARGB worth it?
 512     bool bConverted = false;
 513     if( (nSrcBits == 24) && (nDestBits == 32) )
 514     {
 515         // TODO: extend bmpfast.cxx with a method that can be directly used here
 516         BitmapBuffer aSrcBuf;
 517         aSrcBuf.mnFormat = BMP_FORMAT_24BIT_TC_BGR;
 518         aSrcBuf.mpBits = pSrcData;
 519         aSrcBuf.mnBitCount = nSrcBits;
 520         aSrcBuf.mnScanlineSize = nSrcBytesPerRow;
 521         BitmapBuffer aDstBuf;
 522         aDstBuf.mnFormat = BMP_FORMAT_32BIT_TC_ARGB;
 523         aDstBuf.mpBits = pDestData;
 524         aSrcBuf.mnBitCount = nDestBits;
 525         aDstBuf.mnScanlineSize = nDestBytesPerRow;
 526
 527         aSrcBuf.mnWidth = aDstBuf.mnWidth = nWidth;
 528         aSrcBuf.mnHeight = aDstBuf.mnHeight = nHeight;
 529
 530         SalTwoRect aTwoRects;
 531         aTwoRects.mnSrcX = aTwoRects.mnDestX = 0;
 532         aTwoRects.mnSrcY = aTwoRects.mnDestY = 0;
 533         aTwoRects.mnSrcWidth = aTwoRects.mnDestWidth = mnWidth;
 534         aTwoRects.mnSrcHeight = aTwoRects.mnDestHeight = mnHeight;
 535         bConverted = ::ImplFastBitmapConversion( aDstBuf, aSrcBuf, aTwoRects );
 536     }
 537
 538     if( !bConverted )
 539     {
 540         // TODO: this implementation is for clarety, not for speed
 541
 542         ImplPixelFormat* pD = ImplPixelFormat::GetFormat( nDestBits, rDestPalette );
 543         ImplPixelFormat* pS = ImplPixelFormat::GetFormat( nSrcBits, rSrcPalette );
 544
 545         if( pD && pS )
 546         {
 547             sal_uInt32 nY = nHeight;
 548             while( nY-- )
 549             {
 550                 pD->StartLine( pDestData );
 551                 pS->StartLine( pSrcData );
 552
 553                 sal_uInt32 nX = nWidth;
 554                 while( nX-- )
 555                     pD->WritePixel( pS->ReadPixel() );
 556
 557                 pSrcData += nSrcBytesPerRow;
 558                 pDestData += nDestBytesPerRow;
 559             }
 560         }
 561         delete pS;
 562         delete pD;
 563     }
 564 }
 565
 566 // ------------------------------------------------------------------
 567
 568 Size QuartzSalBitmap::GetSize() const
 569 {
 570     return Size( mnWidth, mnHeight );
 571 }
 572
 573 // ------------------------------------------------------------------
 574
 575 sal_uInt16 QuartzSalBitmap::GetBitCount() const
 576 {
 577     return mnBits;
 578 }
 579
 580 // ------------------------------------------------------------------
 581
 582 static struct pal_entry
 583 {
 584     sal_uInt8 mnRed;
 585     sal_uInt8 mnGreen;
 586     sal_uInt8 mnBlue;
 587 }
 588 const aImplSalSysPalEntryAry[ 16 ] =
 589 {
 590 {    0,    0,    0 },
 591 {    0,    0, 0x80 },
 592 {    0, 0x80,    0 },
 593 {    0, 0x80, 0x80 },
 594 { 0x80,    0,    0 },
 595 { 0x80,    0, 0x80 },
 596 { 0x80, 0x80,    0 },
 597 { 0x80, 0x80, 0x80 },
 598 { 0xC0, 0xC0, 0xC0 },
 599 {    0,    0, 0xFF },
 600 {    0, 0xFF,    0 },
 601 {    0, 0xFF, 0xFF },
 602 { 0xFF,    0,    0 },
 603 { 0xFF,    0, 0xFF },
 604 { 0xFF, 0xFF,    0 },
 605 { 0xFF, 0xFF, 0xFF }
 606 };
 607
 608 const BitmapPalette& GetDefaultPalette( int mnBits, bool bMonochrome )
 609 {
 610     if( bMonochrome )
 611         return Bitmap::GetGreyPalette( 1U << mnBits );
 612
 613     // at this point we should provide some kind of default palette
 614     // since all other platforms do so, too.
 615     static bool bDefPalInit = false;
 616     static BitmapPalette aDefPalette256;
 617     static BitmapPalette aDefPalette16;
 618     static BitmapPalette aDefPalette2;
 619     if( ! bDefPalInit )
 620     {
 621         bDefPalInit = true;
 622         aDefPalette256.SetEntryCount( 256 );
 623         aDefPalette16.SetEntryCount( 16 );
 624         aDefPalette2.SetEntryCount( 2 );
 625
 626         // Standard colors
 627         unsigned int i;
 628         for( i = 0; i < 16; i++ )
 629         {
 630             aDefPalette16[i] =
 631             aDefPalette256[i] = BitmapColor( aImplSalSysPalEntryAry[i].mnRed,
 632                                              aImplSalSysPalEntryAry[i].mnGreen,
 633                                              aImplSalSysPalEntryAry[i].mnBlue );
 634             }
 635
 636         aDefPalette2[0] = BitmapColor( 0, 0, 0 );
 637         aDefPalette2[1] = BitmapColor( 0xff, 0xff, 0xff );
 638
 639         // own palette (6/6/6)
 640         const int DITHER_PAL_STEPS = 6;
 641         const sal_uInt8 DITHER_PAL_DELTA = 51;
 642         int nB, nG, nR;
 643         sal_uInt8 nRed, nGreen, nBlue;
 644         for( nB=0, nBlue=0; nB < DITHER_PAL_STEPS; nB++, nBlue += DITHER_PAL_DELTA )
 645         {
 646             for( nG=0, nGreen=0; nG < DITHER_PAL_STEPS; nG++, nGreen += DITHER_PAL_DELTA )
 647             {
 648                 for( nR=0, nRed=0; nR < DITHER_PAL_STEPS; nR++, nRed += DITHER_PAL_DELTA )
 649                 {
 650                     aDefPalette256[ i ] = BitmapColor( nRed, nGreen, nBlue );
 651                     i++;
 652                 }
 653             }
 654         }
 655     }
 656
 657     // now fill in appropriate palette
 658     switch( mnBits )
 659     {
 660     case 1: return aDefPalette2;
 661     case 4: return aDefPalette16;
 662     case 8: return aDefPalette256;
 663     default: break;
 664     }
 665
 666     const static BitmapPalette aEmptyPalette;
 667     return aEmptyPalette;
 668 }
 669
 670 BitmapBuffer* QuartzSalBitmap::AcquireBuffer( bool /*bReadOnly*/ )
 671 {
 672     if( !maUserBuffer.get() )
 673 //  || maContextBuffer.get() && (maUserBuffer.get() != maContextBuffer.get()) )
 674     {
 675         fprintf(stderr,"ASB::Acq(%dx%d,d=%d)\n",mnWidth,mnHeight,mnBits);
 676         // TODO: AllocateUserData();
 677         return NULL;
 678     }
 679
 680     BitmapBuffer* pBuffer = new BitmapBuffer;
 681     pBuffer->mnWidth = mnWidth;
 682     pBuffer->mnHeight = mnHeight;
 683     pBuffer->maPalette = maPalette;
 684     pBuffer->mnScanlineSize = mnBytesPerRow;
 685     pBuffer->mpBits = maUserBuffer.get();
 686     pBuffer->mnBitCount = mnBits;
 687     switch( mnBits )
 688     {
 689     case 1:     pBuffer->mnFormat = BMP_FORMAT_1BIT_MSB_PAL; break;
 690     case 4:     pBuffer->mnFormat = BMP_FORMAT_4BIT_MSN_PAL; break;
 691     case 8:     pBuffer->mnFormat = BMP_FORMAT_8BIT_PAL; break;
 692     case 16:    pBuffer->mnFormat = BMP_FORMAT_16BIT_TC_MSB_MASK;
 693                 pBuffer->maColorMask  = ColorMask( k16BitRedColorMask, k16BitGreenColorMask, k16BitBlueColorMask );
 694                 break;
 695     case 24:    pBuffer->mnFormat = BMP_FORMAT_24BIT_TC_BGR; break;
 696     case 32:    pBuffer->mnFormat = BMP_FORMAT_32BIT_TC_ARGB;
 697                 pBuffer->maColorMask  = ColorMask( k32BitRedColorMask, k32BitGreenColorMask, k32BitBlueColorMask );
 698                 break;
 699     }
 700     pBuffer->mnFormat |= BMP_FORMAT_BOTTOM_UP;
 701
 702     // some BitmapBuffer users depend on a complete palette
 703     if( (mnBits <= 8) && !maPalette )
 704         pBuffer->maPalette = GetDefaultPalette( mnBits, true );
 705
 706     return pBuffer;
 707 }
 708
 709 // ------------------------------------------------------------------
 710
 711 void QuartzSalBitmap::ReleaseBuffer( BitmapBuffer* pBuffer, bool bReadOnly )
 712 {
 713     // invalidate graphic context if we have different data
 714     if( !bReadOnly )
 715     {
 716         maPalette = pBuffer->maPalette;
 717         if( mxGraphicContext )
 718             DestroyContext();
 719     }
 720
 721     delete pBuffer;
 722 }
 723
 724 // ------------------------------------------------------------------
 725
 726 CGImageRef QuartzSalBitmap::CreateCroppedImage( int nX, int nY, int nNewWidth, int nNewHeight ) const
 727 {
 728     if( !mxCachedImage )
 729     {
 730         if( !mxGraphicContext )
 731             if( !const_cast<QuartzSalBitmap*>(this)->CreateContext() )
 732                 return NULL;
 733
 734         mxCachedImage = CGBitmapContextCreateImage( mxGraphicContext );
 735     }
 736
 737     CGImageRef xCroppedImage = NULL;
 738     // short circuit if there is nothing to crop
 739     if( !nX && !nY && (mnWidth == nNewWidth) && (mnHeight == nNewHeight) )
 740     {
 741           xCroppedImage = mxCachedImage;
 742           CFRetain( xCroppedImage );
 743     }
 744     else
 745     {
 746         nY = mnHeight - (nY + nNewHeight); // adjust for y-mirrored context
 747         const CGRect aCropRect = { { static_cast<CGFloat>(nX), static_cast<CGFloat>(nY) }, { static_cast<CGFloat>(nNewWidth), static_cast<CGFloat>(nNewHeight) } };
 748         xCroppedImage = CGImageCreateWithImageInRect( mxCachedImage, aCropRect );
 749     }
 750
 751     return xCroppedImage;
 752 }
 753
 754 // ------------------------------------------------------------------
 755
 756 static void CFRTLFree(void* /*info*/, const void* data, size_t /*size*/)
 757 {
 758     rtl_freeMemory( const_cast<void*>(data) );
 759 }
 760
 761 CGImageRef QuartzSalBitmap::CreateWithMask( const QuartzSalBitmap& rMask,
 762     int nX, int nY, int nWidth, int nHeight ) const
 763 {
 764     CGImageRef xImage( CreateCroppedImage( nX, nY, nWidth, nHeight ) );
 765     if( !xImage )
 766         return NULL;
 767
 768     CGImageRef xMask = rMask.CreateCroppedImage( nX, nY, nWidth, nHeight );
 769     if( !xMask )
 770         return xImage;
 771
 772     // CGImageCreateWithMask() only likes masks or greyscale images => convert if needed
 773     // TODO: isolate in an extra method?
 774     if( !CGImageIsMask(xMask) || (CGImageGetColorSpace(xMask) != GetSalData()->mxGraySpace) )
 775     {
 776         const CGRect xImageRect=CGRectMake( 0, 0, nWidth, nHeight );//the rect has no offset
 777
 778         // create the alpha mask image fitting our image
 779         // TODO: is caching the full mask or the subimage mask worth it?
 780         int nMaskBytesPerRow = ((nWidth + 3) & ~3);
 781         void* pMaskMem = rtl_allocateMemory( nMaskBytesPerRow * nHeight );
 782         CGContextRef xMaskContext = CGBitmapContextCreate( pMaskMem,
 783             nWidth, nHeight, 8, nMaskBytesPerRow, GetSalData()->mxGraySpace, kCGImageAlphaNone );
 784         CGContextDrawImage( xMaskContext, xImageRect, xMask );
 785         CFRelease( xMask );
 786         CGDataProviderRef xDataProvider( CGDataProviderCreateWithData( NULL,
 787         pMaskMem, nHeight * nMaskBytesPerRow, &CFRTLFree ) );
 788         static const CGFloat* pDecode = NULL;
 789         xMask = CGImageMaskCreate( nWidth, nHeight, 8, 8, nMaskBytesPerRow, xDataProvider, pDecode, false );
 790         CFRelease( xDataProvider );
 791         CFRelease( xMaskContext );
 792     }
 793
 794     if( !xMask )
 795         return xImage;
 796
 797     // combine image and alpha mask
 798     CGImageRef xMaskedImage = CGImageCreateWithMask( xImage, xMask );
 799     CFRelease( xMask );
 800     CFRelease( xImage );
 801     return xMaskedImage;
 802 }
 803
 804 // ------------------------------------------------------------------
 805
 806 /** creates an image from the given rectangle, replacing all black pixels with nMaskColor and make all other full transparent */
 807 CGImageRef QuartzSalBitmap::CreateColorMask( int nX, int nY, int nWidth, int nHeight, SalColor nMaskColor ) const
 808 {
 809     CGImageRef xMask = 0;
 810     if( maUserBuffer.get() && (nX + nWidth <= mnWidth) && (nY + nHeight <= mnHeight) )
 811     {
 812         const sal_uInt32 nDestBytesPerRow = nWidth << 2;
 813         sal_uInt32* pMaskBuffer = static_cast<sal_uInt32*>( rtl_allocateMemory( nHeight * nDestBytesPerRow ) );
 814         sal_uInt32* pDest = pMaskBuffer;
 815
 816         ImplPixelFormat* pSourcePixels = ImplPixelFormat::GetFormat( mnBits, maPalette );
 817
 818         if( pMaskBuffer && pSourcePixels )
 819         {
 820             sal_uInt32 nColor;
 821             reinterpret_cast<sal_uInt8*>(&nColor)[0] = 0xff;
 822             reinterpret_cast<sal_uInt8*>(&nColor)[1] = SALCOLOR_RED( nMaskColor );
 823             reinterpret_cast<sal_uInt8*>(&nColor)[2] = SALCOLOR_GREEN( nMaskColor );
 824             reinterpret_cast<sal_uInt8*>(&nColor)[3] = SALCOLOR_BLUE( nMaskColor );
 825
 826             sal_uInt8* pSource = maUserBuffer.get();
 827             if( nY )
 828                 pSource += nY * mnBytesPerRow;
 829
 830             int y = nHeight;
 831             while( y-- )
 832             {
 833                 pSourcePixels->StartLine( pSource );
 834                 pSourcePixels->SkipPixel(nX);
 835                 sal_uInt32 x = nWidth;
 836                 while( x-- )
 837                 {
 838                     *pDest++ = ( pSourcePixels->ReadPixel() == 0 ) ? nColor : 0;
 839                 }
 840                 pSource += mnBytesPerRow;
 841             }
 842
 843             CGDataProviderRef xDataProvider( CGDataProviderCreateWithData(NULL, pMaskBuffer, nHeight * nDestBytesPerRow, &CFRTLFree) );
 844             xMask = CGImageCreate(nWidth, nHeight, 8, 32, nDestBytesPerRow, GetSalData()->mxRGBSpace, kCGImageAlphaPremultipliedFirst, xDataProvider, NULL, true, kCGRenderingIntentDefault);
 845             CFRelease(xDataProvider);
 846         }
 847         else
 848         {
 849             free(pMaskBuffer);
 850         }
 851
 852         delete pSourcePixels;
 853     }
 854     return xMask;
 855 }
 856
 857 // =======================================================================
 858
 859 /** QuartzSalBitmap::GetSystemData Get platform native image data from existing image
 860  *
 861  *  @param rData struct BitmapSystemData, defined in vcl/inc/bitmap.hxx
 862  *  @return true if successful
 863 **/
 864 bool QuartzSalBitmap::GetSystemData( BitmapSystemData& rData )
 865 {
 866     bool bRet = false;
 867
 868     if( !mxGraphicContext )
 869         CreateContext();
 870
 871     if ( mxGraphicContext )
 872     {
 873         bRet = true;
 874
 875         if ((CGBitmapContextGetBitsPerPixel(mxGraphicContext) == 32) &&
 876             (CGBitmapContextGetBitmapInfo(mxGraphicContext) & kCGBitmapByteOrderMask) != kCGBitmapByteOrder32Host) {
 877             /**
 878              * We need to hack things because VCL does not use kCGBitmapByteOrder32Host, while Cairo requires it.
 879              */
 880             OSL_TRACE("QuartzSalBitmap::%s(): kCGBitmapByteOrder32Host not found => inserting it.",__func__);
 881
 882             CGImageRef xImage = CGBitmapContextCreateImage (mxGraphicContext);
 883
 884             // re-create the context with single change: include kCGBitmapByteOrder32Host flag.
 885             CGContextRef mxGraphicContextNew = CGBitmapContextCreate( CGBitmapContextGetData(mxGraphicContext),
 886                                                                       CGBitmapContextGetWidth(mxGraphicContext),
 887                                                                       CGBitmapContextGetHeight(mxGraphicContext),
 888                                                                       CGBitmapContextGetBitsPerComponent(mxGraphicContext),
 889                                                                       CGBitmapContextGetBytesPerRow(mxGraphicContext),
 890                                                                       CGBitmapContextGetColorSpace(mxGraphicContext),
 891                                                                       CGBitmapContextGetBitmapInfo(mxGraphicContext) | kCGBitmapByteOrder32Host);
 892             CFRelease(mxGraphicContext);
 893
 894             // Needs to be flipped
 895             CGContextSaveGState( mxGraphicContextNew );
 896             CGContextTranslateCTM (mxGraphicContextNew, 0, CGBitmapContextGetHeight(mxGraphicContextNew));
 897             CGContextScaleCTM (mxGraphicContextNew, 1.0, -1.0);
 898
 899             CGContextDrawImage(mxGraphicContextNew, CGRectMake( 0, 0, CGImageGetWidth(xImage), CGImageGetHeight(xImage)), xImage);
 900
 901             // Flip back
 902             CGContextRestoreGState( mxGraphicContextNew );
 903
 904             CGImageRelease( xImage );
 905             mxGraphicContext = mxGraphicContextNew;
 906         }
 907
 908         rData.rImageContext = (void *) mxGraphicContext;
 909         rData.mnWidth = mnWidth;
 910         rData.mnHeight = mnHeight;
 911     }
 912
 913     return bRet;
 914 }
 915
 916 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */