BrawlLib.Wii.Compression.RunLength Class Reference

Public Member Functions
int	Compress (VoidPtr srcAddr, int srcLen, Stream outStream, IProgressTracker progress, int type)
	Parameters type 0 is YAZ0, 1 is YAY0, anything else is CompressionHeader More...

Static Public Member Functions
static int	CompactYAZ0 (VoidPtr srcAddr, int srcLen, Stream outStream, ResourceNode r)
static int	CompactYAY0 (VoidPtr srcAddr, int srcLen, Stream outStream, ResourceNode r)
static int	Compact (VoidPtr srcAddr, int srcLen, Stream outStream, ResourceNode r)
static void	ExpandYAZ0 (YAZ0 *header, VoidPtr dstAddress, int dstLen)
static void	ExpandYAY0 (YAY0 *header, VoidPtr dstAddress, int dstLen)
static void	Expand (CompressionHeader *header, VoidPtr dstAddress, int dstLen)
static void	Expand (VoidPtr srcAddress, VoidPtr dstAddress, int dstLen)
	Expands data at an address using default RunLength compression. Do not use this for YAY0 data, as it uses codes and counts at their own addresses. More...
static void	Expand (ref byte *srcPtr, ref byte *codes, ref byte *counts, byte *dstPtr, int dstLen)

Member Function Documentation

Compact()

static int BrawlLib.Wii.Compression.RunLength.Compact ( VoidPtr  srcAddr, int  srcLen, Stream  outStream, ResourceNode  r  )

inlinestatic

        {
            using (ProgressWindow prog = new ProgressWindow(r.RootNode._mainForm, "RunLength",
                $"Compressing {r.Name}, please wait...", false))
            {
                return new RunLength().Compress(srcAddr, srcLen, outStream, prog, 2);
            }
        }

CompactYAY0()

static int BrawlLib.Wii.Compression.RunLength.CompactYAY0 ( VoidPtr  srcAddr, int  srcLen, Stream  outStream, ResourceNode  r  )

inlinestatic

        {
            using (ProgressWindow prog = new ProgressWindow(r.RootNode._mainForm, "RunLength - YAY0",
                $"Compressing {r.Name}, please wait...", false))
            {
                return new RunLength().Compress(srcAddr, srcLen, outStream, prog, 1);
            }
        }

CompactYAZ0()

static int BrawlLib.Wii.Compression.RunLength.CompactYAZ0 ( VoidPtr  srcAddr, int  srcLen, Stream  outStream, ResourceNode  r  )

inlinestatic

        {
            using (ProgressWindow prog = new ProgressWindow(r.RootNode._mainForm, "RunLength - YAZ0",
                $"Compressing {r.Name}, please wait...", false))
            {
                return new RunLength().Compress(srcAddr, srcLen, outStream, prog, 0);
            }
        }

Compress()

int BrawlLib.Wii.Compression.RunLength.Compress ( VoidPtr  srcAddr, int  srcLen, Stream  outStream, IProgressTracker  progress, int  type  )

inline

Parameters

type	0 is YAZ0, 1 is YAY0, anything else is CompressionHeader

        {
            _pSrc = (byte*) srcAddr;
            _sourceLen = srcLen;
 
            int chunkCount = (int) Math.Ceiling((double) srcLen / _threadChunk);
 
            progress?.Begin(0, srcLen, 0);
 
            _contractions = new List<Contraction>[chunkCount];
 
            bool YAY0Comp = type == 1;
 
            if (type == 0)
            {
                YAZ0 header = new YAZ0
                {
                    _tag = YAZ0.Tag,
                    _unCompDataLen = (uint) _sourceLen
                };
                outStream.Write(&header, YAZ0.Size);
            }
            else if (type == 1)
            {
                //Don't write YAY0 header yet.
                //Collect all compression data first
            }
            else
            {
                CompressionHeader header = new CompressionHeader
                {
                    Algorithm = CompressionType.RunLength,
                    ExpandedSize = (uint) _sourceLen
                };
                outStream.Write(&header, 4 + (header.LargeSize ? 4 : 0));
            }
 
            ParallelLoopResult result = Parallel.For(0, chunkCount, FindContractions);
 
            while (!result.IsCompleted)
            {
                Thread.Sleep(100);
            }
 
            List<Contraction> fullContractions;
            int codeBits, current;
            byte codeByte;
            //byte[] temp;
            int lastUpdate = srcLen;
 
            fullContractions = new List<Contraction>();
            for (int i = 0; i < _contractions.Length; i++)
            {
                fullContractions.AddRange(_contractions[i]);
                _contractions[i].Clear();
                _contractions[i] = null;
            }
 
            _contractions = null;
 
            //temp = new byte[3 * 8];
            codeBits = 0;
            codeByte = 0;
            current = 0;
 
            List<byte> tempCounts = new List<byte>();
            List<byte> tempData = new List<byte>();
            List<byte> codes = new List<byte>();
            List<List<byte>> counts = new List<List<byte>>();
            List<List<byte>> data = new List<List<byte>>();
 
            for (int i = 0; i < srcLen;)
            {
                if (codeBits == 8)
                {
                    codes.Add(codeByte);
                    counts.Add(tempCounts);
                    data.Add(tempData);
 
                    tempCounts = new List<byte>();
                    tempData = new List<byte>();
 
                    codeBits = 0;
                    codeByte = 0;
                }
 
                if (current < fullContractions.Count && fullContractions[current].Location == i)
                {
                    if (fullContractions[current].Size >= 0x12)
                    {
                        byte
                            b1 = (byte) (fullContractions[current].Offset >> 8),
                            b2 = (byte) (fullContractions[current].Offset & 0xFF);
 
                        if (YAY0Comp)
                        {
                            tempCounts.Add(b1);
                            tempCounts.Add(b2);
                        }
                        else
                        {
                            tempData.Add(b1);
                            tempData.Add(b2);
                        }
 
                        tempData.Add((byte) (fullContractions[current].Size - 0x12));
                    }
                    else
                    {
                        byte
                            b1 = (byte) ((fullContractions[current].Offset >> 8) |
                                         ((fullContractions[current].Size - 2) << 4)),
                            b2 = (byte) (fullContractions[current].Offset & 0xFF);
 
                        if (YAY0Comp)
                        {
                            tempCounts.Add(b1);
                            tempCounts.Add(b2);
                        }
                        else
                        {
                            tempData.Add(b1);
                            tempData.Add(b2);
                        }
                    }
 
                    i += fullContractions[current++].Size;
 
                    while (current < fullContractions.Count && fullContractions[current].Location < i)
                    {
                        current++;
                    }
                }
                else
                {
                    codeByte |= (byte) (1 << (7 - codeBits));
                    tempData.Add(_pSrc[i++]);
                }
 
                codeBits++;
 
                if (progress != null)
                {
                    if (i % 0x4000 == 0)
                    {
                        progress.Update(i);
                    }
                }
            }
 
            codes.Add(codeByte);
            counts.Add(tempCounts);
            data.Add(tempData);
 
            if (YAY0Comp)
            {
                //Write header
                YAY0 header = new YAY0
                {
                    _tag = YAY0.Tag,
                    _unCompDataLen = (uint) _sourceLen
                };
                uint offset = 0x10 + (uint) codes.Count;
                header._countOffset = offset;
                foreach (List<byte> list in counts)
                {
                    offset += (uint) list.Count;
                }
 
                header._dataOffset = offset;
                outStream.Write(&header, YAY0.Size);
 
                //Write codes
                foreach (byte c in codes)
                {
                    outStream.WriteByte(c);
                }
 
                //Write counts
                foreach (List<byte> list in counts)
                {
                    outStream.Write(list.ToArray(), 0, list.Count);
                }
 
                //Write data
                foreach (List<byte> list in data)
                {
                    outStream.Write(list.ToArray(), 0, list.Count);
                }
            }
            else
            {
                for (int i = 0; i < codes.Count; i++)
                {
                    //Write code
                    outStream.WriteByte(codes[i]);
                    //Write data
                    outStream.Write(data[i].ToArray(), 0, data[i].Count);
                }
            }
 
            outStream.Flush();
 
            progress?.Finish();
 
            return (int) outStream.Length;
        }

Expand() [1/3]

static void BrawlLib.Wii.Compression.RunLength.Expand ( CompressionHeader *  header, VoidPtr  dstAddress, int  dstLen  )

inlinestatic

        {
            Expand(header->Data, dstAddress, dstLen);
        }

Expand() [2/3]

static void BrawlLib.Wii.Compression.RunLength.Expand ( ref byte *  srcPtr, ref byte *  codes, ref byte *  counts, byte *  dstPtr, int  dstLen  )

inlinestatic

        {
            for (byte* ceiling = dstPtr + dstLen; dstPtr < ceiling;)
            {
                for (byte control = *codes++, bit = 8; bit-- != 0 && dstPtr != ceiling;)
                {
                    if ((control & (1 << bit)) != 0)
                    {
                        *dstPtr++ = *srcPtr++;
                    }
                    else
                    {
                        for (int b1 = *counts++,
                            b2 = *counts++,
                            offset = (((b1 & 0xF) << 8) | b2) + 2,
                            temp = (b1 >> 4) & 0xF,
                            num = temp == 0 ? *srcPtr++ + 0x12 : temp + 2;
                            num-- > 0 && dstPtr != ceiling;
                            *dstPtr++ = dstPtr[-offset])
                        {
                            ;
                        }
                    }
                }
            }
        }

Expand() [3/3]

static void BrawlLib.Wii.Compression.RunLength.Expand ( VoidPtr  srcAddress, VoidPtr  dstAddress, int  dstLen  )

inlinestatic

Expands data at an address using default RunLength compression. Do not use this for YAY0 data, as it uses codes and counts at their own addresses.

        {
            //Use this for reference in the function
            byte* srcData = (byte*) srcAddress;
            Expand(ref srcData, ref srcData, ref srcData, (byte*) dstAddress, dstLen);
        }

ExpandYAY0()

static void BrawlLib.Wii.Compression.RunLength.ExpandYAY0 ( YAY0 *  header, VoidPtr  dstAddress, int  dstLen  )

inlinestatic

        {
            byte*
                codes = (byte*) header + 0x10,
                counts = (byte*) header + header->_countOffset,
                srcPtr = (byte*) header + header->_dataOffset;
 
            Expand(ref srcPtr, ref codes, ref counts, (byte*) dstAddress, dstLen);
        }

ExpandYAZ0()

static void BrawlLib.Wii.Compression.RunLength.ExpandYAZ0 ( YAZ0 *  header, VoidPtr  dstAddress, int  dstLen  )

inlinestatic

        {
            Expand(header->Data, dstAddress, dstLen);
        }

---

The documentation for this class was generated from the following file:

• BrawlLib/Wii/Compression/RunLength.cs