mirror of https://github.com/dwsJason/gsla.git
273 lines
9.0 KiB
C++
273 lines
9.0 KiB
C++
|
//
|
|||
|
|
// C++ Encoder/Decoder
|
|||
|
|
// For GSLA, GS Lzb Animation File Format
|
|||
|
|
//
|
|||
|
|
//
|
|||
|
|
// Care is taken in the encoder, to make sure the 65816 does not have to cross
|
|||
|
|
// bank boundaries during any copy. This is so we can use the MVN instruction,
|
|||
|
|
// and so we can reduce the number of bank checks in the code. We will have an
|
|||
|
|
// opcode, that says <20>source data bank has changed<65>
|
|||
|
|
//
|
|||
|
|
// The file will be laid out such that you load the file in at a 64K memory
|
|||
|
|
// boundary
|
|||
|
|
//
|
|||
|
|
// Goals include a good balance between file size, and playback performance
|
|||
|
|
// (since one often makes a trade off with the other).
|
|||
|
|
//
|
|||
|
|
// The file is defined as a byte stream, loaded on a 64K Bank Boundary
|
|||
|
|
//
|
|||
|
|
//
|
|||
|
|
// file-offset: the thing that is at the offset
|
|||
|
|
//
|
|||
|
|
// Header of the File is 20 bytes as follows
|
|||
|
|
//
|
|||
|
|
//File Offset Data Commentary
|
|||
|
|
//------------------------------------------------------------------
|
|||
|
|
//0 0x47 ; <20>G<EFBFBD> Graphics
|
|||
|
|
//1 0x53 ; <20>S<EFBFBD>
|
|||
|
|
//2 0x4C ; <20>L<EFBFBD> LZB
|
|||
|
|
//3 0x41 ; <20>A<EFBFBD> Animation
|
|||
|
|
//
|
|||
|
|
// File Length, is the total length of the file
|
|||
|
|
//4 FileLengthLow ; Low byte, 32-bit file length
|
|||
|
|
//5 LengthLowHigh ; High byte of low word
|
|||
|
|
//6 LengthHighLow ; Low byte, of high word
|
|||
|
|
//7 LengthHighHigh ; High Byte, of high word
|
|||
|
|
//
|
|||
|
|
// 16 bit word with version #
|
|||
|
|
//8 VL ; Version # of the file format, currently only version 0 exists
|
|||
|
|
//9 VH ; Version High Byte
|
|||
|
|
// ; %RVVV_VVVV_VVVV_VVVV
|
|||
|
|
// ; V is a version #, 0 for now
|
|||
|
|
// ; R is the MSB, R = 0 no ring frame
|
|||
|
|
// ; R = 1, there is a ring frame
|
|||
|
|
// ; A Ring Frame is a frame that will delta from the last
|
|||
|
|
// ; frame of the animation, back to the first, for smoother
|
|||
|
|
// ; playback looping , If a ring frame exists, it<69>s also
|
|||
|
|
// ; included in the frame count
|
|||
|
|
//
|
|||
|
|
// next is a word, width in bytes (likely 160 for now)
|
|||
|
|
//0xA WL ; Display Width in bytes low byte
|
|||
|
|
//0xB WH ; Display Width in bytes high byte
|
|||
|
|
//
|
|||
|
|
// next is a word, height (likely 200 for now)
|
|||
|
|
//0xC HL ; Display Height in bytes, low byte
|
|||
|
|
//0xD HH ; Display Height in bytes, high byte
|
|||
|
|
// 2 bytes, Frame Size in Bytes, since a <20>Frame<6D> may contain more than just the
|
|||
|
|
// width * height, worth of pixels, for now this is $8000, or 32768
|
|||
|
|
//0xE FBL ; Frame Buffer Length Low
|
|||
|
|
//0xF FBH ; Frame Buffer Length High
|
|||
|
|
//
|
|||
|
|
// 4 byte, 32-bit, Frame Count (includes total frame count, so if there is a ring frame, this is included in the total)
|
|||
|
|
//0x10 FrameCountLow
|
|||
|
|
//0x11 FrameCountLowHigh
|
|||
|
|
//0x12 FrameCountHighLow
|
|||
|
|
//0x13 FrameCountHigh
|
|||
|
|
//
|
|||
|
|
//
|
|||
|
|
// After this comes AIFF style chunks of data, basically a 4 byte chunk name,
|
|||
|
|
// followed by a 4 byte length (inclusive of the chunk size). The idea is that
|
|||
|
|
// you can skip chunks you don<6F>t understand.
|
|||
|
|
//
|
|||
|
|
//File Offset:
|
|||
|
|
//0x14 First Chunk (followed by more Chunks, until end of file)
|
|||
|
|
//
|
|||
|
|
//Chunk Definitions
|
|||
|
|
//Name: <20>INIT<49> - Initial Frame Chunk, this is the data used to first initialize the playback buffer
|
|||
|
|
//0: 0x49 <09>I<EFBFBD>
|
|||
|
|
//1: 0x4E <09>N<EFBFBD>
|
|||
|
|
//2: 0x49 <09>I<EFBFBD>
|
|||
|
|
//3: 0x54 <09>T<EFBFBD>
|
|||
|
|
// 32 bit long, length, little endian, including the 8 byte header
|
|||
|
|
//4: length low low
|
|||
|
|
//5: length low high
|
|||
|
|
//6: length high low
|
|||
|
|
//7: length high high
|
|||
|
|
//
|
|||
|
|
//8: <20>. This is a single frame of data, that decodes/decompresses into frame
|
|||
|
|
// sized bytes (right now 0x8000)
|
|||
|
|
// This data stream includes, an end of animation opcode, so that the normal
|
|||
|
|
// animation decompressor, can be called on this data, and it will emit the
|
|||
|
|
// initial frame onto the screen
|
|||
|
|
//
|
|||
|
|
//Name: <20>ANIM<49> - Frames
|
|||
|
|
//0: 0x41 <20>A<EFBFBD>
|
|||
|
|
//1: 0x4E <20>N<EFBFBD>
|
|||
|
|
//2: 0x49 <20>I<EFBFBD>
|
|||
|
|
//3: 0x4D <20>M<EFBFBD>
|
|||
|
|
// 32 bit long, length, little endian, including chunk header
|
|||
|
|
//4: length low low
|
|||
|
|
//5: length low high
|
|||
|
|
//6: length high low
|
|||
|
|
//7: length high high
|
|||
|
|
//
|
|||
|
|
// This is followed by the frames, with the intention of decompressing them at
|
|||
|
|
// 60FPS, which is why no play speed is included, if you need a play-rate
|
|||
|
|
// slower than this, blank frame<6D>s should be inserted into the animation data
|
|||
|
|
//
|
|||
|
|
// Every attempt is made to delta encode the image, meaning we just encode
|
|||
|
|
// information about what changed each frame. We attempt to make the size
|
|||
|
|
// efficient by supporting dictionary copies (where the dictionary is made up
|
|||
|
|
// of existing pixels in the frame buffer).
|
|||
|
|
//
|
|||
|
|
//Command Word, encoded low-high, what the bits mean:
|
|||
|
|
//
|
|||
|
|
// xxx_xxxx_xxxx_xxx is the number of bytes 1-16384 to follow (0 == 1 byte)
|
|||
|
|
//
|
|||
|
|
//%0xxx_xxxx_xxxx_xxx0 - Copy Bytes - straight copy bytes
|
|||
|
|
//%1xxx_xxxx_xxxx_xxx1 - Skip Bytes - skip bytes / move the cursor
|
|||
|
|
//%1xxx_xxxx_xxxx_xxx0 - Dictionary Copy Bytes from frame buffer to frame buffer
|
|||
|
|
//
|
|||
|
|
//%0000_0000_0000_0001- Source Skip -> Source pointer skips to next bank of data
|
|||
|
|
//%0000_0000_0000_0011- End of Frame - end of frame
|
|||
|
|
//%0000_0000_0000_0111- End of Animation / End of File / no more frames
|
|||
|
|
//
|
|||
|
|
// other remaining codes, are reserved for future expansion
|
|||
|
|
|
|||
|
|
#include "gsla_file.h"
|
|||
|
|
#include <stdio.h>
|
|||
|
|
|
|||
|
|
// If these structs are the wrong size, there's an issue with type sizes, and
|
|||
|
|
// your compiler
|
|||
|
|
static_assert(sizeof(GSLA_Header)==20, "GSLA_Header is supposed to be 20 bytes");
|
|||
|
|
static_assert(sizeof(GSLA_INIT)==8, "GSLA_INIT is supposed to be 8 bytes");
|
|||
|
|
static_assert(sizeof(GSLA_ANIM)==8, "GSLA_ANIM is supposed to be 8 bytes");
|
|||
|
|
static_assert(sizeof(GSLA_CHUNK)==8, "GSLA_CHUNK is supposed to be 8 bytes");
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
// Load in a FanFile constructor
|
|||
|
|
//
|
|||
|
|
GSLAFile::GSLAFile(const char *pFilePath)
|
|||
|
|
: m_widthPixels(320)
|
|||
|
|
, m_heightPixels(200)
|
|||
|
|
{
|
|||
|
|
LoadFromFile(pFilePath);
|
|||
|
|
}
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
GSLAFile::~GSLAFile()
|
|||
|
|
{
|
|||
|
|
// Free Up the memory
|
|||
|
|
for (int idx = 0; idx < m_pC1PixelMaps.size(); ++idx)
|
|||
|
|
{
|
|||
|
|
delete[] m_pC1PixelMaps[idx];
|
|||
|
|
m_pC1PixelMaps[ idx ] = nullptr;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
void GSLAFile::LoadFromFile(const char* pFilePath)
|
|||
|
|
{
|
|||
|
|
// Free Up the memory
|
|||
|
|
for (int idx = 0; idx < m_pC1PixelMaps.size(); ++idx)
|
|||
|
|
{
|
|||
|
|
delete[] m_pC1PixelMaps[idx];
|
|||
|
|
m_pC1PixelMaps[ idx ] = nullptr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_pC1PixelMaps.clear();
|
|||
|
|
//--------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
std::vector<unsigned char> bytes;
|
|||
|
|
|
|||
|
|
//--------------------------------------------------------------------------
|
|||
|
|
// Read the file into memory
|
|||
|
|
FILE* pFile = nullptr;
|
|||
|
|
errno_t err = fopen_s(&pFile, pFilePath, "rb");
|
|||
|
|
|
|||
|
|
if (0==err)
|
|||
|
|
{
|
|||
|
|
fseek(pFile, 0, SEEK_END);
|
|||
|
|
size_t length = ftell(pFile); // get file size
|
|||
|
|
fseek(pFile, 0, SEEK_SET);
|
|||
|
|
|
|||
|
|
bytes.resize( length ); // make sure buffer is large enough
|
|||
|
|
|
|||
|
|
// Read in the file
|
|||
|
|
fread(&bytes[0], sizeof(unsigned char), bytes.size(), pFile);
|
|||
|
|
fclose(pFile);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (bytes.size())
|
|||
|
|
{
|
|||
|
|
size_t file_offset = 0; // File Cursor
|
|||
|
|
|
|||
|
|
// Bytes are in the buffer, so let's start looking at what we have
|
|||
|
|
GSLA_Header* pHeader = (GSLA_Header*) &bytes[0];
|
|||
|
|
|
|||
|
|
// Early out if things don't look right
|
|||
|
|
if (!pHeader->IsValid((unsigned int)bytes.size()))
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
// Size in bytes for each frame in this animation
|
|||
|
|
m_frameSize = pHeader->frame_size;
|
|||
|
|
|
|||
|
|
// pre-allocate all the frames
|
|||
|
|
for (unsigned int idx = 0; idx < pHeader->frame_count; ++idx)
|
|||
|
|
{
|
|||
|
|
m_pC1PixelMaps.push_back(new unsigned char[ m_frameSize ]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//----------------------------------------------------------------------
|
|||
|
|
// Process Chunks as we encounter them
|
|||
|
|
file_offset += sizeof(GSLA_Header);
|
|||
|
|
|
|||
|
|
// While we're not at the end of the file
|
|||
|
|
while (file_offset < bytes.size())
|
|||
|
|
{
|
|||
|
|
// This is pretty dumb, just get it done
|
|||
|
|
// These are the types I understand
|
|||
|
|
// every chunk is supposed to contain a value chunk_length
|
|||
|
|
// at offset +4, so that we can ignore ones we don't understand
|
|||
|
|
GSLA_INIT* pINIT = (GSLA_INIT*)&bytes[ file_offset ];
|
|||
|
|
GSLA_ANIM* pANIM = (GSLA_ANIM*)&bytes[ file_offset ];
|
|||
|
|
GSLA_CHUNK* pCHUNK = (GSLA_CHUNK*)&bytes[ file_offset ];
|
|||
|
|
|
|||
|
|
if (pINIT->IsValid())
|
|||
|
|
{
|
|||
|
|
// We have an initial frame chunk
|
|||
|
|
UnpackInitialFrame(pINIT);
|
|||
|
|
}
|
|||
|
|
else if (pANIM->IsValid())
|
|||
|
|
{
|
|||
|
|
// We have a packed animation frames chunk
|
|||
|
|
UnpackAnimation(pANIM, pHeader);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
file_offset += pCHUNK->chunk_length;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
//
|
|||
|
|
// Unpack the initial frame, that's been packed with an empty initial dictionary
|
|||
|
|
// So every byte of the buffer will be written out (no skip opcodes)
|
|||
|
|
//
|
|||
|
|
void GSLAFile::UnpackInitialFrame(GSLA_INIT* pINIT)
|
|||
|
|
{
|
|||
|
|
unsigned char *pData = ((unsigned char*)pINIT) + sizeof(GSLA_INIT);
|
|||
|
|
|
|||
|
|
unsigned char *pTargetBuffer = m_pC1PixelMaps[ 0 ]; // Data needs to be pre allocated
|
|||
|
|
|
|||
|
|
//DecompressFrame(pTargetBuffer, pData);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
//
|
|||
|
|
// Unpack the animation frame, assuming that the initial frame already exists
|
|||
|
|
//
|
|||
|
|
void GSLAFile::UnpackAnimation(GSLA_ANIM* pANIM, GSLA_Header* pHeader)
|
|||
|
|
{
|
|||
|
|
unsigned char *pData = ((unsigned char*)pANIM) + sizeof(GSLA_ANIM);
|
|||
|
|
|
|||
|
|
unsigned char *pTargetBuffer = m_pC1PixelMaps[ 0 ]; // Data needs to be pre allocated
|
|||
|
|
|
|||
|
|
//DecompressAnim(pTargetBuffer, pData);
|
|||
|
|
}
|
|||
|
|
|