Skip to content
Permalink
master
Switch branches/tags

CompileTools/CompileTools/GDT.cs /
Jump to
Code definitions
Code navigation index up-to-date

Go to file
  • Go to file
  • Copy path
  • Copy permalink
 
 
Cannot retrieve contributors at this time
836 lines (757 sloc) 39.4 KB
Raw Blame
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Drawing;
using System.Drawing.Imaging;
namespace CompileTools
{
public class GDT : ConversionMethod
{
public override string Name
{
get { return "GDT"; }
}
public override string[] Outputs
{
get { return new string[] { ".gdt" }; }
}
public override string[] Inputs
{
get { return new string[] { ".bmp" }; }
}
public override bool Verify(Stream input)
{
throw new NotImplementedException();
}
public override void ConvertTo(Stream input, Stream output)
{
// Current encoding functionality: Uses 0x04 (RLE) flag, 0x10 (repeat previous plane), 0x8N (copy nth previous block's analogous plane).
// Things you can do to make images insert a little better:
// 1) Crop the bottom and right black portions of the title images. (just less data for the codec to screw up)
// 2) Play with the dimensions of the images.
// Create new bmp with header
Bitmap bmp = new Bitmap(Bitmap.FromStream(input));
WriteInt16(output, unchecked((short)0xE488));
WriteInt32(output, 0);
WriteInt16(output, (short)bmp.Width);
WriteInt16(output, (short)(bmp.Height / 2));
output.WriteByte(0x11);
List<List<int>> planes = new List<List<int>>();
List<Boolean> planesCopied = new List<Boolean>();
int currentPlane = 0;
// blankPlane will get called a lot, so create it here. (Just an appropriately-sized array of zeroes.)
List<int> blankPlane = new List<int>(Enumerable.Repeat(0x00, bmp.Height / 2));
// Look at the input bmp and consider it in 8-pixel-wide blocks:
for (int width = 0; width < (bmp.Width - 8); width += 8)
{
// First, check if the block is entirely black. If so, we can write "00-00-00" and skip it.
bool allBlack = true;
for (int height = 0; height < bmp.Height && allBlack; height += 2)
{
for (int dw = 0; dw < 8 && allBlack; dw++)
{
if (bmp.GetPixel(width + dw, height).ToArgb() != Color.Black.ToArgb())
{
allBlack = false;
}
}
}
if (allBlack)
{
// Write a blank block, then proceed to the next block
output.WriteByte(0x00);
output.WriteByte(0x00);
output.WriteByte(0x00);
planes.Add(blankPlane);
planes.Add(blankPlane);
planes.Add(blankPlane);
planesCopied.Add(false);
planesCopied.Add(false);
planesCopied.Add(false);
currentPlane += 3;
continue;
}
// If it's not all black, consider it in terms of each plane (B R G)
// plane is which color plane (0, 1, 2); currentPlane is the plane number overall
for (int plane = 0; plane < 3; plane++, currentPlane++)
{
// planeData is the integer representation of each line's data.
List<int> planeData = new List<int>();
//currentPlane++;
Console.WriteLine("Processing plane {0}. {1} plane at {2}", currentPlane, currentPlane % 3, (currentPlane / 3) * 8);
for (int height = 0; height < bmp.Height; height += 2)
{
int data = 0;
for (int dw = 0; dw < 8; dw++) // dw = difference in width; column in the block
{
// If the pixel's color contains a certain threshold of the plane's ideal RGB color, then it's part of that plane data.
// pure color -> ingame color
// #0000FF B -> #0066FF (lighter blue)
// #FF0000 R -> #FF6600 (burnt orange)
// #00FF00 G -> #00FF00 (same green)
if ((bmp.GetPixel(width + dw, height).B > 0) && plane == 0)
// If there's any blue at all, add the data to the blue plane
{
data |= 1 << (7 - dw);
}
if ((bmp.GetPixel(width + dw, height).R > 0) && plane == 1)
// if there's any red at all, add the data to the red plane
{
data |= 1 << (7 - dw);
}
if ((bmp.GetPixel(width + dw, height).G > 102) && plane == 2)
// If there's green, but not the mere 0x66 green mixed in the burnt orange/light blue, add it
{
data |= 1 << (7 - dw);
}
}
planeData.Add(data);
}
// if it's all zeros, just write 0x00 and call it a day
if (planeData.Sum() == 0)
{
Console.WriteLine("Best to just encode 0x00");
output.WriteByte((byte)0x00);
planes.Add(planeData);
planesCopied.Add(false);
continue;
}
// Now, we can compare this data to previous planes and see if we can just copy it.
// You can copy the previous plane (0x10? 0x14?) or the same color plane in the nth previous block (0x80?)
// Use a Hamming distance function. If it's small, you can probably use one of the plane copiers to grab that plane
// and add data with XOR.
int bestPlaneDistance = 99999;
int bestPlaneIndex = 99999;
if (planes.Any())
{
List<int> distances = new List<int>();
// using the 0x8N plane copier, you can only copy one of the most recent 15 planes.
int startPlane = (planes.Count > 15) ? planes.Count - 15 : 0;
for (int comparePlane = startPlane; comparePlane < planes.Count; comparePlane++)
{
if (planesCopied[comparePlane])
{
distances.Add(999);
continue;
}
int distance = 0;
for (int line = 0; line < planeData.Count; line++)
{
if (planes[comparePlane][line] != planeData[line])
{
distance++;
}
}
//Console.WriteLine("Distance from plane {0}: {1}", comparePlane, distance);
distances.Add(distance);
}
bestPlaneDistance = distances.Min();
bestPlaneIndex = startPlane + distances.IndexOf(bestPlaneDistance);
//Console.WriteLine("Best plane to copy would be {0}, which has distance {1}", bestPlaneIndex, bestPlaneDistance);
}
planes.Add(planeData);
int bestPlaneDiff = currentPlane - bestPlaneIndex;
if (bestPlaneDistance == 0 && bestPlaneIndex == planes.Count - 2)
{
Console.WriteLine("Just repeating the previous plane");
output.WriteByte((byte)0x10);
planesCopied.Add(true);
}
// if it's the same plane in a different block, and its diff is 0...
else if (bestPlaneDiff % 3 == 0 && bestPlaneDistance == 0)
{
Console.WriteLine("Copying plane {0}", bestPlaneIndex);
// From the decoder:
// CopyData(block - datab - 1, block, plane, plane);
// copy the same plane from the block (bottom nibble - 1) blocks prior to the current block
int nthPrevBlock = ((currentPlane - bestPlaneIndex) / 3) - 1;
Console.WriteLine(nthPrevBlock);
output.WriteByte((byte)(0x80 + nthPrevBlock));
output.WriteByte((byte)0xFF); // line
output.WriteByte((byte)0x00); // data
planesCopied.Add(true);
}
else
{
// Build an RLE version of the plane.
planesCopied.Add(false);
List<int?> planeRLE = new List<int?>();
int? runLengthData = null;
int runLength = 0;
int row = 0;
foreach (var data in planeData)
{
if (runLengthData == null)
{
runLengthData = data;
runLength = 1;
}
else
{
if (data == runLengthData)
{
runLength++;
}
else
{
// run length of 4 has its own prefix control code, due to collision with 0x04 plane definer.
if (runLength == 4)
{
planeRLE.Add(0xff);
planeRLE.Add(0x84);
planeRLE.Add(runLengthData);
row += 4;
}
else
{
// 0x04 only does run-length encoding on data that has two equal nibbles!! (often 0x00 or 0xFF)
byte dataUpper = (byte)(runLengthData >> 4);
byte dataLower = (byte)(runLengthData & 0xF);
//if (runLengthData >> 4 == (runLengthData & 0xF))
if (dataUpper == dataLower)
{
// Can't have a C byte in the upper byte of the run length.
// (Haven't really checked this yet.)
//byte lengthUpper = (byte)(runLength >> 4);
//if (lengthUpper == (byte)0xC)
//{
// Console.WriteLine("It's a C byte!");
// Console.WriteLine(runLength);
// if (runLength % 2 == 1)
// {
// Console.WriteLine(runLength / 2);
// planeRLE.Add(runLengthData);
// planeRLE.Add(runLength/2);
// planeRLE.Add(runLengthData);
// planeRLE.Add((runLength / 2) + 1);
// row += runLength;
// }
// else
// {
// planeRLE.Add(runLengthData);
// planeRLE.Add(runLength / 2);
// planeRLE.Add(runLengthData);
// planeRLE.Add(runLength / 2);
// row += runLength;
// }
// }
// Length can only go up to 7D; otherwise you need a 7E byte in front.
if (runLength > 0x7D)
{
Console.WriteLine("Length is pretty long, so use 2 bytes for the length");
planeRLE.Add(runLengthData);
planeRLE.Add(0x7e);
planeRLE.Add(runLength);
row += runLength;
Console.Write("{0} {1} {2}", runLengthData, 0x7e, runLength);
Console.WriteLine("");
}
else
{
planeRLE.Add(runLengthData);
planeRLE.Add(runLength);
row += runLength;
Console.Write("{0:X2} {1:X2} ", runLengthData, runLength);
Console.WriteLine("");
}
}
else
{
for (int i = 0; i < runLength; i++)
{
Console.WriteLine("{0:X2} ", runLengthData);
planeRLE.Add(runLengthData);
row += 1;
}
}
}
runLengthData = data;
runLength = 1;
}
}
}
// Add the last run as well, which is not caught in the above loop.
Console.WriteLine("");
planeRLE.Add(runLengthData);
if (runLength > 0x7D)
{
planeRLE.Add(0x7e);
planeRLE.Add(runLength);
}
else
{
planeRLE.Add(runLength);
}
Console.Write("{0:X2} {1:X2} ", runLengthData, runLength);
row += runLength;
Console.WriteLine("length: {0}", row);
// Finally, write the data to the output stream.
Console.WriteLine("writing RLE");
for (var i = 0; i < planeRLE.Count; i++)
{
Console.Write("{0:X2} ", (int)planeRLE[i]);
}
Console.WriteLine("");
output.WriteByte(0x04);
foreach (int d in planeRLE)
{
output.WriteByte((byte)d);
}
}
}
}
for (var i = 0; i < planesCopied.Count; i++)
{
Console.Write("{0}: {1} ", i, planesCopied[i]);
}
if (output.Length == 11)
{
// If it's just a header, it's probably misreading a scanlined image.
Console.WriteLine("Warning: Looks like the output image is blank.");
Console.WriteLine("If the input image has scanlines, try shifting it up or down a line.");
}
}
int height = 0;
bool wtf = false;
public override void ConvertFrom(Stream input, Stream output)
{
// Discarding 6 bytes that appears to always start with 0x88 0xE4
// They probably provide information but this program doesn't know how to deal with them
ReadInt16(input);
ReadInt16(input);
ReadInt16(input);
// Reading the width and height, which is then followed by the end of the "header"
// The last byte appears to always be 0x11
int width = ReadInt16(input);
height = ReadInt16(input);
input.ReadByte();
// The format encodes the image in a series of blocks that are 8 pixels wide and image height tall.
// Each block is seperated into three color planes that hold various instructions on what to draw.
// We initialize the buffer we will be writing to as three dimensional array of integers.
// Each integer represents an 8 pixel draw line at a certain height within a block's color plane.
int numberOfBlocks = width / 8;
pixels = new int[numberOfBlocks, 3, height];
// This is the buffer that will be used to save the file once we are done decoding
Bitmap bmp = new Bitmap(width, height * 2, PixelFormat.Format32bppRgb);
// A try finally is used to make sure we always dump the last image created into the file
// This is done since we don't know how to entirely decode the image at times and the
// program will fail. Dumping the last image allows us to see the progress it made.
try
{
long indexOfPrevPlane = 0;
long endOfPrevPlane = 0;
for (int block = 0; block < numberOfBlocks; block++)
{
for (int plane = 0; plane < 3; plane++)
{
indexOfPrevPlane = input.Position;
// Reads the encoding flag and splits it into nibbles
int data = input.ReadByte();
int datat = data >> 4;
int datab = data & 0x0F;
// Since the each plane is not a continous set of a data we have to keep track
// of the currrent line so we can write data in the correct area as well as keep
// within the bounds of the image
int curLine = 0;
// Use a boolean to notify of known errors that didn't cause the program to crash
bool error = false;
// The format allows an empty (black) plane to be encoded as 0x00
if (data == 0) continue;
wtf = false;
if ((datab & 0x8) == 0x8)
{
// copy the blue plane of this block
CopyData(block, block, 0, plane);
wtf = true;
}
datab &= ~0x8;
if (datat == 0xC)
{
CopyData(block - 1, block, plane, plane);
}
if ((datat & 0x1) == 0x1)
{
// if the flag begins with 0x1, copy the previous plane
// if current plane is the blue plane, that means copy the (green?) plane of the previous block
CopyData(block + (plane == 0 ? -1 : 0), block, (plane + 2) % 3, plane);
wtf = true;
}
datat &= ~0x1;
if (datat == 8)
{
Console.ForegroundColor = ConsoleColor.Yellow;
CopyData(block - datab - 1, block, plane, plane);
while (true)
{
int line = input.ReadByte();
data = input.ReadByte();
if (line >= height)
{
if (line == 0xFF) break;
WriteData(block, plane, line &= ~0x80, data, 1);
break;
}
WriteData(block, plane, line, data, 1);
}
goto print;
}
switch (datab)
{
case 0:
break;
case 2:
Console.ForegroundColor = ConsoleColor.Green;
while (curLine < height)
{
data = input.ReadByte();
datat = (data & 0xF0) >> 4;
datab = data & 0xF;
datab = datab == 0xE ? input.ReadByte() : datab;
if (datat == 0x3)
{
WriteData(block, plane, curLine, input, datab + 1);
}
else if (datat != 0x0)
{
switch (datat)
{
case 2:
data = input.ReadByte();
break;
case 4:
case 5:
case 6:
case 7:
datat -= 0x02;
input.Position -= datat;
data = input.ReadByte();
input.Position += datat - 1;
break;
case 8:
data = 0xFF;
break;
case 0xA:
data = 0xC0;
break;
default:
error = true;
Console.WriteLine("2NR" + datat);
break;
}
WriteData(block, plane, curLine, data, datab + 1);
}
curLine += datab + 1;
}
break;
case 3:
data = input.ReadByte();
WriteData(block, plane, 0, data, height);
break;
case 4:
// description of the 0x04 plane encoding
Console.ForegroundColor = ConsoleColor.Cyan;
while (curLine < height)
{
data = input.ReadByte(); // first byte: direct binary representation of a line
datat = (data & 0xF0) >> 4; // upper nibble
datab = data & 0x0F; // lower nibble
int count = 1;
// Checking if nibbles equal each other
if (datat == datab)
{
count = input.ReadByte();
// WTF shifting thing ???
if ((count & 0xF0) == 0xC0)
{
count -= 0xC0;
if (data == 0xFF)
data = input.ReadByte();
if (data == 0x00)
{
// This obviously doesn't work for the rotate thing
data = (input.ReadByte() << 8) | input.ReadByte();
count *= 2;
}
for (int x = 0; x < count; x++)
{
WriteData(block, plane, curLine + x, data, 1);
datab = (data & 0x1) << 7; // Rotate left 1
data = (data >> 1) | datab;
}
curLine += count;
continue;
}
// Repeat a direct write
if ((count & 0x80) == 0x80)
{
count -= 0x80;
switch (datab)
{
case 0:
data = (input.ReadByte() << 8) | input.ReadByte();
count *= 2;
break;
case 5:
data = 0x55AA;
break;
case 0xA:
data = 0xAA55;
break;
case 0xF:
data = input.ReadByte();
break;
default:
error = true;
Console.WriteLine("4NR" + datab);
break;
}
}
count = count == 0x7E ? input.ReadByte() : count;
}
WriteData(block, plane, curLine, data, count);
curLine += count;
}
break;
case 6:
Console.ForegroundColor = ConsoleColor.Blue;
while (curLine < height)
{
data = input.ReadByte();
datat = (data & 0xF0) >> 4;
datab = data & 0x0F;
if (data == 0)
{
datat = input.ReadByte();
datat = ((datat & 0x80) == 0x80 ? datat - 0x80 : datat) * 2;
data = (input.ReadByte() << 8) | input.ReadByte();
WriteData(block, plane, curLine, data, datat);
goto end6;
}
// Checking for direct write
if (datat == 0)
{
datat = datab == 0xE ? input.ReadByte() : datab;
WriteData(block, plane, curLine, input, datat);
goto end6;
}
// Getting actual length if value is greater than 0xD
if (datat == 0xE)
{
datat = datab;
data = input.ReadByte();
datab = data & 0x0F;
datat = (datat << 4) | (data >> 4);
}
// Finding pattern
switch (datab)
{
case 0:
data = 0x00;
break;
case 1:
data = 0x22;
break;
case 2:
data = 0x55;
break;
case 3:
data = 0x77;
break;
case 4:
data = 0xFF;
break;
case 5:
data = 0xDD;
break;
case 6:
data = 0xAA;
break;
case 7:
data = input.ReadByte();
break;
case 9:
data = 0x2288;
break;
case 0xA:
data = 0x55AA;
break;
case 0xB:
data = 0x77DD;
break;
case 0xD:
data = 0xDD77;
break;
case 0xE:
data = 0xAA55;
break;
case 0xF:
data = input.ReadByte();
for (int x = 0; x < datat; x++)
{
WriteData(block, plane, curLine + x, data, 1);
datab = (data & 0x3) << 6; // Rotate left 2
data = (data >> 2) | datab;
}
goto end6;
default:
error = true;
Console.WriteLine("NR" + datab);
break;
}
WriteData(block, plane, curLine, data, datat);
end6: curLine += datat;
}
break;
default:
error = true;
break;
}
print: endOfPrevPlane = input.Position;
if (error)
Console.ForegroundColor = ConsoleColor.Red;
input.Position = indexOfPrevPlane;
char[] s = ReadStringU(input, (int)(endOfPrevPlane - indexOfPrevPlane)).ToCharArray();
Console.Write("{0:D2} : ", block);
for (int x = 0; x < s.Length; x++)
{
Console.Write("{0:X2} ", (int)s[x]);
}
Console.WriteLine();
input.Position = endOfPrevPlane;
Console.ForegroundColor = ConsoleColor.White;
for (int b = 0; b < numberOfBlocks; b++)
for (int p = 0; p < 3; p++)
for (int l = 0; l < height; l++)
{
data = pixels[b, p, l];
for (int d = 7; d >= 0; d--, data >>= 1)
if (data % 2 == 1)
{
Color oldc = bmp.GetPixel(b * 8 + d, l * 2);
// take the binary or of what's already there and the current plane color
Color newc = Color.FromArgb(oldc.ToArgb() | GetColor(p));
bmp.SetPixel(b * 8 + d, l * 2, newc);
}
}
Directory.CreateDirectory("test/");
Stream output2 = new FileStream("test/b" + block.ToString("D3") + "p" + plane + ".png", FileMode.Create);
bmp.Save(output2, ImageFormat.Png);
output2.Close();
}
}
}
finally
{
for (int b = 0; b < numberOfBlocks; b++)
for (int p = 0; p < 3; p++)
for (int l = 0; l < height; l++)
{
int data = pixels[b, p, l];
for (int d = 7; d >= 0; d--, data >>= 1)
if (data % 2 == 1)
{
Color oldc = bmp.GetPixel(b * 8 + d, l * 2);
Color newc = Color.FromArgb(oldc.ToArgb() | GetColor(p));
bmp.SetPixel(b * 8 + d, l * 2, newc);
}
}
bmp.Save(output, ImageFormat.Png);
}
}
int[,,] pixels;
public int GetColor(int plane)
{
unchecked
{
if (plane == 0)
// Values are used in FromArgb / ToArgb.
// lighter blue
return (int)0xFF0066FF;
if (plane == 1)
// burnt orange
return (int)0xFFFF6600;
if (plane == 2)
// normal green
return (int)0xFF00FF00;
return (int)0xFFFFFFFF;
}
}
public void WriteData(int block, int plane, int line, int data, int count)
{
if (wtf)
// wtf indeed!
{
// hmm. when does this apply? data should be 0xFF at its highest, right?
if ((data & 0xFF00) > 0)
{
for (int l = 0; l < count / 2; l++)
{
pixels[block, plane, line + l * 2] ^= (data & 0xFF00) >> 8;
pixels[block, plane, line + l * 2 + 1] ^= data & 0xFF;
}
if (count % 2 == 1)
pixels[block, plane, line + count - 1] ^= (data & 0xFF00) >> 8;
return;
}
for (int l = 0; l < count; l++)
{
// use the bitwise logical XOR between the data and... what's already there??
// oh yeah, the plane that got copied with CopyData.
pixels[block, plane, line + l] ^= data;
}
}
else
{
if ((data & 0xFF00) > 0)
{
for (int l = 0; l < count / 2; l++)
{
pixels[block, plane, line + l * 2] = (data & 0xFF00) >> 8;
pixels[block, plane, line + l * 2 + 1] = data & 0xFF;
}
if (count % 2 == 1)
pixels[block, plane, line + count - 1] = (data & 0xFF00) >> 8;
return;
}
for (int l = 0; l < count; l++)
{
pixels[block, plane, line + l] = data;
}
}
}
public void WriteData(int block, int plane, int line, Stream input, int count)
{
for (int l = 0; l < count; l++)
{
if (wtf)
{
pixels[block, plane, line + l] ^= input.ReadByte();
}
else
{
pixels[block, plane, line + l] = input.ReadByte();
}
}
}
public void CopyData(int b1, int b2, int p1, int p2)
{
for (int l = 0; l < height; l++)
{
pixels[b2, p2, l] ^= pixels[b1, p1, l];
}
}
public void CopyData(int b1, int b2)
{
for (int p = 0; p < 3; p++)
{
for (int l = 0; l < height; l++)
{
pixels[b2, p, l] = pixels[b1, p, l];
}
}
}
}
}