OSGPSDImageFileType.cpp File Reference

#include "OSGConfig.h"
#include "OSGBaseFunctions.h"
#include "OSGPSDImageFileType.h"
#include <OSGLog.h>

Go to the source code of this file.

Namespaces
namespace	osg
Classes
struct	PSDHeader
Functions
static UInt32	parseUInt32 (char *&ptr)
static UInt16	parseUInt16 (char *&ptr)
static bool	readHeader (std::istream &is, PSDHeader &header)
static bool	readColorModeData (std::istream &is, const PSDHeader &header, char *colormap)
static bool	readResource (std::istream &is, UInt32 &length, Int16 &transparentIndex)
static bool	readImageResources (std::istream &is, Int16 &transparentIndex)
static bool	readLayerAndMaskInformation (std::istream &is)
static bool	readImageData (std::istream &is, const PSDHeader &header, UInt16 relevantChannels, char *colormap, Int16 &transparentIndex, UInt8 *data)
Variables
static const Char8 *	suffixArray []

---

Function Documentation

static UInt32 parseUInt32

(

char *&

ptr

)

[static]

Definition at line 65 of file OSGPSDImageFileType.cpp.

Referenced by osg::readBitmapFileHeader(), osg::readBitmapInfoHeader(), readColorModeData(), readHeader(), readImageResources(), readLayerAndMaskInformation(), and readResource().

{
  UInt32 result =
    (static_cast<UInt32>(static_cast<UInt8>(ptr[0])) << 24) |
    (static_cast<UInt32>(static_cast<UInt8>(ptr[1])) << 16) |
    (static_cast<UInt32>(static_cast<UInt8>(ptr[2])) <<  8) |
    (static_cast<UInt32>(static_cast<UInt8>(ptr[3])) <<  0);
  ptr += 4;
  return result;
}

static UInt16 parseUInt16

(

char *&

ptr

)

[static]

Definition at line 76 of file OSGPSDImageFileType.cpp.

Referenced by osg::readBitmapFileHeader(), osg::readBitmapInfoHeader(), readHeader(), readImageData(), and readResource().

{
  UInt16 result =
    (static_cast<UInt32>(static_cast<UInt8>(ptr[0])) << 8) |
    (static_cast<UInt32>(static_cast<UInt8>(ptr[1])) << 0);
  ptr +=2;
  return result;
}

static bool readHeader	(	std::istream &	is,
		PSDHeader &	header
	)			[static]

Definition at line 98 of file OSGPSDImageFileType.cpp.

References PSDHeader::channels, PSDHeader::columns, PSDHeader::depth, PSDHeader::mode, parseUInt16(), parseUInt32(), PSDHeader::reserved, PSDHeader::rows, PSDHeader::signature, and PSDHeader::version.

Referenced by osg::PSDImageFileType::read().

{
  // Read the header into the buffer
  char buffer[26];
  is.read(buffer, 26);
  if (is.gcount() != 26)
    return false;

  // Parse the header
  char *ptr = buffer;
  memcpy(header.signature, ptr, 4);
  ptr += 4;
  header.version = parseUInt16(ptr);
  memcpy(header.reserved, ptr, 6);
  ptr += 6;
  header.channels = parseUInt16(ptr);
  header.rows = parseUInt32(ptr);
  header.columns = parseUInt32(ptr);
  header.depth = parseUInt16(ptr);
  header.mode = parseUInt16(ptr);

  // Check the header
  if (memcmp(header.signature, "8BPS", 4) != 0)
    return false;
  if (header.version != 1)
    return false;

  return true;
}

static bool readColorModeData	(	std::istream &	is,
		const PSDHeader &	header,
		char *	colormap
	)			[static]

Definition at line 128 of file OSGPSDImageFileType.cpp.

References PSDHeader::mode, and parseUInt32().

Referenced by osg::PSDImageFileType::read().

{
  // Read the length of the color mode data into the buffer
  char buffer[4];
  is.read(buffer, 4);
  if (is.gcount() != 4)
    return false;

  // Parse the length
  char *ptr = buffer;
  UInt32 length = parseUInt32(ptr);

  // Parse the color palette
  if (header.mode == 2)
  {
    if (length != 768)
      return false;
    length = 0;
    is.read(colormap, 768);
    if (static_cast<UInt32>(is.gcount()) != 768)
      return false;
  }

  // Ignore remaining data
  is.ignore(length);
  if (static_cast<UInt32>(is.gcount()) != length)
    return false;

  return true;
}

static bool readResource	(	std::istream &	is,
		UInt32 &	length,
		Int16 &	transparentIndex
	)			[static]

Definition at line 159 of file OSGPSDImageFileType.cpp.

References parseUInt16(), and parseUInt32().

Referenced by readImageResources().

{
  // Parse type, id, name and size
  if (length < 8)
    return false;
  char buffer[8];
  is.read(buffer, 6);
  if (is.gcount() != 6)
    return false;
  length -= 6;
  char *ptr = buffer + 4;
  UInt16 id = parseUInt16(ptr);
  int c = is.get();
  if (c == EOF)
    return false;
  length -= 1;
  if ((c & 1) == 0)
    ++c;
  if (static_cast<UInt32>(c) > length)
    return false;
  is.ignore(c);
  if (is.gcount() != c)
    return false;
  length -= c;
  ptr = buffer + 4;
  is.read(ptr, 4);
  if (is.gcount() != 4)
    return false;
  length -= 4;
  UInt32 size = parseUInt32(ptr);
  if (size > length)
    return false;

  if (memcmp(buffer, "8BIM", 4) == 0)
  {
    switch (id)
    {
    case 0x417:
      if (size == 2)
      {
        ptr = buffer + 4;
        is.read(ptr, 2);
        if (is.gcount() != 2)
          return false;
        size = 0;
        length -= 2;
        transparentIndex = parseUInt16(ptr);
      }
      break;
    }
  }

  if ((size & 1) != 0)
    ++size;
  is.ignore(size);
  if (static_cast<UInt32>(is.gcount()) != size)
    return false;
  length -= size;

  return true;
}

static bool readImageResources	(	std::istream &	is,
		Int16 &	transparentIndex
	)			[static]

Definition at line 221 of file OSGPSDImageFileType.cpp.

References parseUInt32(), and readResource().

Referenced by osg::PSDImageFileType::read().

{
  // Read the length of the image resources into the buffer
  char buffer[4];
  is.read(buffer, 4);
  if (is.gcount() != 4)
    return false;

  // Parse the length
  char *ptr = buffer;
  UInt32 length = parseUInt32(ptr);

  // Parse resources
  while (length > 0)
    if (readResource(is, length, transparentIndex) == false)
      return false;

  return true;
}

static bool readLayerAndMaskInformation

(

std::istream &

is

)

[static]

Definition at line 241 of file OSGPSDImageFileType.cpp.

References parseUInt32().

Referenced by osg::PSDImageFileType::read().

{
  // Read the length of the layer and mask information into the buffer
  char buffer[4];
  is.read(buffer, 4);
  if (is.gcount() != 4)
    return false;

  // Parse the length
  char *ptr = buffer;
  UInt32 length = parseUInt32(ptr);

  // Ignore data
  is.ignore(length);
  if (static_cast<UInt32>(is.gcount()) != length)
    return false;

  return true;
}

static bool readImageData	(	std::istream &	is,
		const PSDHeader &	header,
		UInt16	relevantChannels,
		char *	colormap,
		Int16 &	transparentIndex,
		UInt8 *	data
	)			[static]

Definition at line 261 of file OSGPSDImageFileType.cpp.

References PSDHeader::channels, PSDHeader::columns, PSDHeader::depth, PSDHeader::mode, parseUInt16(), and PSDHeader::rows.

Referenced by osg::PSDImageFileType::read().

{
  // Read the compression into the buffer
  std::vector<char> buffer;
  buffer.resize(2);
  char *ptr = &(buffer.front());
  is.read(ptr, 2);
  if (is.gcount() != 2)
    return false;

  // Parse the compression
  UInt16 compression = parseUInt16(ptr);
  if (compression > 1)
    return false;

  // Calculate the bytes per line
  UInt32 bpl = (header.columns * header.depth + 7) / 8;
  UInt32 dstBpl;
  if (header.mode == 2) // Indexed color
    dstBpl = header.columns * (transparentIndex != -1 ? 4 : 3);
  else
    dstBpl = header.columns * relevantChannels;

  // When the image data is compressed, we have to read the
  // lengths of the lines
  std::vector<UInt16> lineLength;
  if (compression == 1)
  {
    UInt32 numLines = header.rows * header.channels;
    lineLength.resize(numLines);
    UInt32 size = numLines * 2;
    buffer.resize(size);
    ptr = &(buffer.front());
    is.read(ptr, size);
    if (static_cast<UInt32>(is.gcount()) != size)
      return false;
    UInt16 maxLength = 0;
    for (UInt32 i = 0; i < numLines; ++i)
    {
      UInt16 length = parseUInt16(ptr);
      lineLength[i] = length;
      if (length > maxLength)
        maxLength = length;
    }
    buffer.resize(maxLength);
  }
  else
    buffer.resize(bpl);

  UInt32 lineNumber = 0;
  std::vector<char> line(bpl);
  UInt8 *dstPtr;
  for (UInt16 c = 0; c < header.channels; ++c)
  {
    dstPtr = data + c + dstBpl * (header.rows - 1);
    for (UInt32 y = 0; y < header.rows; ++y)
    {
      // Read the line
      UInt32 size;
      if (compression == 1)
      {
        ptr = &(buffer.front());
        size = lineLength[lineNumber];
      }
      else
      {
        ptr = &(line.front());
        size = bpl;
      }
      is.read(ptr, size);
      if (static_cast<UInt32>(is.gcount()) != size)
        return false;

      if (c < relevantChannels)
      {
        // Decompress the line
        if (compression == 1)
        {
          UInt32 src = 0, dst = 0;
          while (src < size)
          {
            UInt8 runCount = buffer[src++];
            if (runCount & 0x80)
            {
              runCount = -runCount + 1;
              if (dst + runCount > bpl)
                return false;
              for (; runCount > 0; --runCount)
                line[dst++] = buffer[src];
              ++src;
            }
            else
            {
              ++runCount;
              if (dst + runCount > bpl)
                return false;
              for (; runCount > 0; --runCount)
                line[dst++] = buffer[src++];
            }
          }
          if (dst != bpl)
            return false;
        }

        // Copy the line into the image
        UInt8 *lineDstPtr = dstPtr;
        switch (header.depth)
        {
        case 1:
          for (UInt32 x = 0; x < header.columns; ++x)
          {
            UInt8 v = line[x / 8] & (1 << (7 - (x & 7)));
            *lineDstPtr = v != 0 ? 0 : 255;
            lineDstPtr += relevantChannels;
          }
          break;
        case 8:
          if (header.mode == 2)
            for (UInt32 x = 0; x < header.columns; ++x)
            {
              UInt8 index = line[x];
              *lineDstPtr++ = colormap[index];
              *lineDstPtr++ = colormap[index + 256];
              *lineDstPtr++ = colormap[index + 512];
              if (transparentIndex != -1)
                *lineDstPtr++ = index == transparentIndex ? 0 : 255;
            }
          else
            for (UInt32 x = 0; x < header.columns; ++x)
            {
              *lineDstPtr = line[x];
              lineDstPtr += relevantChannels;
            }
          break;
        case 16:
          for (UInt32 x = 0; x < header.columns; ++x)
          {
            *lineDstPtr = line[x * 2];
            lineDstPtr += relevantChannels;
          }
          break;
        }
      }
      dstPtr -= dstBpl;

      ++lineNumber;
    }
  }

  return true;
}

---

Variable Documentation

const Char8* suffixArray[] [static]

Initial value:

 {
  "psd"
}

Definition at line 415 of file OSGPSDImageFileType.cpp.