Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 1 | /* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved. |
Pierre Ossman | 2e5a106 | 2014-01-30 17:57:27 +0100 | [diff] [blame] | 2 | * Copyright 2014 Pierre Ossman for Cendio AB |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 3 | * |
| 4 | * This is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License as published by |
| 6 | * the Free Software Foundation; either version 2 of the License, or |
| 7 | * (at your option) any later version. |
| 8 | * |
| 9 | * This software is distributed in the hope that it will be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | * GNU General Public License for more details. |
| 13 | * |
| 14 | * You should have received a copy of the GNU General Public License |
| 15 | * along with this software; if not, write to the Free Software |
| 16 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
| 17 | * USA. |
| 18 | */ |
| 19 | |
| 20 | // -=- PixelBuffer.cxx |
| 21 | // |
| 22 | // The PixelBuffer class encapsulates the PixelFormat and dimensions |
| 23 | // of a block of pixel data. |
| 24 | |
| 25 | #include <rfb/Exception.h> |
| 26 | #include <rfb/LogWriter.h> |
| 27 | #include <rfb/PixelBuffer.h> |
| 28 | |
| 29 | using namespace rfb; |
| 30 | using namespace rdr; |
| 31 | |
| 32 | static LogWriter vlog("PixelBuffer"); |
| 33 | |
| 34 | |
| 35 | // -=- Generic pixel buffer class |
| 36 | |
Pierre Ossman | b6b4dc6 | 2014-01-20 15:05:21 +0100 | [diff] [blame] | 37 | PixelBuffer::PixelBuffer(const PixelFormat& pf, int w, int h) |
| 38 | : format(pf), width_(w), height_(h) {} |
| 39 | PixelBuffer::PixelBuffer() : width_(0), height_(0) {} |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 40 | |
| 41 | PixelBuffer::~PixelBuffer() {} |
| 42 | |
| 43 | |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 44 | void |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 45 | PixelBuffer::getImage(void* imageBuf, const Rect& r, int outStride) const |
| 46 | { |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 47 | int inStride; |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 48 | const U8* data; |
| 49 | int bytesPerPixel, inBytesPerRow, outBytesPerRow, bytesPerMemCpy; |
| 50 | U8* imageBufPos; |
| 51 | const U8* end; |
| 52 | |
| 53 | if (!r.enclosed_by(getRect())) |
| 54 | throw rfb::Exception("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 55 | r.width(), r.height(), |
| 56 | r.tl.x, r.tl.y, width_, height_); |
| 57 | |
| 58 | data = getBuffer(r, &inStride); |
| 59 | |
| 60 | bytesPerPixel = format.bpp/8; |
| 61 | inBytesPerRow = inStride * bytesPerPixel; |
| 62 | |
| 63 | if (!outStride) |
| 64 | outStride = r.width(); |
| 65 | outBytesPerRow = outStride * bytesPerPixel; |
| 66 | bytesPerMemCpy = r.width() * bytesPerPixel; |
| 67 | |
| 68 | imageBufPos = (U8*)imageBuf; |
| 69 | end = data + (inBytesPerRow * r.height()); |
| 70 | |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 71 | while (data < end) { |
| 72 | memcpy(imageBufPos, data, bytesPerMemCpy); |
| 73 | imageBufPos += outBytesPerRow; |
| 74 | data += inBytesPerRow; |
| 75 | } |
| 76 | } |
| 77 | |
Pierre Ossman | 9cbdec6 | 2014-02-12 13:24:15 +0100 | [diff] [blame] | 78 | void PixelBuffer::getImage(const PixelFormat& pf, void* imageBuf, |
Pierre Ossman | d4f718d | 2014-02-13 14:37:25 +0100 | [diff] [blame] | 79 | const Rect& r, int stride) const |
Pierre Ossman | 9cbdec6 | 2014-02-12 13:24:15 +0100 | [diff] [blame] | 80 | { |
| 81 | const rdr::U8* srcBuffer; |
| 82 | int srcStride; |
| 83 | |
| 84 | if (format.equal(pf)) { |
| 85 | getImage(imageBuf, r, stride); |
| 86 | return; |
| 87 | } |
| 88 | |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 89 | if (!r.enclosed_by(getRect())) |
| 90 | throw rfb::Exception("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 91 | r.width(), r.height(), |
| 92 | r.tl.x, r.tl.y, width_, height_); |
| 93 | |
Pierre Ossman | 9cbdec6 | 2014-02-12 13:24:15 +0100 | [diff] [blame] | 94 | if (stride == 0) |
| 95 | stride = r.width(); |
| 96 | |
| 97 | srcBuffer = getBuffer(r, &srcStride); |
| 98 | |
| 99 | pf.bufferFromBuffer((U8*)imageBuf, format, srcBuffer, r.width(), r.height(), |
| 100 | stride, srcStride); |
| 101 | } |
| 102 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 103 | // -=- Modifiable generic pixel buffer class |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 104 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 105 | ModifiablePixelBuffer::ModifiablePixelBuffer(const PixelFormat& pf, |
| 106 | int w, int h) |
| 107 | : PixelBuffer(pf, w, h) |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 108 | { |
Pierre Ossman | 1ed4d50 | 2014-01-07 15:28:45 +0000 | [diff] [blame] | 109 | } |
| 110 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 111 | ModifiablePixelBuffer::ModifiablePixelBuffer() |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 112 | { |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 113 | } |
| 114 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 115 | ModifiablePixelBuffer::~ModifiablePixelBuffer() |
| 116 | { |
| 117 | } |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 118 | |
Pierre Ossman | 56f99d6 | 2015-06-05 12:57:02 +0200 | [diff] [blame] | 119 | void ModifiablePixelBuffer::fillRect(const Rect& r, const void* pix) |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 120 | { |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 121 | int stride; |
Pierre Ossman | a43a3f4 | 2015-02-06 13:51:35 +0100 | [diff] [blame] | 122 | U8 *buf; |
Pierre Ossman | 5c1a153 | 2014-01-30 16:59:14 +0100 | [diff] [blame] | 123 | int w, h, b; |
| 124 | |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 125 | if (!r.enclosed_by(getRect())) |
| 126 | throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 127 | r.width(), r.height(), r.tl.x, r.tl.y, width_, height_); |
Michal Srb | 18c0201 | 2017-01-13 16:32:23 +0200 | [diff] [blame] | 128 | |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 129 | w = r.width(); |
| 130 | h = r.height(); |
Pierre Ossman | 5c1a153 | 2014-01-30 16:59:14 +0100 | [diff] [blame] | 131 | b = format.bpp/8; |
| 132 | |
Pierre Ossman | a43a3f4 | 2015-02-06 13:51:35 +0100 | [diff] [blame] | 133 | if (h == 0) |
| 134 | return; |
Pierre Ossman | 5c1a153 | 2014-01-30 16:59:14 +0100 | [diff] [blame] | 135 | |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 136 | buf = getBufferRW(r, &stride); |
Pierre Ossman | a43a3f4 | 2015-02-06 13:51:35 +0100 | [diff] [blame] | 137 | |
| 138 | if (b == 1) { |
| 139 | while (h--) { |
Pierre Ossman | 56f99d6 | 2015-06-05 12:57:02 +0200 | [diff] [blame] | 140 | memset(buf, *(const U8*)pix, w); |
Pierre Ossman | a43a3f4 | 2015-02-06 13:51:35 +0100 | [diff] [blame] | 141 | buf += stride * b; |
| 142 | } |
| 143 | } else { |
Pierre Ossman | 56f99d6 | 2015-06-05 12:57:02 +0200 | [diff] [blame] | 144 | U8 *start; |
Pierre Ossman | a43a3f4 | 2015-02-06 13:51:35 +0100 | [diff] [blame] | 145 | int w1; |
| 146 | |
| 147 | start = buf; |
| 148 | |
Pierre Ossman | a43a3f4 | 2015-02-06 13:51:35 +0100 | [diff] [blame] | 149 | w1 = w; |
| 150 | while (w1--) { |
Pierre Ossman | 56f99d6 | 2015-06-05 12:57:02 +0200 | [diff] [blame] | 151 | memcpy(buf, pix, b); |
Pierre Ossman | 5c1a153 | 2014-01-30 16:59:14 +0100 | [diff] [blame] | 152 | buf += b; |
| 153 | } |
| 154 | buf += (stride - w) * b; |
Pierre Ossman | a43a3f4 | 2015-02-06 13:51:35 +0100 | [diff] [blame] | 155 | h--; |
| 156 | |
| 157 | while (h--) { |
| 158 | memcpy(buf, start, w * b); |
| 159 | buf += stride * b; |
| 160 | } |
Pierre Ossman | 5c1a153 | 2014-01-30 16:59:14 +0100 | [diff] [blame] | 161 | } |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 162 | |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 163 | commitBufferRW(r); |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 164 | } |
| 165 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 166 | void ModifiablePixelBuffer::imageRect(const Rect& r, |
| 167 | const void* pixels, int srcStride) |
| 168 | { |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 169 | U8* dest; |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 170 | int destStride; |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 171 | int bytesPerPixel, bytesPerDestRow, bytesPerSrcRow, bytesPerFill; |
| 172 | const U8* src; |
| 173 | U8* end; |
| 174 | |
| 175 | if (!r.enclosed_by(getRect())) |
| 176 | throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 177 | r.width(), r.height(), |
| 178 | r.tl.x, r.tl.y, width_, height_); |
| 179 | |
| 180 | bytesPerPixel = getPF().bpp/8; |
| 181 | |
| 182 | dest = getBufferRW(r, &destStride); |
| 183 | |
| 184 | bytesPerDestRow = bytesPerPixel * destStride; |
| 185 | |
| 186 | if (!srcStride) |
| 187 | srcStride = r.width(); |
| 188 | bytesPerSrcRow = bytesPerPixel * srcStride; |
| 189 | bytesPerFill = bytesPerPixel * r.width(); |
| 190 | |
| 191 | src = (const U8*)pixels; |
| 192 | end = dest + (bytesPerDestRow * r.height()); |
| 193 | |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 194 | while (dest < end) { |
| 195 | memcpy(dest, src, bytesPerFill); |
| 196 | dest += bytesPerDestRow; |
| 197 | src += bytesPerSrcRow; |
| 198 | } |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 199 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 200 | commitBufferRW(r); |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 201 | } |
| 202 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 203 | void ModifiablePixelBuffer::copyRect(const Rect &rect, |
| 204 | const Point &move_by_delta) |
| 205 | { |
Pierre Ossman | 8163f54 | 2014-02-13 09:42:48 +0100 | [diff] [blame] | 206 | int srcStride, dstStride; |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 207 | int bytesPerPixel; |
Pierre Ossman | 8163f54 | 2014-02-13 09:42:48 +0100 | [diff] [blame] | 208 | const U8* srcData; |
| 209 | U8* dstData; |
| 210 | |
| 211 | Rect drect, srect; |
Pierre Ossman | 45de20d | 2010-12-21 15:53:42 +0000 | [diff] [blame] | 212 | |
| 213 | drect = rect; |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 214 | if (!drect.enclosed_by(getRect())) |
| 215 | throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 216 | drect.width(), drect.height(), |
| 217 | drect.tl.x, drect.tl.y, width_, height_); |
Pierre Ossman | 45de20d | 2010-12-21 15:53:42 +0000 | [diff] [blame] | 218 | |
| 219 | srect = drect.translate(move_by_delta.negate()); |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 220 | if (!srect.enclosed_by(getRect())) |
| 221 | throw rfb::Exception("Source rect %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 222 | srect.width(), srect.height(), |
| 223 | srect.tl.x, srect.tl.y, width_, height_); |
Pierre Ossman | 45de20d | 2010-12-21 15:53:42 +0000 | [diff] [blame] | 224 | |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 225 | bytesPerPixel = format.bpp/8; |
| 226 | |
Pierre Ossman | 8163f54 | 2014-02-13 09:42:48 +0100 | [diff] [blame] | 227 | srcData = getBuffer(srect, &srcStride); |
| 228 | dstData = getBufferRW(drect, &dstStride); |
| 229 | |
| 230 | if (move_by_delta.y == 0) { |
| 231 | // Possible overlap. Be careful and use memmove(). |
| 232 | int h = drect.height(); |
| 233 | while (h--) { |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 234 | memmove(dstData, srcData, drect.width() * bytesPerPixel); |
| 235 | dstData += dstStride * bytesPerPixel; |
| 236 | srcData += srcStride * bytesPerPixel; |
Pierre Ossman | 8163f54 | 2014-02-13 09:42:48 +0100 | [diff] [blame] | 237 | } |
| 238 | } else if (move_by_delta.y < 0) { |
| 239 | // The data shifted upwards. Copy from top to bottom. |
| 240 | int h = drect.height(); |
| 241 | while (h--) { |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 242 | memcpy(dstData, srcData, drect.width() * bytesPerPixel); |
| 243 | dstData += dstStride * bytesPerPixel; |
| 244 | srcData += srcStride * bytesPerPixel; |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 245 | } |
| 246 | } else { |
Pierre Ossman | 8163f54 | 2014-02-13 09:42:48 +0100 | [diff] [blame] | 247 | // The data shifted downwards. Copy from bottom to top. |
| 248 | int h = drect.height(); |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 249 | dstData += (h-1) * dstStride * bytesPerPixel; |
| 250 | srcData += (h-1) * srcStride * bytesPerPixel; |
Pierre Ossman | 8163f54 | 2014-02-13 09:42:48 +0100 | [diff] [blame] | 251 | while (h--) { |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 252 | memcpy(dstData, srcData, drect.width() * bytesPerPixel); |
| 253 | dstData -= dstStride * bytesPerPixel; |
| 254 | srcData -= srcStride * bytesPerPixel; |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 255 | } |
| 256 | } |
Pierre Ossman | 8163f54 | 2014-02-13 09:42:48 +0100 | [diff] [blame] | 257 | |
| 258 | commitBufferRW(drect); |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 259 | } |
| 260 | |
Pierre Ossman | 9da47f8 | 2014-02-13 10:38:48 +0100 | [diff] [blame] | 261 | void ModifiablePixelBuffer::fillRect(const PixelFormat& pf, const Rect &dest, |
Pierre Ossman | 56f99d6 | 2015-06-05 12:57:02 +0200 | [diff] [blame] | 262 | const void* pix) |
Pierre Ossman | 9da47f8 | 2014-02-13 10:38:48 +0100 | [diff] [blame] | 263 | { |
Pierre Ossman | 56f99d6 | 2015-06-05 12:57:02 +0200 | [diff] [blame] | 264 | rdr::U8 buf[4]; |
| 265 | format.bufferFromBuffer(buf, pf, (const rdr::U8*)pix, 1); |
| 266 | fillRect(dest, buf); |
Pierre Ossman | 9da47f8 | 2014-02-13 10:38:48 +0100 | [diff] [blame] | 267 | } |
| 268 | |
| 269 | void ModifiablePixelBuffer::imageRect(const PixelFormat& pf, const Rect &dest, |
| 270 | const void* pixels, int stride) |
| 271 | { |
| 272 | rdr::U8* dstBuffer; |
| 273 | int dstStride; |
| 274 | |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 275 | if (!dest.enclosed_by(getRect())) |
| 276 | throw rfb::Exception("Destination rect %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 277 | dest.width(), dest.height(), |
| 278 | dest.tl.x, dest.tl.y, width_, height_); |
| 279 | |
Pierre Ossman | 9da47f8 | 2014-02-13 10:38:48 +0100 | [diff] [blame] | 280 | if (stride == 0) |
| 281 | stride = dest.width(); |
| 282 | |
| 283 | dstBuffer = getBufferRW(dest, &dstStride); |
| 284 | format.bufferFromBuffer(dstBuffer, pf, (const rdr::U8*)pixels, |
| 285 | dest.width(), dest.height(), |
| 286 | dstStride, stride); |
| 287 | commitBufferRW(dest); |
| 288 | } |
| 289 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 290 | // -=- Simple pixel buffer with a continuous block of memory |
| 291 | |
| 292 | FullFramePixelBuffer::FullFramePixelBuffer(const PixelFormat& pf, int w, int h, |
| 293 | rdr::U8* data_, int stride_) |
| 294 | : ModifiablePixelBuffer(pf, w, h), data(data_), stride(stride_) |
| 295 | { |
| 296 | } |
| 297 | |
| 298 | FullFramePixelBuffer::FullFramePixelBuffer() : data(0) {} |
| 299 | |
| 300 | FullFramePixelBuffer::~FullFramePixelBuffer() {} |
| 301 | |
| 302 | rdr::U8* FullFramePixelBuffer::getBufferRW(const Rect& r, int* stride_) |
| 303 | { |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 304 | if (!r.enclosed_by(getRect())) |
| 305 | throw rfb::Exception("Pixel buffer request %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 306 | r.width(), r.height(), |
| 307 | r.tl.x, r.tl.y, width_, height_); |
| 308 | |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 309 | *stride_ = stride; |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 310 | return &data[(r.tl.x + (r.tl.y * stride)) * (format.bpp/8)]; |
Pierre Ossman | a32040d | 2014-02-06 16:31:10 +0100 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | void FullFramePixelBuffer::commitBufferRW(const Rect& r) |
| 314 | { |
| 315 | } |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 316 | |
Pierre Ossman | d4f718d | 2014-02-13 14:37:25 +0100 | [diff] [blame] | 317 | const rdr::U8* FullFramePixelBuffer::getBuffer(const Rect& r, int* stride_) const |
| 318 | { |
Pierre Ossman | d5ab3e3 | 2017-01-18 13:34:13 +0100 | [diff] [blame] | 319 | if (!r.enclosed_by(getRect())) |
| 320 | throw rfb::Exception("Pixel buffer request %dx%d at %d,%d exceeds framebuffer %dx%d", |
| 321 | r.width(), r.height(), |
| 322 | r.tl.x, r.tl.y, width_, height_); |
| 323 | |
Pierre Ossman | d4f718d | 2014-02-13 14:37:25 +0100 | [diff] [blame] | 324 | *stride_ = stride; |
Pierre Ossman | f81148c | 2018-07-25 20:44:32 +0200 | [diff] [blame^] | 325 | return &data[(r.tl.x + (r.tl.y * stride)) * (format.bpp/8)]; |
Pierre Ossman | d4f718d | 2014-02-13 14:37:25 +0100 | [diff] [blame] | 326 | } |
| 327 | |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 328 | // -=- Managed pixel buffer class |
| 329 | // Automatically allocates enough space for the specified format & area |
| 330 | |
| 331 | ManagedPixelBuffer::ManagedPixelBuffer() |
Pierre Ossman | b6b4dc6 | 2014-01-20 15:05:21 +0100 | [diff] [blame] | 332 | : datasize(0) |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 333 | { |
| 334 | checkDataSize(); |
| 335 | }; |
| 336 | |
| 337 | ManagedPixelBuffer::ManagedPixelBuffer(const PixelFormat& pf, int w, int h) |
Pierre Ossman | 2e5a106 | 2014-01-30 17:57:27 +0100 | [diff] [blame] | 338 | : FullFramePixelBuffer(pf, w, h, NULL, w), datasize(0) |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 339 | { |
| 340 | checkDataSize(); |
| 341 | }; |
| 342 | |
| 343 | ManagedPixelBuffer::~ManagedPixelBuffer() { |
| 344 | if (data) delete [] data; |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 345 | }; |
| 346 | |
| 347 | |
| 348 | void |
| 349 | ManagedPixelBuffer::setPF(const PixelFormat &pf) { |
Pierre Ossman | 5c1a153 | 2014-01-30 16:59:14 +0100 | [diff] [blame] | 350 | format = pf; checkDataSize(); |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 351 | }; |
| 352 | void |
| 353 | ManagedPixelBuffer::setSize(int w, int h) { |
Pierre Ossman | 2e5a106 | 2014-01-30 17:57:27 +0100 | [diff] [blame] | 354 | width_ = w; height_ = h; stride = w; checkDataSize(); |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 355 | }; |
| 356 | |
| 357 | |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 358 | inline void |
| 359 | ManagedPixelBuffer::checkDataSize() { |
| 360 | unsigned long new_datasize = width_ * height_ * (format.bpp/8); |
| 361 | if (datasize < new_datasize) { |
Constantin Kaplinsky | a2adc8d | 2006-05-25 05:01:55 +0000 | [diff] [blame] | 362 | if (data) { |
| 363 | delete [] data; |
| 364 | datasize = 0; data = 0; |
| 365 | } |
| 366 | if (new_datasize) { |
| 367 | data = new U8[new_datasize]; |
| 368 | if (!data) |
| 369 | throw Exception("rfb::ManagedPixelBuffer unable to allocate buffer"); |
| 370 | datasize = new_datasize; |
| 371 | } |
| 372 | } |
| 373 | }; |