Nova Format

Nova Format

Format type	Image
Hardware	VGA
Colour depth	8-bit (VGA)
Minimum size (pixels)	0×0
Maximum size (pixels)	65535×65535
Palette	External
Plane count	1
Transparent pixels?	No
Hitmap pixels?	No
Games	Cover Girl Strip Poker

Nova is an image format used in the game Cover Girl Strip Poker. The images typically have extension .PPP, but not all files with that extension in the game folder are images; in fact, the extension seems to be used for all game files that are RLE-compressed.

The image files can easily be identified by the fact that each .PPP image has its own colour palette in an accompanying .PAL file of the same name.

The format is named after the fact all files start with the string "NOVA", which is most likely the signature of the game's lead programmer, Samuel Sebastian Nova.

File format

The entire file, including the header, is compressed with a flag-based RLE compression. The very first step to read the file should be to unpack it.

Compression

The compression used is a flag-based run-length encoding algorithm, with 4-byte repeat commands. Because of its size, repeating sequences that are less than 4 bytes long are not compressed.

The repeat commands have the following structure:

Data type	Name	Description
BYTE	Flag	Flag value 0xFF
BYTE	Value	Value to repeat
UINT16LE	Repeat	Amount of times to repeat Value

Header

Once unpacked, the file starts with the following header:

Offset	Data type	Name	Description
0x00	UINT32LE	Magic1	Magic number: the string "NOVA". As a single UInt32, the value is 0x41564F4E
0x04	UINT16LE	Width	Image width.
0x06	UINT16LE	Height	Image height.

Note that for identification purposes, since the "NOVA" string at the start contains no repetitions itself, a quick and accurate preliminary check before doing the full decompression process can be to see if the first three bytes are the string "NOV". The last byte can technically not be guaranteed, since the following width and height could be filled with enough 0x41 values (the letter "A") to trigger its conversion to a run-length command. Still, either the 4th byte should be 0x41, or, as a flag repeat command, the 4th and 5th byte should respectively be 0xFF and 0x41.

Image data

This header is followed by the image data, which is simple linear 8-bit VGA data, to be visualised using the colours from the 256-colour 6-bit VGA palette in the accompanying .PAL file.

Code

RLE Decompression

This code was written by Nyerguds for the Engie File Converter, and is released under the WTF Public License.

public static Byte[] DecompressPppRle(Byte[] data)
{
    Int32 len = data.Length;
    UInt32 expandSize = (UInt32)len * 3;
    Int32 uncompressedSize = data.Length * 3;
    Byte[] bufferOut = new Byte[uncompressedSize];
    Int32 ptr = 0;
    // Decompress flag-based RLE.
    // The flag is 0xFF. It is followed by one byte for the value to fill,
    // and then two bytes for the amount of repetitions.
    Int32 i;
    for (i = 0; i < len; i++)
    {
        Byte value = data[i];
        if (value != 0xFF)
        {
            if (ptr >= bufferOut.Length)
                bufferOut = ExpandBuffer(bufferOut, expandSize);
            bufferOut[ptr++] = value;
        }
        else
        {
            if (i + 3 >= len)
                throw new ArgumentException("Data ends on incomplete repeat command!", "data");
            value = data[++i];
            Int32 repeat = data[++i] + (data[++i] << 8);
            Int32 endPoint = repeat + ptr;
            if (endPoint > bufferOut.Length)
                bufferOut = ExpandBuffer(bufferOut, Math.Max(expandSize, (UInt32)repeat));
            for (; ptr < endPoint; ptr++)
                bufferOut[ptr] = value;
        }
    }
    if (ptr < bufferOut.Length)
    {
        Byte[] bufferSized = new Byte[ptr];
        Array.Copy(bufferOut, 0, bufferSized, 0, ptr);
        bufferOut = bufferSized;
    }
    return bufferOut;
}

private static Byte[] ExpandBuffer(Byte[] bufferOut, UInt32 expandSize)
{
    Byte[] newBuf = new Byte[bufferOut.Length + expandSize];
    Array.Copy(bufferOut, 0, newBuf, 0, bufferOut.Length);
    return newBuf;
}

RLE Compression

This code was written by Nyerguds for the Engie File Converter, and is released under the WTF Public License.

public static Byte[] CompressPppRle(Byte[] data)
{
    Int32 len = data.Length;
    Int32 curBufLen = len;
    // Compressed data should never exceed original size since compression only triggers on sequences of 4 or more,
    // though it could in case of 0xFF bytes, since they always need to be encoded with a flag.
    Byte[] bufferOut = new Byte[curBufLen];
    Int32 ptr = 0;
    for (Int32 i = 0; i < len; i++)
    {
        Byte value = data[i];
        Int32 repeat = i;
        for (; repeat < len && data[repeat] == value; repeat++) { }
        repeat -= i;
        Boolean compress = repeat >= 4 || value == 0xFF;
        Int32 needed = ptr + (compress ? 3 : 0);
        if (curBufLen <= needed)
        {
            // Expand buffer if needed.
            Int32 newLen = Math.Max(curBufLen + len, needed);
            Byte[] newCompressBuffer = new Byte[newLen];
            Array.Copy(bufferOut, 0, newCompressBuffer, 0, curBufLen);
            curBufLen = newLen;
        }
        if (compress)
        {
            i += repeat - 1; // -1 because the loop itself obviously increments it
            do
            {
                Int32 repeat16b = repeat > 0xFFFF ? 0xFFFF : repeat;
                bufferOut[ptr++] = 0xFF;
                bufferOut[ptr++] = value;
                bufferOut[ptr++] = (Byte)repeat16b;
                bufferOut[ptr++] = (Byte)(repeat16b >> 8);
                repeat -= repeat16b;
                // Fix for compressing too-small leftover repeats
                if (repeat < 4 && value != 0xFF)
                    for (; repeat > 0; repeat--)
                        bufferOut[ptr++] = value;
            } while (repeat > 0);
        }
        else
            bufferOut[ptr++] = value;
    }
    Byte[] bufferSized = new Byte[ptr];
    Array.Copy(bufferOut, 0, bufferSized, 0, ptr);
    return bufferSized;
}

Tools

The following tools are able to work with files in this format.

Name	Platform	View images in this format?	Convert/export to another file/format?	Import from another file/format?	Access hidden data?	Edit metadata?	Notes
Engie File Converter	Windows	Yes	Yes	Yes	No	N/A