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/bitmapaccess.hxx>
  21 #include <vcl/BitmapTools.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(const Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  29 {
  30     sal_uInt8& rByte = pScanline[ nX >> 3 ];
  31
  32     if ( rBitmapColor.GetIndex() & 1 )
  33         rByte |= 1 << ( 7 - ( nX & 7 ) );
  34     else
  35         rByte &= ~( 1 << ( 7 - ( nX & 7 ) ) );
  36 }
  37
  38 BitmapColor BitmapReadAccess::GetPixelForN1BitLsbPal(ConstScanline pScanline, long nX, const ColorMask&)
  39 {
  40     return BitmapColor( pScanline[ nX >> 3 ] & ( 1 << ( nX & 7 ) ) ? 1 : 0 );
  41 }
  42
  43 void BitmapReadAccess::SetPixelForN1BitLsbPal(const Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  44 {
  45     sal_uInt8& rByte = pScanline[ nX >> 3 ];
  46
  47     if ( rBitmapColor.GetIndex() & 1 )
  48         rByte |= 1 << ( nX & 7 );
  49     else
  50         rByte &= ~( 1 << ( nX & 7 ) );
  51 }
  52
  53 BitmapColor BitmapReadAccess::GetPixelForN4BitMsnPal(ConstScanline pScanline, long nX, const ColorMask&)
  54 {
  55     return BitmapColor( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 0 : 4 ) ) & 0x0f );
  56 }
  57
  58 void BitmapReadAccess::SetPixelForN4BitMsnPal(const Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  59 {
  60     sal_uInt8& rByte = pScanline[ nX >> 1 ];
  61
  62     if ( nX & 1 )
  63     {
  64         rByte &= 0xf0;
  65         rByte |= ( rBitmapColor.GetIndex() & 0x0f );
  66     }
  67     else
  68     {
  69         rByte &= 0x0f;
  70         rByte |= ( rBitmapColor.GetIndex() << 4 );
  71     }
  72 }
  73
  74 BitmapColor BitmapReadAccess::GetPixelForN4BitLsnPal(ConstScanline pScanline, long nX, const ColorMask&)
  75 {
  76     return BitmapColor( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 4 : 0 ) ) & 0x0f );
  77 }
  78
  79 void BitmapReadAccess::SetPixelForN4BitLsnPal(const Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
  80 {
  81     sal_uInt8& rByte = pScanline[ nX >> 1 ];
  82
  83     if ( nX & 1 )
  84     {
  85         rByte &= 0x0f;
  86         rByte |= ( rBitmapColor.GetIndex() << 4 );
  87     }
  88     else
  89     {
  90         rByte &= 0xf0;
  91         rByte |= ( rBitmapColor.GetIndex() & 0x0f );
  92     }
  93 }
  94
  95 BitmapColor BitmapReadAccess::GetPixelForN8BitPal(ConstScanline pScanline, long nX, const ColorMask&)
  96 {
  97     return BitmapColor( pScanline[ nX ] );
  98 }
  99
 100 void BitmapReadAccess::SetPixelForN8BitPal(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 101 {
 102     pScanline[ nX ] = rBitmapColor.GetIndex();
 103 }
 104
 105 BitmapColor BitmapReadAccess::GetPixelForN8BitTcMask(ConstScanline pScanline, long nX, const ColorMask& rMask)
 106 {
 107     BitmapColor aColor;
 108     rMask.GetColorFor8Bit( aColor, pScanline + nX );
 109     return aColor;
 110 }
 111
 112 void BitmapReadAccess::SetPixelForN8BitTcMask(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask)
 113 {
 114     rMask.SetColorFor8Bit( rBitmapColor, pScanline + nX );
 115 }
 116
 117
 118 BitmapColor BitmapReadAccess::GetPixelForN24BitTcBgr(ConstScanline pScanline, long nX, const ColorMask&)
 119 {
 120     BitmapColor aBitmapColor;
 121
 122     pScanline = pScanline + nX * 3;
 123     aBitmapColor.SetBlue( *pScanline++ );
 124     aBitmapColor.SetGreen( *pScanline++ );
 125     aBitmapColor.SetRed( *pScanline );
 126
 127     return aBitmapColor;
 128 }
 129
 130 void BitmapReadAccess::SetPixelForN24BitTcBgr(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 131 {
 132     pScanline = pScanline + nX * 3;
 133     *pScanline++ = rBitmapColor.GetBlue();
 134     *pScanline++ = rBitmapColor.GetGreen();
 135     *pScanline = rBitmapColor.GetRed();
 136 }
 137
 138 BitmapColor BitmapReadAccess::GetPixelForN24BitTcRgb(ConstScanline pScanline, long nX, const ColorMask&)
 139 {
 140     BitmapColor aBitmapColor;
 141
 142     pScanline = pScanline + nX * 3;
 143     aBitmapColor.SetRed( *pScanline++ );
 144     aBitmapColor.SetGreen( *pScanline++ );
 145     aBitmapColor.SetBlue( *pScanline );
 146
 147     return aBitmapColor;
 148 }
 149
 150 void BitmapReadAccess::SetPixelForN24BitTcRgb(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 151 {
 152     pScanline = pScanline + nX * 3;
 153     *pScanline++ = rBitmapColor.GetRed();
 154     *pScanline++ = rBitmapColor.GetGreen();
 155     *pScanline = rBitmapColor.GetBlue();
 156 }
 157
 158 BitmapColor BitmapReadAccess::GetPixelForN32BitTcAbgr(ConstScanline pScanline, long nX, const ColorMask&)
 159 {
 160     pScanline = pScanline + nX * 4;
 161
 162     sal_uInt8 a = *pScanline++;
 163     sal_uInt8 b = *pScanline++;
 164     sal_uInt8 g = *pScanline++;
 165     sal_uInt8 r = *pScanline;
 166
 167     return BitmapColor(
 168             vcl::bitmap::unpremultiply(r, a),
 169             vcl::bitmap::unpremultiply(g, a),
 170             vcl::bitmap::unpremultiply(b, a),
 171             0xFF - a);
 172 }
 173
 174 BitmapColor BitmapReadAccess::GetPixelForN32BitTcXbgr(ConstScanline pScanline, long nX, const ColorMask&)
 175 {
 176     BitmapColor aBitmapColor;
 177
 178     pScanline = pScanline + ( nX << 2 ) + 1;
 179     aBitmapColor.SetBlue( *pScanline++ );
 180     aBitmapColor.SetGreen( *pScanline++ );
 181     aBitmapColor.SetRed( *pScanline );
 182
 183     return aBitmapColor;
 184 }
 185
 186 void BitmapReadAccess::SetPixelForN32BitTcAbgr(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 187 {
 188     pScanline = pScanline + nX * 4;
 189
 190     sal_uInt8 alpha = 0xFF - rBitmapColor.GetAlpha();
 191     *pScanline++ = alpha;
 192     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
 193     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
 194     *pScanline   = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
 195 }
 196
 197 void BitmapReadAccess::SetPixelForN32BitTcXbgr(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 198 {
 199     pScanline = pScanline + ( nX << 2 );
 200     *pScanline++ = 0xFF;
 201     *pScanline++ = rBitmapColor.GetBlue();
 202     *pScanline++ = rBitmapColor.GetGreen();
 203     *pScanline = rBitmapColor.GetRed();
 204 }
 205
 206 BitmapColor BitmapReadAccess::GetPixelForN32BitTcArgb(ConstScanline pScanline, long nX, const ColorMask&)
 207 {
 208     pScanline = pScanline + nX * 4;
 209
 210     sal_uInt8 a = *pScanline++;
 211     sal_uInt8 r = *pScanline++;
 212     sal_uInt8 g = *pScanline++;
 213     sal_uInt8 b = *pScanline;
 214
 215     return BitmapColor(
 216             vcl::bitmap::unpremultiply(r, a),
 217             vcl::bitmap::unpremultiply(g, a),
 218             vcl::bitmap::unpremultiply(b, a),
 219             0xFF - a);
 220 }
 221
 222 BitmapColor BitmapReadAccess::GetPixelForN32BitTcXrgb(ConstScanline pScanline, long nX, const ColorMask&)
 223 {
 224     BitmapColor aBitmapColor;
 225
 226     pScanline = pScanline + ( nX << 2 ) + 1;
 227     aBitmapColor.SetRed( *pScanline++ );
 228     aBitmapColor.SetGreen( *pScanline++ );
 229     aBitmapColor.SetBlue( *pScanline );
 230
 231     return aBitmapColor;
 232 }
 233
 234 void BitmapReadAccess::SetPixelForN32BitTcArgb(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 235 {
 236     pScanline = pScanline + nX * 4;
 237
 238     sal_uInt8 alpha = 0xFF - rBitmapColor.GetAlpha();
 239     *pScanline++ = alpha;
 240     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
 241     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
 242     *pScanline   = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
 243 }
 244
 245 void BitmapReadAccess::SetPixelForN32BitTcXrgb(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 246 {
 247     pScanline = pScanline + ( nX << 2 );
 248     *pScanline++ = 0xFF;
 249     *pScanline++ = rBitmapColor.GetRed();
 250     *pScanline++ = rBitmapColor.GetGreen();
 251     *pScanline = rBitmapColor.GetBlue();
 252 }
 253
 254 BitmapColor BitmapReadAccess::GetPixelForN32BitTcBgra(ConstScanline pScanline, long nX, const ColorMask&)
 255 {
 256     pScanline = pScanline + nX * 4;
 257
 258     sal_uInt8 b = *pScanline++;
 259     sal_uInt8 g = *pScanline++;
 260     sal_uInt8 r = *pScanline++;
 261     sal_uInt8 a = *pScanline;
 262
 263     return BitmapColor(
 264             vcl::bitmap::unpremultiply(r, a),
 265             vcl::bitmap::unpremultiply(g, a),
 266             vcl::bitmap::unpremultiply(b, a),
 267             0xFF - a);
 268 }
 269
 270 BitmapColor BitmapReadAccess::GetPixelForN32BitTcBgrx(ConstScanline pScanline, long nX, const ColorMask&)
 271 {
 272     BitmapColor aBitmapColor;
 273
 274     pScanline = pScanline + ( nX << 2 );
 275     aBitmapColor.SetBlue( *pScanline++ );
 276     aBitmapColor.SetGreen( *pScanline++ );
 277     aBitmapColor.SetRed( *pScanline );
 278
 279     return aBitmapColor;
 280 }
 281
 282 void BitmapReadAccess::SetPixelForN32BitTcBgra(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 283 {
 284     pScanline = pScanline + nX * 4;
 285
 286     sal_uInt8 alpha = 0xFF - rBitmapColor.GetAlpha();
 287     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
 288     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
 289     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
 290     *pScanline = alpha;
 291 }
 292
 293 void BitmapReadAccess::SetPixelForN32BitTcBgrx(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 294 {
 295     pScanline = pScanline + ( nX << 2 );
 296     *pScanline++ = rBitmapColor.GetBlue();
 297     *pScanline++ = rBitmapColor.GetGreen();
 298     *pScanline++ = rBitmapColor.GetRed();
 299     *pScanline = 0xFF;
 300 }
 301
 302 BitmapColor BitmapReadAccess::GetPixelForN32BitTcRgba(ConstScanline pScanline, long nX, const ColorMask&)
 303 {
 304     pScanline = pScanline + nX * 4;
 305
 306     sal_uInt8 r = *pScanline++;
 307     sal_uInt8 g = *pScanline++;
 308     sal_uInt8 b = *pScanline++;
 309     sal_uInt8 a = *pScanline;
 310
 311     return BitmapColor(
 312             vcl::bitmap::unpremultiply(r, a),
 313             vcl::bitmap::unpremultiply(g, a),
 314             vcl::bitmap::unpremultiply(b, a),
 315             0xFF - a);
 316 }
 317
 318 BitmapColor BitmapReadAccess::GetPixelForN32BitTcRgbx(ConstScanline pScanline, long nX, const ColorMask&)
 319 {
 320     BitmapColor aBitmapColor;
 321
 322     pScanline = pScanline + ( nX << 2 );
 323     aBitmapColor.SetRed( *pScanline++ );
 324     aBitmapColor.SetGreen( *pScanline++ );
 325     aBitmapColor.SetBlue( *pScanline );
 326
 327     return aBitmapColor;
 328 }
 329
 330 void BitmapReadAccess::SetPixelForN32BitTcRgba(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 331 {
 332     pScanline = pScanline + nX * 4;
 333
 334     sal_uInt8 alpha = 0xFF - rBitmapColor.GetAlpha();
 335     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
 336     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
 337     *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
 338     *pScanline = alpha;
 339 }
 340
 341 void BitmapReadAccess::SetPixelForN32BitTcRgbx(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask&)
 342 {
 343     pScanline = pScanline + ( nX << 2 );
 344     *pScanline++ = rBitmapColor.GetRed();
 345     *pScanline++ = rBitmapColor.GetGreen();
 346     *pScanline++ = rBitmapColor.GetBlue();
 347     *pScanline = 0xFF;
 348 }
 349
 350 BitmapColor BitmapReadAccess::GetPixelForN32BitTcMask(ConstScanline pScanline, long nX, const ColorMask& rMask)
 351 {
 352     BitmapColor aColor;
 353     rMask.GetColorFor32Bit( aColor, pScanline + ( nX << 2 ) );
 354     return aColor;
 355 }
 356
 357 void BitmapReadAccess::SetPixelForN32BitTcMask(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask)
 358 {
 359     rMask.SetColorFor32Bit( rBitmapColor, pScanline + ( nX << 2 ) );
 360 }
 361
 362 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */