mirror of
https://github.com/electronicarts/CnC_Remastered_Collection.git
synced 2025-08-16 11:04:30 +02:00
C&C Remastered Map Editor
Initial commit of C&C Remastered Map Editor code
This commit is contained in:
PG-SteveT
689
CnCTDRAMapEditor/Utility/WWCompression.cs
Normal file
689
CnCTDRAMapEditor/Utility/WWCompression.cs
Normal file
@@ -0,0 +1,689 @@
|
||||
//
|
||||
// Copyright 2020 Electronic Arts Inc.
|
||||
//
|
||||
// The Command & Conquer Map Editor and corresponding source code is free
|
||||
// software: you can redistribute it and/or modify it under the terms of
|
||||
// the GNU General Public License as published by the Free Software Foundation,
|
||||
// either version 3 of the License, or (at your option) any later version.
|
||||
|
||||
// The Command & Conquer Map Editor and corresponding source code is distributed
|
||||
// in the hope that it will be useful, but with permitted additional restrictions
|
||||
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
|
||||
// distributed with this program. You should have received a copy of the
|
||||
// GNU General Public License along with permitted additional restrictions
|
||||
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
|
||||
using System;
|
||||
|
||||
namespace MobiusEditor.Utility
|
||||
{
|
||||
/// <summary>
|
||||
/// This class contains encoders and decoders for the Westwood XOR Delta and LCW compression schemes.
|
||||
/// </summary>
|
||||
public static class WWCompression
|
||||
{
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Notes
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// LCW streams should always start and end with the fill command (& 0x80) though
|
||||
// the decompressor doesn't strictly require that it start with one the ability
|
||||
// to use the offset commands in place of the RLE command early in the stream
|
||||
// relies on it. Streams larger than 64k that need the relative versions of the
|
||||
// 3 and 5 byte commands should start with a null byte before the first 0x80
|
||||
// command to flag that they are relative compressed.
|
||||
//
|
||||
// LCW uses the following rules to decide which command to use:
|
||||
// 1. Runs of the same colour should only use 4 byte RLE command if longer than
|
||||
// 64 bytes. 2 and 3 byte offset commands are more efficient otherwise.
|
||||
// 2. Runs of less than 3 should just be stored as is with the one byte fill
|
||||
// command.
|
||||
// 3. Runs greater than 10 or if the relative offset is greater than
|
||||
// 4095 use an absolute copy. Less than 64 bytes uses 3 byte command, else it
|
||||
// uses the 5 byte command.
|
||||
// 4. If Absolute rule isn't met then copy from a relative offset with 2 byte
|
||||
// command.
|
||||
//
|
||||
// Absolute LCW can efficiently compress data that is 64k in size, much greater
|
||||
// and relative offsets for the 3 and 5 byte commands are needed.
|
||||
//
|
||||
// The XOR delta generator code works to the following assumptions
|
||||
//
|
||||
// 1. Any skip command is preferable if source and base are same
|
||||
// 2. Fill is preferable to XOR if 4 or larger, XOR takes same data plus at
|
||||
// least 1 byte
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Some defines used by the encoders
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
public const Byte XOR_SMALL = 0x7F;
|
||||
public const Byte XOR_MED = 0xFF;
|
||||
public const Int32 XOR_LARGE = 0x3FFF;
|
||||
public const Int32 XOR_MAX = 0x7FFF;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Some utility functions to get worst case sizes for buffer allocation
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
public static Int32 LCWWorstCase(Int32 datasize)
|
||||
{
|
||||
return datasize + (datasize / 63) + 1;
|
||||
}
|
||||
|
||||
public static Int32 XORWorstCase(Int32 datasize)
|
||||
{
|
||||
return datasize + ((datasize / 63) * 3) + 4;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Compresses data to the proprietary LCW format used in
|
||||
/// many games developed by Westwood Studios. Compression is better
|
||||
/// than that achieved by popular community tools. This is a new
|
||||
/// implementation based on understanding of the compression gained from
|
||||
/// the reference code.
|
||||
/// </summary>
|
||||
/// <param name="input">Array of the data to compress.</param>
|
||||
/// <returns>The compressed data.</returns>
|
||||
/// <remarks>Commonly known in the community as "format80".</remarks>
|
||||
public static Byte[] LcwCompress(Byte[] input)
|
||||
{
|
||||
if (input == null || input.Length == 0)
|
||||
return new Byte[0];
|
||||
|
||||
//Decide if we are going to do relative offsets for 3 and 5 byte commands
|
||||
Boolean relative = input.Length > UInt16.MaxValue;
|
||||
|
||||
// Nyer's C# conversion: replacements for write and read for pointers.
|
||||
Int32 getp = 0;
|
||||
Int32 putp = 0;
|
||||
// Input length. Used commonly enough to warrant getting it out in advance I guess.
|
||||
Int32 getend = input.Length;
|
||||
// "Worst case length" code by OmniBlade. We'll just use a buffer of
|
||||
// that max length and cut it down to the actual used size at the end.
|
||||
// Not using it- it's not big enough in case of some small images.
|
||||
//LCWWorstCase(getend)
|
||||
Int32 worstcase = Math.Max(10000, getend * 2);
|
||||
Byte[] output = new Byte[worstcase];
|
||||
// relative LCW starts with 0 as flag to decoder.
|
||||
// this is only used by later games for decoding hi-color vqa files.
|
||||
if (relative)
|
||||
output[putp++] = 0;
|
||||
|
||||
//Implementations that properly conform to the WestWood encoder should
|
||||
//write a starting cmd1. It's important for using the offset copy commands
|
||||
//to do more efficient RLE in some cases than the cmd4.
|
||||
|
||||
//we also set bool to flag that we have an on going cmd1.
|
||||
Int32 cmd_onep = putp;
|
||||
output[putp++] = 0x81;
|
||||
output[putp++] = input[getp++];
|
||||
Boolean cmd_one = true;
|
||||
|
||||
//Compress data until we reach end of input buffer.
|
||||
while (getp < getend)
|
||||
{
|
||||
//Is RLE encode (4bytes) worth evaluating?
|
||||
if (getend - getp > 64 && input[getp] == input[getp + 64])
|
||||
{
|
||||
//RLE run length is encoded as a short so max is UINT16_MAX
|
||||
Int32 rlemax = (getend - getp) < UInt16.MaxValue ? getend : getp + UInt16.MaxValue;
|
||||
Int32 rlep = getp + 1;
|
||||
while (rlep < rlemax && input[rlep] == input[getp])
|
||||
rlep++;
|
||||
|
||||
UInt16 run_length = (UInt16)(rlep - getp);
|
||||
|
||||
//If run length is long enough, write the command and start loop again
|
||||
if (run_length >= 0x41)
|
||||
{
|
||||
//write 4byte command 0b11111110
|
||||
cmd_one = false;
|
||||
output[putp++] = 0xFE;
|
||||
output[putp++] = (Byte)(run_length & 0xFF);
|
||||
output[putp++] = (Byte)((run_length >> 8) & 0xFF);
|
||||
output[putp++] = input[getp];
|
||||
getp = rlep;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
//current block size for an offset copy
|
||||
UInt16 block_size = 0;
|
||||
//Set where we start looking for matching runs.
|
||||
Int32 offstart = relative ? getp < UInt16.MaxValue ? 0 : getp - UInt16.MaxValue : 0;
|
||||
|
||||
//Look for matching runs
|
||||
Int32 offchk = offstart;
|
||||
Int32 offsetp = getp;
|
||||
while (offchk < getp)
|
||||
{
|
||||
//Move offchk to next matching position
|
||||
while (offchk < getp && input[offchk] != input[getp])
|
||||
offchk++;
|
||||
|
||||
//If the checking pointer has reached current pos, break
|
||||
if (offchk >= getp)
|
||||
break;
|
||||
|
||||
//find out how long the run of matches goes for
|
||||
Int32 i;
|
||||
for (i = 1; getp + i < getend; ++i)
|
||||
if (input[offchk + i] != input[getp + i])
|
||||
break;
|
||||
if (i >= block_size)
|
||||
{
|
||||
block_size = (UInt16)i;
|
||||
offsetp = offchk;
|
||||
}
|
||||
offchk++;
|
||||
}
|
||||
|
||||
//decide what encoding to use for current run
|
||||
//If it's less than 2 bytes long, we store as is with cmd1
|
||||
if (block_size <= 2)
|
||||
{
|
||||
//short copy 0b10??????
|
||||
//check we have an existing 1 byte command and if its value is still
|
||||
//small enough to handle additional bytes
|
||||
//start a new command if current one doesn't have space or we don't
|
||||
//have one to continue
|
||||
if (cmd_one && output[cmd_onep] < 0xBF)
|
||||
{
|
||||
//increment command value
|
||||
output[cmd_onep]++;
|
||||
output[putp++] = input[getp++];
|
||||
}
|
||||
else
|
||||
{
|
||||
cmd_onep = putp;
|
||||
output[putp++] = 0x81;
|
||||
output[putp++] = input[getp++];
|
||||
cmd_one = true;
|
||||
}
|
||||
//Otherwise we need to decide what relative copy command is most efficient
|
||||
}
|
||||
else
|
||||
{
|
||||
Int32 offset;
|
||||
Int32 rel_offset = getp - offsetp;
|
||||
if (block_size > 0xA || ((rel_offset) > 0xFFF))
|
||||
{
|
||||
//write 5 byte command 0b11111111
|
||||
if (block_size > 0x40)
|
||||
{
|
||||
output[putp++] = 0xFF;
|
||||
output[putp++] = (Byte)(block_size & 0xFF);
|
||||
output[putp++] = (Byte)((block_size >> 8) & 0xFF);
|
||||
//write 3 byte command 0b11??????
|
||||
}
|
||||
else
|
||||
{
|
||||
output[putp++] = (Byte)((block_size - 3) | 0xC0);
|
||||
}
|
||||
|
||||
offset = relative ? rel_offset : offsetp;
|
||||
//write 2 byte command? 0b0???????
|
||||
}
|
||||
else
|
||||
{
|
||||
offset = rel_offset << 8 | (16 * (block_size - 3) + (rel_offset >> 8));
|
||||
}
|
||||
output[putp++] = (Byte)(offset & 0xFF);
|
||||
output[putp++] = (Byte)((offset >> 8) & 0xFF);
|
||||
getp += block_size;
|
||||
cmd_one = false;
|
||||
}
|
||||
}
|
||||
|
||||
//write final 0x80, basically an empty cmd1 to signal the end of the stream.
|
||||
output[putp++] = 0x80;
|
||||
|
||||
Byte[] finalOutput = new Byte[putp];
|
||||
Array.Copy(output, 0, finalOutput, 0, putp);
|
||||
// Return the final compressed data.
|
||||
return finalOutput;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decompresses data in the proprietary LCW format used in many games
|
||||
/// developed by Westwood Studios.
|
||||
/// </summary>
|
||||
/// <param name="input">The data to decompress.</param>
|
||||
/// <param name="readOffset">Location to start at in the input array.</param>
|
||||
/// <param name="output">The buffer to store the decompressed data. This is assumed to be initialized to the correct size.</param>
|
||||
/// <param name="readEnd">End offset for reading. Use 0 to take the end of the given data array.</param>
|
||||
/// <returns>Length of the decompressed data in bytes.</returns>
|
||||
public static Int32 LcwDecompress(Byte[] input, ref Int32 readOffset, Byte[] output, Int32 readEnd)
|
||||
{
|
||||
if (input == null || input.Length == 0 || output == null || output.Length == 0)
|
||||
return 0;
|
||||
Boolean relative = false;
|
||||
// Nyer's C# conversion: replacements for write and read for pointers.
|
||||
Int32 writeOffset = 0;
|
||||
// Output length should be part of the information given in the file format using LCW.
|
||||
// Techncically it can just be cropped at the end, though this value is used to
|
||||
// automatically cut off repeat-commands that go too far.
|
||||
Int32 writeEnd = output.Length;
|
||||
if (readEnd <= 0)
|
||||
readEnd = input.Length;
|
||||
|
||||
//Decide if the stream uses relative 3 and 5 byte commands
|
||||
//Extension allows effective compression of data > 64k
|
||||
//https://github.com/madmoose/scummvm/blob/bladerunner/engines/bladerunner/decompress_lcw.cpp
|
||||
// this is only used by later games for decoding hi-color vqa files.
|
||||
// For other stuff (like shp), just check in advance to decide if the data is too big.
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
if (input[readOffset] == 0)
|
||||
{
|
||||
relative = true;
|
||||
readOffset++;
|
||||
}
|
||||
//DEBUG_SAY("LCW Decompression... \n");
|
||||
while (writeOffset < writeEnd)
|
||||
{
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
Byte flag = input[readOffset++];
|
||||
UInt16 cpysize;
|
||||
UInt16 offset;
|
||||
|
||||
if ((flag & 0x80) != 0)
|
||||
{
|
||||
if ((flag & 0x40) != 0)
|
||||
{
|
||||
cpysize = (UInt16)((flag & 0x3F) + 3);
|
||||
//long set 0b11111110
|
||||
if (flag == 0xFE)
|
||||
{
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
cpysize = input[readOffset++];
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
cpysize += (UInt16)((input[readOffset++]) << 8);
|
||||
if (cpysize > writeEnd - writeOffset)
|
||||
cpysize = (UInt16)(writeEnd - writeOffset);
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
//DEBUG_SAY("0b11111110 Source Pos %ld, Dest Pos %ld, Count %d\n", source - sstart - 3, dest - start, cpysize);
|
||||
for (; cpysize > 0; --cpysize)
|
||||
{
|
||||
if (writeOffset >= writeEnd)
|
||||
return writeOffset;
|
||||
output[writeOffset++] = input[readOffset];
|
||||
}
|
||||
readOffset++;
|
||||
}
|
||||
else
|
||||
{
|
||||
Int32 s;
|
||||
//long move, abs 0b11111111
|
||||
if (flag == 0xFF)
|
||||
{
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
cpysize = input[readOffset++];
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
cpysize += (UInt16)((input[readOffset++]) << 8);
|
||||
if (cpysize > writeEnd - writeOffset)
|
||||
cpysize = (UInt16)(writeEnd - writeOffset);
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
offset = input[readOffset++];
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
offset += (UInt16)((input[readOffset++]) << 8);
|
||||
//extended format for VQA32
|
||||
if (relative)
|
||||
s = writeOffset - offset;
|
||||
else
|
||||
s = offset;
|
||||
//DEBUG_SAY("0b11111111 Source Pos %ld, Dest Pos %ld, Count %d, Offset %d\n", source - sstart - 5, dest - start, cpysize, offset);
|
||||
for (; cpysize > 0; --cpysize)
|
||||
{
|
||||
if (writeOffset >= writeEnd)
|
||||
return writeOffset;
|
||||
output[writeOffset++] = output[s++];
|
||||
}
|
||||
//short move abs 0b11??????
|
||||
}
|
||||
else
|
||||
{
|
||||
if (cpysize > writeEnd - writeOffset)
|
||||
cpysize = (UInt16)(writeEnd - writeOffset);
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
offset = input[readOffset++];
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
offset += (UInt16)((input[readOffset++]) << 8);
|
||||
//extended format for VQA32
|
||||
if (relative)
|
||||
s = writeOffset - offset;
|
||||
else
|
||||
s = offset;
|
||||
//DEBUG_SAY("0b11?????? Source Pos %ld, Dest Pos %ld, Count %d, Offset %d\n", source - sstart - 3, dest - start, cpysize, offset);
|
||||
for (; cpysize > 0; --cpysize)
|
||||
{
|
||||
if (writeOffset >= writeEnd)
|
||||
return writeOffset;
|
||||
output[writeOffset++] = output[s++];
|
||||
}
|
||||
}
|
||||
}
|
||||
//short copy 0b10??????
|
||||
}
|
||||
else
|
||||
{
|
||||
if (flag == 0x80)
|
||||
{
|
||||
//DEBUG_SAY("0b10?????? Source Pos %ld, Dest Pos %ld, Count %d\n", source - sstart - 1, dest - start, 0);
|
||||
return writeOffset;
|
||||
}
|
||||
cpysize = (UInt16)(flag & 0x3F);
|
||||
if (cpysize > writeEnd - writeOffset)
|
||||
cpysize = (UInt16)(writeEnd - writeOffset);
|
||||
//DEBUG_SAY("0b10?????? Source Pos %ld, Dest Pos %ld, Count %d\n", source - sstart - 1, dest - start, cpysize);
|
||||
for (; cpysize > 0; --cpysize)
|
||||
{
|
||||
if (readOffset >= readEnd || writeOffset >= writeEnd)
|
||||
return writeOffset;
|
||||
output[writeOffset++] = input[readOffset++];
|
||||
}
|
||||
}
|
||||
//short move rel 0b0???????
|
||||
}
|
||||
else
|
||||
{
|
||||
cpysize = (UInt16)((flag >> 4) + 3);
|
||||
if (cpysize > writeEnd - writeOffset)
|
||||
cpysize = (UInt16)(writeEnd - writeOffset);
|
||||
if (readOffset >= readEnd)
|
||||
return writeOffset;
|
||||
offset = (UInt16)(((flag & 0xF) << 8) + input[readOffset++]);
|
||||
//DEBUG_SAY("0b0??????? Source Pos %ld, Dest Pos %ld, Count %d, Offset %d\n", source - sstart - 2, dest - start, cpysize, offset);
|
||||
for (; cpysize > 0; --cpysize)
|
||||
{
|
||||
if (writeOffset >= writeEnd || writeOffset < offset)
|
||||
return writeOffset;
|
||||
output[writeOffset] = output[writeOffset - offset];
|
||||
writeOffset++;
|
||||
}
|
||||
}
|
||||
}
|
||||
// If buffer is full, make sure to skip end command!
|
||||
if (writeOffset == writeEnd && readOffset < input.Length && input[readOffset] == 0x80)
|
||||
readOffset++;
|
||||
return writeOffset;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates a binary delta between two buffers. Mainly used for image data.
|
||||
/// </summary>
|
||||
/// <param name="source">Buffer containing data to generate the delta for.</param>
|
||||
/// <param name="base">Buffer containing data that is the base for the delta.</param>
|
||||
/// <returns>The generated delta as bytes array.</returns>
|
||||
/// <remarks>Commonly known in the community as "format40".</remarks>
|
||||
public static Byte[] GenerateXorDelta(Byte[] source, Byte[] @base)
|
||||
{
|
||||
// Nyer's C# conversion: replacements for write and read for pointers.
|
||||
// -for our delta (output)
|
||||
Int32 putp = 0;
|
||||
// -for the image we go to
|
||||
Int32 getsp = 0;
|
||||
// -for the image we come from
|
||||
Int32 getbp = 0;
|
||||
//Length to process
|
||||
Int32 getsendp = Math.Min(source.Length, @base.Length);
|
||||
Byte[] dest = new Byte[XORWorstCase(getsendp)];
|
||||
|
||||
//Only check getsp to save a redundant check.
|
||||
//Both source and base should be same size and both pointers should be
|
||||
//incremented at the same time.
|
||||
while (getsp < getsendp)
|
||||
{
|
||||
UInt32 fillcount = 0;
|
||||
UInt32 xorcount = 0;
|
||||
UInt32 skipcount = 0;
|
||||
Byte lastxor = (Byte)(source[getsp] ^ @base[getbp]);
|
||||
Int32 testsp = getsp;
|
||||
Int32 testbp = getbp;
|
||||
|
||||
//Only evaluate other options if we don't have a matched pair
|
||||
while (testsp < getsendp && source[testsp] != @base[testbp])
|
||||
{
|
||||
if ((source[testsp] ^ @base[testbp]) == lastxor)
|
||||
{
|
||||
++fillcount;
|
||||
++xorcount;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (fillcount > 3)
|
||||
break;
|
||||
lastxor = (Byte)(source[testsp] ^ @base[testbp]);
|
||||
fillcount = 1;
|
||||
++xorcount;
|
||||
}
|
||||
testsp++;
|
||||
testbp++;
|
||||
}
|
||||
|
||||
//fillcount should always be lower than xorcount and should be greater
|
||||
//than 3 to warrant using the fill commands.
|
||||
fillcount = fillcount > 3 ? fillcount : 0;
|
||||
|
||||
//Okay, lets see if we have any xor bytes we need to handle
|
||||
xorcount -= fillcount;
|
||||
while (xorcount != 0)
|
||||
{
|
||||
UInt16 count;
|
||||
//It's cheaper to do the small cmd twice than do the large cmd once
|
||||
//for data that can be handled by two small cmds.
|
||||
//cmd 0???????
|
||||
if (xorcount < XOR_MED)
|
||||
{
|
||||
count = (UInt16)(xorcount <= XOR_SMALL ? xorcount : XOR_SMALL);
|
||||
dest[putp++] = (Byte)count;
|
||||
//cmd 10000000 10?????? ??????
|
||||
}
|
||||
else
|
||||
{
|
||||
count = (UInt16)(xorcount <= XOR_LARGE ? xorcount : XOR_LARGE);
|
||||
dest[putp++] = 0x80;
|
||||
dest[putp++] = (Byte)(count & 0xFF);
|
||||
dest[putp++] = (Byte)(((count >> 8) & 0xFF) | 0x80);
|
||||
}
|
||||
|
||||
while (count != 0)
|
||||
{
|
||||
dest[putp++] = (Byte)(source[getsp++] ^ @base[getbp++]);
|
||||
count--;
|
||||
xorcount--;
|
||||
}
|
||||
}
|
||||
|
||||
//lets handle the bytes that are best done as xorfill
|
||||
while (fillcount != 0)
|
||||
{
|
||||
UInt16 count;
|
||||
//cmd 00000000 ????????
|
||||
if (fillcount <= XOR_MED)
|
||||
{
|
||||
count = (UInt16)fillcount;
|
||||
dest[putp++] = 0;
|
||||
dest[putp++] = (Byte)(count & 0xFF);
|
||||
//cmd 10000000 11?????? ??????
|
||||
}
|
||||
else
|
||||
{
|
||||
count = (UInt16)(fillcount <= XOR_LARGE ? fillcount : XOR_LARGE);
|
||||
dest[putp++] = 0x80;
|
||||
dest[putp++] = (Byte)(count & 0xFF);
|
||||
dest[putp++] = (Byte)(((count >> 8) & 0xFF) | 0xC0);
|
||||
}
|
||||
dest[putp++] = (Byte)(source[getsp] ^ @base[getbp]);
|
||||
fillcount -= count;
|
||||
getsp += count;
|
||||
getbp += count;
|
||||
}
|
||||
|
||||
//Handle regions that match exactly
|
||||
while (testsp < getsendp && source[testsp] == @base[testbp])
|
||||
{
|
||||
skipcount++;
|
||||
testsp++;
|
||||
testbp++;
|
||||
}
|
||||
|
||||
while (skipcount != 0)
|
||||
{
|
||||
UInt16 count;
|
||||
//Again it's cheaper to do the small cmd twice than do the large cmd
|
||||
//once for data that can be handled by two small cmds.
|
||||
//cmd 1???????
|
||||
if (skipcount < XOR_MED)
|
||||
{
|
||||
count = (Byte)(skipcount <= XOR_SMALL ? skipcount : XOR_SMALL);
|
||||
dest[putp++] = (Byte)(count | 0x80);
|
||||
//cmd 10000000 0??????? ????????
|
||||
}
|
||||
else
|
||||
{
|
||||
count = (UInt16)(skipcount <= XOR_MAX ? skipcount : XOR_MAX);
|
||||
dest[putp++] = 0x80;
|
||||
dest[putp++] = (Byte)(count & 0xFF);
|
||||
dest[putp++] = (Byte)((count >> 8) & 0xFF);
|
||||
}
|
||||
skipcount -= count;
|
||||
getsp += count;
|
||||
getbp += count;
|
||||
}
|
||||
}
|
||||
|
||||
//final skip command of 0 to signal end of stream.
|
||||
dest[putp++] = 0x80;
|
||||
dest[putp++] = 0;
|
||||
dest[putp++] = 0;
|
||||
|
||||
Byte[] finalOutput = new Byte[putp];
|
||||
Array.Copy(dest, 0, finalOutput, 0, putp);
|
||||
// Return the final data
|
||||
return finalOutput;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Applies a binary delta to a buffer.
|
||||
/// </summary>
|
||||
/// <param name="data">The data to apply the xor to.</param>
|
||||
/// <param name="xorSource">The the delta data to apply.</param>
|
||||
/// <param name="xorStart">Start offset in the data.</param>
|
||||
/// <param name="xorEnd">End offset in the data. Use 0 to take the end of the whole array.</param>
|
||||
public static void ApplyXorDelta(Byte[] data, Byte[] xorSource, ref Int32 xorStart, Int32 xorEnd)
|
||||
{
|
||||
// Nyer's C# conversion: replacements for write and read for pointers.
|
||||
Int32 putp = 0;
|
||||
Byte value = 0;
|
||||
Int32 dataEnd = data.Length;
|
||||
if (xorEnd <= 0)
|
||||
xorEnd = xorSource.Length;
|
||||
while (putp < dataEnd && xorStart < xorEnd)
|
||||
{
|
||||
//DEBUG_SAY("XOR_Delta Put pos: %u, Get pos: %u.... ", putp - scast<sint8*>(dest), getp - scast<sint8*>(source));
|
||||
Byte cmd = xorSource[xorStart++];
|
||||
UInt16 count = cmd;
|
||||
Boolean xorval = false;
|
||||
|
||||
if ((cmd & 0x80) == 0)
|
||||
{
|
||||
//0b00000000
|
||||
if (cmd == 0)
|
||||
{
|
||||
if (xorStart >= xorEnd)
|
||||
return;
|
||||
count = (UInt16)(xorSource[xorStart++] & 0xFF);
|
||||
if (xorStart >= xorEnd)
|
||||
return;
|
||||
value = xorSource[xorStart++];
|
||||
xorval = true;
|
||||
//DEBUG_SAY("0b00000000 Val Count %d ", count);
|
||||
//0b0???????
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//0b1??????? remove most significant bit
|
||||
count &= 0x7F;
|
||||
if (count != 0)
|
||||
{
|
||||
putp += count;
|
||||
//DEBUG_SAY("0b1??????? Skip Count %d\n", count);
|
||||
continue;
|
||||
}
|
||||
if (xorStart >= xorEnd)
|
||||
return;
|
||||
count = (UInt16) (xorSource[xorStart++] & 0xFF);
|
||||
if (xorStart >= xorEnd)
|
||||
return;
|
||||
count += (UInt16) (xorSource[xorStart++] << 8);
|
||||
|
||||
//0b10000000 0 0
|
||||
if (count == 0)
|
||||
{
|
||||
//DEBUG_SAY("0b10000000 Count %d to end delta\n", count);
|
||||
return;
|
||||
}
|
||||
|
||||
//0b100000000 0?
|
||||
if ((count & 0x8000) == 0)
|
||||
{
|
||||
putp += count;
|
||||
//DEBUG_SAY("0b100000000 0? Skip Count %d\n", count);
|
||||
continue;
|
||||
}
|
||||
//0b10000000 11
|
||||
if ((count & 0x4000) != 0)
|
||||
{
|
||||
count &= 0x3FFF;
|
||||
if (xorStart >= xorEnd)
|
||||
return;
|
||||
value = xorSource[xorStart++];
|
||||
//DEBUG_SAY("0b10000000 11 Val Count %d ", count);
|
||||
xorval = true;
|
||||
//0b10000000 10
|
||||
}
|
||||
else
|
||||
{
|
||||
count &= 0x3FFF;
|
||||
//DEBUG_SAY("0b10000000 10 XOR Count %d ", count);
|
||||
}
|
||||
}
|
||||
|
||||
if (xorval)
|
||||
{
|
||||
//DEBUG_SAY("XOR Val %d\n", value);
|
||||
for (; count > 0; --count)
|
||||
{
|
||||
if (putp >= dataEnd)
|
||||
return;
|
||||
data[putp++] ^= value;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//DEBUG_SAY("XOR Source to Dest\n");
|
||||
for (; count > 0; --count)
|
||||
{
|
||||
if (putp >= dataEnd || xorStart >= xorEnd)
|
||||
return;
|
||||
data[putp++] ^= xorSource[xorStart++];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user