old-nall/decode/png.hpp

#pragma once

#include <nall/string.hpp>
#include <nall/decode/inflate.hpp>

namespace nall { namespace Decode {

struct PNG {
  inline PNG();
  inline ~PNG();

  inline auto load(const string& filename) -> bool;
  inline auto load(const uint8_t* sourceData, uint sourceSize) -> bool;
  inline auto readbits(const uint8_t*& data) -> uint;

  struct Info {
    uint width;
    uint height;
    uint bitDepth;
    //colorType:
    //0 = L (luma)
    //2 = R,G,B
    //3 = P (palette)
    //4 = L,A
    //6 = R,G,B,A
    uint colorType;
    uint compressionMethod;
    uint filterType;
    uint interlaceMethod;

    uint bytesPerPixel;
    uint pitch;

    uint8_t palette[256][3];
  } info;

  uint8_t* data = nullptr;
  uint size = 0;

  uint bitpos = 0;

protected:
  enum class FourCC : uint {
    IHDR = 0x49484452,
    PLTE = 0x504c5445,
    IDAT = 0x49444154,
    IEND = 0x49454e44,
  };

  inline auto interlace(uint pass, uint index) -> uint;
  inline auto inflateSize() -> uint;
  inline auto deinterlace(const uint8_t*& inputData, uint pass) -> bool;
  inline auto filter(uint8_t* outputData, const uint8_t* inputData, uint width, uint height) -> bool;
  inline auto read(const uint8_t* data, uint length) -> uint;
};

PNG::PNG() {
}

PNG::~PNG() {
  if(data) delete[] data;
}

auto PNG::load(const string& filename) -> bool {
  if(auto memory = file::read(filename)) {
    return load(memory.data(), memory.size());
  }
  return false;
}

auto PNG::load(const uint8_t* sourceData, uint sourceSize) -> bool {
  if(sourceSize < 8) return false;
  if(read(sourceData + 0, 4) != 0x89504e47) return false;
  if(read(sourceData + 4, 4) != 0x0d0a1a0a) return false;

  uint8_t* compressedData = nullptr;
  uint compressedSize = 0;

  uint offset = 8;
  while(offset < sourceSize) {
    uint length   = read(sourceData + offset + 0, 4);
    uint fourCC   = read(sourceData + offset + 4, 4);
    uint checksum = read(sourceData + offset + 8 + length, 4);

    if(fourCC == (uint)FourCC::IHDR) {
      info.width             = read(sourceData + offset +  8, 4);
      info.height            = read(sourceData + offset + 12, 4);
      info.bitDepth          = read(sourceData + offset + 16, 1);
      info.colorType         = read(sourceData + offset + 17, 1);
      info.compressionMethod = read(sourceData + offset + 18, 1);
      info.filterType        = read(sourceData + offset + 19, 1);
      info.interlaceMethod   = read(sourceData + offset + 20, 1);

      if(info.bitDepth == 0 || info.bitDepth > 16) return false;
      if(info.bitDepth & (info.bitDepth - 1)) return false;  //not a power of two
      if(info.compressionMethod != 0) return false;
      if(info.filterType != 0) return false;
      if(info.interlaceMethod != 0 && info.interlaceMethod != 1) return false;

      switch(info.colorType) {
      case 0: info.bytesPerPixel = info.bitDepth * 1; break;  //L
      case 2: info.bytesPerPixel = info.bitDepth * 3; break;  //R,G,B
      case 3: info.bytesPerPixel = info.bitDepth * 1; break;  //P
      case 4: info.bytesPerPixel = info.bitDepth * 2; break;  //L,A
      case 6: info.bytesPerPixel = info.bitDepth * 4; break;  //R,G,B,A
      default: return false;
      }

      if(info.colorType == 2 || info.colorType == 4 || info.colorType == 6) {
        if(info.bitDepth != 8 && info.bitDepth != 16) return false;
      }
      if(info.colorType == 3 && info.bitDepth == 16) return false;

      info.bytesPerPixel = (info.bytesPerPixel + 7) / 8;
      info.pitch = (int)info.width * info.bytesPerPixel;
    }

    if(fourCC == (uint)FourCC::PLTE) {
      if(length % 3) return false;
      for(uint n = 0, p = offset + 8; n < length / 3; n++) {
        info.palette[n][0] = sourceData[p++];
        info.palette[n][1] = sourceData[p++];
        info.palette[n][2] = sourceData[p++];
      }
    }

    if(fourCC == (uint)FourCC::IDAT) {
      compressedData = (uint8_t*)realloc(compressedData, compressedSize + length);
      memcpy(compressedData + compressedSize, sourceData + offset + 8, length);
      compressedSize += length;
    }

    if(fourCC == (uint)FourCC::IEND) {
      break;
    }

    offset += 4 + 4 + length + 4;
  }

  uint interlacedSize = inflateSize();
  auto interlacedData = new uint8_t[interlacedSize];

  bool result = inflate(interlacedData, interlacedSize, compressedData + 2, compressedSize - 6);
  free(compressedData);

  if(result == false) {
    delete[] interlacedData;
    return false;
  }

  size = info.width * info.height * info.bytesPerPixel;
  data = new uint8_t[size];

  if(info.interlaceMethod == 0) {
    if(filter(data, interlacedData, info.width, info.height) == false) {
      delete[] interlacedData;
      delete[] data;
      data = nullptr;
      return false;
    }
  } else {
    const uint8_t* passData = interlacedData;
    for(uint pass = 0; pass < 7; pass++) {
      if(deinterlace(passData, pass) == false) {
        delete[] interlacedData;
        delete[] data;
        data = nullptr;
        return false;
      }
    }
  }

  delete[] interlacedData;
  return true;
}

auto PNG::interlace(uint pass, uint index) -> uint {
  static const uint data[7][4] = {
    //x-distance, y-distance, x-origin, y-origin
    {8, 8, 0, 0},
    {8, 8, 4, 0},
    {4, 8, 0, 4},
    {4, 4, 2, 0},
    {2, 4, 0, 2},
    {2, 2, 1, 0},
    {1, 2, 0, 1},
  };
  return data[pass][index];
}

auto PNG::inflateSize() -> uint {
  if(info.interlaceMethod == 0) {
    return info.width * info.height * info.bytesPerPixel + info.height;
  }

  uint size = 0;
  for(uint pass = 0; pass < 7; pass++) {
    uint xd = interlace(pass, 0), yd = interlace(pass, 1);
    uint xo = interlace(pass, 2), yo = interlace(pass, 3);
    uint width  = (info.width  + (xd - xo - 1)) / xd;
    uint height = (info.height + (yd - yo - 1)) / yd;
    if(width == 0 || height == 0) continue;
    size += width * height * info.bytesPerPixel + height;
  }
  return size;
}

auto PNG::deinterlace(const uint8_t*& inputData, uint pass) -> bool {
  uint xd = interlace(pass, 0), yd = interlace(pass, 1);
  uint xo = interlace(pass, 2), yo = interlace(pass, 3);
  uint width  = (info.width  + (xd - xo - 1)) / xd;
  uint height = (info.height + (yd - yo - 1)) / yd;
  if(width == 0 || height == 0) return true;

  uint outputSize = width * height * info.bytesPerPixel;
  auto outputData = new uint8_t[outputSize];
  bool result = filter(outputData, inputData, width, height);

  const uint8_t* rd = outputData;
  for(uint y = yo; y < info.height; y += yd) {
    uint8_t* wr = data + y * info.pitch;
    for(uint x = xo; x < info.width; x += xd) {
      for(uint b = 0; b < info.bytesPerPixel; b++) {
        wr[x * info.bytesPerPixel + b] = *rd++;
      }
    }
  }

  inputData += outputSize + height;
  delete[] outputData;
  return result;
}

auto PNG::filter(uint8_t* outputData, const uint8_t* inputData, uint width, uint height) -> bool {
  uint8_t* wr = outputData;
  const uint8_t* rd = inputData;
  int bpp = info.bytesPerPixel, pitch = width * bpp;
  for(int y = 0; y < height; y++) {
    uint8_t filter = *rd++;

    switch(filter) {
    case 0x00:  //None
      for(int x = 0; x < pitch; x++) {
        wr[x] = rd[x];
      }
      break;

    case 0x01:  //Subtract
      for(int x = 0; x < pitch; x++) {
        wr[x] = rd[x] + (x - bpp < 0 ? 0 : wr[x - bpp]);
      }
      break;

    case 0x02:  //Above
      for(int x = 0; x < pitch; x++) {
        wr[x] = rd[x] + (y - 1 < 0 ? 0 : wr[x - pitch]);
      }
      break;

    case 0x03:  //Average
      for(int x = 0; x < pitch; x++) {
        short a = x - bpp < 0 ? 0 : wr[x - bpp];
        short b = y - 1 < 0 ? 0 : wr[x - pitch];

        wr[x] = rd[x] + (uint8_t)((a + b) / 2);
      }
      break;

    case 0x04:  //Paeth
      for(int x = 0; x < pitch; x++) {
        short a = x - bpp < 0 ? 0 : wr[x - bpp];
        short b = y - 1 < 0 ? 0 : wr[x - pitch];
        short c = x - bpp < 0 || y - 1 < 0 ? 0 : wr[x - pitch - bpp];

        short p = a + b - c;
        short pa = p > a ? p - a : a - p;
        short pb = p > b ? p - b : b - p;
        short pc = p > c ? p - c : c - p;

        auto paeth = (uint8_t)((pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c);

        wr[x] = rd[x] + paeth;
      }
      break;

    default:  //Invalid
      return false;
    }

    rd += pitch;
    wr += pitch;
  }

  return true;
}

auto PNG::read(const uint8_t* data, uint length) -> uint {
  uint result = 0;
  while(length--) result = (result << 8) | (*data++);
  return result;
}

auto PNG::readbits(const uint8_t*& data) -> uint {
  uint result = 0;
  switch(info.bitDepth) {
  case 1:
    result = (*data >> bitpos) & 1;
    bitpos++;
    if(bitpos == 8) { data++; bitpos = 0; }
    break;
  case 2:
    result = (*data >> bitpos) & 3;
    bitpos += 2;
    if(bitpos == 8) { data++; bitpos = 0; }
    break;
  case 4:
    result = (*data >> bitpos) & 15;
    bitpos += 4;
    if(bitpos == 8) { data++; bitpos = 0; }
    break;
  case 8:
    result = *data++;
    break;
  case 16:
    result = (data[0] << 8) | (data[1] << 0);
    data += 2;
    break;
  }
  return result;
}

}}