public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 2]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = 0x0000; pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 2] >> 3) << 11); pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 1] >> 2) << 5); pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 0] >> 3) << 0); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 2] * 0x1F / 0xFF) & 0x1F) << 11); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 1] * 0x3F / 0xFF) & 0x3F) << 5); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 0] * 0x1F / 0xFF) & 0x1F) << 0); PTMethods.GetBytesBE(pixel).CopyTo(output, offset); offset += 2; } } } } return(output); }
public override byte[] Decompress(byte[] input, int DataOffset, VrPixelCodec PixelCodec, VrDataCodec DataCodec) { byte[] output = new byte[BitConverter.ToUInt32(input, 0x00)]; int SourcePointer = DataOffset; int DestPointer = 0x00; int PixelSize = (DataCodec.GetBpp(PixelCodec) / 8); // Copy the header if (DataOffset - 4 > 0) { Array.Copy(input, 0x04, output, 0x00, DataOffset - 4); DestPointer += (DataOffset - 4); } // Decompress while (SourcePointer < input.Length && DestPointer < output.Length) { int amount = input[SourcePointer + PixelSize] + 1; for (int i = 0; i < amount; i++) { Array.Copy(input, SourcePointer, output, DestPointer, PixelSize); DestPointer += PixelSize; } SourcePointer += PixelSize + 1; } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 2]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { int loc = ((y + y2) * width) + (x + x2); byte entry = (byte)((0.30 * input[loc + 2]) + (0.59 * input[loc + 1]) + (0.11 * input[loc + 0])); output[offset + 0] = input[loc + 3]; output[offset + 1] = entry; offset += 2; } } } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { output[offset + 0] = input[((((y + y2) * width) + (x + x2)) * 4) + 3]; output[offset + 1] = input[((((y + y2) * width) + (x + x2)) * 4) + 2]; output[offset + 32] = input[((((y + y2) * width) + (x + x2)) * 4) + 1]; output[offset + 33] = input[((((y + y2) * width) + (x + x2)) * 4) + 0]; offset += 2; } } offset += 32; } } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 8; x2++) { int loc = ((y + y2) * width) + (x + x2); byte entry = (byte)(((0.30 * input[loc + 2]) + (0.59 * input[loc + 1]) + (0.11 * input[loc + 0])) * 0x0F / 0xFF); entry = (byte)(((((input[loc + 3]) * 0x0F / 0xFF) & 0x0F) << 4) | (entry & 0x0F)); output[offset] = entry; offset++; } } } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[(width * height) / 2]; bool IsSwizzled = (width >= 128 && height >= 128); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { int offset = GetSwizzledOffset4(x, y, width, height); byte entry = (byte)(input[(y * width) + x] & 0x0F); if (IsSwizzled) { entry = (byte)((output[offset] & (0x0F << ((y >> 1) & 0x01) * 4)) | (entry << ((~(y >> 1) & 0x01) * 4))); } else { entry = (byte)((output[offset] & (0x0F << (x & 0x01) * 4)) | (entry << ((~x & 0x01) * 4))); } output[GetSwizzledOffset4(x, y, width, height)] = entry; } } return(output); }
public override byte[] Decompress(byte[] input, int DataOffset, VrPixelCodec PixelCodec, VrDataCodec DataCodec) { byte[] output = new byte[PTMethods.ToUInt32(input, 0x00, true)]; int SourcePointer = DataOffset; int DestPointer = 0x00; int PixelSize = (DataCodec.Bpp >> 3); // Copy the header if (DataOffset - 4 > 0) { Array.Copy(input, 0x04, output, 0x00, DataOffset - 4); DestPointer += (DataOffset - 4); } // Decompress while (SourcePointer < input.Length && DestPointer < output.Length) { int amount = input[SourcePointer + PixelSize] + 1; for (int i = 0; i < amount; i++) { Array.Copy(input, SourcePointer, output, DestPointer, PixelSize); DestPointer += PixelSize; } SourcePointer += PixelSize + 1; } return(output); }
public override byte[] Compress(byte[] input, int DataOffset, VrPixelCodec PixelCodec, VrDataCodec DataCodec) { // We can't compress 4-bit textures if (DataCodec.Bpp < 8) { return(input); } MemoryStream output = new MemoryStream(); int SourcePointer = DataOffset; int DestPointer = DataOffset + 4; int PixelSize = (DataCodec.Bpp >> 3); using (BinaryWriter Writer = new BinaryWriter(output)) { Writer.Write(input.Length); // Decompressed filesize Writer.Write(input, 0x00, DataOffset); // Header while (SourcePointer < input.Length) { byte[] pixel = new byte[PixelSize]; Array.Copy(input, SourcePointer, pixel, 0x00, PixelSize); Writer.Write(pixel); SourcePointer += PixelSize; DestPointer += PixelSize; int repeat = 0; while (SourcePointer + PixelSize < input.Length && repeat < 255) { bool match = true; for (int i = 0; i < PixelSize && match; i++) { if (input[SourcePointer + i] != pixel[i]) { match = false; break; } } if (match) { repeat++; SourcePointer += PixelSize; } else { break; } } Writer.Write((byte)repeat); DestPointer++; } Writer.Flush(); } return(output.ToArray()); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { output[offset + 0] = input[((((y + y2) * width) + (x + x2)) * 4) + 3]; output[offset + 1] = input[((((y + y2) * width) + (x + x2)) * 4) + 2]; output[offset + 32] = input[((((y + y2) * width) + (x + x2)) * 4) + 1]; output[offset + 33] = input[((((y + y2) * width) + (x + x2)) * 4) + 0]; offset += 2; } } offset += 32; } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[(width * height) / 2]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2++) { for (int x2 = 0; x2 < 8; x2++) { byte entry = (byte)(input[((y + y2) * width) + (x + x2)] & 0x0F); entry = (byte)((output[offset] & (0x0F << (x2 & 0x01) * 4)) | (entry << ((~x2 & 0x01) * 4))); output[offset] = entry; if ((x2 & 0x01) != 0) { offset++; } } } } } return(output); }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; byte[,] clut = ClutData; int ChunkSize = Math.Min(width, height); TwiddledMap TwiddledMap = new TwiddledMap(ChunkSize, GetBpp(PixelCodec)); for (int y = 0; y < height; y += ChunkSize) { for (int x = 0; x < width; x += ChunkSize) { int StartOffset = offset; for (int y2 = 0; y2 < ChunkSize; y2++) { for (int x2 = 0; x2 < ChunkSize; x2++) { byte entry = input[StartOffset + TwiddledMap.GetTwiddledOffset(x2, y2)]; entry = (byte)((entry >> ((y2 & 0x01) * 4)) & 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 3] = clut[entry, 3]; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = clut[entry, 2]; output[((((y + y2) * width) + (x + x2)) * 4) + 1] = clut[entry, 1]; output[((((y + y2) * width) + (x + x2)) * 4) + 0] = clut[entry, 0]; if ((x2 & 0x01) != 0) offset++; } } } } return output; }
public override byte[] Compress(byte[] input, int DataOffset, VrPixelCodec PixelCodec, VrDataCodec DataCodec) { // We can't compress 4-bit textures if (DataCodec.Bpp < 8) return input; MemoryStream output = new MemoryStream(); int SourcePointer = DataOffset; int DestPointer = DataOffset + 4; int PixelSize = (DataCodec.Bpp >> 3); using (BinaryWriter Writer = new BinaryWriter(output)) { Writer.Write(input.Length); // Decompressed filesize Writer.Write(input, 0x00, DataOffset); // Header while (SourcePointer < input.Length) { byte[] pixel = new byte[PixelSize]; Array.Copy(input, SourcePointer, pixel, 0x00, PixelSize); Writer.Write(pixel); SourcePointer += PixelSize; DestPointer += PixelSize; int repeat = 0; while (SourcePointer + PixelSize < input.Length && repeat < 255) { bool match = true; for (int i = 0; i < PixelSize && match; i++) { if (input[SourcePointer + i] != pixel[i]) { match = false; break; } } if (match) { repeat++; SourcePointer += PixelSize; } else break; } Writer.Write((byte)repeat); DestPointer++; } Writer.Flush(); } return output.ToArray(); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 2]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = 0x0000; if (input[((((y + y2) * width) + (x + x2)) * 4) + 3] <= 0xDA) // Argb3444 { pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 3] >> 5) << 12); pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 2] >> 4) << 8); pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 1] >> 4) << 4); pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 0] >> 4) << 0); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 3] * 0x07 / 0xFF) & 0x07) << 12); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 2] * 0x0F / 0xFF) & 0x0F) << 8); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 1] * 0x0F / 0xFF) & 0x0F) << 4); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 0] * 0x0F / 0xFF) & 0x0F) << 0); } else // Rgb555 { pixel |= 0x8000; pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 2] >> 3) << 10); pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 1] >> 3) << 5); pixel |= (ushort)((input[((((y + y2) * width) + (x + x2)) * 4) + 0] >> 3) << 0); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 2] * 0x1F / 0xFF) & 0x1F) << 10); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 1] * 0x1F / 0xFF) & 0x1F) << 5); //pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 0] * 0x1F / 0xFF) & 0x1F) << 0); } PTMethods.GetBytesBE(pixel).CopyTo(output, offset); offset += 2; } } } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height]; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { byte entry = input[(y * width) + x]; entry = (byte)((entry & 0xE7) | ((entry & 0x10) >> 1) | ((entry & 0x08) << 1)); output[GetSwizzledOffset8(x, y, width, height)] = entry; } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height / 2]; byte[] subBlock; byte[] result; result = new byte[32]; subBlock = new byte[64]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2 += 4) { for (int x2 = 0; x2 < 8; x2 += 4) { int i = 0; for (int y3 = 0; y3 < 4; y3++) { for (int x3 = 0; x3 < 4; x3++) { subBlock[i + 3] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 3]; subBlock[i + 2] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 2]; subBlock[i + 1] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 1]; subBlock[i + 0] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 0]; i += 4; } } ConvertBlockToQuaterCmpr(subBlock).CopyTo(output, offset); offset += 8; } } } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 8; x2++) { output[offset] = input[((y + y2) * width) + (x + x2)]; offset++; } } } } return(output); }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; byte[][] clut = palette; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2++) { for (int x2 = 0; x2 < 8; x2++) { byte entry = (byte)((input[offset] >> ((~x2 & 0x01) * 4)) & 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 3] = clut[entry][3]; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = clut[entry][2]; output[((((y + y2) * width) + (x + x2)) * 4) + 1] = clut[entry][1]; output[((((y + y2) * width) + (x + x2)) * 4) + 0] = clut[entry][0]; if ((x2 & 0x01) != 0) { offset++; } } } } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height]; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { byte entry = input[(y * width) + x]; entry = (byte)((entry & 0xE7) | ((entry & 0x10) >> 1) | ((entry & 0x08) << 1)); output[GetSwizzledOffset8(x, y, width, height)] = entry; } } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * (GetBpp(PixelCodec) / 8)]; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { byte[] palette = PixelCodec.CreatePixelPalette(input, (((y * width) + x) * 4)); palette.CopyTo(output, GetSwizzledOffset(x, y, width, height, GetBpp(PixelCodec))); } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; int StartOffset = offset; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { byte[] palette = PixelCodec.GetPixelPalette(input, StartOffset + GetSwizzledOffset(x, y, width, height, GetBpp(PixelCodec))); output[(((y * width) + x) * 4) + 3] = palette[3]; output[(((y * width) + x) * 4) + 2] = palette[2]; output[(((y * width) + x) * 4) + 1] = palette[1]; output[(((y * width) + x) * 4) + 0] = palette[0]; offset += (GetBpp(PixelCodec) / 8); } } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height / 2]; byte[] subBlock; byte[] result; result = new byte[32]; subBlock = new byte[64]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2 += 4) { for (int x2 = 0; x2 < 8; x2 += 4) { int i = 0; for (int y3 = 0; y3 < 4; y3++) { for (int x3 = 0; x3 < 4; x3++) { subBlock[i + 3] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 3]; subBlock[i + 2] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 2]; subBlock[i + 1] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 1]; subBlock[i + 0] = input[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 0]; i += 4; } } ConvertBlockToQuaterCmpr(subBlock).CopyTo(output, offset); offset += 8; } } } } return output; }
public override int GetBpp(VrPixelCodec PixelCodec) { return PixelCodec.GetBpp(); }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; byte[,] clut = ClutData; int StartOffset = offset; bool IsSwizzled = (width >= 128 && height >= 128); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { // We use width = height for swizzling. This is for rectangle textures // as they require that. Square textures already are width = height. // Most significant bits first byte entry = input[StartOffset + GetSwizzledOffset4(x, y, width, height)]; if (IsSwizzled) entry = (byte)((entry >> ((y >> 1) & 0x01) * 4) & 0x0F); else entry = (byte)((entry >> (x & 0x01) * 4) & 0x0F); output[(((y * width) + x) * 4) + 3] = clut[entry, 3]; output[(((y * width) + x) * 4) + 2] = clut[entry, 2]; output[(((y * width) + x) * 4) + 1] = clut[entry, 1]; output[(((y * width) + x) * 4) + 0] = clut[entry, 0]; if ((x & 0x01) != 0) offset++; } } return output; }
private PvrPixelFormat pixelFormat; // Pixel format #endregion Fields #region Constructors internal PvpPaletteEncoder(byte[][] palette, ushort numColors, PvrPixelFormat pixelFormat, VrPixelCodec pixelCodec) : base(palette, numColors, pixelCodec) { this.pixelFormat = pixelFormat; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; byte[,] clut = ClutData; int StartOffset = offset; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { byte entry = input[StartOffset + GetSwizzledOffset8(x, y, width, height)]; entry = (byte)((entry & 0xE7) | ((entry & 0x10) >> 1) | ((entry & 0x08) << 1)); output[(((y * width) + x) * 4) + 3] = clut[entry, 3]; output[(((y * width) + x) * 4) + 2] = clut[entry, 2]; output[(((y * width) + x) * 4) + 1] = clut[entry, 1]; output[(((y * width) + x) * 4) + 0] = clut[entry, 0]; offset++; } } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { return null; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 8; x2++) { output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = input[offset]; output[((((y + y2) * width) + (x + x2)) * 4) + 1] = input[offset]; output[((((y + y2) * width) + (x + x2)) * 4) + 0] = input[offset]; offset++; } } } } return(output); }
public abstract byte[] Compress(byte[] input, int DataOffset, VrPixelCodec PixelCodec, VrDataCodec DataCodec);
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = PTMethods.ToUInt16BE(input, offset); //output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; //output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 11) & 0x1F) << 11); //output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 5) & 0x3F) << 10); //output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x1F) << 11); output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 11) & 0x1F) * 0xFF / 0x1F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 5) & 0x3F) * 0xFF / 0x3F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x1F) * 0xFF / 0x1F); offset += 2; } } } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; // Palette for each 4x4 block byte[][] palette = new byte[4][]; palette[0] = new byte[4]; palette[1] = new byte[4]; palette[2] = new byte[4]; palette[3] = new byte[4]; // The two colors that determine the palette ushort[] pixel = new ushort[2]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2 += 4) { for (int x2 = 0; x2 < 8; x2 += 4) { // Get the first two colors pixel[0] = PTMethods.ToUInt16BE(input, offset); pixel[1] = PTMethods.ToUInt16BE(input, offset + 2); palette[0][3] = 0xFF; palette[0][2] = (byte)(((pixel[0] >> 11) & 0x1F) * 0xFF / 0x1F); palette[0][1] = (byte)(((pixel[0] >> 5) & 0x3F) * 0xFF / 0x3F); palette[0][0] = (byte)(((pixel[0] >> 0) & 0x1F) * 0xFF / 0x1F); palette[1][3] = 0xFF; palette[1][2] = (byte)(((pixel[1] >> 11) & 0x1F) * 0xFF / 0x1F); palette[1][1] = (byte)(((pixel[1] >> 5) & 0x3F) * 0xFF / 0x3F); palette[1][0] = (byte)(((pixel[1] >> 0) & 0x1F) * 0xFF / 0x1F); // Determine the next two colors based on how the first two are stored if (pixel[0] > pixel[1]) { palette[2][3] = 0xFF; palette[2][2] = (byte)(((palette[0][2] * 2) + palette[1][2]) / 3); palette[2][1] = (byte)(((palette[0][1] * 2) + palette[1][1]) / 3); palette[2][0] = (byte)(((palette[0][0] * 2) + palette[1][0]) / 3); palette[3][3] = 0xFF; palette[3][2] = (byte)(((palette[1][2] * 2) + palette[0][2]) / 3); palette[3][1] = (byte)(((palette[1][1] * 2) + palette[0][1]) / 3); palette[3][0] = (byte)(((palette[1][0] * 2) + palette[0][0]) / 3); } else { palette[2][3] = 0xFF; palette[2][2] = (byte)((palette[0][2] + palette[1][2]) / 2); palette[2][1] = (byte)((palette[0][1] + palette[1][1]) / 2); palette[2][0] = (byte)((palette[0][0] + palette[1][0]) / 2); palette[3][3] = 0x00; palette[3][2] = 0x00; palette[3][1] = 0x00; palette[3][0] = 0x00; } offset += 4; for (int y3 = 0; y3 < 4; y3++) { for (int x3 = 0; x3 < 4; x3++) { output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 3] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][3]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 2] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][2]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 1] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][1]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 0] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][0]; } offset++; } } } } } return(output); }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = SwapUShort(BitConverter.ToUInt16(input, offset)); if ((pixel & 0x8000) != 0) // Rgb555 { output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 10) & 0x1F) * 0xFF / 0x1F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 5) & 0x1F) * 0xFF / 0x1F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x1F) * 0xFF / 0x1F); } else // Argb3444 { output[((((y + y2) * width) + (x + x2)) * 4) + 3] = (byte)(((pixel >> 12) & 0x07) * 0xFF / 0x07); output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 8) & 0x0F) * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 4) & 0x0F) * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x0F) * 0xFF / 0x0F); } offset += 2; } } } } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[(width * height) / 2]; bool IsSwizzled = (width >= 128 && height >= 128); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { int offset = GetSwizzledOffset4(x, y, width, height); byte entry = (byte)(input[(y * width) + x] & 0x0F); if (IsSwizzled) entry = (byte)((output[offset] & (0x0F << ((y >> 1) & 0x01) * 4)) | (entry << ((~(y >> 1) & 0x01) * 4))); else entry = (byte)((output[offset] & (0x0F << (x & 0x01) * 4)) | (entry << ((~x & 0x01) * 4))); output[GetSwizzledOffset4(x, y, width, height)] = entry; } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; // Palette for each 4x4 block byte[][] palette = new byte[4][]; palette[0] = new byte[4]; palette[1] = new byte[4]; palette[2] = new byte[4]; palette[3] = new byte[4]; // The two colors that determine the palette ushort[] pixel = new ushort[2]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2 += 4) { for (int x2 = 0; x2 < 8; x2 += 4) { // Get the first two colors pixel[0] = PTMethods.ToUInt16BE(input, offset); pixel[1] = PTMethods.ToUInt16BE(input, offset + 2); palette[0][3] = 0xFF; palette[0][2] = (byte)(((pixel[0] >> 11) & 0x1F) * 0xFF / 0x1F); palette[0][1] = (byte)(((pixel[0] >> 5) & 0x3F) * 0xFF / 0x3F); palette[0][0] = (byte)(((pixel[0] >> 0) & 0x1F) * 0xFF / 0x1F); palette[1][3] = 0xFF; palette[1][2] = (byte)(((pixel[1] >> 11) & 0x1F) * 0xFF / 0x1F); palette[1][1] = (byte)(((pixel[1] >> 5) & 0x3F) * 0xFF / 0x3F); palette[1][0] = (byte)(((pixel[1] >> 0) & 0x1F) * 0xFF / 0x1F); // Determine the next two colors based on how the first two are stored if (pixel[0] > pixel[1]) { palette[2][3] = 0xFF; palette[2][2] = (byte)(((palette[0][2] * 2) + palette[1][2]) / 3); palette[2][1] = (byte)(((palette[0][1] * 2) + palette[1][1]) / 3); palette[2][0] = (byte)(((palette[0][0] * 2) + palette[1][0]) / 3); palette[3][3] = 0xFF; palette[3][2] = (byte)(((palette[1][2] * 2) + palette[0][2]) / 3); palette[3][1] = (byte)(((palette[1][1] * 2) + palette[0][1]) / 3); palette[3][0] = (byte)(((palette[1][0] * 2) + palette[0][0]) / 3); } else { palette[2][3] = 0xFF; palette[2][2] = (byte)((palette[0][2] + palette[1][2]) / 2); palette[2][1] = (byte)((palette[0][1] + palette[1][1]) / 2); palette[2][0] = (byte)((palette[0][0] + palette[1][0]) / 2); palette[3][3] = 0x00; palette[3][2] = 0x00; palette[3][1] = 0x00; palette[3][0] = 0x00; } offset += 4; for (int y3 = 0; y3 < 4; y3++) { for (int x3 = 0; x3 < 4; x3++) { output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 3] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][3]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 2] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][2]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 1] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][1]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 0] = palette[((input[offset] >> (6 - (x3 * 2))) & 0x03)][0]; } offset++; } } } } } return output; }
public abstract byte[] Decompress(byte[] input, int DataOffset, VrPixelCodec PixelCodec, VrDataCodec DataCodec);
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 8; x2++) { output[offset] = input[((y + y2) * width) + (x + x2)]; offset++; } } } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2 += 4) { for (int x2 = 0; x2 < 8; x2 += 4) { // Determine the colors for the 4x4 clut byte[,] Clut = new byte[4, 4]; ushort[] pixel = new ushort[2]; // Get the first two colors pixel[0] = SwapUShort(BitConverter.ToUInt16(input, offset)); pixel[1] = SwapUShort(BitConverter.ToUInt16(input, offset + 2)); Clut[0, 3] = 0xFF; Clut[0, 2] = (byte)(((pixel[0] >> 11) & 0x1F) * 0xFF / 0x1F); Clut[0, 1] = (byte)(((pixel[0] >> 5) & 0x3F) * 0xFF / 0x3F); Clut[0, 0] = (byte)(((pixel[0] >> 0) & 0x1F) * 0xFF / 0x1F); Clut[1, 3] = 0xFF; Clut[1, 2] = (byte)(((pixel[1] >> 11) & 0x1F) * 0xFF / 0x1F); Clut[1, 1] = (byte)(((pixel[1] >> 5) & 0x3F) * 0xFF / 0x3F); Clut[1, 0] = (byte)(((pixel[1] >> 0) & 0x1F) * 0xFF / 0x1F); // Determine the next two colors based on how the first two are stored if (pixel[0] > pixel[1]) { Clut[2, 3] = 0xFF; Clut[2, 2] = (byte)(((Clut[0, 2] * 2) + Clut[1, 2]) / 3); Clut[2, 1] = (byte)(((Clut[0, 1] * 2) + Clut[1, 1]) / 3); Clut[2, 0] = (byte)(((Clut[0, 0] * 2) + Clut[1, 0]) / 3); Clut[3, 3] = 0xFF; Clut[3, 2] = (byte)(((Clut[1, 2] * 2) + Clut[0, 2]) / 3); Clut[3, 1] = (byte)(((Clut[1, 1] * 2) + Clut[0, 1]) / 3); Clut[3, 0] = (byte)(((Clut[1, 0] * 2) + Clut[0, 0]) / 3); } else { Clut[2, 3] = 0xFF; Clut[2, 2] = (byte)((Clut[0, 2] + Clut[1, 2]) / 2); Clut[2, 1] = (byte)((Clut[0, 1] + Clut[1, 1]) / 2); Clut[2, 0] = (byte)((Clut[0, 0] + Clut[1, 0]) / 2); Clut[3, 3] = 0x00; Clut[3, 2] = 0x00; Clut[3, 1] = 0x00; Clut[3, 0] = 0x00; } offset += 4; for (int y3 = 0; y3 < 4; y3++) { for (int x3 = 0; x3 < 4; x3++) { output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 3] = Clut[((input[offset] >> (6 - (x3 * 2))) & 0x03), 3]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 2] = Clut[((input[offset] >> (6 - (x3 * 2))) & 0x03), 2]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 1] = Clut[((input[offset] >> (6 - (x3 * 2))) & 0x03), 1]; output[((((y + y2 + y3) * width) + (x + x2 + x3)) * 4) + 0] = Clut[((input[offset] >> (6 - (x3 * 2))) & 0x03), 0]; } offset++; } } } } } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[(width * height) / 2]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2++) { for (int x2 = 0; x2 < 8; x2++) { int loc = ((y + y2) * width) + (x + x2); byte entry = (byte)(((0.30 * input[loc + 2]) + (0.59 * input[loc + 1]) + (0.11 * input[loc + 0])) * 0x0F / 0xFF); entry = (byte)((output[offset] & (0x0F << (x2 & 0x01) * 4)) | (entry << ((~x2 & 0x01) * 4))); output[offset] = entry; if ((x2 & 0x01) != 0) offset++; } } } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; byte[,] clut = ClutData; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 8; x2++) { output[((((y + y2) * width) + (x + x2)) * 4) + 3] = clut[input[offset], 3]; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = clut[input[offset], 2]; output[((((y + y2) * width) + (x + x2)) * 4) + 1] = clut[input[offset], 1]; output[((((y + y2) * width) + (x + x2)) * 4) + 0] = clut[input[offset], 0]; offset++; } } } } return output; }
public override byte[] DecodeMipmap(byte[] input, int offset, int mipmap, int width, int height, VrPixelCodec PixelCodec) { // Get the width of the mipmap and go to the correct offset int MipmapWidth = width; for (int i = 0; i < mipmap; i++) MipmapWidth >>= 1; for (int i = 1; i < MipmapWidth; i <<= 1) offset += (Math.Max(i * i, 4) >> 2); return Decode(input, offset, MipmapWidth, MipmapWidth, PixelCodec); }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 8) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 8; y2++) { for (int x2 = 0; x2 < 8; x2++) { byte entry = (byte)((input[offset] >> ((~x2 & 0x01) * 4)) & 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(entry * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(entry * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(entry * 0xFF / 0x0F); if ((x2 & 0x01) != 0) offset++; } } } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 8; x2++) { output[((((y + y2) * width) + (x + x2)) * 4) + 3] = (byte)(((input[offset] >> 4) & 0x0F) * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)((input[offset] & 0x0F) * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)((input[offset] & 0x0F) * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)((input[offset] & 0x0F) * 0xFF / 0x0F); offset++; } } } } return output; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 2]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { int loc = ((y + y2) * width) + (x + x2); byte entry = (byte)((0.30 * input[loc + 2]) + (0.59 * input[loc + 1]) + (0.11 * input[loc + 0])); output[offset + 0] = input[loc + 3]; output[offset + 1] = entry; offset += 2; } } } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; byte[][] clut = palette; int StartOffset = offset; bool IsSwizzled = (width >= 128 && height >= 128); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { // We use width = height for swizzling. This is for rectangle textures // as they require that. Square textures already are width = height. // Most significant bits first byte entry = input[StartOffset + GetSwizzledOffset4(x, y, width, height)]; if (IsSwizzled) { entry = (byte)((entry >> ((y >> 1) & 0x01) * 4) & 0x0F); } else { entry = (byte)((entry >> (x & 0x01) * 4) & 0x0F); } output[(((y * width) + x) * 4) + 3] = clut[entry][3]; output[(((y * width) + x) * 4) + 2] = clut[entry][2]; output[(((y * width) + x) * 4) + 1] = clut[entry][1]; output[(((y * width) + x) * 4) + 0] = clut[entry][0]; if ((x & 0x01) != 0) { offset++; } } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 8) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 8; x2++) { int loc = ((y + y2) * width) + (x + x2); byte entry = (byte)(((0.30 * input[loc + 2]) + (0.59 * input[loc + 1]) + (0.11 * input[loc + 0])) * 0x0F / 0xFF); entry = (byte)(((((input[loc + 3]) * 0x0F / 0xFF) & 0x0F) << 4) | (entry & 0x0F)); output[offset] = entry; offset++; } } } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = PTMethods.ToUInt16BE(input, offset); //output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; //output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 11) & 0x1F) << 11); //output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 5) & 0x3F) << 10); //output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x1F) << 11); output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 11) & 0x1F) * 0xFF / 0x1F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 5) & 0x3F) * 0xFF / 0x3F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x1F) * 0xFF / 0x1F); offset += 2; } } } } return(output); }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 2]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = 0x0000; pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 2] * 0x1F / 0xFF) & 0x1F) << 11); pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 1] * 0x3F / 0xFF) & 0x3F) << 5); pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 0] * 0x1F / 0xFF) & 0x1F) << 0); BitConverter.GetBytes(SwapUShort(pixel)).CopyTo(output, offset); offset += 2; } } } } return output; }
public override int GetBpp(VrPixelCodec PixelCodec) { return 16; }
public override byte[] Encode(byte[] input, int width, int height, VrPixelCodec PixelCodec) { int offset = 0; byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = 0x0000; if (input[((((y + y2) * width) + (x + x2)) * 4) + 3] <= 0xDA) // Argb3444 { pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 3] * 0x07 / 0xFF) & 0x07) << 12); pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 2] * 0x0F / 0xFF) & 0x0F) << 8); pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 1] * 0x0F / 0xFF) & 0x0F) << 4); pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 0] * 0x0F / 0xFF) & 0x0F) << 0); } else // Rgb555 { pixel |= 0x8000; pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 2] * 0x1F / 0xFF) & 0x1F) << 10); pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 1] * 0x1F / 0xFF) & 0x1F) << 5); pixel |= (ushort)(((input[((((y + y2) * width) + (x + x2)) * 4) + 0] * 0x1F / 0xFF) & 0x1F) << 0); } BitConverter.GetBytes(SwapUShort(pixel)).CopyTo(output, offset); offset += 2; } } } } return output; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; byte[][] clut = palette; int StartOffset = offset; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { byte entry = input[StartOffset + GetSwizzledOffset8(x, y, width, height)]; entry = (byte)((entry & 0xE7) | ((entry & 0x10) >> 1) | ((entry & 0x08) << 1)); output[(((y * width) + x) * 4) + 3] = clut[entry][3]; output[(((y * width) + x) * 4) + 2] = clut[entry][2]; output[(((y * width) + x) * 4) + 1] = clut[entry][1]; output[(((y * width) + x) * 4) + 0] = clut[entry][0]; offset++; } } return(output); }
private PvrPixelFormat pixelFormat; // Pixel format #endregion #region Constructors & Initalizers internal PvpPaletteEncoder(byte[][] palette, ushort numColors, PvrPixelFormat pixelFormat, VrPixelCodec pixelCodec) : base(palette, numColors, pixelCodec) { this.pixelFormat = pixelFormat; }
public override byte[] Decode(byte[] input, int offset, int width, int height, VrPixelCodec PixelCodec) { byte[] output = new byte[width * height * 4]; for (int y = 0; y < height; y += 4) { for (int x = 0; x < width; x += 4) { for (int y2 = 0; y2 < 4; y2++) { for (int x2 = 0; x2 < 4; x2++) { ushort pixel = PTMethods.ToUInt16BE(input, offset); if ((pixel & 0x8000) != 0) // Rgb555 { output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 10) & 0x1F) * 0xFF / 0x1F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 5) & 0x1F) * 0xFF / 0x1F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x1F) * 0xFF / 0x1F); //output[((((y + y2) * width) + (x + x2)) * 4) + 3] = 0xFF; //output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 10) & 0x1F) << 11); //output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 5) & 0x1F) << 11); //output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x1F) << 11); } else // Argb3444 { output[((((y + y2) * width) + (x + x2)) * 4) + 3] = (byte)(((pixel >> 12) & 0x07) * 0xFF / 0x07); output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 8) & 0x0F) * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 4) & 0x0F) * 0xFF / 0x0F); output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x0F) * 0xFF / 0x0F); //output[((((y + y2) * width) + (x + x2)) * 4) + 3] = (byte)(((pixel >> 12) & 0x07) << 13); //output[((((y + y2) * width) + (x + x2)) * 4) + 2] = (byte)(((pixel >> 8) & 0x0F) << 12); //output[((((y + y2) * width) + (x + x2)) * 4) + 1] = (byte)(((pixel >> 4) & 0x0F) << 12); //output[((((y + y2) * width) + (x + x2)) * 4) + 0] = (byte)(((pixel >> 0) & 0x0F) << 12); } offset += 2; } } } } return(output); }