Framebuffer.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/Framebuffer.h"
#include "pedigree/kernel/processor/MemoryRegion.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/utilities/utility.h"
 
Framebuffer::Framebuffer() : m_pParent(0), m_FramebufferBase(0), m_bActive(true) {
  m_Palette = new uint32_t[256];
 
  size_t i = 0;
  for (size_t g = 0; g <= 255; g += 0x33)
    for (size_t b = 0; b <= 255; b += 0x33)
      for (size_t r = 0; r <= 255; r += 0x33)
        m_Palette[i++] = Graphics::createRgb(r, g, b);
 
  NOTICE("Framebuffer: created " << Dec << i << Hex << " entries in the default palette");
}
 
Framebuffer::~Framebuffer() {}
 
size_t Framebuffer::getWidth() const {
  return m_nWidth;
}
 
size_t Framebuffer::getHeight() const {
  return m_nHeight;
}
 
Graphics::PixelFormat Framebuffer::getFormat() const {
  return m_PixelFormat;
}
 
bool Framebuffer::getActive() const {
  return m_bActive;
}
 
void Framebuffer::setActive(bool b) {
  m_bActive = b;
}
 
void Framebuffer::setPalette(uint32_t* palette, size_t nEntries) {
  delete[] m_Palette;
  m_Palette = new uint32_t[nEntries];
  MemoryCopy(m_Palette, palette, nEntries * sizeof(uint32_t));
 
  NOTICE("Framebuffer: new palette set with " << Dec << nEntries << Hex << " entries");
}
 
uint32_t* Framebuffer::getPalette() const {
  return m_Palette;
}
 
void* Framebuffer::getRawBuffer() const {
  if (m_pParent)
    return m_pParent->getRawBuffer();
  return reinterpret_cast<void*>(m_FramebufferBase);
}
 
physical_uintptr_t Framebuffer::getPhysicalPage(size_t) const {
  return ~physical_uintptr_t(0);
}
 
Graphics::Buffer* Framebuffer::createBuffer(const void* srcData, Graphics::PixelFormat srcFormat,
                                            size_t width, size_t height, uint32_t* pPalette) {
  if (m_pParent)
    return m_pParent->createBuffer(srcData, srcFormat, width, height, pPalette);
  return swCreateBuffer(srcData, srcFormat, width, height, pPalette);
}
 
void Framebuffer::destroyBuffer(Graphics::Buffer* pBuffer) {
  // if(m_pParent)
  //     m_pParent->destroyBuffer(pBuffer);
  // else
  swDestroyBuffer(pBuffer);
}
 
void Framebuffer::redraw(size_t x, size_t y, size_t w, size_t h, bool bChild) {
  if (m_pParent) {
    // Redraw with parent:
    // 1. Draw our framebuffer. This will go to the top without
    //    changing intermediate framebuffers.
    // 2. Pass a redraw up the chain. This will reach the top level
    //    (with modified x/y) and cause our screen region to be redrawn.
 
 
    // If the redraw was not caused by a child, make sure our
    // framebuffer has precedence over any children.
    if (!bChild) {
      if (m_pParent->getFormat() == m_PixelFormat) {
        Graphics::Buffer buf = bufferFromSelf();
        m_pParent->draw(&buf, x, y, m_XPos + x, m_YPos + y, w, h, false);
        // m_pParent->draw(reinterpret_cast<void*>(m_FramebufferBase),
        // x, y, m_XPos + x, m_YPos + y, w, h, m_PixelFormat,
        // false);
      } else {
        ERROR(
            "Child framebuffer has different pixel format to "
            "parent!");
      }
    }
 
    // Now we are a child requesting a redraw, so the parent will not
    // have precedence over us.
    m_pParent->redraw(m_XPos + x, m_YPos + y, w, h, true);
  } else
    hwRedraw(x, y, w, h);
}
 
void Framebuffer::blit(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx,
                       size_t desty, size_t width, size_t height, bool bLowestCall) {
  if (m_pParent)
    m_pParent->blit(pBuffer, srcx, srcy, m_XPos + destx, m_YPos + desty, width, height, false);
  if (bLowestCall || !m_pParent)
    swBlit(pBuffer, srcx, srcy, destx, desty, width, height);
}
 
void Framebuffer::draw(void* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
                       size_t width, size_t height, Graphics::PixelFormat format,
                       bool bLowestCall) {
  // Draw is implemented as a "create buffer and blit"... so we can
  // avoid checking for parent here as we don't want to poison the
  // parent's buffer.
  swDraw(pBuffer, srcx, srcy, destx, desty, width, height, format, bLowestCall);
}
 
void Framebuffer::rect(size_t x, size_t y, size_t width, size_t height, uint32_t colour,
                       Graphics::PixelFormat format, bool bLowestCall) {
  if (m_pParent)
    m_pParent->rect(m_XPos + x, m_YPos + y, width, height, colour, format, false);
  if (bLowestCall || !m_pParent)
    swRect(x, y, width, height, colour, format);
}
 
void Framebuffer::copy(size_t srcx, size_t srcy, size_t destx, size_t desty, size_t w, size_t h,
                       bool bLowestCall) {
  if (m_pParent)
    m_pParent->copy(m_XPos + srcx, m_YPos + srcy, m_XPos + destx, m_YPos + desty, w, h, false);
  if (bLowestCall || !m_pParent)
    swCopy(srcx, srcy, destx, desty, w, h);
}
 
void Framebuffer::line(size_t x1, size_t y1, size_t x2, size_t y2, uint32_t colour,
                       Graphics::PixelFormat format, bool bLowestCall) {
  if (m_pParent)
    m_pParent->line(m_XPos + x1, m_YPos + y1, m_XPos + x2, m_YPos + y2, colour, format, false);
  if (bLowestCall || !m_pParent)
    swLine(x1, y1, x2, y2, colour, format);
}
 
void Framebuffer::setPixel(size_t x, size_t y, uint32_t colour, Graphics::PixelFormat format,
                           bool bLowestCall) {
  if (m_pParent)
    m_pParent->setPixel(m_XPos + x, m_YPos + y, colour, format, false);
  if (bLowestCall || !m_pParent)
    swSetPixel(x, y, colour, format);
}
 
void Framebuffer::setXPos(size_t x) {
  m_XPos = x;
}
 
void Framebuffer::setYPos(size_t y) {
  m_YPos = y;
}
 
void Framebuffer::setWidth(size_t w) {
  m_nWidth = w;
}
 
void Framebuffer::setHeight(size_t h) {
  m_nHeight = h;
}
 
void Framebuffer::setFormat(Graphics::PixelFormat pf) {
  m_PixelFormat = pf;
}
 
void Framebuffer::setBytesPerPixel(size_t b) {
  m_nBytesPerPixel = b;
}
 
uint32_t Framebuffer::getBytesPerPixel() const {
  return m_nBytesPerPixel;
}
 
void Framebuffer::setBytesPerLine(size_t b) {
  m_nBytesPerLine = b;
}
 
uint32_t Framebuffer::getBytesPerLine() const {
  return m_nBytesPerLine;
}
 
void Framebuffer::setParent(Framebuffer* p) {
  m_pParent = p;
}
 
Framebuffer* Framebuffer::getParent() const {
  return m_pParent;
}
 
void Framebuffer::setFramebuffer(uintptr_t p) {
  m_FramebufferBase = p;
}
 
Graphics::Buffer Framebuffer::bufferFromSelf() {
  Graphics::Buffer ret;
  ret.base = m_FramebufferBase;
  ret.width = m_nWidth;
  ret.height = m_nHeight;
  ret.format = m_PixelFormat;
  ret.bytesPerPixel = m_nBytesPerPixel;
  ret.bufferId = 0;
  ret.pBacking = 0;
  return ret;
}
 
void Framebuffer::draw(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx,
                       size_t desty, size_t width, size_t height, bool bLowestCall) {
  swDraw(pBuffer, srcx, srcy, destx, desty, width, height, bLowestCall);
}
 
Graphics::Buffer* Framebuffer::swCreateBuffer(const void* srcData, Graphics::PixelFormat srcFormat,
                                              size_t width, size_t height, uint32_t* pPalette) {
  if (UNLIKELY(!m_FramebufferBase))
    return 0;
  if (UNLIKELY(!(width && height)))
    return 0;
 
  Graphics::PixelFormat destFormat = m_PixelFormat;
 
  size_t sourceBytesPerPixel = bytesPerPixel(srcFormat);
  size_t sourceBytesPerLine = width * sourceBytesPerPixel;
 
  size_t destBytesPerPixel = m_nBytesPerPixel;
  size_t destBytesPerLine = width * destBytesPerPixel;
 
  size_t fullBufferSize = height * destBytesPerLine;
  const size_t pageSize = PhysicalMemoryManager::getPageSize();
 
  MemoryRegion* pRegion = new MemoryRegion("sw-framebuffer-buffer");
  bool bSuccess = PhysicalMemoryManager::instance().allocateRegion(
      *pRegion, (fullBufferSize + pageSize - 1) / pageSize, 0, VirtualAddressSpace::Write);
 
  if (!bSuccess) {
    delete pRegion;
    return 0;
  }
 
  // Copy the buffer in full
  void* pAddress = pRegion->virtualAddress();
  if (((sourceBytesPerPixel == destBytesPerPixel) && (sourceBytesPerLine == destBytesPerLine)) &&
      (srcFormat == destFormat)) {
    // Same pixel format and same pixel size. Safe to do a conventional
    // memcpy. The pixel size check is to handle cases where a buffer may
    // be, say, 24-bit RGB, and the display driver also 24-bit RGB, but
    // the display's framebuffer reserves 32 bits for pixels (even though
    // the actual depth is 24 bits).
    MemoryCopy(pAddress, srcData, fullBufferSize);
  } else {
    // Have to convert and pack each pixel, much slower than memcpy.
    size_t x, y;
    for (y = 0; y < height; y++) {
      for (x = 0; x < width; x++) {
        size_t sourceOffset = (y * sourceBytesPerLine) + (x * sourceBytesPerPixel);
        size_t destOffset = (y * destBytesPerLine) + (x * destBytesPerPixel);
 
        // We'll always access the beginning of a pixel, which makes
        // things here much simpler.
        const uint32_t* pSource =
            reinterpret_cast<const uint32_t*>(adjust_pointer(srcData, sourceOffset));
 
        uint32_t transform = 0;
        if (srcFormat == Graphics::Bits8_Idx) {
          uint32_t source = pPalette[(*pSource) & 0xFF];
          Graphics::convertPixel(source, Graphics::Bits24_Bgr, transform, destFormat);
        } else {
          Graphics::convertPixel(*pSource, srcFormat, transform, destFormat);
        }
 
        if (destBytesPerPixel == 4) {
          uint32_t* pDest = reinterpret_cast<uint32_t*>(adjust_pointer(pAddress, destOffset));
 
          if (sourceBytesPerPixel == 3)
            transform &= 0xFFFFFF;
          else if (sourceBytesPerPixel == 2)
            transform &= 0xFFFF;
 
          *pDest = transform;
        } else if (destBytesPerPixel == 3) {
          // Handle existing data after this byte if it exists
          uint32_t* pDest = reinterpret_cast<uint32_t*>(adjust_pointer(pAddress, destOffset));
          *pDest = (*pDest & 0xFF000000) | (transform & 0xFFFFFF);
        } else if (destBytesPerPixel == 2) {
          uint16_t* pDest = reinterpret_cast<uint16_t*>(adjust_pointer(pAddress, destOffset));
          *pDest = transform & 0xFFFF;
        } else if (destBytesPerPixel == 1) {
        }
      }
    }
  }
 
  Graphics::Buffer* pBuffer = new Graphics::Buffer;
  pBuffer->base = reinterpret_cast<uintptr_t>(pRegion->virtualAddress());
  pBuffer->width = width;
  pBuffer->height = height;
  pBuffer->format = m_PixelFormat;
  pBuffer->bytesPerPixel = destBytesPerPixel;
  pBuffer->bufferId = 0;
  pBuffer->pBacking = reinterpret_cast<void*>(pRegion);
 
  return pBuffer;
}
 
void Framebuffer::swDestroyBuffer(Graphics::Buffer* pBuffer) {
  if (pBuffer) {
    if (pBuffer->base) {
      MemoryRegion* pRegion = reinterpret_cast<MemoryRegion*>(pBuffer->pBacking);
      delete pRegion;  // Unmaps the memory as well
    }
    delete pBuffer;
  }
}
 
void Framebuffer::swBlit(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx,
                         size_t desty, size_t width, size_t height) {
  if (UNLIKELY(!m_FramebufferBase))
    return;
  if (UNLIKELY(!(width && height)))
    return;
  if (UNLIKELY(!pBuffer))
    return;
 
  size_t bytesPerLine = m_nBytesPerLine;
  size_t destBytesPerPixel = m_nBytesPerPixel;
 
  size_t sourceBytesPerPixel = pBuffer->bytesPerPixel;
  size_t sourceBytesPerLine = pBuffer->width * destBytesPerPixel;
 
  // Sanity check and clip
  if ((srcx > pBuffer->width) || (srcy > pBuffer->height))
    return;
  if ((destx > m_nWidth) || (desty > m_nHeight))
    return;
  if ((srcx + width) > pBuffer->width)
    width = (srcx + width) - pBuffer->width;
  if ((srcy + height) > pBuffer->height)
    height = (srcy + height) - pBuffer->height;
  if ((destx + width) > m_nWidth)
    width = m_nWidth - destx;  // (destx + width) - m_nWidth;
  if ((desty + height) > m_nHeight)
    height = m_nHeight - desty;  // (desty + height) - m_nHeight;
 
 
  void* pSrc = reinterpret_cast<void*>(pBuffer->base);
 
  // A full-width source can still be tightly packed while scanout has padding.
  // Copy rows separately unless both buffers have the same packed stride.
  if (UNLIKELY((srcx == 0) && (destx == 0) && (width * destBytesPerPixel == bytesPerLine) &&
               (sourceBytesPerLine == bytesPerLine))) {
    size_t sourceBufferOffset = (srcy * sourceBytesPerLine);
    size_t frameBufferOffset = (desty * bytesPerLine);
 
    void* dest = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffset);
    void* src = adjust_pointer(pSrc, sourceBufferOffset);
 
    MemoryCopy(dest, src, bytesPerLine * height);
  } else {
    // Line-by-line copy
    for (size_t y1 = desty, y2 = srcy; y1 < (desty + height); y1++, y2++) {
      size_t sourceBufferOffset = (y2 * sourceBytesPerLine) + (srcx * sourceBytesPerPixel);
      size_t frameBufferOffset = (y1 * bytesPerLine) + (destx * destBytesPerPixel);
 
      void* dest = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffset);
      void* src = adjust_pointer(pSrc, sourceBufferOffset);
 
      MemoryCopy(dest, src, width * destBytesPerPixel);
    }
  }
}
 
void Framebuffer::swRect(size_t x, size_t y, size_t width, size_t height, uint32_t colour,
                         Graphics::PixelFormat format) {
  if (UNLIKELY(!m_FramebufferBase))
    return;
  if (UNLIKELY(!(width && height)))
    return;
 
  // Sanity check and clip
  if ((x > m_nWidth) || (y > m_nHeight))
    return;
  if (width > m_nWidth)
    width = m_nWidth;
  if (height > m_nHeight)
    height = m_nHeight;
  if ((x + width) > m_nWidth)
    width = (x + width) - m_nWidth;
  if ((y + height) > m_nHeight)
    height = (y + height) - m_nHeight;
 
  uint32_t transformColour = 0;
  if (format == Graphics::Bits8_Idx) {
    uint32_t source = m_Palette[colour & 0xFF];
    Graphics::convertPixel(source, Graphics::Bits24_Bgr, transformColour, m_PixelFormat);
  } else
    Graphics::convertPixel(colour, format, transformColour, m_PixelFormat);
 
  size_t bytesPerPixel = m_nBytesPerPixel;
  size_t bytesPerLine = m_nBytesPerLine;
 
  // Can we just do an easy memset?
  if (UNLIKELY((!x) && (width == m_nWidth))) {
    size_t frameBufferOffset = (y * bytesPerLine) + (x * bytesPerPixel);
 
    void* dest = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffset);
 
    size_t copySize = (bytesPerLine * height);
    if (bytesPerPixel == 4)  
    {
      if ((copySize % 8) == 0)  // QWORD boundary
      {
        uint64_t val = (static_cast<uint64_t>(transformColour) << 32) | transformColour;
        QuadWordSet(dest, val, copySize / 8);
      } else
        DoubleWordSet(dest, transformColour, copySize / 4);
    } else if (bytesPerPixel == 3) {
      // 24-bit has to set three bytes at a time and leave the top byte
      // untouched. Painful.
      for (size_t i = 0; i < (copySize / 3); i++) {
        uint32_t* p = reinterpret_cast<uint32_t*>(m_FramebufferBase + frameBufferOffset + (i * 3));
        *p = (*p & 0xFF000000) | transformColour;
      }
    } else if (bytesPerPixel == 2) {
      if ((copySize % 8) == 0)  // QWORD boundary
      {
        uint64_t val = (static_cast<uint64_t>(transformColour) << 48) |
                       (static_cast<uint64_t>(transformColour) << 32) | (transformColour << 16) |
                       transformColour;
        QuadWordSet(dest, val, copySize / 8);
      } else if ((copySize % 4) == 0)  // DWORD boundary
      {
        uint32_t val = (transformColour << 16) | transformColour;
        DoubleWordSet(dest, val, copySize / 4);
      } else
        WordSet(dest, transformColour, copySize / 2);
    } else
      ByteSet(dest, transformColour, (bytesPerLine * height));
  } else {
    // Line-by-line fill
    for (size_t desty = y; desty < (y + height); desty++) {
      size_t frameBufferOffset = (desty * bytesPerLine) + (x * bytesPerPixel);
 
      void* dest = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffset);
 
      size_t copySize = width * bytesPerPixel;
      if (bytesPerPixel == 4)  
      {
        if ((copySize % 8) == 0)  // QWORD boundary
        {
          uint64_t val = (static_cast<uint64_t>(transformColour) << 32) | transformColour;
          QuadWordSet(dest, val, copySize / 8);
        } else
          DoubleWordSet(dest, transformColour, copySize / 4);
      } else if (bytesPerPixel == 3) {
        // 24-bit has to set three bytes at a time and leave the top
        // byte untouched. Painful.
        for (size_t i = 0; i < (copySize / 3); i++) {
          uint32_t* p =
              reinterpret_cast<uint32_t*>(m_FramebufferBase + frameBufferOffset + (i * 3));
          *p = (*p & 0xFF000000) | transformColour;
        }
      } else if (bytesPerPixel == 2) {
        if ((copySize % 8) == 0)  // QWORD boundary
        {
          uint64_t val = (static_cast<uint64_t>(transformColour) << 48) |
                         (static_cast<uint64_t>(transformColour) << 32) | (transformColour << 16) |
                         transformColour;
          QuadWordSet(dest, val, copySize / 8);
        } else if ((copySize % 4) == 0)  // DWORD boundary
        {
          uint32_t val = (transformColour << 16) | transformColour;
          DoubleWordSet(dest, val, copySize / 4);
        } else
          WordSet(dest, transformColour, copySize / 2);
      } else
        ByteSet(dest, transformColour, (width * bytesPerPixel));
    }
  }
}
 
void Framebuffer::swCopy(size_t srcx, size_t srcy, size_t destx, size_t desty, size_t w, size_t h) {
  if (UNLIKELY(!m_FramebufferBase))
    return;
  if (UNLIKELY(!(w && h)))
    return;
  if (UNLIKELY((srcx == destx) && (srcy == desty)))
    return;
 
  // Sanity check and clip
  if ((srcx > m_nWidth) || (srcy > m_nHeight))
    return;
  if ((destx > m_nWidth) || (desty > m_nHeight))
    return;
  if ((srcx + w) > m_nWidth)
    w = (srcx + w) - m_nWidth;
  if ((srcy + h) > m_nHeight)
    h = (srcy + h) - m_nHeight;
  if ((destx + w) > m_nWidth)
    w = (destx + w) - m_nWidth;
  if ((desty + h) > m_nHeight)
    h = (desty + h) - m_nHeight;
 
  if ((srcx == destx) && (srcy == desty))
    return;
  if (!(w && h))
    return;
 
  size_t bytesPerLine = m_nBytesPerLine;
  size_t bytesPerPixel = m_nBytesPerPixel;
 
  // Easy memcpy?
  if (UNLIKELY(((!srcx) && (!destx)) && (w == m_nWidth))) {
    size_t frameBufferOffsetSrc = (srcy * bytesPerLine) + (srcx * bytesPerPixel);
    size_t frameBufferOffsetDest = (desty * bytesPerLine) + (destx * bytesPerPixel);
 
    void* dest = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffsetDest);
    void* src = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffsetSrc);
 
    MemoryCopy(dest, src, h * bytesPerLine);
  } else {
    // Not so easy, but still not too hard
    for (size_t yoff = 0; yoff < h; yoff++) {
      size_t frameBufferOffsetSrc = ((srcy + yoff) * bytesPerLine) + (srcx * bytesPerPixel);
      size_t frameBufferOffsetDest = ((desty + yoff) * bytesPerLine) + (destx * bytesPerPixel);
 
      void* dest = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffsetDest);
      void* src = reinterpret_cast<void*>(m_FramebufferBase + frameBufferOffsetSrc);
 
      MemoryCopy(dest, src, w * bytesPerPixel);
    }
  }
}
 
void Framebuffer::swLine(size_t x1, size_t y1, size_t x2, size_t y2, uint32_t colour,
                         Graphics::PixelFormat format) {
  if (UNLIKELY(!m_FramebufferBase))
    return;
 
  // Clip co-ordinates where necessary
  if (x1 > m_nWidth)
    x1 = m_nWidth;
  if (x2 > m_nWidth)
    x2 = m_nWidth;
  if (y1 > m_nHeight)
    y1 = m_nHeight;
  if (y2 > m_nHeight)
    y2 = m_nHeight;
 
  // NOTICE("swLine(" << Dec << x1 << ", " << y1 << " -> " << x2 << ", " << y2
  // << Hex << ")");
 
  if (UNLIKELY((x1 == x2) && (y1 == y2)))
    return;
 
  uint32_t transformColour = 0;
  if (format == Graphics::Bits8_Idx) {
    uint32_t source = m_Palette[colour & 0xFF];
    Graphics::convertPixel(source, Graphics::Bits24_Bgr, transformColour, m_PixelFormat);
  } else
    Graphics::convertPixel(colour, format, transformColour, m_PixelFormat);
 
  // Special cases
  if (x1 == x2)  // Vertical line
  {
    if (y1 > y2)
      swap(y1, y2);
    for (size_t y = y1; y < y2; y++)
      setPixel(x1, y, transformColour, m_PixelFormat);
    return;
  } else if (y1 == y2) {
    if (x1 > x2)
      swap(x1, x2);
    for (size_t x = x1; x < x2; x++)
      setPixel(x, y1, transformColour, m_PixelFormat);
    return;
  }
 
  // Bresenham's algorithm, referred to Computer Graphics, C Version (2nd
  // Edition) from 1997, by D. Hearn and M. Pauline Baker (page 88)
  // http://www.amazon.com/Computer-Graphics-C-Version-2nd/dp/0135309247
 
  ssize_t dx = static_cast<ssize_t>(x2) - static_cast<ssize_t>(x1);
  ssize_t dy = static_cast<ssize_t>(y2) - static_cast<ssize_t>(y1);
  ssize_t p = 2 * (dy - dx);
  ssize_t x, y, xEnd;
 
  if (x1 > x2) {
    x = x2;
    y = y2;
    xEnd = x1;
  } else {
    x = x1;
    y = y1;
    xEnd = x2;
  }
 
  setPixel(x, y, transformColour, m_PixelFormat);
 
  while (x < xEnd) {
    x++;
    if (p < 0)
      p += (dy * 2);
    else {
      y++;
      p += 2 * (dy - dx);
    }
 
    setPixel(x, y, transformColour, m_PixelFormat);
  }
}
 
void Framebuffer::swSetPixel(size_t x, size_t y, uint32_t colour, Graphics::PixelFormat format) {
  if (UNLIKELY(!m_FramebufferBase))
    return;
 
  if (x > m_nWidth)
    x = m_nWidth;
  if (y > m_nHeight)
    y = m_nHeight;
 
  size_t bytesPerPixel = m_nBytesPerPixel;
  size_t bytesPerLine = m_nBytesPerLine;
 
  uint32_t transformColour = 0;
  if (format == Graphics::Bits8_Idx) {
    uint32_t source = m_Palette[colour & 0xFF];
    Graphics::convertPixel(source, Graphics::Bits24_Bgr, transformColour, m_PixelFormat);
  } else
    Graphics::convertPixel(colour, format, transformColour, m_PixelFormat);
 
  size_t frameBufferOffset = (y * bytesPerLine) + (x * bytesPerPixel);
 
  if (bytesPerPixel == 4) {
    uint32_t* pDest = reinterpret_cast<uint32_t*>(m_FramebufferBase + frameBufferOffset);
    *pDest = transformColour;
  } else if (bytesPerPixel == 3) {
    // Handle existing data after this byte if it exists
    uint32_t* pDest = reinterpret_cast<uint32_t*>(m_FramebufferBase + frameBufferOffset);
    *pDest = (*pDest & 0xFF000000) | (transformColour & 0xFFFFFF);
  } else if (bytesPerPixel == 2) {
    uint16_t* pDest = reinterpret_cast<uint16_t*>(m_FramebufferBase + frameBufferOffset);
    *pDest = transformColour & 0xFFFF;
  } else if (bytesPerPixel == 1) {
  }
}
 
void Framebuffer::swDraw(void* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
                         size_t width, size_t height, Graphics::PixelFormat format,
                         bool bLowestCall) {
  // Potentially inefficient use of RAM and VRAM, but best way to avoid
  // redundant copies of code lying around.
  Graphics::Buffer* p = createBuffer(pBuffer, format, srcx + width, srcy + height, m_Palette);
  if (!p) {
    return;
  }
  blit(p, srcx, srcy, destx, desty, width, height, bLowestCall);
  destroyBuffer(p);
}
 
void Framebuffer::swDraw(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx,
                         size_t desty, size_t width, size_t height, bool bLowestCall) {
  blit(pBuffer, srcx, srcy, destx, desty, width, height, bLowestCall);
}
 
void Framebuffer::hwRedraw(size_t x, size_t y, size_t w, size_t h) {}