vcl/generic/glyphs/gcach_rbmp.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 "generic/glyphcache.hxx"
  21 #include <string.h>
  22
  23 RawBitmap::RawBitmap()
  24     : mnAllocated(0)
  25     , mnWidth(0)
  26     , mnHeight(0)
  27     , mnScanlineSize(0)
  28     , mnBitCount(0)
  29     , mnXOffset(0)
  30     , mnYOffset(0)
  31 {
  32 }
  33
  34 RawBitmap::~RawBitmap()
  35 {}
  36
  37 // used by 90 and 270 degree rotations on 8 bit deep bitmaps
  38 static void ImplRotate8_90( unsigned char* p1, const unsigned char* p2,
  39     int xmax, int ymax, int dx, int dy, int nPad )
  40 {
  41     for( int y = ymax; --y >= 0; p2 += dy )
  42     {
  43         for( int x = xmax; --x >= 0; p2 += dx )
  44             *(p1++) = *p2;
  45         for( int i = nPad; --i >= 0; )
  46             *(p1++) = 0;
  47     }
  48 }
  49
  50 // used by inplace 180 degree rotation on 8 bit deep bitmaps
  51 static void ImplRotate8_180( unsigned char* p1, int xmax, int ymax, int nPad )
  52 {
  53     unsigned char* p2 = p1 + ymax * (xmax + nPad);
  54     for( int y = ymax/2; --y >= 0; )
  55     {
  56         p2 -= nPad;
  57         for( int x = xmax; --x >= 0; )
  58         {
  59             unsigned char cTmp = *(--p2);
  60             *p2 = *p1;
  61             *(p1++) = cTmp;
  62         }
  63         p1 += nPad;
  64     }
  65
  66     // reverse middle line
  67     p2 -= nPad;
  68     while( p1 < p2 )
  69     {
  70         unsigned char cTmp = *(--p2);
  71         *p2 = *p1;
  72         *(p1++) = cTmp;
  73     }
  74 }
  75
  76 // used by 90 or 270 degree rotations on 1 bit deep bitmaps
  77 static void ImplRotate1_90( unsigned char* p1, const unsigned char* p2,
  78     int xmax, int ymax, int dx, int nShift, int nDeltaShift, int nPad )
  79 {
  80     for( int y = ymax; --y >= 0; )
  81     {
  82         unsigned nTemp = 1;
  83         const unsigned char* p20 = p2;
  84         for( int x = xmax; --x >= 0; p2 += dx )
  85         {
  86             // build bitwise and store when byte finished
  87            nTemp += nTemp + ((*p2 >> nShift) & 1);
  88             if( nTemp >= 0x100U )
  89             {
  90                 *(p1++) = (unsigned char)nTemp;
  91                 nTemp = 1;
  92             }
  93         }
  94         p2 = p20;
  95
  96         // store left aligned remainder if needed
  97         if( nTemp > 1 )
  98         {
  99             for(; nTemp < 0x100U; nTemp += nTemp ) ;
 100             *(p1++) = (unsigned char)nTemp;
 101         }
 102         // pad scanline with zeroes
 103         for( int i = nPad; --i >= 0;)
 104             *(p1++) = 0;
 105
 106         // increase/decrease shift, but keep bound inside 0 to 7
 107         nShift += nDeltaShift;
 108         if( nShift != (nShift & 7) )
 109             p2 -= nDeltaShift;
 110         nShift &= 7;
 111     }
 112 }
 113
 114 // used by 180 degrees rotations on 1 bit deep bitmaps
 115 static void ImplRotate1_180( unsigned char* p1, const unsigned char* p2,
 116     int xmax, int ymax, int nPad )
 117 {
 118     --p2;
 119     for( int y = ymax; --y >= 0; )
 120     {
 121         p2 -= nPad;
 122
 123         unsigned nTemp = 1;
 124         unsigned nInp = (0x100 + *p2) >> (-xmax & 7);
 125         for( int x = xmax; --x >= 0; )
 126         {
 127             // build bitwise and store when byte finished
 128             nTemp += nTemp + (nInp & 1);
 129             if( nTemp >= 0x100 )
 130             {
 131                 *(p1++) = (unsigned char)nTemp;
 132                 nTemp = 1;
 133             }
 134             // update input byte if needed (and available)
 135             if( (nInp >>= 1) <= 1 && ((y != 0) || (x != 0)) )
 136                 nInp = 0x100 + *(--p2);
 137         }
 138
 139         // store left aligned remainder if needed
 140         if( nTemp > 1 )
 141         {
 142             for(; nTemp < 0x100; nTemp += nTemp ) ;
 143             *(p1++) = (unsigned char)nTemp;
 144         }
 145         // scanline pad is already clean
 146         p1 += nPad;
 147     }
 148 }
 149
 150 bool RawBitmap::Rotate( int nAngle )
 151 {
 152     sal_uLong nNewScanlineSize = 0;
 153     sal_uLong nNewHeight = 0;
 154     sal_uLong nNewWidth = 0;
 155
 156     // do inplace rotation or prepare double buffered rotation
 157     switch( nAngle )
 158     {
 159         case 0:     // nothing to do
 160         case 3600:
 161             return true;
 162         default:    // non rectangular angles not allowed
 163             return false;
 164         case 1800:  // rotate by 180 degrees
 165             mnXOffset = -(mnXOffset + mnWidth);
 166             mnYOffset = -(mnYOffset + mnHeight);
 167             if( mnBitCount == 8 )
 168             {
 169                 ImplRotate8_180( mpBits.get(), mnWidth, mnHeight, mnScanlineSize-mnWidth );
 170                 return true;
 171             }
 172             nNewWidth        = mnWidth;
 173             nNewHeight       = mnHeight;
 174             nNewScanlineSize = mnScanlineSize;
 175             break;
 176         case +900:  // left by 90 degrees
 177         case -900:
 178         case 2700:  // right by 90 degrees
 179             nNewWidth        = mnHeight;
 180             nNewHeight       = mnWidth;
 181             if( mnBitCount==1 )
 182                 nNewScanlineSize = (nNewWidth + 7) / 8;
 183             else
 184                 nNewScanlineSize = (nNewWidth + 3) & -4;
 185             break;
 186     }
 187
 188     unsigned int nBufSize = nNewHeight * nNewScanlineSize;
 189     unsigned char* pBuf = new unsigned char[ nBufSize ];
 190     if( !pBuf )
 191         return false;
 192
 193     memset( pBuf, 0, nBufSize );
 194     int i;
 195
 196     // dispatch non-inplace rotations
 197     switch( nAngle )
 198     {
 199         case 1800:  // rotate by 180 degrees
 200             // we know we only need to deal with 1 bit depth
 201             ImplRotate1_180( pBuf, mpBits.get() + mnHeight * mnScanlineSize,
 202                 mnWidth, mnHeight, mnScanlineSize - (mnWidth + 7) / 8 );
 203             break;
 204         case +900:  // rotate left by 90 degrees
 205             i = mnXOffset;
 206             mnXOffset = mnYOffset;
 207             mnYOffset = -nNewHeight - i;
 208             if( mnBitCount == 8 )
 209                 ImplRotate8_90( pBuf, mpBits.get() + mnWidth - 1,
 210                     nNewWidth, nNewHeight, +mnScanlineSize, -1-mnHeight*mnScanlineSize,
 211                     nNewScanlineSize - nNewWidth );
 212             else
 213                 ImplRotate1_90( pBuf, mpBits.get() + (mnWidth - 1) / 8,
 214                     nNewWidth, nNewHeight, +mnScanlineSize,
 215                     (-mnWidth & 7), +1, nNewScanlineSize - (nNewWidth + 7) / 8 );
 216             break;
 217         case 2700:  // rotate right by 90 degrees
 218         case -900:
 219             i = mnXOffset;
 220             mnXOffset = -(nNewWidth + mnYOffset);
 221             mnYOffset = i;
 222             if( mnBitCount == 8 )
 223                 ImplRotate8_90( pBuf, mpBits.get() + mnScanlineSize * (mnHeight-1),
 224                     nNewWidth, nNewHeight, -mnScanlineSize, +1+mnHeight*mnScanlineSize,
 225                     nNewScanlineSize - nNewWidth );
 226             else
 227                 ImplRotate1_90( pBuf, mpBits.get() + mnScanlineSize * (mnHeight-1),
 228                     nNewWidth, nNewHeight, -mnScanlineSize,
 229                     +7, -1, nNewScanlineSize - (nNewWidth + 7) / 8 );
 230             break;
 231     }
 232
 233     mnWidth        = nNewWidth;
 234     mnHeight       = nNewHeight;
 235     mnScanlineSize = nNewScanlineSize;
 236
 237     if( nBufSize < mnAllocated )
 238     {
 239         memcpy( mpBits.get(), pBuf, nBufSize );
 240         delete[] pBuf;
 241     }
 242     else
 243     {
 244         mpBits.reset(pBuf);
 245         mnAllocated = nBufSize;
 246     }
 247
 248     return true;
 249 }
 250
 251 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */