BrawlLib.Wii.Compressor Class Reference

Static Public Member Functions
static bool	Supports (CompressionType type)
static CompressionType	GetAlgorithm (DataSource source)
static CompressionType	GetAlgorithm (VoidPtr addr, int length)
static uint	GetExpandedLength (VoidPtr addr, int length)
static FileMap	TryExpand (ref DataSource source, bool doTest=true)
static void	Expand (CompressionHeader *header, VoidPtr dstAddr, int dstLen)
static void	Expand (YAZ0 *header, VoidPtr dstAddr, int dstLen)
static void	Expand (YAY0 *header, VoidPtr dstAddr, int dstLen)
static void	Compact (CompressionType type, VoidPtr srcAddr, int srcLen, Stream outStream, ResourceNode r)

Member Function Documentation

Compact()

static void BrawlLib.Wii.Compressor.Compact ( CompressionType  type, VoidPtr  srcAddr, int  srcLen, Stream  outStream, ResourceNode  r  )

inlinestatic

        {
            switch (type)
            {
                case CompressionType.LZ77:
                {
                    LZ77.Compact(srcAddr, srcLen, outStream, r, false);
                    break;
                }
 
                case CompressionType.ExtendedLZ77:
                {
                    LZ77.Compact(srcAddr, srcLen, outStream, r, true);
                    break;
                }
 
                case CompressionType.RunLength:
                {
                    RunLength.Compact(srcAddr, srcLen, outStream, r);
                    break;
                }
 
                case CompressionType.RunLengthYAZ0:
                {
                    RunLength.CompactYAZ0(srcAddr, srcLen, outStream, r);
                    break;
                }
 
                case CompressionType.RunLengthYAY0:
                {
                    RunLength.CompactYAY0(srcAddr, srcLen, outStream, r);
                    break;
                }
            }
        }

Expand() [1/3]

static void BrawlLib.Wii.Compressor.Expand ( CompressionHeader *  header, VoidPtr  dstAddr, int  dstLen  )

inlinestatic

        {
            switch (header->Algorithm)
            {
                case CompressionType.LZ77:
                case CompressionType.ExtendedLZ77:
                {
                    LZ77.Expand(header, dstAddr, dstLen);
                    break;
                }
 
                case CompressionType.RunLength:
                {
                    RunLength.Expand(header, dstAddr, dstLen);
                    break;
                }
 
                //case CompressionType.Huffman: { Huffman.Expand(header, dstAddr, dstLen); break; }
                //case CompressionType.Differential: { Differential.Expand(header, dstAddr, dstLen); break; }
                default:
                    throw new InvalidCompressionException("Unknown compression type.");
            }
        }

Expand() [2/3]

static void BrawlLib.Wii.Compressor.Expand ( YAY0 *  header, VoidPtr  dstAddr, int  dstLen  )

inlinestatic

        {
            RunLength.ExpandYAY0(header, dstAddr, dstLen);
        }

Expand() [3/3]

static void BrawlLib.Wii.Compressor.Expand ( YAZ0 *  header, VoidPtr  dstAddr, int  dstLen  )

inlinestatic

        {
            RunLength.ExpandYAZ0(header, dstAddr, dstLen);
        }

GetAlgorithm() [1/2]

static CompressionType BrawlLib.Wii.Compressor.GetAlgorithm ( DataSource  source )

inlinestatic

        {
            return GetAlgorithm(source.Address, source.Length);
        }

GetAlgorithm() [2/2]

static CompressionType BrawlLib.Wii.Compressor.GetAlgorithm ( VoidPtr  addr, int  length  )

inlinestatic

        {
            if (length < 4)
            {
                return CompressionType.None;
            }
            BinTag compTag = *(BinTag*) addr;
            if (compTag == YAZ0.Tag)
            {
                return CompressionType.RunLengthYAZ0;
            }
 
            if (compTag == YAY0.Tag)
            {
                return CompressionType.RunLengthYAY0;
            }
 
            CompressionHeader* cmpr = (CompressionHeader*) addr;
 
            if (cmpr->ExpandedSize < length)
            {
                return CompressionType.None;
            }
 
            if (!cmpr->HasLegitCompression())
            {
                return CompressionType.None;
            }
 
            //Check to make sure we're not reading a tag
            if (IsTag((byte*) addr))
            {
                return CompressionType.None;
            }
 
            return cmpr->Algorithm;
        }

GetExpandedLength()

static uint BrawlLib.Wii.Compressor.GetExpandedLength ( VoidPtr  addr, int  length  )

inlinestatic

        {
            BinTag compTag = *(BinTag*) addr;
            if (compTag == YAZ0.Tag)
            {
                return ((YAZ0*) addr)->_unCompDataLen;
            }
 
            if (compTag == YAY0.Tag)
            {
                return ((YAY0*) addr)->_unCompDataLen;
            }
 
            return ((CompressionHeader*) addr)->ExpandedSize;
        }

Supports()

static bool BrawlLib.Wii.Compressor.Supports ( CompressionType  type )

inlinestatic

        {
            return type != CompressionType.None && _supportedCompressionTypes.Contains(type);
        }

TryExpand()

static FileMap BrawlLib.Wii.Compressor.TryExpand ( ref DataSource  source, bool  doTest = true  )

inlinestatic

        {
            FileMap decompressedMap = null;
            CompressionType algorithm = GetAlgorithm(source);
            if (Supports(source.Compression = algorithm))
            {
                try
                {
                    if (doTest && !Test(algorithm, source.Address))
                    {
                        return null;
                    }
 
                    uint len = 0;
                    if (algorithm == CompressionType.RunLengthYAZ0)
                    {
                        len = *(buint*) (source.Address + 4);
                        decompressedMap = FileMap.FromTempFile((int) len);
                        Expand((YAZ0*) source.Address, decompressedMap.Address, decompressedMap.Length);
                    }
                    else if (algorithm == CompressionType.RunLengthYAY0)
                    {
                        len = *(buint*) (source.Address + 4);
                        decompressedMap = FileMap.FromTempFile((int) len);
                        Expand((YAY0*) source.Address, decompressedMap.Address, decompressedMap.Length);
                    }
                    else
                    {
                        CompressionHeader* hdr = (CompressionHeader*) source.Address;
                        len = hdr->ExpandedSize;
 
                        decompressedMap = FileMap.FromTempFile((int) len);
                        Expand(hdr, decompressedMap.Address, decompressedMap.Length);
                    }
                }
                catch (InvalidCompressionException e)
                {
                    MessageBox.Show(e.ToString());
                }
            }
 
            return decompressedMap;
        }

---

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

• BrawlLib/Wii/Compressor.cs