src/servers/app/ServerBitmap.cpp

   1 /*
   2  * Copyright 2001-2010, Haiku.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              DarkWyrm <bpmagic@columbus.rr.com>
   7  *              Axel Dörfler, axeld@pinc-software.de
   8  */
   9
  10
  11 #include "ServerBitmap.h"
  12
  13 #include <new>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17
  18 #include "BitmapManager.h"
  19 #include "ClientMemoryAllocator.h"
  20 #include "ColorConversion.h"
  21 #include "HWInterface.h"
  22 #include "InterfacePrivate.h"
  23 #include "Overlay.h"
  24 #include "ServerApp.h"
  25
  26
  27 using std::nothrow;
  28 using namespace BPrivate;
  29
  30
  31 /*!     A word about memory housekeeping and why it's implemented this way:
  32
  33         The reason why this looks so complicated is to optimize the most common
  34         path (bitmap creation from the application), and don't cause any further
  35         memory allocations for maintaining memory in that case.
  36         If a bitmap was allocated this way, both, the fAllocator and
  37         fAllocationCookie members are used.
  38
  39         For overlays, the allocator only allocates a small piece of client memory
  40         for use with the overlay_client_data structure - the actual buffer will be
  41         placed in the graphics frame buffer and is allocated by the graphics driver.
  42
  43         If the memory was allocated on the app_server heap, neither fAllocator, nor
  44         fAllocationCookie are used, and the buffer is just freed in that case when
  45         the bitmap is destructed. This method is mainly used for cursors.
  46 */
  47
  48
  49 /*!     \brief Constructor called by the BitmapManager (only).
  50         \param rect Size of the bitmap.
  51         \param space Color space of the bitmap
  52         \param flags Various bitmap flags to tweak the bitmap as defined in Bitmap.h
  53         \param bytesperline Number of bytes in each row. -1 implies the default
  54                 value. Any value less than the the default will less than the default
  55                 will be overridden, but any value greater than the default will result
  56                 in the number of bytes specified.
  57         \param screen Screen assigned to the bitmap.
  58 */
  59 ServerBitmap::ServerBitmap(BRect rect, color_space space, uint32 flags,
  60                 int32 bytesPerRow, screen_id screen)
  61         :
  62         fMemory(NULL),
  63         fOverlay(NULL),
  64         fBuffer(NULL),
  65         // WARNING: '1' is added to the width and height.
  66         // Same is done in FBBitmap subclass, so if you
  67         // modify here make sure to do the same under
  68         // FBBitmap::SetSize(...)
  69         fWidth(rect.IntegerWidth() + 1),
  70         fHeight(rect.IntegerHeight() + 1),
  71         fBytesPerRow(0),
  72         fSpace(space),
  73         fFlags(flags),
  74         fOwner(NULL)
  75         // fToken is initialized (if used) by the BitmapManager
  76 {
  77         int32 minBytesPerRow = get_bytes_per_row(space, fWidth);
  78
  79         fBytesPerRow = max_c(bytesPerRow, minBytesPerRow);
  80 }
  81
  82
  83 //! Copy constructor does not copy the buffer.
  84 ServerBitmap::ServerBitmap(const ServerBitmap* bitmap)
  85         :
  86         fMemory(NULL),
  87         fOverlay(NULL),
  88         fBuffer(NULL),
  89         fOwner(NULL)
  90 {
  91         if (bitmap) {
  92                 fWidth = bitmap->fWidth;
  93                 fHeight = bitmap->fHeight;
  94                 fBytesPerRow = bitmap->fBytesPerRow;
  95                 fSpace = bitmap->fSpace;
  96                 fFlags = bitmap->fFlags;
  97         } else {
  98                 fWidth = 0;
  99                 fHeight = 0;
 100                 fBytesPerRow = 0;
 101                 fSpace = B_NO_COLOR_SPACE;
 102                 fFlags = 0;
 103         }
 104 }
 105
 106
 107 ServerBitmap::~ServerBitmap()
 108 {
 109         if (fMemory != NULL) {
 110                 if (fMemory != &fClientMemory)
 111                         delete fMemory;
 112         } else
 113                 delete[] fBuffer;
 114
 115         delete fOverlay;
 116                 // deleting the overlay will also free the overlay buffer
 117 }
 118
 119
 120 /*!     \brief Internal function used by subclasses
 121
 122         Subclasses should call this so the buffer can automagically
 123         be allocated on the heap.
 124 */
 125 void
 126 ServerBitmap::AllocateBuffer()
 127 {
 128         uint32 length = BitsLength();
 129         if (length > 0) {
 130                 delete[] fBuffer;
 131                 fBuffer = new(std::nothrow) uint8[length];
 132         }
 133 }
 134
 135
 136 status_t
 137 ServerBitmap::ImportBits(const void *bits, int32 bitsLength, int32 bytesPerRow,
 138         color_space colorSpace)
 139 {
 140         if (!bits || bitsLength < 0 || bytesPerRow <= 0)
 141                 return B_BAD_VALUE;
 142
 143         return BPrivate::ConvertBits(bits, fBuffer, bitsLength, BitsLength(),
 144                 bytesPerRow, fBytesPerRow, colorSpace, fSpace, fWidth, fHeight);
 145 }
 146
 147
 148 status_t
 149 ServerBitmap::ImportBits(const void *bits, int32 bitsLength, int32 bytesPerRow,
 150         color_space colorSpace, BPoint from, BPoint to, int32 width, int32 height)
 151 {
 152         if (!bits || bitsLength < 0 || bytesPerRow <= 0 || width < 0 || height < 0)
 153                 return B_BAD_VALUE;
 154
 155         return BPrivate::ConvertBits(bits, fBuffer, bitsLength, BitsLength(),
 156                 bytesPerRow, fBytesPerRow, colorSpace, fSpace, from, to, width,
 157                 height);
 158 }
 159
 160
 161 area_id
 162 ServerBitmap::Area() const
 163 {
 164         if (fMemory != NULL)
 165                 return fMemory->Area();
 166
 167         return B_ERROR;
 168 }
 169
 170
 171 uint32
 172 ServerBitmap::AreaOffset() const
 173 {
 174         if (fMemory != NULL)
 175                 return fMemory->AreaOffset();
 176
 177         return 0;
 178 }
 179
 180
 181 void
 182 ServerBitmap::SetOverlay(::Overlay* overlay)
 183 {
 184         fOverlay = overlay;
 185 }
 186
 187
 188 ::Overlay*
 189 ServerBitmap::Overlay() const
 190 {
 191         return fOverlay;
 192 }
 193
 194
 195 void
 196 ServerBitmap::SetOwner(ServerApp* owner)
 197 {
 198         fOwner = owner;
 199 }
 200
 201
 202 ServerApp*
 203 ServerBitmap::Owner() const
 204 {
 205         return fOwner;
 206 }
 207
 208
 209 void
 210 ServerBitmap::PrintToStream()
 211 {
 212         printf("Bitmap@%p: (%" B_PRId32 ":%" B_PRId32 "), space %" B_PRId32 ", "
 213                 "bpr %" B_PRId32 ", buffer %p\n", this, fWidth, fHeight, (int32)fSpace,
 214                 fBytesPerRow, fBuffer);
 215 }
 216
 217
 218 //      #pragma mark -
 219
 220
 221 UtilityBitmap::UtilityBitmap(BRect rect, color_space space, uint32 flags,
 222                 int32 bytesPerRow, screen_id screen)
 223         :
 224         ServerBitmap(rect, space, flags, bytesPerRow, screen)
 225 {
 226         AllocateBuffer();
 227 }
 228
 229
 230 UtilityBitmap::UtilityBitmap(const ServerBitmap* bitmap)
 231         :
 232         ServerBitmap(bitmap)
 233 {
 234         AllocateBuffer();
 235
 236         if (bitmap->Bits())
 237                 memcpy(Bits(), bitmap->Bits(), bitmap->BitsLength());
 238 }
 239
 240
 241 UtilityBitmap::UtilityBitmap(const uint8* alreadyPaddedData, uint32 width,
 242                 uint32 height, color_space format)
 243         :
 244         ServerBitmap(BRect(0, 0, width - 1, height - 1), format, 0)
 245 {
 246         AllocateBuffer();
 247         if (Bits())
 248                 memcpy(Bits(), alreadyPaddedData, BitsLength());
 249 }
 250
 251
 252 UtilityBitmap::~UtilityBitmap()
 253 {
 254 }