vcl/source/gdi/bmpacc2.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 #include <vcl/salbtype.hxx>
  21 #include <vcl/bitmapaccess.hxx>
  22
  23 BitmapColor BitmapReadAccess::GetPixelForN1BitMsbPal(ConstScanline pScanline, long nX, const ColorMask&)
  24 {
  25     return BitmapColor( pScanline[ nX >> 3 ] & ( 1 << ( 7 - ( nX & 7 ) ) ) ? 1 : 0 );
  26 }
  27
  28 void BitmapReadAccess::SetPixelForN1BitMsbPal(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  29 {
  30     sal_uInt8& rByte = pScanline[ nX >> 3 ];
  31
  32     ( rBitmapColor.GetIndex() & 1 ) ? ( rByte |= 1 << ( 7 - ( nX & 7 ) ) ) :
  33                                       ( rByte &= ~( 1 << ( 7 - ( nX & 7 ) ) ) );
  34 }
  35
  36 BitmapColor BitmapReadAccess::GetPixelForN1BitLsbPal(ConstScanline pScanline, long nX, const ColorMask&)
  37 {
  38     return BitmapColor( pScanline[ nX >> 3 ] & ( 1 << ( nX & 7 ) ) ? 1 : 0 );
  39 }
  40
  41 void BitmapReadAccess::SetPixelForN1BitLsbPal(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  42 {
  43     sal_uInt8& rByte = pScanline[ nX >> 3 ];
  44
  45     ( rBitmapColor.GetIndex() & 1 ) ? ( rByte |= 1 << ( nX & 7 ) ) :
  46                                       ( rByte &= ~( 1 << ( nX & 7 ) ) );
  47 }
  48
  49 BitmapColor BitmapReadAccess::GetPixelForN4BitMsnPal(ConstScanline pScanline, long nX, const ColorMask&)
  50 {
  51     return BitmapColor( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 0 : 4 ) ) & 0x0f );
  52 }
  53
  54 void BitmapReadAccess::SetPixelForN4BitMsnPal(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  55 {
  56     sal_uInt8& rByte = pScanline[ nX >> 1 ];
  57
  58     ( nX & 1 ) ? ( rByte &= 0xf0, rByte |= ( rBitmapColor.GetIndex() & 0x0f ) ) :
  59                  ( rByte &= 0x0f, rByte |= ( rBitmapColor.GetIndex() << 4 ) );
  60 }
  61
  62 BitmapColor BitmapReadAccess::GetPixelForN4BitLsnPal(ConstScanline pScanline, long nX, const ColorMask&)
  63 {
  64     return BitmapColor( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 4 : 0 ) ) & 0x0f );
  65 }
  66
  67 void BitmapReadAccess::SetPixelForN4BitLsnPal(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  68 {
  69     sal_uInt8& rByte = pScanline[ nX >> 1 ];
  70
  71     ( nX & 1 ) ? ( rByte &= 0x0f, rByte |= ( rBitmapColor.GetIndex() << 4 ) ) :
  72                  ( rByte &= 0xf0, rByte |= ( rBitmapColor.GetIndex() & 0x0f ) );
  73 }
  74
  75 BitmapColor BitmapReadAccess::GetPixelForN8BitPal(ConstScanline pScanline, long nX, const ColorMask&)
  76 {
  77     return BitmapColor( pScanline[ nX ] );
  78 }
  79
  80 void BitmapReadAccess::SetPixelForN8BitPal(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  81 {
  82     if (rBitmapColor.IsIndex())
  83         pScanline[ nX ] = rBitmapColor.GetIndex();
  84     else
  85         // Let's hope that the RGB color values equal, so it doesn't matter what do we pick
  86         pScanline[ nX ] = rBitmapColor.GetBlueOrIndex();
  87 }
  88
  89 BitmapColor BitmapReadAccess::GetPixelForN8BitTcMask(ConstScanline pScanline, long nX, const ColorMask& rMask)
  90 {
  91     BitmapColor aColor;
  92     rMask.GetColorFor8Bit( aColor, pScanline + nX );
  93     return aColor;
  94 }
  95
  96 void BitmapReadAccess::SetPixelForN8BitTcMask(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask)
  97 {
  98     rMask.SetColorFor8Bit( rBitmapColor, pScanline + nX );
  99 }
 100
 101
 102 BitmapColor BitmapReadAccess::GetPixelForN16BitTcMsbMask(ConstScanline pScanline, long nX, const ColorMask& rMask)
 103 {
 104     BitmapColor aColor;
 105     rMask.GetColorFor16BitMSB( aColor, pScanline + ( nX << 1UL ) );
 106     return aColor;
 107 }
 108
 109 void BitmapReadAccess::SetPixelForN16BitTcMsbMask(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask)
 110 {
 111     rMask.SetColorFor16BitMSB( rBitmapColor, pScanline + ( nX << 1UL ) );
 112 }
 113
 114 BitmapColor BitmapReadAccess::GetPixelForN16BitTcLsbMask(ConstScanline pScanline, long nX, const ColorMask& rMask)
 115 {
 116     BitmapColor aColor;
 117     rMask.GetColorFor16BitLSB( aColor, pScanline + ( nX << 1UL ) );
 118     return aColor;
 119 }
 120
 121 void BitmapReadAccess::SetPixelForN16BitTcLsbMask(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask)
 122 {
 123     rMask.SetColorFor16BitLSB( rBitmapColor, pScanline + ( nX << 1UL ) );
 124 }
 125
 126 BitmapColor BitmapReadAccess::GetPixelForN24BitTcBgr(ConstScanline pScanline, long nX, const ColorMask&)
 127 {
 128     BitmapColor aBitmapColor;
 129
 130     pScanline = pScanline + nX * 3;
 131     aBitmapColor.SetBlue( *pScanline++ );
 132     aBitmapColor.SetGreen( *pScanline++ );
 133     aBitmapColor.SetRed( *pScanline );
 134
 135     return aBitmapColor;
 136 }
 137
 138 void BitmapReadAccess::SetPixelForN24BitTcBgr(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 139 {
 140     pScanline = pScanline + nX * 3;
 141     *pScanline++ = rBitmapColor.GetBlue();
 142     *pScanline++ = rBitmapColor.GetGreen();
 143     *pScanline = rBitmapColor.GetRed();
 144 }
 145
 146 BitmapColor BitmapReadAccess::GetPixelForN24BitTcRgb(ConstScanline pScanline, long nX, const ColorMask&)
 147 {
 148     BitmapColor aBitmapColor;
 149
 150     pScanline = pScanline + nX * 3;
 151     aBitmapColor.SetRed( *pScanline++ );
 152     aBitmapColor.SetGreen( *pScanline++ );
 153     aBitmapColor.SetBlue( *pScanline );
 154
 155     return aBitmapColor;
 156 }
 157
 158 void BitmapReadAccess::SetPixelForN24BitTcRgb(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 159 {
 160     pScanline = pScanline + nX * 3;
 161     *pScanline++ = rBitmapColor.GetRed();
 162     *pScanline++ = rBitmapColor.GetGreen();
 163     *pScanline = rBitmapColor.GetBlue();
 164 }
 165
 166 BitmapColor BitmapReadAccess::GetPixelForN32BitTcAbgr(ConstScanline pScanline, long nX, const ColorMask&)
 167 {
 168     BitmapColor aBitmapColor;
 169
 170     pScanline = pScanline + ( nX << 2 ) + 1;
 171     aBitmapColor.SetBlue( *pScanline++ );
 172     aBitmapColor.SetGreen( *pScanline++ );
 173     aBitmapColor.SetRed( *pScanline );
 174
 175     return aBitmapColor;
 176 }
 177
 178 void BitmapReadAccess::SetPixelForN32BitTcAbgr(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 179 {
 180     pScanline = pScanline + ( nX << 2 );
 181     *pScanline++ = 0xFF;
 182     *pScanline++ = rBitmapColor.GetBlue();
 183     *pScanline++ = rBitmapColor.GetGreen();
 184     *pScanline = rBitmapColor.GetRed();
 185 }
 186
 187 BitmapColor BitmapReadAccess::GetPixelForN32BitTcArgb(ConstScanline pScanline, long nX, const ColorMask&)
 188 {
 189     BitmapColor aBitmapColor;
 190
 191     pScanline = pScanline + ( nX << 2 ) + 1;
 192     aBitmapColor.SetRed( *pScanline++ );
 193     aBitmapColor.SetGreen( *pScanline++ );
 194     aBitmapColor.SetBlue( *pScanline );
 195
 196     return aBitmapColor;
 197 }
 198
 199 void BitmapReadAccess::SetPixelForN32BitTcArgb(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 200 {
 201     pScanline = pScanline + ( nX << 2 );
 202     *pScanline++ = 0xFF;
 203     *pScanline++ = rBitmapColor.GetRed();
 204     *pScanline++ = rBitmapColor.GetGreen();
 205     *pScanline = rBitmapColor.GetBlue();
 206 }
 207
 208 BitmapColor BitmapReadAccess::GetPixelForN32BitTcBgra(ConstScanline pScanline, long nX, const ColorMask&)
 209 {
 210     BitmapColor aBitmapColor;
 211
 212     pScanline = pScanline + ( nX << 2 );
 213     aBitmapColor.SetBlue( *pScanline++ );
 214     aBitmapColor.SetGreen( *pScanline++ );
 215     aBitmapColor.SetRed( *pScanline );
 216
 217     return aBitmapColor;
 218 }
 219
 220 void BitmapReadAccess::SetPixelForN32BitTcBgra(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 221 {
 222     pScanline = pScanline + ( nX << 2 );
 223     *pScanline++ = rBitmapColor.GetBlue();
 224     *pScanline++ = rBitmapColor.GetGreen();
 225     *pScanline++ = rBitmapColor.GetRed();
 226     *pScanline = 0xFF;
 227 }
 228
 229 BitmapColor BitmapReadAccess::GetPixelForN32BitTcRgba(ConstScanline pScanline, long nX, const ColorMask&)
 230 {
 231     BitmapColor aBitmapColor;
 232
 233     pScanline = pScanline + ( nX << 2 );
 234     aBitmapColor.SetRed( *pScanline++ );
 235     aBitmapColor.SetGreen( *pScanline++ );
 236     aBitmapColor.SetBlue( *pScanline );
 237
 238     return aBitmapColor;
 239 }
 240
 241 void BitmapReadAccess::SetPixelForN32BitTcRgba(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 242 {
 243     pScanline = pScanline + ( nX << 2 );
 244     *pScanline++ = rBitmapColor.GetRed();
 245     *pScanline++ = rBitmapColor.GetGreen();
 246     *pScanline++ = rBitmapColor.GetBlue();
 247     *pScanline = 0xFF;
 248 }
 249
 250 BitmapColor BitmapReadAccess::GetPixelForN32BitTcMask(ConstScanline pScanline, long nX, const ColorMask& rMask)
 251 {
 252     BitmapColor aColor;
 253     rMask.GetColorFor32Bit( aColor, pScanline + ( nX << 2UL ) );
 254     return aColor;
 255 }
 256
 257 void BitmapReadAccess::SetPixelForN32BitTcMask(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask)
 258 {
 259     rMask.SetColorFor32Bit( rBitmapColor, pScanline + ( nX << 2UL ) );
 260 }
 261
 262 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */