Public API Reference

csgfx/packrgb.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2003 by Jorrit Tyberghein
                       2003 by Frank Richter

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CSGFX_PACKRGB_H__
#define __CSGFX_PACKRGB_H__

#include "csextern.h"

#include "cstypes.h"
#include "csgfx/rgbpixel.h"


struct csPackRGB
{
  static bool IsRGBcolorSane() { return (sizeof(csRGBcolor) == 3); }
  static void PackRGBcolorToRGBBuffer (uint8* buf, 
    const csRGBcolor* pixels, size_t numPixels)
  {
    if (IsRGBcolorSane())
      memcpy (buf, pixels, numPixels * 3);
    else
    {
      uint8* bufptr = buf;
      while (numPixels--)
      {
        *bufptr++ = pixels->red;
        *bufptr++ = pixels->green;
        *bufptr++ = pixels->blue;
        pixels++; 
      }
    }
  }
  static const uint8* PackRGBcolorToRGB (const csRGBcolor* pixels, 
    size_t numPixels)
  {
    if (IsRGBcolorSane())
      return (uint8*)pixels;
    else
    {
      uint8* buf = new uint8[numPixels * 3];
      PackRGBcolorToRGBBuffer (buf, pixels, numPixels);
      return buf;
    }
  }
  static void DiscardPackedRGB (const uint8* rgb) 
  {
    if (!IsRGBcolorSane())
      delete[] (uint8*)rgb;
  }
  static void UnpackRGBtoRGBcolor (csRGBcolor* buf, const uint8* rgb, 
    size_t numPixels)
  {
    if (IsRGBcolorSane())
      memcpy (buf, rgb, numPixels * 3);
    else
    {
      csRGBcolor* bufptr = buf;
      while (numPixels--)
      {
        bufptr->red = *rgb++;
        bufptr->green = *rgb++;
        bufptr->blue = *rgb++;
        bufptr++; 
      }
    }
  }
  static const csRGBcolor* UnpackRGBtoRGBcolor (const uint8* rgb, 
    size_t numPixels)
  {
    if (IsRGBcolorSane())
      return (const csRGBcolor*)rgb;
    else
    {
      csRGBcolor* buf = new csRGBcolor[numPixels];
      UnpackRGBtoRGBcolor (buf, rgb, numPixels);
      return buf;
    }
  }
  static void DiscardUnpackedRGBcolor (const csRGBcolor* pixels) 
  {
    if (!IsRGBcolorSane())
      delete[] (csRGBcolor*)pixels;
  }
  static inline uint8* PackRGBpixelToRGB (const csRGBpixel* pixels, 
    size_t numPixels)
  {
    uint8* buf = new uint8[numPixels * 3];
    uint8* bufptr = buf;
    while (numPixels--)
    {
      *bufptr++ = pixels->red;
      *bufptr++ = pixels->green;
      *bufptr++ = pixels->blue;
      pixels++; 
    }
    return buf;
  }
  static void UnpackRGBtoRGBpixelBuffer (csRGBpixel* buf, uint8* rgb,
    size_t numPixels)
  {
    csRGBpixel* bufptr = buf;
    while (numPixels--)
    {
      bufptr->red = *rgb++;
      bufptr->green = *rgb++;
      bufptr->blue = *rgb++;
      bufptr++; 
    }
  }
};

struct csPackRGBA
{
  static bool IsRGBpixelSane() { return (sizeof(csRGBpixel) == 4); }
  static void PackRGBpixelToRGBA (uint8* buf, const csRGBpixel* pixels, 
    size_t numPixels)
  {
    if (IsRGBpixelSane())
      memcpy (buf, pixels, numPixels * 4);
    else
    {
      uint8* bufptr = buf;
      while (numPixels--)
      {
        *bufptr++ = pixels->red;
        *bufptr++ = pixels->green;
        *bufptr++ = pixels->blue;
        *bufptr++ = pixels->alpha;
        pixels++; 
      }
    }
  }
  static const uint8* PackRGBpixelToRGBA (const csRGBpixel* pixels, 
    size_t numPixels)
  {
    if (IsRGBpixelSane())
      return (uint8*)pixels;
    else
    {
      uint8* buf = new uint8[numPixels * 4];
      PackRGBpixelToRGBA (buf, pixels, numPixels);
      return buf;
    }
  }
  static void DiscardPackedRGBA (const uint8* rgba) 
  {
    if (!IsRGBpixelSane())
    {
      delete[] (uint8*)rgba;
    }
  }
  static void UnpackRGBAtoRGBpixel (csRGBpixel* buf, const uint8* rgba, 
    size_t numPixels)
  {
    if (IsRGBpixelSane())
      memcpy (buf, rgba, numPixels * 4);
    else
    {
      csRGBpixel* bufptr = buf;
      while (numPixels--)
      {
        bufptr->red = *rgba++;
        bufptr->green = *rgba++;
        bufptr->blue = *rgba++;
        bufptr->alpha = *rgba++;
        bufptr++; 
      }
    }
  }
  static const csRGBpixel* UnpackRGBAtoRGBpixel (const uint8* rgba, 
    size_t numPixels)
  {
    if (IsRGBpixelSane())
      return (csRGBpixel*)rgba;
    else
    {
      csRGBpixel* buf = new csRGBpixel[numPixels];
      UnpackRGBAtoRGBpixel (buf, rgba, numPixels);
      return buf;
    }
  }
  static csRGBpixel* CopyUnpackRGBAtoRGBpixel (const uint8* rgba, 
    size_t numPixels)
  {
    if (IsRGBpixelSane())
    {
      csRGBpixel* buf = new csRGBpixel[numPixels];
      memcpy (buf, rgba, numPixels * sizeof(csRGBpixel));
      return buf;
    }
    else
      return (csRGBpixel*)UnpackRGBAtoRGBpixel (rgba, numPixels);
  }
  static void csDiscardUnpackedRGBpixel (const csRGBpixel* pixels) 
  {
    if (!IsRGBpixelSane())
      delete[] (csRGBpixel*)pixels;
  }
  static inline csRGBcolor* UnpackRGBAtoRGBcolor (const uint8* rgba, 
    size_t numPixels)
  {
    csRGBcolor* buf = new csRGBcolor[numPixels];
    csRGBcolor* bufptr = buf;
    while (numPixels--)
    {
      bufptr->red = *rgba++;
      bufptr->green = *rgba++;
      bufptr->blue = *rgba++;
      rgba++;
      bufptr++; 
    }
    return buf;
  }
};

#endif // __CSGFX_PACKRGB_H__

---