1.1 --- a/.hgignore	Tue Sep 10 15:29:45 2013 +0300
     1.2 +++ b/.hgignore	Thu Sep 26 04:47:05 2013 +0300
     1.3 @@ -9,3 +9,4 @@
     1.4  \.suo$
     1.5  x64/
     1.6  \.tlog$
     1.7 +^tags$

     2.1 --- a/Makefile	Tue Sep 10 15:29:45 2013 +0300
     2.2 +++ b/Makefile	Thu Sep 26 04:47:05 2013 +0300
     2.3 @@ -8,6 +8,11 @@
     2.4  obj = $(src:.cc=.o)
     2.5  dep = $(obj:.o=.d)
     2.6  
     2.7 +openctm = libs/openctm/libopenctm.a
     2.8 +
     2.9 +extinc = -Ilibs/openctm
    2.10 +extlibs = $(openctm)
    2.11 +
    2.12  name = goat3d
    2.13  so_major = 0
    2.14  so_minor = 1
    2.15 @@ -26,18 +31,21 @@
    2.16  	pic = -fPIC
    2.17  endif
    2.18  
    2.19 -CXXFLAGS = -pedantic -Wall $(dbg) $(opt) $(pic)
    2.20 -LDFLAGS = -lvmath -lanim
    2.21 +CXXFLAGS = -pedantic -Wall $(dbg) $(opt) $(pic) $(extinc)
    2.22 +LDFLAGS = $(extlibs) -lvmath -lanim
    2.23  
    2.24  .PHONY: all
    2.25  all: $(lib_so) $(lib_a)
    2.26  
    2.27 -$(lib_so): $(obj)
    2.28 +$(lib_so): $(obj) $(extlibs)
    2.29  	$(CXX) -o $@ $(shared) $(obj) $(LDFLAGS)
    2.30  
    2.31 -$(lib_a): $(obj)
    2.32 +$(lib_a): $(obj) $(extlibs)
    2.33  	$(AR) rcs $@ $(obj)
    2.34  
    2.35 +$(openctm):
    2.36 +	$(MAKE) -C libs/openctm
    2.37 +
    2.38  -include $(dep)
    2.39  
    2.40  %.d: %.cc

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/doc/goatfmt	Thu Sep 26 04:47:05 2013 +0300
     3.3 @@ -0,0 +1,110 @@
     3.4 +Chunk structure
     3.5 +---------------
     3.6 +
     3.7 +Leaf nodes which carry actual data are marked with <SINGLE_CHILD>, or
     3.8 +[MULTIPLE_CHILDREN]. Where choice is involved, options are seperated with the |
     3.9 +symbol.
    3.10 +
    3.11 +SCENE
    3.12 + +--ENV
    3.13 + |   +--AMBIENT
    3.14 + |   |   +--<FLOAT3>
    3.15 + |   +--FOG
    3.16 + |       +--FOG_COLOR
    3.17 + |       |   +--<FLOAT3>
    3.18 + |       +--FOG_EXP
    3.19 + |           +--<FLOAT>
    3.20 + +--MTL
    3.21 + |   +--MTL_NAME
    3.22 + |   |   +--<STRING>
    3.23 + |   +--MTL_ATTR
    3.24 + |       +--MTL_ATTR_NAME
    3.25 + |       |   +--<STRING>
    3.26 + |       +--MTL_ATTR_VAL
    3.27 + |       |   +--<FLOAT|FLOAT3|FLOAT4>
    3.28 + |       +--MTL_ATTR_MAP
    3.29 + |           +--<STRING>      (filename)
    3.30 + +--MESH
    3.31 + |   +--MESH_NAME
    3.32 + |   |   +--<STRING>
    3.33 + |   +--MESH_MATERIAL
    3.34 + |   |   +--<STRING>          (material name)
    3.35 + |   +--MESH_VERTEX_LIST
    3.36 + |   |   +--[FLOAT3]
    3.37 + |   +--MESH_NORMAL_LIST
    3.38 + |   |   +--[FLOAT3]
    3.39 + |   +--MESH_TANGENT_LIST
    3.40 + |   |   +--[FLOAT3]
    3.41 + |   +--MESH_TEXCOORD_LIST
    3.42 + |   |   +--[FLOAT3]
    3.43 + |   +--MESH_SKINWEIGHT_LIST
    3.44 + |   |   +--[FLOAT4]          (vector elements are the 4 skin weights/vertex)
    3.45 + |   +--MESH_SKINMATRIX_LIST
    3.46 + |   |   +--[INT4]            (vector elements are the 4 matrix indices/vertex)
    3.47 + |   +--MESH_COLOR_LIST
    3.48 + |   |   +--[FLOAT4]
    3.49 + |   +--MESH_BONES_LIST
    3.50 + |   |   +--[INT|STRING]      (list of bone nodes by name or index)
    3.51 + |   +--MESH_FACE_LIST
    3.52 + |   |   +--MESH_FACE
    3.53 + |   |       +--[INT]         (three INT chunks for the vertex indices)
    3.54 + |   +--MESH_FILE
    3.55 + |       +--<STRING>          (filename of mesh file to get all the data from)
    3.56 + +--LIGHT
    3.57 + |   +--LIGHT_NAME
    3.58 + |   |   +--<STRING>
    3.59 + |   +--LIGHT_POS
    3.60 + |   |   +--<FLOAT3>
    3.61 + |   +--LIGHT_COLOR
    3.62 + |   |   +--<FLOAT3>
    3.63 + |   +--LIGHT_ATTEN
    3.64 + |   |   +--<FLOAT3>           (constant, linear, and quadratic attenuation)
    3.65 + |   +--LIGHT_DISTANCE
    3.66 + |   |   +--<FLOAT>
    3.67 + |   +--LIGHT_DIR
    3.68 + |   |   +--<FLOAT3>
    3.69 + |   +--LIGHT_CONE_INNER
    3.70 + |   |   +--<FLOAT>
    3.71 + |   +--LIGHT_CONE_OUTER
    3.72 + |       +--<FLOAT>
    3.73 + +--CAMERA
    3.74 + |   +--CAMERA_NAME
    3.75 + |   |   +--<STRING>
    3.76 + |   +--CAMERA_POS
    3.77 + |   |   +--<FLOAT3>
    3.78 + |   +--CAMERA_TARGET
    3.79 + |   |   +--<FLOAT3>
    3.80 + |   +--CAMERA_FOV
    3.81 + |   |   +--<FLOAT>
    3.82 + |   +--CAMERA_NEARCLIP
    3.83 + |   |   +--<FLOAT>
    3.84 + |   +--CAMERA_FARCLIP
    3.85 + |       +--<FLOAT>
    3.86 + +--NODE
    3.87 +     +--NODE_NAME
    3.88 +     |   +--<STRING>
    3.89 +     +--NODE_PARENT
    3.90 +     |   +--<INT|STRING>
    3.91 +     +--NODE_MESH|NODE_LIGHT|NODE_CAMERA
    3.92 +     |   +--<INT|STRING>
    3.93 +     +--NODE_POS
    3.94 +     |   +--<FLOAT3>
    3.95 +     +--NODE_ROT
    3.96 +     |   +--<FLOAT4>           ([x, y, z], w <- real part)
    3.97 +     +--NODE_SCALE
    3.98 +     |   +--<FLOAT3>
    3.99 +     +--NODE_PIVOT
   3.100 +     |   +--<FLOAT3>
   3.101 +     +--NODE_MATRIX0
   3.102 +     |   +--<FLOAT4>           (first row)
   3.103 +     +--NODE_MATRIX1
   3.104 +     |   +--<FLOAT4>           (second row)
   3.105 +     +--NODE_MATRIX2
   3.106 +         +--<FLOAT4>           (third row)
   3.107 +
   3.108 +NOTES:
   3.109 + * Name chunks are mandatory. If something doesn't have a name, one must be made
   3.110 +   up, even if it's just "object%d".
   3.111 + * In node chunks, both POS/ROT/SCALE, and MATRIX0/MATRIX1/MATRIX2 are mandatory
   3.112 +   and they must agree. Makes it easy for the reader to pick the transformation
   3.113 +   data in whichever way is more convenient.

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/libs/openctm/LICENSE.txt	Thu Sep 26 04:47:05 2013 +0300
     4.3 @@ -0,0 +1,20 @@
     4.4 +Copyright (c) 2009-2010 Marcus Geelnard
     4.5 +
     4.6 +This software is provided 'as-is', without any express or implied
     4.7 +warranty. In no event will the authors be held liable for any damages
     4.8 +arising from the use of this software.
     4.9 +
    4.10 +Permission is granted to anyone to use this software for any purpose,
    4.11 +including commercial applications, and to alter it and redistribute it
    4.12 +freely, subject to the following restrictions:
    4.13 +
    4.14 +    1. The origin of this software must not be misrepresented; you must not
    4.15 +    claim that you wrote the original software. If you use this software
    4.16 +    in a product, an acknowledgment in the product documentation would be
    4.17 +    appreciated but is not required.
    4.18 +
    4.19 +    2. Altered source versions must be plainly marked as such, and must not
    4.20 +    be misrepresented as being the original software.
    4.21 +
    4.22 +    3. This notice may not be removed or altered from any source
    4.23 +    distribution.

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/libs/openctm/Makefile	Thu Sep 26 04:47:05 2013 +0300
     5.3 @@ -0,0 +1,16 @@
     5.4 +src = $(wildcard *.c) $(wildcard liblzma/*.c)
     5.5 +obj = $(src:.c=.o)
     5.6 +lib = libopenctm.a
     5.7 +
     5.8 +ifneq ($(shell uname -s), Darwin)
     5.9 +	pic = -fPIC
    5.10 +endif
    5.11 +
    5.12 +CFLAGS = -g -Iliblzma $(pic)
    5.13 +
    5.14 +$(lib): $(obj)
    5.15 +	$(AR) rcs $@ $(obj)
    5.16 +
    5.17 +.PHONY: clean
    5.18 +clean:
    5.19 +	rm -f $(obj) $(lib)

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/libs/openctm/README.txt	Thu Sep 26 04:47:05 2013 +0300
     6.3 @@ -0,0 +1,152 @@
     6.4 +1. INTRODUCTION
     6.5 +===============
     6.6 +
     6.7 +Welcome to OpenCTM!
     6.8 +
     6.9 +OpenCTM is a file format, a software library and a tool set for compression of
    6.10 +3D triangle meshes. The geometry is compressed to a fraction of comparable file
    6.11 +formats (3DS, STL, COLLADA, VRML...), and the format is easily accessible
    6.12 +through a simple, portable API.
    6.13 +
    6.14 +The library is written in portable C (C99), and should compile nicely on any
    6.15 +32/64-bit system regardless of endianity (big endian or little endian).
    6.16 +
    6.17 +
    6.18 +2. LICENSE
    6.19 +==========
    6.20 +
    6.21 +The OpenCTM API and the OpenCTM tools are released under the zlib/libpng
    6.22 +license (see LICENSE.txt).
    6.23 +
    6.24 +3. CREDITS
    6.25 +==========
    6.26 +
    6.27 +Many people have helped out in the development process of OpenCTM, with
    6.28 +valuable feedback, programming efforts, test models and conceptual ideas.
    6.29 +Also, OpenCTM relies heavily on many other open source projects.
    6.30 +
    6.31 +Here is an incomplete list of persons that deserve credit:
    6.32 +
    6.33 +- Igor Pavlov (LZMA library)
    6.34 +- Jonas Innala (COLLADA importer, Maya exporter plugin)
    6.35 +- Ilian Dinev (help with the OpenCTM file format design and the LWO loader)
    6.36 +- Lee Thomason (TinyXML)
    6.37 +- Diego Nehab (RPly - for loading PLY files)
    6.38 +- Lev Povalahev, Marcelo E. Magallon, Milan Ikits (GLEW)
    6.39 +- Thomas G. Lane, Guido Vollbeding (libjpeg)
    6.40 +- Jean-loup Gailly, Mark Adler (zlib)
    6.41 +- Daniel Karling (pnglite)
    6.42 +
    6.43 +During the development of OpenCTM, the following software has been used
    6.44 +extensively:
    6.45 +
    6.46 +- Ubuntu (www.ubuntu.com)
    6.47 +- Blender (www.blender.org)
    6.48 +- GCC (gcc.gnu.org)
    6.49 +- SciTE (www.scintilla.org/SciTE.html)
    6.50 +- Notepad++ (notepad-plus.sourceforge.net)
    6.51 +- Smultron (smultron.sourceforge.net)
    6.52 +
    6.53 +Legal notices:
    6.54 +
    6.55 +- This software is based in part on the work of the Independent JPEG Group.
    6.56 +
    6.57 +
    6.58 +4. CHANGES
    6.59 +==========
    6.60 +
    6.61 +v1.0.3 - 2010.01.15
    6.62 +-------------------
    6.63 +- Added support for PNG format textures (ctmviewer).
    6.64 +
    6.65 +- Added support for LightWave LWO files (ctmconv and ctmviewer).
    6.66 +
    6.67 +- Added support for Geomview OFF files, e.g. as used by the Princeton Shape
    6.68 +  Benchmark (ctmconv and ctmviewer).
    6.69 +
    6.70 +- Improved the OBJ file loader (ctmviewer and ctmconv).
    6.71 +
    6.72 +- Experimental support for VRML 2.0 files - export only (ctmconv and ctmviewer).
    6.73 +
    6.74 +- Made it possible to run ctmviewer without command line arguments.
    6.75 +
    6.76 +- Improved the normal calculation algorithm (ctmviewer and ctmconv).
    6.77 +
    6.78 +- Normals are no longer exported if no normals were present in the input file
    6.79 +  (ctmviewer).
    6.80 +
    6.81 +
    6.82 +v1.0.2 - 2009.12.13
    6.83 +-------------------
    6.84 +- Added an OpenCTM exporter plugin for Maya [Jonas Innala].
    6.85 +
    6.86 +- Added the possiblity to save and load files from ctmviewer, effectively
    6.87 +  turning it into a quick and simple converter tool (without all the options
    6.88 +  in the ctmconv program, though).
    6.89 +
    6.90 +- Added a function to load texture files from ctmviewer.
    6.91 +
    6.92 +- Improved the camera control in ctmviewer (panning with the right mouse
    6.93 +  button, zooming with the middle mouse button and the mouse wheel, feature
    6.94 +  focusing by double clicking, Y/Z up axis selection and "fit to screen"
    6.95 +  function).
    6.96 +
    6.97 +- Added a GUI dialog for showing errors in ctmviewer (this is especially useful
    6.98 +  under Windows, where console output is disabeled).
    6.99 +
   6.100 +- Added an option for calculating the normals in ctmconv (if the input file
   6.101 +  does not have normals).
   6.102 +
   6.103 +- Added options for turning off normals, texture coordinates and/or vertex
   6.104 +  colors for the output file in ctmconv.
   6.105 +
   6.106 +- Added manuals for ctmviewer and ctmconv (man pages).
   6.107 +
   6.108 +- Added a "make install" build target for Mac OS X and Linux for simple system
   6.109 +  wide installation (see COMPILING.txt).
   6.110 +
   6.111 +- NOTE: The Linux/X11 version of ctmviewer now reqires GTK+ 2.0.
   6.112 +
   6.113 +
   6.114 +v1.0.1 - 2009.11.15
   6.115 +-------------------
   6.116 +- Notable reduction of the memory footprint by tuning of the LZMA compression
   6.117 +  parameters.
   6.118 +
   6.119 +- Added a Wavefront OBJ file importer/exporter.
   6.120 +
   6.121 +- Some improvements to ctmviewer and ctmconv.
   6.122 +
   6.123 +- Some directory structure and build system cleanups.
   6.124 +
   6.125 +
   6.126 +v1.0 - 2009.11.09
   6.127 +-----------------
   6.128 +- Added a COLLADA converter module to the ctmconv program [Jonas Innala].
   6.129 +
   6.130 +- Added Python bindings and a demo Python program.
   6.131 +
   6.132 +- Improved the internal mesh integrity checking, to minimize the risk of invalid
   6.133 +  data processing.
   6.134 +
   6.135 +- Improved the file format specification document.
   6.136 +
   6.137 +
   6.138 +v0.8 (beta) - 2009.09.14
   6.139 +------------------------
   6.140 +- Introduced a new API function for controlling the compression level
   6.141 +  (ctmCompressionLevel), and set the default compression level to 5 (rather
   6.142 +  than 9, which would eat a lot of memory, usally without much difference).
   6.143 +
   6.144 +- Changed the name "texture map" in the API to "UV map" (and all
   6.145 +  corresponding constant and function names). This is more in line with
   6.146 +  the nomenclature of most 3D authoring software, and avoids the confusion
   6.147 +  with the term texture mapping in 3D hardware (which is not limited to
   6.148 +  2D UV mapping coordinates).
   6.149 +
   6.150 +- A few updates to the documentation.
   6.151 +
   6.152 +
   6.153 +v0.7 (beta) - 2009.08.29
   6.154 +------------------------
   6.155 +- This was the first public release of OpenCTM.

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/libs/openctm/compressMG1.c	Thu Sep 26 04:47:05 2013 +0300
     7.3 @@ -0,0 +1,324 @@
     7.4 +//-----------------------------------------------------------------------------
     7.5 +// Product:     OpenCTM
     7.6 +// File:        compressMG1.c
     7.7 +// Description: Implementation of the MG1 compression method.
     7.8 +//-----------------------------------------------------------------------------
     7.9 +// Copyright (c) 2009-2010 Marcus Geelnard
    7.10 +//
    7.11 +// This software is provided 'as-is', without any express or implied
    7.12 +// warranty. In no event will the authors be held liable for any damages
    7.13 +// arising from the use of this software.
    7.14 +//
    7.15 +// Permission is granted to anyone to use this software for any purpose,
    7.16 +// including commercial applications, and to alter it and redistribute it
    7.17 +// freely, subject to the following restrictions:
    7.18 +//
    7.19 +//     1. The origin of this software must not be misrepresented; you must not
    7.20 +//     claim that you wrote the original software. If you use this software
    7.21 +//     in a product, an acknowledgment in the product documentation would be
    7.22 +//     appreciated but is not required.
    7.23 +//
    7.24 +//     2. Altered source versions must be plainly marked as such, and must not
    7.25 +//     be misrepresented as being the original software.
    7.26 +//
    7.27 +//     3. This notice may not be removed or altered from any source
    7.28 +//     distribution.
    7.29 +//-----------------------------------------------------------------------------
    7.30 +
    7.31 +#include <stdlib.h>
    7.32 +#include <math.h>
    7.33 +#include "openctm.h"
    7.34 +#include "internal.h"
    7.35 +
    7.36 +#ifdef __DEBUG_
    7.37 +#include <stdio.h>
    7.38 +#endif
    7.39 +
    7.40 +
    7.41 +//-----------------------------------------------------------------------------
    7.42 +// _compareTriangle() - Comparator for the triangle sorting.
    7.43 +//-----------------------------------------------------------------------------
    7.44 +static int _compareTriangle(const void * elem1, const void * elem2)
    7.45 +{
    7.46 +  CTMuint * tri1 = (CTMuint *) elem1;
    7.47 +  CTMuint * tri2 = (CTMuint *) elem2;
    7.48 +  if(tri1[0] != tri2[0])
    7.49 +    return tri1[0] - tri2[0];
    7.50 +  else
    7.51 +    return tri1[1] - tri2[1];
    7.52 +}
    7.53 +
    7.54 +//-----------------------------------------------------------------------------
    7.55 +// _ctmReArrangeTriangles() - Re-arrange all triangles for optimal
    7.56 +// compression.
    7.57 +//-----------------------------------------------------------------------------
    7.58 +static void _ctmReArrangeTriangles(_CTMcontext * self, CTMuint * aIndices)
    7.59 +{
    7.60 +  CTMuint * tri, tmp, i;
    7.61 +
    7.62 +  // Step 1: Make sure that the first index of each triangle is the smallest
    7.63 +  // one (rotate triangle nodes if necessary)
    7.64 +  for(i = 0; i < self->mTriangleCount; ++ i)
    7.65 +  {
    7.66 +    tri = &aIndices[i * 3];
    7.67 +    if((tri[1] < tri[0]) && (tri[1] < tri[2]))
    7.68 +    {
    7.69 +      tmp = tri[0];
    7.70 +      tri[0] = tri[1];
    7.71 +      tri[1] = tri[2];
    7.72 +      tri[2] = tmp;
    7.73 +    }
    7.74 +    else if((tri[2] < tri[0]) && (tri[2] < tri[1]))
    7.75 +    {
    7.76 +      tmp = tri[0];
    7.77 +      tri[0] = tri[2];
    7.78 +      tri[2] = tri[1];
    7.79 +      tri[1] = tmp;
    7.80 +    }
    7.81 +  }
    7.82 +
    7.83 +  // Step 2: Sort the triangles based on the first triangle index
    7.84 +  qsort((void *) aIndices, self->mTriangleCount, sizeof(CTMuint) * 3, _compareTriangle);
    7.85 +}
    7.86 +
    7.87 +//-----------------------------------------------------------------------------
    7.88 +// _ctmMakeIndexDeltas() - Calculate various forms of derivatives in order to
    7.89 +// reduce data entropy.
    7.90 +//-----------------------------------------------------------------------------
    7.91 +static void _ctmMakeIndexDeltas(_CTMcontext * self, CTMuint * aIndices)
    7.92 +{
    7.93 +  CTMint i;
    7.94 +  for(i = self->mTriangleCount - 1; i >= 0; -- i)
    7.95 +  {
    7.96 +    // Step 1: Calculate delta from second triangle index to the previous
    7.97 +    // second triangle index, if the previous triangle shares the same first
    7.98 +    // index, otherwise calculate the delta to the first triangle index
    7.99 +    if((i >= 1) && (aIndices[i * 3] == aIndices[(i - 1) * 3]))
   7.100 +      aIndices[i * 3 + 1] -= aIndices[(i - 1) * 3 + 1];
   7.101 +    else
   7.102 +      aIndices[i * 3 + 1] -= aIndices[i * 3];
   7.103 +
   7.104 +    // Step 2: Calculate delta from third triangle index to the first triangle
   7.105 +    // index
   7.106 +    aIndices[i * 3 + 2] -= aIndices[i * 3];
   7.107 +
   7.108 +    // Step 3: Calculate derivative of the first triangle index
   7.109 +    if(i >= 1)
   7.110 +      aIndices[i * 3] -= aIndices[(i - 1) * 3];
   7.111 +  }
   7.112 +}
   7.113 +
   7.114 +//-----------------------------------------------------------------------------
   7.115 +// _ctmRestoreIndices() - Restore original indices (inverse derivative
   7.116 +// operation).
   7.117 +//-----------------------------------------------------------------------------
   7.118 +static void _ctmRestoreIndices(_CTMcontext * self, CTMuint * aIndices)
   7.119 +{
   7.120 +  CTMuint i;
   7.121 +
   7.122 +  for(i = 0; i < self->mTriangleCount; ++ i)
   7.123 +  {
   7.124 +    // Step 1: Reverse derivative of the first triangle index
   7.125 +    if(i >= 1)
   7.126 +      aIndices[i * 3] += aIndices[(i - 1) * 3];
   7.127 +
   7.128 +    // Step 2: Reverse delta from third triangle index to the first triangle
   7.129 +    // index
   7.130 +    aIndices[i * 3 + 2] += aIndices[i * 3];
   7.131 +
   7.132 +    // Step 3: Reverse delta from second triangle index to the previous
   7.133 +    // second triangle index, if the previous triangle shares the same first
   7.134 +    // index, otherwise reverse the delta to the first triangle index
   7.135 +    if((i >= 1) && (aIndices[i * 3] == aIndices[(i - 1) * 3]))
   7.136 +      aIndices[i * 3 + 1] += aIndices[(i - 1) * 3 + 1];
   7.137 +    else
   7.138 +      aIndices[i * 3 + 1] += aIndices[i * 3];
   7.139 +  }
   7.140 +}
   7.141 +
   7.142 +//-----------------------------------------------------------------------------
   7.143 +// _ctmCompressMesh_MG1() - Compress the mesh that is stored in the CTM
   7.144 +// context, and write it the the output stream in the CTM context.
   7.145 +//-----------------------------------------------------------------------------
   7.146 +int _ctmCompressMesh_MG1(_CTMcontext * self)
   7.147 +{
   7.148 +  CTMuint * indices;
   7.149 +  _CTMfloatmap * map;
   7.150 +  CTMuint i;
   7.151 +
   7.152 +#ifdef __DEBUG_
   7.153 +  printf("COMPRESSION METHOD: MG1\n");
   7.154 +#endif
   7.155 +
   7.156 +  // Perpare (sort) indices
   7.157 +  indices = (CTMuint *) malloc(sizeof(CTMuint) * self->mTriangleCount * 3);
   7.158 +  if(!indices)
   7.159 +  {
   7.160 +    self->mError = CTM_OUT_OF_MEMORY;
   7.161 +    return CTM_FALSE;
   7.162 +  }
   7.163 +  for(i = 0; i < self->mTriangleCount * 3; ++ i)
   7.164 +    indices[i] = self->mIndices[i];
   7.165 +  _ctmReArrangeTriangles(self, indices);
   7.166 +
   7.167 +  // Calculate index deltas (entropy-reduction)
   7.168 +  _ctmMakeIndexDeltas(self, indices);
   7.169 +
   7.170 +  // Write triangle indices
   7.171 +#ifdef __DEBUG_
   7.172 +  printf("Inidices: ");
   7.173 +#endif
   7.174 +  _ctmStreamWrite(self, (void *) "INDX", 4);
   7.175 +  if(!_ctmStreamWritePackedInts(self, (CTMint *) indices, self->mTriangleCount, 3, CTM_FALSE))
   7.176 +  {
   7.177 +    free((void *) indices);
   7.178 +    return CTM_FALSE;
   7.179 +  }
   7.180 +
   7.181 +  // Free temporary resources
   7.182 +  free((void *) indices);
   7.183 +
   7.184 +  // Write vertices
   7.185 +#ifdef __DEBUG_
   7.186 +  printf("Vertices: ");
   7.187 +#endif
   7.188 +  _ctmStreamWrite(self, (void *) "VERT", 4);
   7.189 +  if(!_ctmStreamWritePackedFloats(self, self->mVertices, self->mVertexCount * 3, 1))
   7.190 +  {
   7.191 +    free((void *) indices);
   7.192 +    return CTM_FALSE;
   7.193 +  }
   7.194 +
   7.195 +  // Write normals
   7.196 +  if(self->mNormals)
   7.197 +  {
   7.198 +#ifdef __DEBUG_
   7.199 +    printf("Normals: ");
   7.200 +#endif
   7.201 +    _ctmStreamWrite(self, (void *) "NORM", 4);
   7.202 +    if(!_ctmStreamWritePackedFloats(self, self->mNormals, self->mVertexCount, 3))
   7.203 +      return CTM_FALSE;
   7.204 +  }
   7.205 +
   7.206 +  // Write UV maps
   7.207 +  map = self->mUVMaps;
   7.208 +  while(map)
   7.209 +  {
   7.210 +#ifdef __DEBUG_
   7.211 +    printf("UV coordinates (%s): ", map->mName ? map->mName : "no name");
   7.212 +#endif
   7.213 +    _ctmStreamWrite(self, (void *) "TEXC", 4);
   7.214 +    _ctmStreamWriteSTRING(self, map->mName);
   7.215 +    _ctmStreamWriteSTRING(self, map->mFileName);
   7.216 +    if(!_ctmStreamWritePackedFloats(self, map->mValues, self->mVertexCount, 2))
   7.217 +      return CTM_FALSE;
   7.218 +    map = map->mNext;
   7.219 +  }
   7.220 +
   7.221 +  // Write attribute maps
   7.222 +  map = self->mAttribMaps;
   7.223 +  while(map)
   7.224 +  {
   7.225 +#ifdef __DEBUG_
   7.226 +    printf("Vertex attributes (%s): ", map->mName ? map->mName : "no name");
   7.227 +#endif
   7.228 +    _ctmStreamWrite(self, (void *) "ATTR", 4);
   7.229 +    _ctmStreamWriteSTRING(self, map->mName);
   7.230 +    if(!_ctmStreamWritePackedFloats(self, map->mValues, self->mVertexCount, 4))
   7.231 +      return CTM_FALSE;
   7.232 +    map = map->mNext;
   7.233 +  }
   7.234 +
   7.235 +  return CTM_TRUE;
   7.236 +}
   7.237 +
   7.238 +//-----------------------------------------------------------------------------
   7.239 +// _ctmUncompressMesh_MG1() - Uncmpress the mesh from the input stream in the
   7.240 +// CTM context, and store the resulting mesh in the CTM context.
   7.241 +//-----------------------------------------------------------------------------
   7.242 +int _ctmUncompressMesh_MG1(_CTMcontext * self)
   7.243 +{
   7.244 +  CTMuint * indices;
   7.245 +  _CTMfloatmap * map;
   7.246 +  CTMuint i;
   7.247 +
   7.248 +  // Allocate memory for the indices
   7.249 +  indices = (CTMuint *) malloc(sizeof(CTMuint) * self->mTriangleCount * 3);
   7.250 +  if(!indices)
   7.251 +  {
   7.252 +    self->mError = CTM_OUT_OF_MEMORY;
   7.253 +    return CTM_FALSE;
   7.254 +  }
   7.255 +
   7.256 +  // Read triangle indices
   7.257 +  if(_ctmStreamReadUINT(self) != FOURCC("INDX"))
   7.258 +  {
   7.259 +    self->mError = CTM_BAD_FORMAT;
   7.260 +    free(indices);
   7.261 +    return CTM_FALSE;
   7.262 +  }
   7.263 +  if(!_ctmStreamReadPackedInts(self, (CTMint *) indices, self->mTriangleCount, 3, CTM_FALSE))
   7.264 +    return CTM_FALSE;
   7.265 +
   7.266 +  // Restore indices
   7.267 +  _ctmRestoreIndices(self, indices);
   7.268 +  for(i = 0; i < self->mTriangleCount * 3; ++ i)
   7.269 +    self->mIndices[i] = indices[i];
   7.270 +
   7.271 +  // Free temporary resources
   7.272 +  free(indices);
   7.273 +
   7.274 +  // Read vertices
   7.275 +  if(_ctmStreamReadUINT(self) != FOURCC("VERT"))
   7.276 +  {
   7.277 +    self->mError = CTM_BAD_FORMAT;
   7.278 +    return CTM_FALSE;
   7.279 +  }
   7.280 +  if(!_ctmStreamReadPackedFloats(self, self->mVertices, self->mVertexCount * 3, 1))
   7.281 +    return CTM_FALSE;
   7.282 +
   7.283 +  // Read normals
   7.284 +  if(self->mNormals)
   7.285 +  {
   7.286 +    if(_ctmStreamReadUINT(self) != FOURCC("NORM"))
   7.287 +    {
   7.288 +      self->mError = CTM_BAD_FORMAT;
   7.289 +      return CTM_FALSE;
   7.290 +    }
   7.291 +    if(!_ctmStreamReadPackedFloats(self, self->mNormals, self->mVertexCount, 3))
   7.292 +      return CTM_FALSE;
   7.293 +  }
   7.294 +
   7.295 +  // Read UV maps
   7.296 +  map = self->mUVMaps;
   7.297 +  while(map)
   7.298 +  {
   7.299 +    if(_ctmStreamReadUINT(self) != FOURCC("TEXC"))
   7.300 +    {
   7.301 +      self->mError = CTM_BAD_FORMAT;
   7.302 +      return 0;
   7.303 +    }
   7.304 +    _ctmStreamReadSTRING(self, &map->mName);
   7.305 +    _ctmStreamReadSTRING(self, &map->mFileName);
   7.306 +    if(!_ctmStreamReadPackedFloats(self, map->mValues, self->mVertexCount, 2))
   7.307 +      return CTM_FALSE;
   7.308 +    map = map->mNext;
   7.309 +  }
   7.310 +
   7.311 +  // Read vertex attribute maps
   7.312 +  map = self->mAttribMaps;
   7.313 +  while(map)
   7.314 +  {
   7.315 +    if(_ctmStreamReadUINT(self) != FOURCC("ATTR"))
   7.316 +    {
   7.317 +      self->mError = CTM_BAD_FORMAT;
   7.318 +      return 0;
   7.319 +    }
   7.320 +    _ctmStreamReadSTRING(self, &map->mName);
   7.321 +    if(!_ctmStreamReadPackedFloats(self, map->mValues, self->mVertexCount, 4))
   7.322 +      return CTM_FALSE;
   7.323 +    map = map->mNext;
   7.324 +  }
   7.325 +
   7.326 +  return CTM_TRUE;
   7.327 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/libs/openctm/compressMG2.c	Thu Sep 26 04:47:05 2013 +0300
     8.3 @@ -0,0 +1,1319 @@
     8.4 +//-----------------------------------------------------------------------------
     8.5 +// Product:     OpenCTM
     8.6 +// File:        compressMG2.c
     8.7 +// Description: Implementation of the MG2 compression method.
     8.8 +//-----------------------------------------------------------------------------
     8.9 +// Copyright (c) 2009-2010 Marcus Geelnard
    8.10 +//
    8.11 +// This software is provided 'as-is', without any express or implied
    8.12 +// warranty. In no event will the authors be held liable for any damages
    8.13 +// arising from the use of this software.
    8.14 +//
    8.15 +// Permission is granted to anyone to use this software for any purpose,
    8.16 +// including commercial applications, and to alter it and redistribute it
    8.17 +// freely, subject to the following restrictions:
    8.18 +//
    8.19 +//     1. The origin of this software must not be misrepresented; you must not
    8.20 +//     claim that you wrote the original software. If you use this software
    8.21 +//     in a product, an acknowledgment in the product documentation would be
    8.22 +//     appreciated but is not required.
    8.23 +//
    8.24 +//     2. Altered source versions must be plainly marked as such, and must not
    8.25 +//     be misrepresented as being the original software.
    8.26 +//
    8.27 +//     3. This notice may not be removed or altered from any source
    8.28 +//     distribution.
    8.29 +//-----------------------------------------------------------------------------
    8.30 +
    8.31 +#include <stdlib.h>
    8.32 +#include <math.h>
    8.33 +#include "openctm.h"
    8.34 +#include "internal.h"
    8.35 +
    8.36 +#ifdef __DEBUG_
    8.37 +#include <stdio.h>
    8.38 +#endif
    8.39 +
    8.40 +// We need PI
    8.41 +#ifndef PI
    8.42 +#define PI 3.141592653589793238462643f
    8.43 +#endif
    8.44 +
    8.45 +
    8.46 +//-----------------------------------------------------------------------------
    8.47 +// _CTMgrid - 3D space subdivision grid.
    8.48 +//-----------------------------------------------------------------------------
    8.49 +typedef struct {
    8.50 +  // Axis-aligned boudning box for the grid.
    8.51 +  CTMfloat mMin[3];
    8.52 +  CTMfloat mMax[3];
    8.53 +
    8.54 +  // How many divisions per axis (minimum 1).
    8.55 +  CTMuint mDivision[3];
    8.56 +
    8.57 +  // Size of each grid box.
    8.58 +  CTMfloat mSize[3];
    8.59 +} _CTMgrid;
    8.60 +
    8.61 +//-----------------------------------------------------------------------------
    8.62 +// _CTMsortvertex - Vertex information.
    8.63 +//-----------------------------------------------------------------------------
    8.64 +typedef struct {
    8.65 +  // Vertex X coordinate (used for sorting).
    8.66 +  CTMfloat x;
    8.67 +
    8.68 +  // Grid index. This is the index into the 3D space subdivision grid.
    8.69 +  CTMuint mGridIndex;
    8.70 +
    8.71 +  // Original index (before sorting).
    8.72 +  CTMuint mOriginalIndex;
    8.73 +} _CTMsortvertex;
    8.74 +
    8.75 +//-----------------------------------------------------------------------------
    8.76 +// _ctmSetupGrid() - Setup the 3D space subdivision grid.
    8.77 +//-----------------------------------------------------------------------------
    8.78 +static void _ctmSetupGrid(_CTMcontext * self, _CTMgrid * aGrid)
    8.79 +{
    8.80 +  CTMuint i;
    8.81 +  CTMfloat factor[3], sum, wantedGrids;
    8.82 +
    8.83 +  // Calculate the mesh bounding box
    8.84 +  aGrid->mMin[0] = aGrid->mMax[0] = self->mVertices[0];
    8.85 +  aGrid->mMin[1] = aGrid->mMax[1] = self->mVertices[1];
    8.86 +  aGrid->mMin[2] = aGrid->mMax[2] = self->mVertices[2];
    8.87 +  for(i = 1; i < self->mVertexCount; ++ i)
    8.88 +  {
    8.89 +    if(self->mVertices[i * 3] < aGrid->mMin[0])
    8.90 +      aGrid->mMin[0] = self->mVertices[i * 3];
    8.91 +    else if(self->mVertices[i * 3] > aGrid->mMax[0])
    8.92 +      aGrid->mMax[0] = self->mVertices[i * 3];
    8.93 +    if(self->mVertices[i * 3 + 1] < aGrid->mMin[1])
    8.94 +      aGrid->mMin[1] = self->mVertices[i * 3 + 1];
    8.95 +    else if(self->mVertices[i * 3 + 1] > aGrid->mMax[1])
    8.96 +      aGrid->mMax[1] = self->mVertices[i * 3 + 1];
    8.97 +    if(self->mVertices[i * 3 + 2] < aGrid->mMin[2])
    8.98 +      aGrid->mMin[2] = self->mVertices[i * 3 + 2];
    8.99 +    else if(self->mVertices[i * 3 + 2] > aGrid->mMax[2])
   8.100 +      aGrid->mMax[2] = self->mVertices[i * 3 + 2];
   8.101 +  }
   8.102 +
   8.103 +  // Determine optimal grid resolution, based on the number of vertices and
   8.104 +  // the bounding box.
   8.105 +  // NOTE: This algorithm is quite crude, and could very well be optimized for
   8.106 +  // better compression levels in the future without affecting the file format
   8.107 +  // or backward compatibility at all.
   8.108 +  for(i = 0; i < 3; ++ i)
   8.109 +    factor[i] = aGrid->mMax[i] - aGrid->mMin[i];
   8.110 +  sum = factor[0] + factor[1] + factor[2];
   8.111 +  if(sum > 1e-30f)
   8.112 +  {
   8.113 +    sum = 1.0f / sum;
   8.114 +    for(i = 0; i < 3; ++ i)
   8.115 +      factor[i] *= sum;
   8.116 +    wantedGrids = powf(100.0f * self->mVertexCount, 1.0f / 3.0f);
   8.117 +    for(i = 0; i < 3; ++ i)
   8.118 +    {
   8.119 +      aGrid->mDivision[i] = (CTMuint) ceilf(wantedGrids * factor[i]);
   8.120 +      if(aGrid->mDivision[i] < 1)
   8.121 +        aGrid->mDivision[i] = 1;
   8.122 +    }
   8.123 +  }
   8.124 +  else
   8.125 +  {
   8.126 +    aGrid->mDivision[0] = 4;
   8.127 +    aGrid->mDivision[1] = 4;
   8.128 +    aGrid->mDivision[2] = 4;
   8.129 +  }
   8.130 +#ifdef __DEBUG_
   8.131 +  printf("Division: (%d %d %d)\n", aGrid->mDivision[0], aGrid->mDivision[1], aGrid->mDivision[2]);
   8.132 +#endif
   8.133 +
   8.134 +  // Calculate grid sizes
   8.135 +  for(i = 0; i < 3; ++ i)
   8.136 +    aGrid->mSize[i] = (aGrid->mMax[i] - aGrid->mMin[i]) / aGrid->mDivision[i];
   8.137 +}
   8.138 +
   8.139 +//-----------------------------------------------------------------------------
   8.140 +// _ctmPointToGridIdx() - Convert a point to a grid index.
   8.141 +//-----------------------------------------------------------------------------
   8.142 +static CTMuint _ctmPointToGridIdx(_CTMgrid * aGrid, CTMfloat * aPoint)
   8.143 +{
   8.144 +  CTMuint i, idx[3];
   8.145 +
   8.146 +  for(i = 0; i < 3; ++ i)
   8.147 +  {
   8.148 +    idx[i] = (CTMuint) floorf((aPoint[i] - aGrid->mMin[i]) / aGrid->mSize[i]);
   8.149 +    if(idx[i] >= aGrid->mDivision[i])
   8.150 +      idx[i] = aGrid->mDivision[i] - 1;
   8.151 +  }
   8.152 +
   8.153 +  return idx[0] + aGrid->mDivision[0] * (idx[1] + aGrid->mDivision[1] * idx[2]);
   8.154 +}
   8.155 +
   8.156 +//-----------------------------------------------------------------------------
   8.157 +// _ctmGridIdxToPoint() - Convert a grid index to a point (the min x/y/z for
   8.158 +// the given grid box).
   8.159 +//-----------------------------------------------------------------------------
   8.160 +static void _ctmGridIdxToPoint(_CTMgrid * aGrid, CTMuint aIdx, CTMfloat * aPoint)
   8.161 +{
   8.162 +  CTMuint gridIdx[3], zdiv, ydiv, i;
   8.163 +
   8.164 +  zdiv = aGrid->mDivision[0] * aGrid->mDivision[1];
   8.165 +  ydiv = aGrid->mDivision[0];
   8.166 +
   8.167 +  gridIdx[2] =  aIdx / zdiv;
   8.168 +  aIdx -= gridIdx[2] * zdiv;
   8.169 +  gridIdx[1] =  aIdx / ydiv;
   8.170 +  aIdx -= gridIdx[1] * ydiv;
   8.171 +  gridIdx[0] = aIdx;
   8.172 +
   8.173 +  for(i = 0; i < 3; ++ i)
   8.174 +    aPoint[i] = gridIdx[i] * aGrid->mSize[i] + aGrid->mMin[i];
   8.175 +}
   8.176 +
   8.177 +//-----------------------------------------------------------------------------
   8.178 +// _compareVertex() - Comparator for the vertex sorting.
   8.179 +//-----------------------------------------------------------------------------
   8.180 +static int _compareVertex(const void * elem1, const void * elem2)
   8.181 +{
   8.182 +  _CTMsortvertex * v1 = (_CTMsortvertex *) elem1;
   8.183 +  _CTMsortvertex * v2 = (_CTMsortvertex *) elem2;
   8.184 +  if(v1->mGridIndex != v2->mGridIndex)
   8.185 +    return v1->mGridIndex - v2->mGridIndex;
   8.186 +  else if(v1->x < v2->x)
   8.187 +    return -1;
   8.188 +  else if(v1->x > v2->x)
   8.189 +    return 1;
   8.190 +  else
   8.191 +    return 0;
   8.192 +}
   8.193 +
   8.194 +//-----------------------------------------------------------------------------
   8.195 +// _ctmSortVertices() - Setup the vertex array. Assign each vertex to a grid
   8.196 +// box, and sort all vertices.
   8.197 +//-----------------------------------------------------------------------------
   8.198 +static void _ctmSortVertices(_CTMcontext * self, _CTMsortvertex * aSortVertices,
   8.199 +  _CTMgrid * aGrid)
   8.200 +{
   8.201 +  CTMuint i;
   8.202 +
   8.203 +  // Prepare sort vertex array
   8.204 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.205 +  {
   8.206 +    // Store vertex properties in the sort vertex array
   8.207 +    aSortVertices[i].x = self->mVertices[i * 3];
   8.208 +    aSortVertices[i].mGridIndex = _ctmPointToGridIdx(aGrid, &self->mVertices[i * 3]);
   8.209 +    aSortVertices[i].mOriginalIndex = i;
   8.210 +  }
   8.211 +
   8.212 +  // Sort vertices. The elements are first sorted by their grid indices, and
   8.213 +  // scondly by their x coordinates.
   8.214 +  qsort((void *) aSortVertices, self->mVertexCount, sizeof(_CTMsortvertex), _compareVertex);
   8.215 +}
   8.216 +
   8.217 +//-----------------------------------------------------------------------------
   8.218 +// _ctmReIndexIndices() - Re-index all indices, based on the sorted vertices.
   8.219 +//-----------------------------------------------------------------------------
   8.220 +static int _ctmReIndexIndices(_CTMcontext * self, _CTMsortvertex * aSortVertices,
   8.221 +  CTMuint * aIndices)
   8.222 +{
   8.223 +  CTMuint i, * indexLUT;
   8.224 +
   8.225 +  // Create temporary lookup-array, O(n)
   8.226 +  indexLUT = (CTMuint *) malloc(sizeof(CTMuint) * self->mVertexCount);
   8.227 +  if(!indexLUT)
   8.228 +  {
   8.229 +    self->mError = CTM_OUT_OF_MEMORY;
   8.230 +    return CTM_FALSE;
   8.231 +  }
   8.232 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.233 +    indexLUT[aSortVertices[i].mOriginalIndex] = i;
   8.234 +
   8.235 +  // Convert old indices to new indices, O(n)
   8.236 +  for(i = 0; i < self->mTriangleCount * 3; ++ i)
   8.237 +    aIndices[i] = indexLUT[self->mIndices[i]];
   8.238 +
   8.239 +  // Free temporary lookup-array
   8.240 +  free((void *) indexLUT);
   8.241 +
   8.242 +  return CTM_TRUE;
   8.243 +}
   8.244 +
   8.245 +//-----------------------------------------------------------------------------
   8.246 +// _compareTriangle() - Comparator for the triangle sorting.
   8.247 +//-----------------------------------------------------------------------------
   8.248 +static int _compareTriangle(const void * elem1, const void * elem2)
   8.249 +{
   8.250 +  CTMuint * tri1 = (CTMuint *) elem1;
   8.251 +  CTMuint * tri2 = (CTMuint *) elem2;
   8.252 +  if(tri1[0] != tri2[0])
   8.253 +    return tri1[0] - tri2[0];
   8.254 +  else
   8.255 +    return tri1[1] - tri2[1];
   8.256 +}
   8.257 +
   8.258 +//-----------------------------------------------------------------------------
   8.259 +// _ctmReArrangeTriangles() - Re-arrange all triangles for optimal
   8.260 +// compression.
   8.261 +//-----------------------------------------------------------------------------
   8.262 +static void _ctmReArrangeTriangles(_CTMcontext * self, CTMuint * aIndices)
   8.263 +{
   8.264 +  CTMuint * tri, tmp, i;
   8.265 +
   8.266 +  // Step 1: Make sure that the first index of each triangle is the smallest
   8.267 +  // one (rotate triangle nodes if necessary)
   8.268 +  for(i = 0; i < self->mTriangleCount; ++ i)
   8.269 +  {
   8.270 +    tri = &aIndices[i * 3];
   8.271 +    if((tri[1] < tri[0]) && (tri[1] < tri[2]))
   8.272 +    {
   8.273 +      tmp = tri[0];
   8.274 +      tri[0] = tri[1];
   8.275 +      tri[1] = tri[2];
   8.276 +      tri[2] = tmp;
   8.277 +    }
   8.278 +    else if((tri[2] < tri[0]) && (tri[2] < tri[1]))
   8.279 +    {
   8.280 +      tmp = tri[0];
   8.281 +      tri[0] = tri[2];
   8.282 +      tri[2] = tri[1];
   8.283 +      tri[1] = tmp;
   8.284 +    }
   8.285 +  }
   8.286 +
   8.287 +  // Step 2: Sort the triangles based on the first triangle index
   8.288 +  qsort((void *) aIndices, self->mTriangleCount, sizeof(CTMuint) * 3, _compareTriangle);
   8.289 +}
   8.290 +
   8.291 +//-----------------------------------------------------------------------------
   8.292 +// _ctmMakeIndexDeltas() - Calculate various forms of derivatives in order to
   8.293 +// reduce data entropy.
   8.294 +//-----------------------------------------------------------------------------
   8.295 +static void _ctmMakeIndexDeltas(_CTMcontext * self, CTMuint * aIndices)
   8.296 +{
   8.297 +  CTMint i;
   8.298 +  for(i = self->mTriangleCount - 1; i >= 0; -- i)
   8.299 +  {
   8.300 +    // Step 1: Calculate delta from second triangle index to the previous
   8.301 +    // second triangle index, if the previous triangle shares the same first
   8.302 +    // index, otherwise calculate the delta to the first triangle index
   8.303 +    if((i >= 1) && (aIndices[i * 3] == aIndices[(i - 1) * 3]))
   8.304 +      aIndices[i * 3 + 1] -= aIndices[(i - 1) * 3 + 1];
   8.305 +    else
   8.306 +      aIndices[i * 3 + 1] -= aIndices[i * 3];
   8.307 +
   8.308 +    // Step 2: Calculate delta from third triangle index to the first triangle
   8.309 +    // index
   8.310 +    aIndices[i * 3 + 2] -= aIndices[i * 3];
   8.311 +
   8.312 +    // Step 3: Calculate derivative of the first triangle index
   8.313 +    if(i >= 1)
   8.314 +      aIndices[i * 3] -= aIndices[(i - 1) * 3];
   8.315 +  }
   8.316 +}
   8.317 +
   8.318 +//-----------------------------------------------------------------------------
   8.319 +// _ctmRestoreIndices() - Restore original indices (inverse derivative
   8.320 +// operation).
   8.321 +//-----------------------------------------------------------------------------
   8.322 +static void _ctmRestoreIndices(_CTMcontext * self, CTMuint * aIndices)
   8.323 +{
   8.324 +  CTMuint i;
   8.325 +
   8.326 +  for(i = 0; i < self->mTriangleCount; ++ i)
   8.327 +  {
   8.328 +    // Step 1: Reverse derivative of the first triangle index
   8.329 +    if(i >= 1)
   8.330 +      aIndices[i * 3] += aIndices[(i - 1) * 3];
   8.331 +
   8.332 +    // Step 2: Reverse delta from third triangle index to the first triangle
   8.333 +    // index
   8.334 +    aIndices[i * 3 + 2] += aIndices[i * 3];
   8.335 +
   8.336 +    // Step 3: Reverse delta from second triangle index to the previous
   8.337 +    // second triangle index, if the previous triangle shares the same first
   8.338 +    // index, otherwise reverse the delta to the first triangle index
   8.339 +    if((i >= 1) && (aIndices[i * 3] == aIndices[(i - 1) * 3]))
   8.340 +      aIndices[i * 3 + 1] += aIndices[(i - 1) * 3 + 1];
   8.341 +    else
   8.342 +      aIndices[i * 3 + 1] += aIndices[i * 3];
   8.343 +  }
   8.344 +}
   8.345 +
   8.346 +//-----------------------------------------------------------------------------
   8.347 +// _ctmMakeVertexDeltas() - Calculate various forms of derivatives in order to
   8.348 +// reduce data entropy.
   8.349 +//-----------------------------------------------------------------------------
   8.350 +static void _ctmMakeVertexDeltas(_CTMcontext * self, CTMint * aIntVertices,
   8.351 +  _CTMsortvertex * aSortVertices, _CTMgrid * aGrid)
   8.352 +{
   8.353 +  CTMuint i, gridIdx, prevGridIndex, oldIdx;
   8.354 +  CTMfloat gridOrigin[3], scale;
   8.355 +  CTMint deltaX, prevDeltaX;
   8.356 +
   8.357 +  // Vertex scaling factor
   8.358 +  scale = 1.0f / self->mVertexPrecision;
   8.359 +
   8.360 +  prevGridIndex = 0x7fffffff;
   8.361 +  prevDeltaX = 0;
   8.362 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.363 +  {
   8.364 +    // Get grid box origin
   8.365 +    gridIdx = aSortVertices[i].mGridIndex;
   8.366 +    _ctmGridIdxToPoint(aGrid, gridIdx, gridOrigin);
   8.367 +
   8.368 +    // Get old vertex coordinate index (before vertex sorting)
   8.369 +    oldIdx = aSortVertices[i].mOriginalIndex;
   8.370 +
   8.371 +    // Store delta to the grid box origin in the integer vertex array. For the
   8.372 +    // X axis (which is sorted) we also do the delta to the previous coordinate
   8.373 +    // in the box.
   8.374 +    deltaX = (CTMint) floorf(scale * (self->mVertices[oldIdx * 3] - gridOrigin[0]) + 0.5f);
   8.375 +    if(gridIdx == prevGridIndex)
   8.376 +      aIntVertices[i * 3] = deltaX - prevDeltaX;
   8.377 +    else
   8.378 +      aIntVertices[i * 3] = deltaX;
   8.379 +    aIntVertices[i * 3 + 1] = (CTMint) floorf(scale * (self->mVertices[oldIdx * 3 + 1] - gridOrigin[1]) + 0.5f);
   8.380 +    aIntVertices[i * 3 + 2] = (CTMint) floorf(scale * (self->mVertices[oldIdx * 3 + 2] - gridOrigin[2]) + 0.5f);
   8.381 +
   8.382 +    prevGridIndex = gridIdx;
   8.383 +    prevDeltaX = deltaX;
   8.384 +  }
   8.385 +}
   8.386 +
   8.387 +//-----------------------------------------------------------------------------
   8.388 +// _ctmRestoreVertices() - Calculate inverse derivatives of the vertices.
   8.389 +//-----------------------------------------------------------------------------
   8.390 +static void _ctmRestoreVertices(_CTMcontext * self, CTMint * aIntVertices,
   8.391 +  CTMuint * aGridIndices, _CTMgrid * aGrid, CTMfloat * aVertices)
   8.392 +{
   8.393 +  CTMuint i, gridIdx, prevGridIndex;
   8.394 +  CTMfloat gridOrigin[3], scale;
   8.395 +  CTMint deltaX, prevDeltaX;
   8.396 +
   8.397 +  scale = self->mVertexPrecision;
   8.398 +
   8.399 +  prevGridIndex = 0x7fffffff;
   8.400 +  prevDeltaX = 0;
   8.401 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.402 +  {
   8.403 +    // Get grid box origin
   8.404 +    gridIdx = aGridIndices[i];
   8.405 +    _ctmGridIdxToPoint(aGrid, gridIdx, gridOrigin);
   8.406 +
   8.407 +    // Restore original point
   8.408 +    deltaX = aIntVertices[i * 3];
   8.409 +    if(gridIdx == prevGridIndex)
   8.410 +      deltaX += prevDeltaX;
   8.411 +    aVertices[i * 3] = scale * deltaX + gridOrigin[0];
   8.412 +    aVertices[i * 3 + 1] = scale * aIntVertices[i * 3 + 1] + gridOrigin[1];
   8.413 +    aVertices[i * 3 + 2] = scale * aIntVertices[i * 3 + 2] + gridOrigin[2];
   8.414 +
   8.415 +    prevGridIndex = gridIdx;
   8.416 +    prevDeltaX = deltaX;
   8.417 +  }
   8.418 +}
   8.419 +
   8.420 +//-----------------------------------------------------------------------------
   8.421 +// _ctmCalcSmoothNormals() - Calculate the smooth normals for a given mesh.
   8.422 +// These are used as the nominal normals for normal deltas & reconstruction.
   8.423 +//-----------------------------------------------------------------------------
   8.424 +static void _ctmCalcSmoothNormals(_CTMcontext * self, CTMfloat * aVertices,
   8.425 +  CTMuint * aIndices, CTMfloat * aSmoothNormals)
   8.426 +{
   8.427 +  CTMuint i, j, k, tri[3];
   8.428 +  CTMfloat len;
   8.429 +  CTMfloat v1[3], v2[3], n[3];
   8.430 +
   8.431 +  // Clear smooth normals array
   8.432 +  for(i = 0; i < 3 * self->mVertexCount; ++ i)
   8.433 +    aSmoothNormals[i] = 0.0f;
   8.434 +
   8.435 +  // Calculate sums of all neigbouring triangle normals for each vertex
   8.436 +  for(i = 0; i < self->mTriangleCount; ++ i)
   8.437 +  {
   8.438 +    // Get triangle corner indices
   8.439 +    for(j = 0; j < 3; ++ j)
   8.440 +      tri[j] = aIndices[i * 3 + j];
   8.441 +
   8.442 +    // Calculate the normalized cross product of two triangle edges (i.e. the
   8.443 +    // flat triangle normal)
   8.444 +    for(j = 0; j < 3; ++ j)
   8.445 +    {
   8.446 +      v1[j] = aVertices[tri[1] * 3 + j] - aVertices[tri[0] * 3 + j];
   8.447 +      v2[j] = aVertices[tri[2] * 3 + j] - aVertices[tri[0] * 3 + j];
   8.448 +    }
   8.449 +    n[0] = v1[1] * v2[2] - v1[2] * v2[1];
   8.450 +    n[1] = v1[2] * v2[0] - v1[0] * v2[2];
   8.451 +    n[2] = v1[0] * v2[1] - v1[1] * v2[0];
   8.452 +    len = sqrtf(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
   8.453 +    if(len > 1e-10f)
   8.454 +      len = 1.0f / len;
   8.455 +    else
   8.456 +      len = 1.0f;
   8.457 +    for(j = 0; j < 3; ++ j)
   8.458 +      n[j] *= len;
   8.459 +
   8.460 +    // Add the flat normal to all three triangle vertices
   8.461 +    for(k = 0; k < 3; ++ k)
   8.462 +      for(j = 0; j < 3; ++ j)
   8.463 +        aSmoothNormals[tri[k] * 3 + j] += n[j];
   8.464 +  }
   8.465 +
   8.466 +  // Normalize the normal sums, which gives the unit length smooth normals
   8.467 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.468 +  {
   8.469 +    len = sqrtf(aSmoothNormals[i * 3] * aSmoothNormals[i * 3] + 
   8.470 +                aSmoothNormals[i * 3 + 1] * aSmoothNormals[i * 3 + 1] +
   8.471 +                aSmoothNormals[i * 3 + 2] * aSmoothNormals[i * 3 + 2]);
   8.472 +    if(len > 1e-10f)
   8.473 +      len = 1.0f / len;
   8.474 +    else
   8.475 +      len = 1.0f;
   8.476 +    for(j = 0; j < 3; ++ j)
   8.477 +      aSmoothNormals[i * 3 + j] *= len;
   8.478 +  }
   8.479 +}
   8.480 +
   8.481 +//-----------------------------------------------------------------------------
   8.482 +// _ctmMakeNormalCoordSys() - Create an ortho-normalized coordinate system
   8.483 +// where the Z-axis is aligned with the given normal.
   8.484 +// Note 1: This function is central to how the compressed normal data is
   8.485 +//  interpreted, and it can not be changed (mathematically) without making the
   8.486 +//  coder/decoder incompatible with other versions of the library!
   8.487 +// Note 2: Since we do this for every single normal, this routine needs to be
   8.488 +//  fast. The current implementation uses: 12 MUL, 1 DIV, 1 SQRT, ~6 ADD.
   8.489 +//-----------------------------------------------------------------------------
   8.490 +static void _ctmMakeNormalCoordSys(CTMfloat * aNormal, CTMfloat * aBasisAxes)
   8.491 +{
   8.492 +  CTMfloat len, * x, * y, * z;
   8.493 +  CTMuint i;
   8.494 +
   8.495 +  // Pointers to the basis axes (aBasisAxes is a 3x3 matrix)
   8.496 +  x = aBasisAxes;
   8.497 +  y = &aBasisAxes[3];
   8.498 +  z = &aBasisAxes[6];
   8.499 +
   8.500 +  // Z = normal (must be unit length!)
   8.501 +  for(i = 0; i < 3; ++ i)
   8.502 +    z[i] = aNormal[i];
   8.503 +
   8.504 +  // Calculate a vector that is guaranteed to be orthogonal to the normal, non-
   8.505 +  // zero, and a continuous function of the normal (no discrete jumps):
   8.506 +  // X = (0,0,1) x normal + (1,0,0) x normal
   8.507 +  x[0] =  -aNormal[1];
   8.508 +  x[1] =  aNormal[0] - aNormal[2];
   8.509 +  x[2] =  aNormal[1];
   8.510 +
   8.511 +  // Normalize the new X axis (note: |x[2]| = |x[0]|)
   8.512 +  len = sqrtf(2.0 * x[0] * x[0] + x[1] * x[1]);
   8.513 +  if(len > 1.0e-20f)
   8.514 +  {
   8.515 +    len = 1.0f / len;
   8.516 +    x[0] *= len;
   8.517 +    x[1] *= len;
   8.518 +    x[2] *= len;
   8.519 +  }
   8.520 +
   8.521 +  // Let Y = Z x X  (no normalization needed, since |Z| = |X| = 1)
   8.522 +  y[0] = z[1] * x[2] - z[2] * x[1];
   8.523 +  y[1] = z[2] * x[0] - z[0] * x[2];
   8.524 +  y[2] = z[0] * x[1] - z[1] * x[0];
   8.525 +}
   8.526 +
   8.527 +//-----------------------------------------------------------------------------
   8.528 +// _ctmMakeNormalDeltas() - Convert the normals to a new coordinate system:
   8.529 +// magnitude, phi, theta (relative to predicted smooth normals).
   8.530 +//-----------------------------------------------------------------------------
   8.531 +static CTMint _ctmMakeNormalDeltas(_CTMcontext * self, CTMint * aIntNormals,
   8.532 +  CTMfloat * aVertices, CTMuint * aIndices, _CTMsortvertex * aSortVertices)
   8.533 +{
   8.534 +  CTMuint i, j, oldIdx, intPhi;
   8.535 +  CTMfloat magn, phi, theta, scale, thetaScale;
   8.536 +  CTMfloat * smoothNormals, n[3], n2[3], basisAxes[9];
   8.537 +
   8.538 +  // Allocate temporary memory for the nominal vertex normals
   8.539 +  smoothNormals = (CTMfloat *) malloc(3 * sizeof(CTMfloat) * self->mVertexCount);
   8.540 +  if(!smoothNormals)
   8.541 +  {
   8.542 +    self->mError = CTM_OUT_OF_MEMORY;
   8.543 +    return CTM_FALSE;
   8.544 +  }
   8.545 +
   8.546 +  // Calculate smooth normals (Note: aVertices and aIndices use the sorted
   8.547 +  // index space, so smoothNormals will too)
   8.548 +  _ctmCalcSmoothNormals(self, aVertices, aIndices, smoothNormals);
   8.549 +
   8.550 +  // Normal scaling factor
   8.551 +  scale = 1.0f / self->mNormalPrecision;
   8.552 +
   8.553 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.554 +  {
   8.555 +    // Get old normal index (before vertex sorting)
   8.556 +    oldIdx = aSortVertices[i].mOriginalIndex;
   8.557 +
   8.558 +    // Calculate normal magnitude (should always be 1.0 for unit length normals)
   8.559 +    magn = sqrtf(self->mNormals[oldIdx * 3] * self->mNormals[oldIdx * 3] +
   8.560 +                 self->mNormals[oldIdx * 3 + 1] * self->mNormals[oldIdx * 3 + 1] +
   8.561 +                 self->mNormals[oldIdx * 3 + 2] * self->mNormals[oldIdx * 3 + 2]);
   8.562 +    if(magn < 1e-10f)
   8.563 +      magn = 1.0f;
   8.564 +
   8.565 +    // Invert magnitude if the normal is negative compared to the predicted
   8.566 +    // smooth normal
   8.567 +    if((smoothNormals[i * 3] * self->mNormals[oldIdx * 3] +
   8.568 +        smoothNormals[i * 3 + 1] * self->mNormals[oldIdx * 3 + 1] +
   8.569 +        smoothNormals[i * 3 + 2] * self->mNormals[oldIdx * 3 + 2]) < 0.0f)
   8.570 +      magn = -magn;
   8.571 +
   8.572 +    // Store the magnitude in the first element of the three normal elements
   8.573 +    aIntNormals[i * 3] = (CTMint) floorf(scale * magn + 0.5f);
   8.574 +
   8.575 +    // Normalize the normal (1 / magn) - and flip it if magn < 0
   8.576 +    magn = 1.0f / magn;
   8.577 +    for(j = 0; j < 3; ++ j)
   8.578 +      n[j] = self->mNormals[oldIdx * 3 + j] * magn;
   8.579 +
   8.580 +    // Convert the normal to angular representation (phi, theta) in a coordinate
   8.581 +    // system where the nominal (smooth) normal is the Z-axis
   8.582 +    _ctmMakeNormalCoordSys(&smoothNormals[i * 3], basisAxes);
   8.583 +    for(j = 0; j < 3; ++ j)
   8.584 +      n2[j] = basisAxes[j * 3] * n[0] +
   8.585 +              basisAxes[j * 3 + 1] * n[1] +
   8.586 +              basisAxes[j * 3 + 2] * n[2];
   8.587 +    if(n2[2] >= 1.0f)
   8.588 +      phi = 0.0f;
   8.589 +    else
   8.590 +      phi = acosf(n2[2]);
   8.591 +    theta = atan2f(n2[1], n2[0]);
   8.592 +
   8.593 +    // Round phi and theta (spherical coordinates) to integers. Note: We let the
   8.594 +    // theta resolution vary with the x/y circumference (roughly phi).
   8.595 +    intPhi = (CTMint) floorf(phi * (scale / (0.5f * PI)) + 0.5f);
   8.596 +    if(intPhi == 0)
   8.597 +      thetaScale = 0.0f;
   8.598 +    else if(intPhi <= 4)
   8.599 +      thetaScale = 2.0f / PI;
   8.600 +    else
   8.601 +      thetaScale = ((CTMfloat) intPhi) / (2.0f * PI);
   8.602 +    aIntNormals[i * 3 + 1] = intPhi;
   8.603 +    aIntNormals[i * 3 + 2] = (CTMint) floorf((theta + PI) * thetaScale + 0.5f);
   8.604 +  }
   8.605 +
   8.606 +  // Free temporary resources
   8.607 +  free(smoothNormals);
   8.608 +
   8.609 +  return CTM_TRUE;
   8.610 +}
   8.611 +
   8.612 +//-----------------------------------------------------------------------------
   8.613 +// _ctmRestoreNormals() - Convert the normals back to cartesian coordinates.
   8.614 +//-----------------------------------------------------------------------------
   8.615 +static CTMint _ctmRestoreNormals(_CTMcontext * self, CTMint * aIntNormals)
   8.616 +{
   8.617 +  CTMuint i, j, intPhi;
   8.618 +  CTMfloat magn, phi, theta, scale, thetaScale;
   8.619 +  CTMfloat * smoothNormals, n[3], n2[3], basisAxes[9];
   8.620 +
   8.621 +  // Allocate temporary memory for the nominal vertex normals
   8.622 +  smoothNormals = (CTMfloat *) malloc(3 * sizeof(CTMfloat) * self->mVertexCount);
   8.623 +  if(!smoothNormals)
   8.624 +  {
   8.625 +    self->mError = CTM_OUT_OF_MEMORY;
   8.626 +    return CTM_FALSE;
   8.627 +  }
   8.628 +
   8.629 +  // Calculate smooth normals (nominal normals)
   8.630 +  _ctmCalcSmoothNormals(self, self->mVertices, self->mIndices, smoothNormals);
   8.631 +
   8.632 +  // Normal scaling factor
   8.633 +  scale = self->mNormalPrecision;
   8.634 +
   8.635 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.636 +  {
   8.637 +    // Get the normal magnitude from the first of the three normal elements
   8.638 +    magn = aIntNormals[i * 3] * scale;
   8.639 +
   8.640 +    // Get phi and theta (spherical coordinates, relative to the smooth normal).
   8.641 +    intPhi = aIntNormals[i * 3 + 1];
   8.642 +    phi = intPhi * (0.5f * PI) * scale;
   8.643 +    if(intPhi == 0)
   8.644 +      thetaScale = 0.0f;
   8.645 +    else if(intPhi <= 4)
   8.646 +      thetaScale = PI / 2.0f;
   8.647 +    else
   8.648 +      thetaScale = (2.0f * PI) / ((CTMfloat) intPhi);
   8.649 +    theta = aIntNormals[i * 3 + 2] * thetaScale - PI;
   8.650 +
   8.651 +    // Convert the normal from the angular representation (phi, theta) back to
   8.652 +    // cartesian coordinates
   8.653 +    n2[0] = sinf(phi) * cosf(theta);
   8.654 +    n2[1] = sinf(phi) * sinf(theta);
   8.655 +    n2[2] = cosf(phi);
   8.656 +    _ctmMakeNormalCoordSys(&smoothNormals[i * 3], basisAxes);
   8.657 +    for(j = 0; j < 3; ++ j)
   8.658 +      n[j] = basisAxes[j] * n2[0] +
   8.659 +             basisAxes[3 + j] * n2[1] +
   8.660 +             basisAxes[6 + j] * n2[2];
   8.661 +
   8.662 +    // Apply normal magnitude, and output to the normals array
   8.663 +    for(j = 0; j < 3; ++ j)
   8.664 +      self->mNormals[i * 3 + j] = n[j] * magn;
   8.665 +  }
   8.666 +
   8.667 +  // Free temporary resources
   8.668 +  free(smoothNormals);
   8.669 +
   8.670 +  return CTM_TRUE;
   8.671 +}
   8.672 +
   8.673 +//-----------------------------------------------------------------------------
   8.674 +// _ctmMakeUVCoordDeltas() - Calculate various forms of derivatives in order
   8.675 +// to reduce data entropy.
   8.676 +//-----------------------------------------------------------------------------
   8.677 +static void _ctmMakeUVCoordDeltas(_CTMcontext * self, _CTMfloatmap * aMap,
   8.678 +  CTMint * aIntUVCoords, _CTMsortvertex * aSortVertices)
   8.679 +{
   8.680 +  CTMuint i, oldIdx;
   8.681 +  CTMint u, v, prevU, prevV;
   8.682 +  CTMfloat scale;
   8.683 +
   8.684 +  // UV coordinate scaling factor
   8.685 +  scale = 1.0f / aMap->mPrecision;
   8.686 +
   8.687 +  prevU = prevV = 0;
   8.688 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.689 +  {
   8.690 +    // Get old UV coordinate index (before vertex sorting)
   8.691 +    oldIdx = aSortVertices[i].mOriginalIndex;
   8.692 +
   8.693 +    // Convert to fixed point
   8.694 +    u = (CTMint) floorf(scale * aMap->mValues[oldIdx * 2] + 0.5f);
   8.695 +    v = (CTMint) floorf(scale * aMap->mValues[oldIdx * 2 + 1] + 0.5f);
   8.696 +
   8.697 +    // Calculate delta and store it in the converted array. NOTE: Here we rely
   8.698 +    // on the fact that vertices are sorted, and usually close to each other,
   8.699 +    // which means that UV coordinates should also be close to each other...
   8.700 +    aIntUVCoords[i * 2] = u - prevU;
   8.701 +    aIntUVCoords[i * 2 + 1] = v - prevV;
   8.702 +
   8.703 +    prevU = u;
   8.704 +    prevV = v;
   8.705 +  }
   8.706 +}
   8.707 +
   8.708 +//-----------------------------------------------------------------------------
   8.709 +// _ctmRestoreUVCoords() - Calculate inverse derivatives of the UV
   8.710 +// coordinates.
   8.711 +//-----------------------------------------------------------------------------
   8.712 +static void _ctmRestoreUVCoords(_CTMcontext * self, _CTMfloatmap * aMap,
   8.713 +  CTMint * aIntUVCoords)
   8.714 +{
   8.715 +  CTMuint i;
   8.716 +  CTMint u, v, prevU, prevV;
   8.717 +  CTMfloat scale;
   8.718 +
   8.719 +  // UV coordinate scaling factor
   8.720 +  scale = aMap->mPrecision;
   8.721 +
   8.722 +  prevU = prevV = 0;
   8.723 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.724 +  {
   8.725 +    // Calculate inverse delta
   8.726 +    u = aIntUVCoords[i * 2] + prevU;
   8.727 +    v = aIntUVCoords[i * 2 + 1] + prevV;
   8.728 +
   8.729 +    // Convert to floating point
   8.730 +    aMap->mValues[i * 2] = (CTMfloat) u * scale;
   8.731 +    aMap->mValues[i * 2 + 1] = (CTMfloat) v * scale;
   8.732 +
   8.733 +    prevU = u;
   8.734 +    prevV = v;
   8.735 +  }
   8.736 +}
   8.737 +
   8.738 +//-----------------------------------------------------------------------------
   8.739 +// _ctmMakeAttribDeltas() - Calculate various forms of derivatives in order
   8.740 +// to reduce data entropy.
   8.741 +//-----------------------------------------------------------------------------
   8.742 +static void _ctmMakeAttribDeltas(_CTMcontext * self, _CTMfloatmap * aMap,
   8.743 +  CTMint * aIntAttribs, _CTMsortvertex * aSortVertices)
   8.744 +{
   8.745 +  CTMuint i, j, oldIdx;
   8.746 +  CTMint value[4], prev[4];
   8.747 +  CTMfloat scale;
   8.748 +
   8.749 +  // Attribute scaling factor
   8.750 +  scale = 1.0f / aMap->mPrecision;
   8.751 +
   8.752 +  for(j = 0; j < 4; ++ j)
   8.753 +    prev[j] = 0;
   8.754 +
   8.755 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.756 +  {
   8.757 +    // Get old attribute index (before vertex sorting)
   8.758 +    oldIdx = aSortVertices[i].mOriginalIndex;
   8.759 +
   8.760 +    // Convert to fixed point, and calculate delta and store it in the converted
   8.761 +    // array. NOTE: Here we rely on the fact that vertices are sorted, and
   8.762 +    // usually close to each other, which means that attributes should also
   8.763 +    // be close to each other (and we assume that they somehow vary slowly with
   8.764 +    // the geometry)...
   8.765 +    for(j = 0; j < 4; ++ j)
   8.766 +    {
   8.767 +      value[j] = (CTMint) floorf(scale * aMap->mValues[oldIdx * 4 + j] + 0.5f);
   8.768 +      aIntAttribs[i * 4 + j] = value[j] - prev[j];
   8.769 +      prev[j] = value[j];
   8.770 +    }
   8.771 +  }
   8.772 +}
   8.773 +
   8.774 +//-----------------------------------------------------------------------------
   8.775 +// _ctmRestoreAttribs() - Calculate inverse derivatives of the vertex
   8.776 +// attributes.
   8.777 +//-----------------------------------------------------------------------------
   8.778 +static void _ctmRestoreAttribs(_CTMcontext * self, _CTMfloatmap * aMap,
   8.779 +  CTMint * aIntAttribs)
   8.780 +{
   8.781 +  CTMuint i, j;
   8.782 +  CTMint value[4], prev[4];
   8.783 +  CTMfloat scale;
   8.784 +
   8.785 +  // Attribute scaling factor
   8.786 +  scale = aMap->mPrecision;
   8.787 +
   8.788 +  for(j = 0; j < 4; ++ j)
   8.789 +    prev[j] = 0;
   8.790 +
   8.791 +  for(i = 0; i < self->mVertexCount; ++ i)
   8.792 +  {
   8.793 +    // Calculate inverse delta, and convert to floating point
   8.794 +    for(j = 0; j < 4; ++ j)
   8.795 +    {
   8.796 +      value[j] = aIntAttribs[i * 4 + j] + prev[j];
   8.797 +      aMap->mValues[i * 4 + j] = (CTMfloat) value[j] * scale;
   8.798 +      prev[j] = value[j];
   8.799 +    }
   8.800 +  }
   8.801 +}
   8.802 +
   8.803 +//-----------------------------------------------------------------------------
   8.804 +// _ctmCompressMesh_MG2() - Compress the mesh that is stored in the CTM
   8.805 +// context, and write it the the output stream in the CTM context.
   8.806 +//-----------------------------------------------------------------------------
   8.807 +int _ctmCompressMesh_MG2(_CTMcontext * self)
   8.808 +{
   8.809 +  _CTMgrid grid;
   8.810 +  _CTMsortvertex * sortVertices;
   8.811 +  _CTMfloatmap * map;
   8.812 +  CTMuint * indices, * deltaIndices, * gridIndices;
   8.813 +  CTMint * intVertices, * intNormals, * intUVCoords, * intAttribs;
   8.814 +  CTMfloat * restoredVertices;
   8.815 +  CTMuint i;
   8.816 +
   8.817 +#ifdef __DEBUG_
   8.818 +  printf("COMPRESSION METHOD: MG2\n");
   8.819 +#endif
   8.820 +
   8.821 +  // Setup 3D space subdivision grid
   8.822 +  _ctmSetupGrid(self, &grid);
   8.823 +
   8.824 +  // Write MG2-specific header information to the stream
   8.825 +  _ctmStreamWrite(self, (void *) "MG2H", 4);
   8.826 +  _ctmStreamWriteFLOAT(self, self->mVertexPrecision);
   8.827 +  _ctmStreamWriteFLOAT(self, self->mNormalPrecision);
   8.828 +  _ctmStreamWriteFLOAT(self, grid.mMin[0]);
   8.829 +  _ctmStreamWriteFLOAT(self, grid.mMin[1]);
   8.830 +  _ctmStreamWriteFLOAT(self, grid.mMin[2]);
   8.831 +  _ctmStreamWriteFLOAT(self, grid.mMax[0]);
   8.832 +  _ctmStreamWriteFLOAT(self, grid.mMax[1]);
   8.833 +  _ctmStreamWriteFLOAT(self, grid.mMax[2]);
   8.834 +  _ctmStreamWriteUINT(self, grid.mDivision[0]);
   8.835 +  _ctmStreamWriteUINT(self, grid.mDivision[1]);
   8.836 +  _ctmStreamWriteUINT(self, grid.mDivision[2]);
   8.837 +
   8.838 +  // Prepare (sort) vertices
   8.839 +  sortVertices = (_CTMsortvertex *) malloc(sizeof(_CTMsortvertex) * self->mVertexCount);
   8.840 +  if(!sortVertices)
   8.841 +  {
   8.842 +    self->mError = CTM_OUT_OF_MEMORY;
   8.843 +    return CTM_FALSE;
   8.844 +  }
   8.845 +  _ctmSortVertices(self, sortVertices, &grid);
   8.846 +
   8.847 +  // Convert vertices to integers and calculate vertex deltas (entropy-reduction)
   8.848 +  intVertices = (CTMint *) malloc(sizeof(CTMint) * 3 * self->mVertexCount);
   8.849 +  if(!intVertices)
   8.850 +  {
   8.851 +    self->mError = CTM_OUT_OF_MEMORY;
   8.852 +    free((void *) sortVertices);
   8.853 +    return CTM_FALSE;
   8.854 +  }
   8.855 +  _ctmMakeVertexDeltas(self, intVertices, sortVertices, &grid);
   8.856 +
   8.857 +  // Write vertices
   8.858 +#ifdef __DEBUG_
   8.859 +  printf("Vertices: ");
   8.860 +#endif
   8.861 +  _ctmStreamWrite(self, (void *) "VERT", 4);
   8.862 +  if(!_ctmStreamWritePackedInts(self, intVertices, self->mVertexCount, 3, CTM_FALSE))
   8.863 +  {
   8.864 +    free((void *) intVertices);
   8.865 +    free((void *) sortVertices);
   8.866 +    return CTM_FALSE;
   8.867 +  }
   8.868 +
   8.869 +  // Prepare grid indices (deltas)
   8.870 +  gridIndices = (CTMuint *) malloc(sizeof(CTMuint) * self->mVertexCount);
   8.871 +  if(!gridIndices)
   8.872 +  {
   8.873 +    self->mError = CTM_OUT_OF_MEMORY;
   8.874 +    free((void *) intVertices);
   8.875 +    free((void *) sortVertices);
   8.876 +    return CTM_FALSE;
   8.877 +  }
   8.878 +  gridIndices[0] = sortVertices[0].mGridIndex;
   8.879 +  for(i = 1; i < self->mVertexCount; ++ i)
   8.880 +    gridIndices[i] = sortVertices[i].mGridIndex - sortVertices[i - 1].mGridIndex;
   8.881 +  
   8.882 +  // Write grid indices
   8.883 +#ifdef __DEBUG_
   8.884 +  printf("Grid indices: ");
   8.885 +#endif
   8.886 +  _ctmStreamWrite(self, (void *) "GIDX", 4);
   8.887 +  if(!_ctmStreamWritePackedInts(self, (CTMint *) gridIndices, self->mVertexCount, 1, CTM_FALSE))
   8.888 +  {
   8.889 +    free((void *) gridIndices);
   8.890 +    free((void *) intVertices);
   8.891 +    free((void *) sortVertices);
   8.892 +    return CTM_FALSE;
   8.893 +  }
   8.894 +
   8.895 +  // Calculate the result of the compressed -> decompressed vertices, in order
   8.896 +  // to use the same vertex data for calculating nominal normals as the
   8.897 +  // decompression routine (i.e. compensate for the vertex error when
   8.898 +  // calculating the normals)
   8.899 +  restoredVertices = (CTMfloat *) malloc(sizeof(CTMfloat) * 3 * self->mVertexCount);
   8.900 +  if(!restoredVertices)
   8.901 +  {
   8.902 +    self->mError = CTM_OUT_OF_MEMORY;
   8.903 +    free((void *) gridIndices);
   8.904 +    free((void *) intVertices);
   8.905 +    free((void *) sortVertices);
   8.906 +    return CTM_FALSE;
   8.907 +  }
   8.908 +  for(i = 1; i < self->mVertexCount; ++ i)
   8.909 +    gridIndices[i] += gridIndices[i - 1];
   8.910 +  _ctmRestoreVertices(self, intVertices, gridIndices, &grid, restoredVertices);
   8.911 +
   8.912 +  // Free temporary resources
   8.913 +  free((void *) gridIndices);
   8.914 +  free((void *) intVertices);
   8.915 +
   8.916 +  // Perpare (sort) indices
   8.917 +  indices = (CTMuint *) malloc(sizeof(CTMuint) * self->mTriangleCount * 3);
   8.918 +  if(!indices)
   8.919 +  {
   8.920 +    self->mError = CTM_OUT_OF_MEMORY;
   8.921 +    free((void *) restoredVertices);
   8.922 +    free((void *) sortVertices);
   8.923 +    return CTM_FALSE;
   8.924 +  }
   8.925 +  if(!_ctmReIndexIndices(self, sortVertices, indices))
   8.926 +  {
   8.927 +    free((void *) indices);
   8.928 +    free((void *) restoredVertices);
   8.929 +    free((void *) sortVertices);
   8.930 +    return CTM_FALSE;
   8.931 +  }
   8.932 +  _ctmReArrangeTriangles(self, indices);
   8.933 +
   8.934 +  // Calculate index deltas (entropy-reduction)
   8.935 +  deltaIndices = (CTMuint *) malloc(sizeof(CTMuint) * self->mTriangleCount * 3);
   8.936 +  if(!indices)
   8.937 +  {
   8.938 +    self->mError = CTM_OUT_OF_MEMORY;
   8.939 +    free((void *) indices);
   8.940 +    free((void *) restoredVertices);
   8.941 +    free((void *) sortVertices);
   8.942 +    return CTM_FALSE;
   8.943 +  }
   8.944 +  for(i = 0; i < self->mTriangleCount * 3; ++ i)
   8.945 +    deltaIndices[i] = indices[i];
   8.946 +  _ctmMakeIndexDeltas(self, deltaIndices);
   8.947 +
   8.948 +  // Write triangle indices
   8.949 +#ifdef __DEBUG_
   8.950 +  printf("Indices: ");
   8.951 +#endif
   8.952 +  _ctmStreamWrite(self, (void *) "INDX", 4);
   8.953 +  if(!_ctmStreamWritePackedInts(self, (CTMint *) deltaIndices, self->mTriangleCount, 3, CTM_FALSE))
   8.954 +  {
   8.955 +    free((void *) deltaIndices);
   8.956 +    free((void *) indices);
   8.957 +    free((void *) restoredVertices);
   8.958 +    free((void *) sortVertices);
   8.959 +    return CTM_FALSE;
   8.960 +  }
   8.961 +
   8.962 +  // Free temporary data for the indices
   8.963 +  free((void *) deltaIndices);
   8.964 +
   8.965 +  if(self->mNormals)
   8.966 +  {
   8.967 +    // Convert normals to integers and calculate deltas (entropy-reduction)
   8.968 +    intNormals = (CTMint *) malloc(sizeof(CTMint) * 3 * self->mVertexCount);
   8.969 +    if(!intNormals)
   8.970 +    {
   8.971 +      self->mError = CTM_OUT_OF_MEMORY;
   8.972 +      free((void *) indices);
   8.973 +      free((void *) restoredVertices);
   8.974 +      free((void *) sortVertices);
   8.975 +      return CTM_FALSE;
   8.976 +    }
   8.977 +    if(!_ctmMakeNormalDeltas(self, intNormals, restoredVertices, indices, sortVertices))
   8.978 +    {
   8.979 +      free((void *) indices);
   8.980 +      free((void *) intNormals);
   8.981 +      free((void *) restoredVertices);
   8.982 +      free((void *) sortVertices);
   8.983 +      return CTM_FALSE;
   8.984 +    }
   8.985 +
   8.986 +    // Write normals
   8.987 +#ifdef __DEBUG_
   8.988 +    printf("Normals: ");
   8.989 +#endif
   8.990 +    _ctmStreamWrite(self, (void *) "NORM", 4);
   8.991 +    if(!_ctmStreamWritePackedInts(self, intNormals, self->mVertexCount, 3, CTM_FALSE))
   8.992 +    {
   8.993 +      free((void *) indices);
   8.994 +      free((void *) intNormals);
   8.995 +      free((void *) restoredVertices);
   8.996 +      free((void *) sortVertices);
   8.997 +      return CTM_FALSE;
   8.998 +    }
   8.999 +
  8.1000 +    // Free temporary normal data
  8.1001 +    free((void *) intNormals);
  8.1002 +  }
  8.1003 +
  8.1004 +  // Free restored indices and vertices
  8.1005 +  free((void *) indices);
  8.1006 +  free((void *) restoredVertices);
  8.1007 +
  8.1008 +  // Write UV maps
  8.1009 +  map = self->mUVMaps;
  8.1010 +  while(map)
  8.1011 +  {
  8.1012 +    // Convert UV coordinates to integers and calculate deltas (entropy-reduction)
  8.1013 +    intUVCoords = (CTMint *) malloc(sizeof(CTMint) * 2 * self->mVertexCount);
  8.1014 +    if(!intUVCoords)
  8.1015 +    {
  8.1016 +      self->mError = CTM_OUT_OF_MEMORY;
  8.1017 +      free((void *) sortVertices);
  8.1018 +      return CTM_FALSE;
  8.1019 +    }
  8.1020 +    _ctmMakeUVCoordDeltas(self, map, intUVCoords, sortVertices);
  8.1021 +
  8.1022 +    // Write UV coordinates
  8.1023 +#ifdef __DEBUG_
  8.1024 +    printf("Texture coordinates (%s): ", map->mName ? map->mName : "no name");
  8.1025 +#endif
  8.1026 +    _ctmStreamWrite(self, (void *) "TEXC", 4);
  8.1027 +    _ctmStreamWriteSTRING(self, map->mName);
  8.1028 +    _ctmStreamWriteSTRING(self, map->mFileName);
  8.1029 +    _ctmStreamWriteFLOAT(self, map->mPrecision);
  8.1030 +    if(!_ctmStreamWritePackedInts(self, intUVCoords, self->mVertexCount, 2, CTM_TRUE))
  8.1031 +    {
  8.1032 +      free((void *) intUVCoords);
  8.1033 +      free((void *) sortVertices);
  8.1034 +      return CTM_FALSE;
  8.1035 +    }
  8.1036 +
  8.1037 +    // Free temporary UV coordinate data
  8.1038 +    free((void *) intUVCoords);
  8.1039 +
  8.1040 +    map = map->mNext;
  8.1041 +  }
  8.1042 +
  8.1043 +  // Write vertex attribute maps
  8.1044 +  map = self->mAttribMaps;
  8.1045 +  while(map)
  8.1046 +  {
  8.1047 +    // Convert vertex attributes to integers and calculate deltas (entropy-reduction)
  8.1048 +    intAttribs = (CTMint *) malloc(sizeof(CTMint) * 4 * self->mVertexCount);
  8.1049 +    if(!intAttribs)
  8.1050 +    {
  8.1051 +      self->mError = CTM_OUT_OF_MEMORY;
  8.1052 +      free((void *) sortVertices);
  8.1053 +      return CTM_FALSE;
  8.1054 +    }
  8.1055 +    _ctmMakeAttribDeltas(self, map, intAttribs, sortVertices);
  8.1056 +
  8.1057 +    // Write vertex attributes
  8.1058 +#ifdef __DEBUG_
  8.1059 +    printf("Vertex attributes (%s): ", map->mName ? map->mName : "no name");
  8.1060 +#endif
  8.1061 +    _ctmStreamWrite(self, (void *) "ATTR", 4);
  8.1062 +    _ctmStreamWriteSTRING(self, map->mName);
  8.1063 +    _ctmStreamWriteFLOAT(self, map->mPrecision);
  8.1064 +    if(!_ctmStreamWritePackedInts(self, intAttribs, self->mVertexCount, 4, CTM_TRUE))
  8.1065 +    {
  8.1066 +      free((void *) intAttribs);
  8.1067 +      free((void *) sortVertices);
  8.1068 +      return CTM_FALSE;
  8.1069 +    }
  8.1070 +
  8.1071 +    // Free temporary vertex attribute data
  8.1072 +    free((void *) intAttribs);
  8.1073 +
  8.1074 +    map = map->mNext;
  8.1075 +  }
  8.1076 +
  8.1077 +  // Free temporary data
  8.1078 +  free((void *) sortVertices);
  8.1079 +
  8.1080 +  return CTM_TRUE;
  8.1081 +}
  8.1082 +
  8.1083 +//-----------------------------------------------------------------------------
  8.1084 +// _ctmUncompressMesh_MG2() - Uncmpress the mesh from the input stream in the
  8.1085 +// CTM context, and store the resulting mesh in the CTM context.
  8.1086 +//-----------------------------------------------------------------------------
  8.1087 +int _ctmUncompressMesh_MG2(_CTMcontext * self)
  8.1088 +{
  8.1089 +  CTMuint * gridIndices, i;
  8.1090 +  CTMint * intVertices, * intNormals, * intUVCoords, * intAttribs;
  8.1091 +  _CTMfloatmap * map;
  8.1092 +  _CTMgrid grid;
  8.1093 +
  8.1094 +  // Read MG2-specific header information from the stream
  8.1095 +  if(_ctmStreamReadUINT(self) != FOURCC("MG2H"))
  8.1096 +  {
  8.1097 +    self->mError = CTM_BAD_FORMAT;
  8.1098 +    return CTM_FALSE;
  8.1099 +  }
  8.1100 +  self->mVertexPrecision = _ctmStreamReadFLOAT(self);
  8.1101 +  if(self->mVertexPrecision <= 0.0f)
  8.1102 +  {
  8.1103 +    self->mError = CTM_BAD_FORMAT;
  8.1104 +    return CTM_FALSE;
  8.1105 +  }
  8.1106 +  self->mNormalPrecision = _ctmStreamReadFLOAT(self);
  8.1107 +  if(self->mNormalPrecision <= 0.0f)
  8.1108 +  {
  8.1109 +    self->mError = CTM_BAD_FORMAT;
  8.1110 +    return CTM_FALSE;
  8.1111 +  }
  8.1112 +  grid.mMin[0] = _ctmStreamReadFLOAT(self);
  8.1113 +  grid.mMin[1] = _ctmStreamReadFLOAT(self);
  8.1114 +  grid.mMin[2] = _ctmStreamReadFLOAT(self);
  8.1115 +  grid.mMax[0] = _ctmStreamReadFLOAT(self);
  8.1116 +  grid.mMax[1] = _ctmStreamReadFLOAT(self);
  8.1117 +  grid.mMax[2] = _ctmStreamReadFLOAT(self);
  8.1118 +  if((grid.mMax[0] < grid.mMin[0]) ||
  8.1119 +     (grid.mMax[1] < grid.mMin[1]) ||
  8.1120 +     (grid.mMax[2] < grid.mMin[2]))
  8.1121 +  {
  8.1122 +    self->mError = CTM_BAD_FORMAT;
  8.1123 +    return CTM_FALSE;
  8.1124 +  }
  8.1125 +  grid.mDivision[0] = _ctmStreamReadUINT(self);
  8.1126 +  grid.mDivision[1] = _ctmStreamReadUINT(self);
  8.1127 +  grid.mDivision[2] = _ctmStreamReadUINT(self);
  8.1128 +  if((grid.mDivision[0] < 1) || (grid.mDivision[1] < 1) || (grid.mDivision[2] < 1))
  8.1129 +  {
  8.1130 +    self->mError = CTM_BAD_FORMAT;
  8.1131 +    return CTM_FALSE;
  8.1132 +  }
  8.1133 +
  8.1134 +  // Initialize 3D space subdivision grid
  8.1135 +  for(i = 0; i < 3; ++ i)
  8.1136 +    grid.mSize[i] = (grid.mMax[i] - grid.mMin[i]) / grid.mDivision[i];
  8.1137 +
  8.1138 +  // Read vertices
  8.1139 +  if(_ctmStreamReadUINT(self) != FOURCC("VERT"))
  8.1140 +  {
  8.1141 +    self->mError = CTM_BAD_FORMAT;
  8.1142 +    return CTM_FALSE;
  8.1143 +  }
  8.1144 +  intVertices = (CTMint *) malloc(sizeof(CTMint) * self->mVertexCount * 3);
  8.1145 +  if(!intVertices)
  8.1146 +  {
  8.1147 +    self->mError = CTM_OUT_OF_MEMORY;
  8.1148 +    return CTM_FALSE;
  8.1149 +  }
  8.1150 +  if(!_ctmStreamReadPackedInts(self, intVertices, self->mVertexCount, 3, CTM_FALSE))
  8.1151 +  {
  8.1152 +    free((void *) intVertices);
  8.1153 +    return CTM_FALSE;
  8.1154 +  }
  8.1155 +
  8.1156 +  // Read grid indices
  8.1157 +  if(_ctmStreamReadUINT(self) != FOURCC("GIDX"))
  8.1158 +  {
  8.1159 +    free((void *) intVertices);
  8.1160 +    self->mError = CTM_BAD_FORMAT;
  8.1161 +    return CTM_FALSE;
  8.1162 +  }
  8.1163 +  gridIndices = (CTMuint *) malloc(sizeof(CTMuint) * self->mVertexCount);
  8.1164 +  if(!gridIndices)
  8.1165 +  {
  8.1166 +    self->mError = CTM_OUT_OF_MEMORY;
  8.1167 +    free((void *) intVertices);
  8.1168 +    return CTM_FALSE;
  8.1169 +  }
  8.1170 +  if(!_ctmStreamReadPackedInts(self, (CTMint *) gridIndices, self->mVertexCount, 1, CTM_FALSE))
  8.1171 +  {
  8.1172 +    free((void *) gridIndices);
  8.1173 +    free((void *) intVertices);
  8.1174 +    return CTM_FALSE;
  8.1175 +  }
  8.1176 +
  8.1177 +  // Restore grid indices (deltas)
  8.1178 +  for(i = 1; i < self->mVertexCount; ++ i)
  8.1179 +    gridIndices[i] += gridIndices[i - 1];
  8.1180 +
  8.1181 +  // Restore vertices
  8.1182 +  _ctmRestoreVertices(self, intVertices, gridIndices, &grid, self->mVertices);
  8.1183 +
  8.1184 +  // Free temporary resources
  8.1185 +  free((void *) gridIndices);
  8.1186 +  free((void *) intVertices);
  8.1187 +
  8.1188 +  // Read triangle indices
  8.1189 +  if(_ctmStreamReadUINT(self) != FOURCC("INDX"))
  8.1190 +  {
  8.1191 +    self->mError = CTM_BAD_FORMAT;
  8.1192 +    return CTM_FALSE;
  8.1193 +  }
  8.1194 +  if(!_ctmStreamReadPackedInts(self, (CTMint *) self->mIndices, self->mTriangleCount, 3, CTM_FALSE))
  8.1195 +    return CTM_FALSE;
  8.1196 +
  8.1197 +  // Restore indices
  8.1198 +  _ctmRestoreIndices(self, self->mIndices);
  8.1199 +
  8.1200 +  // Check that all indices are within range
  8.1201 +  for(i = 0; i < (self->mTriangleCount * 3); ++ i)
  8.1202 +  {
  8.1203 +    if(self->mIndices[i] >= self->mVertexCount)
  8.1204 +    {
  8.1205 +      self->mError = CTM_INVALID_MESH;
  8.1206 +      return CTM_FALSE;
  8.1207 +    }
  8.1208 +  }
  8.1209 +
  8.1210 +  // Read normals
  8.1211 +  if(self->mNormals)
  8.1212 +  {
  8.1213 +    intNormals = (CTMint *) malloc(sizeof(CTMint) * self->mVertexCount * 3);
  8.1214 +    if(!intNormals)
  8.1215 +    {
  8.1216 +      self->mError = CTM_OUT_OF_MEMORY;
  8.1217 +      return CTM_FALSE;
  8.1218 +    }
  8.1219 +    if(_ctmStreamReadUINT(self) != FOURCC("NORM"))
  8.1220 +    {
  8.1221 +      self->mError = CTM_BAD_FORMAT;
  8.1222 +      free((void *) intNormals);
  8.1223 +      return CTM_FALSE;
  8.1224 +    }
  8.1225 +    if(!_ctmStreamReadPackedInts(self, intNormals, self->mVertexCount, 3, CTM_FALSE))
  8.1226 +    {
  8.1227 +      free((void *) intNormals);
  8.1228 +      return CTM_FALSE;
  8.1229 +    }
  8.1230 +
  8.1231 +    // Restore normals
  8.1232 +    if(!_ctmRestoreNormals(self, intNormals))
  8.1233 +    {
  8.1234 +      free((void *) intNormals);
  8.1235 +      return CTM_FALSE;
  8.1236 +    }
  8.1237 +
  8.1238 +    // Free temporary normals data
  8.1239 +    free((void *) intNormals);
  8.1240 +  }
  8.1241 +
  8.1242 +  // Read UV maps
  8.1243 +  map = self->mUVMaps;
  8.1244 +  while(map)
  8.1245 +  {
  8.1246 +    intUVCoords = (CTMint *) malloc(sizeof(CTMint) * self->mVertexCount * 2);
  8.1247 +    if(!intUVCoords)
  8.1248 +    {
  8.1249 +      self->mError = CTM_OUT_OF_MEMORY;
  8.1250 +      return CTM_FALSE;
  8.1251 +    }
  8.1252 +    if(_ctmStreamReadUINT(self) != FOURCC("TEXC"))
  8.1253 +    {
  8.1254 +      self->mError = CTM_BAD_FORMAT;
  8.1255 +      free((void *) intUVCoords);
  8.1256 +      return CTM_FALSE;
  8.1257 +    }
  8.1258 +    _ctmStreamReadSTRING(self, &map->mName);
  8.1259 +    _ctmStreamReadSTRING(self, &map->mFileName);
  8.1260 +    map->mPrecision = _ctmStreamReadFLOAT(self);
  8.1261 +    if(map->mPrecision <= 0.0f)
  8.1262 +    {
  8.1263 +      self->mError = CTM_BAD_FORMAT;
  8.1264 +      free((void *) intUVCoords);
  8.1265 +      return CTM_FALSE;
  8.1266 +    }
  8.1267 +    if(!_ctmStreamReadPackedInts(self, intUVCoords, self->mVertexCount, 2, CTM_TRUE))
  8.1268 +    {
  8.1269 +      free((void *) intUVCoords);
  8.1270 +      return CTM_FALSE;
  8.1271 +    }
  8.1272 +
  8.1273 +    // Restore UV coordinates
  8.1274 +    _ctmRestoreUVCoords(self, map, intUVCoords);
  8.1275 +
  8.1276 +    // Free temporary UV coordinate data
  8.1277 +    free((void *) intUVCoords);
  8.1278 +
  8.1279 +    map = map->mNext;
  8.1280 +  }
  8.1281 +
  8.1282 +  // Read vertex attribute maps
  8.1283 +  map = self->mAttribMaps;
  8.1284 +  while(map)
  8.1285 +  {
  8.1286 +    intAttribs = (CTMint *) malloc(sizeof(CTMint) * self->mVertexCount * 4);
  8.1287 +    if(!intAttribs)
  8.1288 +    {
  8.1289 +      self->mError = CTM_OUT_OF_MEMORY;
  8.1290 +      return CTM_FALSE;
  8.1291 +    }
  8.1292 +    if(_ctmStreamReadUINT(self) != FOURCC("ATTR"))
  8.1293 +    {
  8.1294 +      self->mError = CTM_BAD_FORMAT;
  8.1295 +      free((void *) intAttribs);
  8.1296 +      return CTM_FALSE;
  8.1297 +    }
  8.1298 +    _ctmStreamReadSTRING(self, &map->mName);
  8.1299 +    map->mPrecision = _ctmStreamReadFLOAT(self);
  8.1300 +    if(map->mPrecision <= 0.0f)
  8.1301 +    {
  8.1302 +      self->mError = CTM_BAD_FORMAT;
  8.1303 +      free((void *) intAttribs);
  8.1304 +      return CTM_FALSE;
  8.1305 +    }
  8.1306 +    if(!_ctmStreamReadPackedInts(self, intAttribs, self->mVertexCount, 4, CTM_TRUE))
  8.1307 +    {
  8.1308 +      free((void *) intAttribs);
  8.1309 +      return CTM_FALSE;
  8.1310 +    }
  8.1311 +
  8.1312 +    // Restore vertex attributes
  8.1313 +    _ctmRestoreAttribs(self, map, intAttribs);
  8.1314 +
  8.1315 +    // Free temporary vertex attribute data
  8.1316 +    free((void *) intAttribs);
  8.1317 +
  8.1318 +    map = map->mNext;
  8.1319 +  }
  8.1320 +
  8.1321 +  return CTM_TRUE;
  8.1322 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/libs/openctm/compressRAW.c	Thu Sep 26 04:47:05 2013 +0300
     9.3 @@ -0,0 +1,181 @@
     9.4 +//-----------------------------------------------------------------------------
     9.5 +// Product:     OpenCTM
     9.6 +// File:        compressRAW.c
     9.7 +// Description: Implementation of the RAW compression method.
     9.8 +//-----------------------------------------------------------------------------
     9.9 +// Copyright (c) 2009-2010 Marcus Geelnard
    9.10 +//
    9.11 +// This software is provided 'as-is', without any express or implied
    9.12 +// warranty. In no event will the authors be held liable for any damages
    9.13 +// arising from the use of this software.
    9.14 +//
    9.15 +// Permission is granted to anyone to use this software for any purpose,
    9.16 +// including commercial applications, and to alter it and redistribute it
    9.17 +// freely, subject to the following restrictions:
    9.18 +//
    9.19 +//     1. The origin of this software must not be misrepresented; you must not
    9.20 +//     claim that you wrote the original software. If you use this software
    9.21 +//     in a product, an acknowledgment in the product documentation would be
    9.22 +//     appreciated but is not required.
    9.23 +//
    9.24 +//     2. Altered source versions must be plainly marked as such, and must not
    9.25 +//     be misrepresented as being the original software.
    9.26 +//
    9.27 +//     3. This notice may not be removed or altered from any source
    9.28 +//     distribution.
    9.29 +//-----------------------------------------------------------------------------
    9.30 +
    9.31 +#include "openctm.h"
    9.32 +#include "internal.h"
    9.33 +
    9.34 +#ifdef __DEBUG_
    9.35 +#include <stdio.h>
    9.36 +#endif
    9.37 +
    9.38 +
    9.39 +//-----------------------------------------------------------------------------
    9.40 +// _ctmCompressMesh_RAW() - Compress the mesh that is stored in the CTM
    9.41 +// context using the RAW method, and write it the the output stream in the CTM
    9.42 +// context.
    9.43 +//-----------------------------------------------------------------------------
    9.44 +int _ctmCompressMesh_RAW(_CTMcontext * self)
    9.45 +{
    9.46 +  CTMuint i;
    9.47 +  _CTMfloatmap * map;
    9.48 +
    9.49 +#ifdef __DEBUG_
    9.50 +  printf("COMPRESSION METHOD: RAW\n");
    9.51 +#endif
    9.52 +
    9.53 +  // Write triangle indices
    9.54 +#ifdef __DEBUG_
    9.55 +  printf("Inidices: %d bytes\n", (CTMuint)(self->mTriangleCount * 3 * sizeof(CTMuint)));
    9.56 +#endif
    9.57 +  _ctmStreamWrite(self, (void *) "INDX", 4);
    9.58 +  for(i = 0; i < self->mTriangleCount * 3; ++ i)
    9.59 +    _ctmStreamWriteUINT(self, self->mIndices[i]);
    9.60 +
    9.61 +  // Write vertices
    9.62 +#ifdef __DEBUG_
    9.63 +  printf("Vertices: %d bytes\n", (CTMuint)(self->mVertexCount * 3 * sizeof(CTMfloat)));
    9.64 +#endif
    9.65 +  _ctmStreamWrite(self, (void *) "VERT", 4);
    9.66 +  for(i = 0; i < self->mVertexCount * 3; ++ i)
    9.67 +    _ctmStreamWriteFLOAT(self, self->mVertices[i]);
    9.68 +
    9.69 +  // Write normals
    9.70 +  if(self->mNormals)
    9.71 +  {
    9.72 +#ifdef __DEBUG_
    9.73 +    printf("Normals: %d bytes\n", (CTMuint)(self->mVertexCount * 3 * sizeof(CTMfloat)));
    9.74 +#endif
    9.75 +    _ctmStreamWrite(self, (void *) "NORM", 4);
    9.76 +    for(i = 0; i < self->mVertexCount * 3; ++ i)
    9.77 +      _ctmStreamWriteFLOAT(self, self->mNormals[i]);
    9.78 +  }
    9.79 +
    9.80 +  // Write UV maps
    9.81 +  map = self->mUVMaps;
    9.82 +  while(map)
    9.83 +  {
    9.84 +#ifdef __DEBUG_
    9.85 +    printf("UV coordinates (%s): %d bytes\n", map->mName ? map->mName : "no name", (CTMuint)(self->mVertexCount * 2 * sizeof(CTMfloat)));
    9.86 +#endif
    9.87 +    _ctmStreamWrite(self, (void *) "TEXC", 4);
    9.88 +    _ctmStreamWriteSTRING(self, map->mName);
    9.89 +    _ctmStreamWriteSTRING(self, map->mFileName);
    9.90 +    for(i = 0; i < self->mVertexCount * 2; ++ i)
    9.91 +      _ctmStreamWriteFLOAT(self, map->mValues[i]);
    9.92 +    map = map->mNext;
    9.93 +  }
    9.94 +
    9.95 +  // Write attribute maps
    9.96 +  map = self->mAttribMaps;
    9.97 +  while(map)
    9.98 +  {
    9.99 +#ifdef __DEBUG_
   9.100 +    printf("Vertex attributes (%s): %d bytes\n", map->mName ? map->mName : "no name", (CTMuint)(self->mVertexCount * 4 * sizeof(CTMfloat)));
   9.101 +#endif
   9.102 +    _ctmStreamWrite(self, (void *) "ATTR", 4);
   9.103 +    _ctmStreamWriteSTRING(self, map->mName);
   9.104 +    for(i = 0; i < self->mVertexCount * 4; ++ i)
   9.105 +      _ctmStreamWriteFLOAT(self, map->mValues[i]);
   9.106 +    map = map->mNext;
   9.107 +  }
   9.108 +
   9.109 +  return 1;
   9.110 +}
   9.111 +
   9.112 +//-----------------------------------------------------------------------------
   9.113 +// _ctmUncompressMesh_RAW() - Uncmpress the mesh from the input stream in the
   9.114 +// CTM context using the RAW method, and store the resulting mesh in the CTM
   9.115 +// context.
   9.116 +//-----------------------------------------------------------------------------
   9.117 +int _ctmUncompressMesh_RAW(_CTMcontext * self)
   9.118 +{
   9.119 +  CTMuint i;
   9.120 +  _CTMfloatmap * map;
   9.121 +
   9.122 +  // Read triangle indices
   9.123 +  if(_ctmStreamReadUINT(self) != FOURCC("INDX"))
   9.124 +  {
   9.125 +    self->mError = CTM_BAD_FORMAT;
   9.126 +    return 0;
   9.127 +  }
   9.128 +  for(i = 0; i < self->mTriangleCount * 3; ++ i)
   9.129 +    self->mIndices[i] = _ctmStreamReadUINT(self);
   9.130 +
   9.131 +  // Read vertices
   9.132 +  if(_ctmStreamReadUINT(self) != FOURCC("VERT"))
   9.133 +  {
   9.134 +    self->mError = CTM_BAD_FORMAT;
   9.135 +    return 0;
   9.136 +  }
   9.137 +  for(i = 0; i < self->mVertexCount * 3; ++ i)
   9.138 +    self->mVertices[i] = _ctmStreamReadFLOAT(self);
   9.139 +
   9.140 +  // Read normals
   9.141 +  if(self->mNormals)
   9.142 +  {
   9.143 +    if(_ctmStreamReadUINT(self) != FOURCC("NORM"))
   9.144 +    {
   9.145 +      self->mError = CTM_BAD_FORMAT;
   9.146 +      return 0;
   9.147 +    }
   9.148 +    for(i = 0; i < self->mVertexCount * 3; ++ i)
   9.149 +      self->mNormals[i] = _ctmStreamReadFLOAT(self);
   9.150 +  }
   9.151 +
   9.152 +  // Read UV maps
   9.153 +  map = self->mUVMaps;
   9.154 +  while(map)
   9.155 +  {
   9.156 +    if(_ctmStreamReadUINT(self) != FOURCC("TEXC"))
   9.157 +    {
   9.158 +      self->mError = CTM_BAD_FORMAT;
   9.159 +      return 0;
   9.160 +    }
   9.161 +    _ctmStreamReadSTRING(self, &map->mName);
   9.162 +    _ctmStreamReadSTRING(self, &map->mFileName);
   9.163 +    for(i = 0; i < self->mVertexCount * 2; ++ i)
   9.164 +      map->mValues[i] = _ctmStreamReadFLOAT(self);
   9.165 +    map = map->mNext;
   9.166 +  }
   9.167 +
   9.168 +  // Read attribute maps
   9.169 +  map = self->mAttribMaps;
   9.170 +  while(map)
   9.171 +  {
   9.172 +    if(_ctmStreamReadUINT(self) != FOURCC("ATTR"))
   9.173 +    {
   9.174 +      self->mError = CTM_BAD_FORMAT;
   9.175 +      return 0;
   9.176 +    }
   9.177 +    _ctmStreamReadSTRING(self, &map->mName);
   9.178 +    for(i = 0; i < self->mVertexCount * 4; ++ i)
   9.179 +      map->mValues[i] = _ctmStreamReadFLOAT(self);
   9.180 +    map = map->mNext;
   9.181 +  }
   9.182 +
   9.183 +  return 1;
   9.184 +}

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/libs/openctm/internal.h	Thu Sep 26 04:47:05 2013 +0300
    10.3 @@ -0,0 +1,147 @@
    10.4 +//-----------------------------------------------------------------------------
    10.5 +// Product:     OpenCTM
    10.6 +// File:        internal.h
    10.7 +// Description: Internal (private) declarations, types and function prototypes.
    10.8 +//-----------------------------------------------------------------------------
    10.9 +// Copyright (c) 2009-2010 Marcus Geelnard
   10.10 +//
   10.11 +// This software is provided 'as-is', without any express or implied
   10.12 +// warranty. In no event will the authors be held liable for any damages
   10.13 +// arising from the use of this software.
   10.14 +//
   10.15 +// Permission is granted to anyone to use this software for any purpose,
   10.16 +// including commercial applications, and to alter it and redistribute it
   10.17 +// freely, subject to the following restrictions:
   10.18 +//
   10.19 +//     1. The origin of this software must not be misrepresented; you must not
   10.20 +//     claim that you wrote the original software. If you use this software
   10.21 +//     in a product, an acknowledgment in the product documentation would be
   10.22 +//     appreciated but is not required.
   10.23 +//
   10.24 +//     2. Altered source versions must be plainly marked as such, and must not
   10.25 +//     be misrepresented as being the original software.
   10.26 +//
   10.27 +//     3. This notice may not be removed or altered from any source
   10.28 +//     distribution.
   10.29 +//-----------------------------------------------------------------------------
   10.30 +
   10.31 +#ifndef __OPENCTM_INTERNAL_H_
   10.32 +#define __OPENCTM_INTERNAL_H_
   10.33 +
   10.34 +//-----------------------------------------------------------------------------
   10.35 +// Constants
   10.36 +//-----------------------------------------------------------------------------
   10.37 +// OpenCTM file format version (v5).
   10.38 +#define _CTM_FORMAT_VERSION  0x00000005
   10.39 +
   10.40 +// Flags for the Mesh flags field of the file header
   10.41 +#define _CTM_HAS_NORMALS_BIT 0x00000001
   10.42 +
   10.43 +//-----------------------------------------------------------------------------
   10.44 +// _CTMfloatmap - Internal representation of a floating point based vertex map
   10.45 +// (used for UV maps and attribute maps).
   10.46 +//-----------------------------------------------------------------------------
   10.47 +typedef struct _CTMfloatmap_struct _CTMfloatmap;
   10.48 +struct _CTMfloatmap_struct {
   10.49 +  char * mName;         // Unique name
   10.50 +  char * mFileName;     // File name reference (used only for UV maps)
   10.51 +  CTMfloat mPrecision;  // Precision for this map
   10.52 +  CTMfloat * mValues;   // Attribute/UV coordinate values (per vertex)
   10.53 +  _CTMfloatmap * mNext; // Pointer to the next map in the list (linked list)
   10.54 +};
   10.55 +
   10.56 +//-----------------------------------------------------------------------------
   10.57 +// _CTMcontext - Internal CTM context structure.
   10.58 +//-----------------------------------------------------------------------------
   10.59 +typedef struct {
   10.60 +  // Context mode (import or export)
   10.61 +  CTMenum mMode;
   10.62 +
   10.63 +  // Vertices
   10.64 +  CTMfloat * mVertices;
   10.65 +  CTMuint mVertexCount;
   10.66 +
   10.67 +  // Indices
   10.68 +  CTMuint * mIndices;
   10.69 +  CTMuint mTriangleCount;
   10.70 +
   10.71 +  // Normals (optional)
   10.72 +  CTMfloat * mNormals;
   10.73 +
   10.74 +  // Multiple sets of UV coordinate maps (optional)
   10.75 +  CTMuint mUVMapCount;
   10.76 +  _CTMfloatmap * mUVMaps;
   10.77 +
   10.78 +  // Multiple sets of custom vertex attribute maps (optional)
   10.79 +  CTMuint mAttribMapCount;
   10.80 +  _CTMfloatmap * mAttribMaps;
   10.81 +
   10.82 +  // Last error code
   10.83 +  CTMenum mError;
   10.84 +
   10.85 +  // The selected compression method
   10.86 +  CTMenum mMethod;
   10.87 +
   10.88 +  // The selected compression level
   10.89 +  CTMuint mCompressionLevel;
   10.90 +
   10.91 +  // Vertex coordinate precision
   10.92 +  CTMfloat mVertexPrecision;
   10.93 +
   10.94 +  // Normal precision (angular + magnitude)
   10.95 +  CTMfloat mNormalPrecision;
   10.96 +
   10.97 +  // File comment
   10.98 +  char * mFileComment;
   10.99 +
  10.100 +  // Read() function pointer
  10.101 +  CTMreadfn mReadFn;
  10.102 +
  10.103 +  // Write() function pointer
  10.104 +  CTMwritefn mWriteFn;
  10.105 +
  10.106 +  // User data (for stream read/write - usually the stream handle)
  10.107 +  void * mUserData;
  10.108 +} _CTMcontext;
  10.109 +
  10.110 +//-----------------------------------------------------------------------------
  10.111 +// Macros
  10.112 +//-----------------------------------------------------------------------------
  10.113 +#define FOURCC(str) (((CTMuint) str[0]) | (((CTMuint) str[1]) << 8) | \
  10.114 +                    (((CTMuint) str[2]) << 16) | (((CTMuint) str[3]) << 24))
  10.115 +
  10.116 +//-----------------------------------------------------------------------------
  10.117 +// Funcion prototypes for stream.c
  10.118 +//-----------------------------------------------------------------------------
  10.119 +CTMuint _ctmStreamRead(_CTMcontext * self, void * aBuf, CTMuint aCount);
  10.120 +CTMuint _ctmStreamWrite(_CTMcontext * self, void * aBuf, CTMuint aCount);
  10.121 +CTMuint _ctmStreamReadUINT(_CTMcontext * self);
  10.122 +void _ctmStreamWriteUINT(_CTMcontext * self, CTMuint aValue);
  10.123 +CTMfloat _ctmStreamReadFLOAT(_CTMcontext * self);
  10.124 +void _ctmStreamWriteFLOAT(_CTMcontext * self, CTMfloat aValue);
  10.125 +void _ctmStreamReadSTRING(_CTMcontext * self, char ** aValue);
  10.126 +void _ctmStreamWriteSTRING(_CTMcontext * self, const char * aValue);
  10.127 +int _ctmStreamReadPackedInts(_CTMcontext * self, CTMint * aData, CTMuint aCount, CTMuint aSize, CTMint aSignedInts);
  10.128 +int _ctmStreamWritePackedInts(_CTMcontext * self, CTMint * aData, CTMuint aCount, CTMuint aSize, CTMint aSignedInts);
  10.129 +int _ctmStreamReadPackedFloats(_CTMcontext * self, CTMfloat * aData, CTMuint aCount, CTMuint aSize);
  10.130 +int _ctmStreamWritePackedFloats(_CTMcontext * self, CTMfloat * aData, CTMuint aCount, CTMuint aSize);
  10.131 +
  10.132 +//-----------------------------------------------------------------------------
  10.133 +// Funcion prototypes for compressRAW.c
  10.134 +//-----------------------------------------------------------------------------
  10.135 +int _ctmCompressMesh_RAW(_CTMcontext * self);
  10.136 +int _ctmUncompressMesh_RAW(_CTMcontext * self);
  10.137 +
  10.138 +//-----------------------------------------------------------------------------
  10.139 +// Funcion prototypes for compressMG1.c
  10.140 +//-----------------------------------------------------------------------------
  10.141 +int _ctmCompressMesh_MG1(_CTMcontext * self);
  10.142 +int _ctmUncompressMesh_MG1(_CTMcontext * self);
  10.143 +
  10.144 +//-----------------------------------------------------------------------------
  10.145 +// Funcion prototypes for compressMG2.c
  10.146 +//-----------------------------------------------------------------------------
  10.147 +int _ctmCompressMesh_MG2(_CTMcontext * self);
  10.148 +int _ctmUncompressMesh_MG2(_CTMcontext * self);
  10.149 +
  10.150 +#endif // __OPENCTM_INTERNAL_H_

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/libs/openctm/liblzma/Alloc.c	Thu Sep 26 04:47:05 2013 +0300
    11.3 @@ -0,0 +1,127 @@
    11.4 +/* Alloc.c -- Memory allocation functions
    11.5 +2008-09-24
    11.6 +Igor Pavlov
    11.7 +Public domain */
    11.8 +
    11.9 +#ifdef _WIN32
   11.10 +#include <windows.h>
   11.11 +#endif
   11.12 +#include <stdlib.h>
   11.13 +
   11.14 +#include "Alloc.h"
   11.15 +
   11.16 +/* #define _SZ_ALLOC_DEBUG */
   11.17 +
   11.18 +/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
   11.19 +#ifdef _SZ_ALLOC_DEBUG
   11.20 +#include <stdio.h>
   11.21 +int g_allocCount = 0;
   11.22 +int g_allocCountMid = 0;
   11.23 +int g_allocCountBig = 0;
   11.24 +#endif
   11.25 +
   11.26 +void *MyAlloc(size_t size)
   11.27 +{
   11.28 +  if (size == 0)
   11.29 +    return 0;
   11.30 +  #ifdef _SZ_ALLOC_DEBUG
   11.31 +  {
   11.32 +    void *p = malloc(size);
   11.33 +    fprintf(stderr, "\nAlloc %10d bytes, count = %10d,  addr = %8X", size, g_allocCount++, (unsigned)p);
   11.34 +    return p;
   11.35 +  }
   11.36 +  #else
   11.37 +  return malloc(size);
   11.38 +  #endif
   11.39 +}
   11.40 +
   11.41 +void MyFree(void *address)
   11.42 +{
   11.43 +  #ifdef _SZ_ALLOC_DEBUG
   11.44 +  if (address != 0)
   11.45 +    fprintf(stderr, "\nFree; count = %10d,  addr = %8X", --g_allocCount, (unsigned)address);
   11.46 +  #endif
   11.47 +  free(address);
   11.48 +}
   11.49 +
   11.50 +#ifdef _WIN32
   11.51 +
   11.52 +void *MidAlloc(size_t size)
   11.53 +{
   11.54 +  if (size == 0)
   11.55 +    return 0;
   11.56 +  #ifdef _SZ_ALLOC_DEBUG
   11.57 +  fprintf(stderr, "\nAlloc_Mid %10d bytes;  count = %10d", size, g_allocCountMid++);
   11.58 +  #endif
   11.59 +  return VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);
   11.60 +}
   11.61 +
   11.62 +void MidFree(void *address)
   11.63 +{
   11.64 +  #ifdef _SZ_ALLOC_DEBUG
   11.65 +  if (address != 0)
   11.66 +    fprintf(stderr, "\nFree_Mid; count = %10d", --g_allocCountMid);
   11.67 +  #endif
   11.68 +  if (address == 0)
   11.69 +    return;
   11.70 +  VirtualFree(address, 0, MEM_RELEASE);
   11.71 +}
   11.72 +
   11.73 +#ifndef MEM_LARGE_PAGES
   11.74 +#undef _7ZIP_LARGE_PAGES
   11.75 +#endif
   11.76 +
   11.77 +#ifdef _7ZIP_LARGE_PAGES
   11.78 +SIZE_T g_LargePageSize = 0;
   11.79 +typedef SIZE_T (WINAPI *GetLargePageMinimumP)();
   11.80 +#endif
   11.81 +
   11.82 +void SetLargePageSize()
   11.83 +{
   11.84 +  #ifdef _7ZIP_LARGE_PAGES
   11.85 +  SIZE_T size = 0;
   11.86 +  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)
   11.87 +        GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");
   11.88 +  if (largePageMinimum == 0)
   11.89 +    return;
   11.90 +  size = largePageMinimum();
   11.91 +  if (size == 0 || (size & (size - 1)) != 0)
   11.92 +    return;
   11.93 +  g_LargePageSize = size;
   11.94 +  #endif
   11.95 +}
   11.96 +
   11.97 +
   11.98 +void *BigAlloc(size_t size)
   11.99 +{
  11.100 +  if (size == 0)
  11.101 +    return 0;
  11.102 +  #ifdef _SZ_ALLOC_DEBUG
  11.103 +  fprintf(stderr, "\nAlloc_Big %10d bytes;  count = %10d", size, g_allocCountBig++);
  11.104 +  #endif
  11.105 +  
  11.106 +  #ifdef _7ZIP_LARGE_PAGES
  11.107 +  if (g_LargePageSize != 0 && g_LargePageSize <= (1 << 30) && size >= (1 << 18))
  11.108 +  {
  11.109 +    void *res = VirtualAlloc(0, (size + g_LargePageSize - 1) & (~(g_LargePageSize - 1)),
  11.110 +        MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
  11.111 +    if (res != 0)
  11.112 +      return res;
  11.113 +  }
  11.114 +  #endif
  11.115 +  return VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);
  11.116 +}
  11.117 +
  11.118 +void BigFree(void *address)
  11.119 +{
  11.120 +  #ifdef _SZ_ALLOC_DEBUG
  11.121 +  if (address != 0)
  11.122 +    fprintf(stderr, "\nFree_Big; count = %10d", --g_allocCountBig);
  11.123 +  #endif
  11.124 +  
  11.125 +  if (address == 0)
  11.126 +    return;
  11.127 +  VirtualFree(address, 0, MEM_RELEASE);
  11.128 +}
  11.129 +
  11.130 +#endif

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/libs/openctm/liblzma/Alloc.h	Thu Sep 26 04:47:05 2013 +0300
    12.3 @@ -0,0 +1,34 @@
    12.4 +/* Alloc.h -- Memory allocation functions
    12.5 +2008-03-13
    12.6 +Igor Pavlov
    12.7 +Public domain */
    12.8 +
    12.9 +#ifndef __COMMON_ALLOC_H
   12.10 +#define __COMMON_ALLOC_H
   12.11 +
   12.12 +#include <stddef.h>
   12.13 +
   12.14 +#include "NameMangle.h"
   12.15 +
   12.16 +void *MyAlloc(size_t size);
   12.17 +void MyFree(void *address);
   12.18 +
   12.19 +#ifdef _WIN32
   12.20 +
   12.21 +void SetLargePageSize();
   12.22 +
   12.23 +void *MidAlloc(size_t size);
   12.24 +void MidFree(void *address);
   12.25 +void *BigAlloc(size_t size);
   12.26 +void BigFree(void *address);
   12.27 +
   12.28 +#else
   12.29 +
   12.30 +#define MidAlloc(size) MyAlloc(size)
   12.31 +#define MidFree(address) MyFree(address)
   12.32 +#define BigAlloc(size) MyAlloc(size)
   12.33 +#define BigFree(address) MyFree(address)
   12.34 +
   12.35 +#endif
   12.36 +
   12.37 +#endif

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/libs/openctm/liblzma/LzFind.c	Thu Sep 26 04:47:05 2013 +0300
    13.3 @@ -0,0 +1,751 @@
    13.4 +/* LzFind.c -- Match finder for LZ algorithms
    13.5 +2008-10-04 : Igor Pavlov : Public domain */
    13.6 +
    13.7 +#include <string.h>
    13.8 +
    13.9 +#include "LzFind.h"
   13.10 +#include "LzHash.h"
   13.11 +
   13.12 +#define kEmptyHashValue 0
   13.13 +#define kMaxValForNormalize ((UInt32)0xFFFFFFFF)
   13.14 +#define kNormalizeStepMin (1 << 10) /* it must be power of 2 */
   13.15 +#define kNormalizeMask (~(kNormalizeStepMin - 1))
   13.16 +#define kMaxHistorySize ((UInt32)3 << 30)
   13.17 +
   13.18 +#define kStartMaxLen 3
   13.19 +
   13.20 +static void LzInWindow_Free(CMatchFinder *p, ISzAlloc *alloc)
   13.21 +{
   13.22 +  if (!p->directInput)
   13.23 +  {
   13.24 +    alloc->Free(alloc, p->bufferBase);
   13.25 +    p->bufferBase = 0;
   13.26 +  }
   13.27 +}
   13.28 +
   13.29 +/* keepSizeBefore + keepSizeAfter + keepSizeReserv must be < 4G) */
   13.30 +
   13.31 +static int LzInWindow_Create(CMatchFinder *p, UInt32 keepSizeReserv, ISzAlloc *alloc)
   13.32 +{
   13.33 +  UInt32 blockSize = p->keepSizeBefore + p->keepSizeAfter + keepSizeReserv;
   13.34 +  if (p->directInput)
   13.35 +  {
   13.36 +    p->blockSize = blockSize;
   13.37 +    return 1;
   13.38 +  }
   13.39 +  if (p->bufferBase == 0 || p->blockSize != blockSize)
   13.40 +  {
   13.41 +    LzInWindow_Free(p, alloc);
   13.42 +    p->blockSize = blockSize;
   13.43 +    p->bufferBase = (Byte *)alloc->Alloc(alloc, (size_t)blockSize);
   13.44 +  }
   13.45 +  return (p->bufferBase != 0);
   13.46 +}
   13.47 +
   13.48 +Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p) { return p->buffer; }
   13.49 +Byte MatchFinder_GetIndexByte(CMatchFinder *p, Int32 index) { return p->buffer[index]; }
   13.50 +
   13.51 +UInt32 MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return p->streamPos - p->pos; }
   13.52 +
   13.53 +void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue)
   13.54 +{
   13.55 +  p->posLimit -= subValue;
   13.56 +  p->pos -= subValue;
   13.57 +  p->streamPos -= subValue;
   13.58 +}
   13.59 +
   13.60 +static void MatchFinder_ReadBlock(CMatchFinder *p)
   13.61 +{
   13.62 +  if (p->streamEndWasReached || p->result != SZ_OK)
   13.63 +    return;
   13.64 +  for (;;)
   13.65 +  {
   13.66 +    Byte *dest = p->buffer + (p->streamPos - p->pos);
   13.67 +    size_t size = (p->bufferBase + p->blockSize - dest);
   13.68 +    if (size == 0)
   13.69 +      return;
   13.70 +    p->result = p->stream->Read(p->stream, dest, &size);
   13.71 +    if (p->result != SZ_OK)
   13.72 +      return;
   13.73 +    if (size == 0)
   13.74 +    {
   13.75 +      p->streamEndWasReached = 1;
   13.76 +      return;
   13.77 +    }
   13.78 +    p->streamPos += (UInt32)size;
   13.79 +    if (p->streamPos - p->pos > p->keepSizeAfter)
   13.80 +      return;
   13.81 +  }
   13.82 +}
   13.83 +
   13.84 +void MatchFinder_MoveBlock(CMatchFinder *p)
   13.85 +{
   13.86 +  memmove(p->bufferBase,
   13.87 +    p->buffer - p->keepSizeBefore,
   13.88 +    (size_t)(p->streamPos - p->pos + p->keepSizeBefore));
   13.89 +  p->buffer = p->bufferBase + p->keepSizeBefore;
   13.90 +}
   13.91 +
   13.92 +int MatchFinder_NeedMove(CMatchFinder *p)
   13.93 +{
   13.94 +  /* if (p->streamEndWasReached) return 0; */
   13.95 +  return ((size_t)(p->bufferBase + p->blockSize - p->buffer) <= p->keepSizeAfter);
   13.96 +}
   13.97 +
   13.98 +void MatchFinder_ReadIfRequired(CMatchFinder *p)
   13.99 +{
  13.100 +  if (p->streamEndWasReached)
  13.101 +    return;
  13.102 +  if (p->keepSizeAfter >= p->streamPos - p->pos)
  13.103 +    MatchFinder_ReadBlock(p);
  13.104 +}
  13.105 +
  13.106 +static void MatchFinder_CheckAndMoveAndRead(CMatchFinder *p)
  13.107 +{
  13.108 +  if (MatchFinder_NeedMove(p))
  13.109 +    MatchFinder_MoveBlock(p);
  13.110 +  MatchFinder_ReadBlock(p);
  13.111 +}
  13.112 +
  13.113 +static void MatchFinder_SetDefaultSettings(CMatchFinder *p)
  13.114 +{
  13.115 +  p->cutValue = 32;
  13.116 +  p->btMode = 1;
  13.117 +  p->numHashBytes = 4;
  13.118 +  /* p->skipModeBits = 0; */
  13.119 +  p->directInput = 0;
  13.120 +  p->bigHash = 0;
  13.121 +}
  13.122 +
  13.123 +#define kCrcPoly 0xEDB88320
  13.124 +
  13.125 +void MatchFinder_Construct(CMatchFinder *p)
  13.126 +{
  13.127 +  UInt32 i;
  13.128 +  p->bufferBase = 0;
  13.129 +  p->directInput = 0;
  13.130 +  p->hash = 0;
  13.131 +  MatchFinder_SetDefaultSettings(p);
  13.132 +
  13.133 +  for (i = 0; i < 256; i++)
  13.134 +  {
  13.135 +    UInt32 r = i;
  13.136 +    int j;
  13.137 +    for (j = 0; j < 8; j++)
  13.138 +      r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
  13.139 +    p->crc[i] = r;
  13.140 +  }
  13.141 +}
  13.142 +
  13.143 +static void MatchFinder_FreeThisClassMemory(CMatchFinder *p, ISzAlloc *alloc)
  13.144 +{
  13.145 +  alloc->Free(alloc, p->hash);
  13.146 +  p->hash = 0;
  13.147 +}
  13.148 +
  13.149 +void MatchFinder_Free(CMatchFinder *p, ISzAlloc *alloc)
  13.150 +{
  13.151 +  MatchFinder_FreeThisClassMemory(p, alloc);
  13.152 +  LzInWindow_Free(p, alloc);
  13.153 +}
  13.154 +
  13.155 +static CLzRef* AllocRefs(UInt32 num, ISzAlloc *alloc)
  13.156 +{
  13.157 +  size_t sizeInBytes = (size_t)num * sizeof(CLzRef);
  13.158 +  if (sizeInBytes / sizeof(CLzRef) != num)
  13.159 +    return 0;
  13.160 +  return (CLzRef *)alloc->Alloc(alloc, sizeInBytes);
  13.161 +}
  13.162 +
  13.163 +int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
  13.164 +    UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
  13.165 +    ISzAlloc *alloc)
  13.166 +{
  13.167 +  UInt32 sizeReserv;
  13.168 +  if (historySize > kMaxHistorySize)
  13.169 +  {
  13.170 +    MatchFinder_Free(p, alloc);
  13.171 +    return 0;
  13.172 +  }
  13.173 +  sizeReserv = historySize >> 1;
  13.174 +  if (historySize > ((UInt32)2 << 30))
  13.175 +    sizeReserv = historySize >> 2;
  13.176 +  sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19);
  13.177 +
  13.178 +  p->keepSizeBefore = historySize + keepAddBufferBefore + 1;
  13.179 +  p->keepSizeAfter = matchMaxLen + keepAddBufferAfter;
  13.180 +  /* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */
  13.181 +  if (LzInWindow_Create(p, sizeReserv, alloc))
  13.182 +  {
  13.183 +    UInt32 newCyclicBufferSize = (historySize /* >> p->skipModeBits */) + 1;
  13.184 +    UInt32 hs;
  13.185 +    p->matchMaxLen = matchMaxLen;
  13.186 +    {
  13.187 +      p->fixedHashSize = 0;
  13.188 +      if (p->numHashBytes == 2)
  13.189 +        hs = (1 << 16) - 1;
  13.190 +      else
  13.191 +      {
  13.192 +        hs = historySize - 1;
  13.193 +        hs |= (hs >> 1);
  13.194 +        hs |= (hs >> 2);
  13.195 +        hs |= (hs >> 4);
  13.196 +        hs |= (hs >> 8);
  13.197 +        hs >>= 1;
  13.198 +        /* hs >>= p->skipModeBits; */
  13.199 +        hs |= 0xFFFF; /* don't change it! It's required for Deflate */
  13.200 +        if (hs > (1 << 24))
  13.201 +        {
  13.202 +          if (p->numHashBytes == 3)
  13.203 +            hs = (1 << 24) - 1;
  13.204 +          else
  13.205 +            hs >>= 1;
  13.206 +        }
  13.207 +      }
  13.208 +      p->hashMask = hs;
  13.209 +      hs++;
  13.210 +      if (p->numHashBytes > 2) p->fixedHashSize += kHash2Size;
  13.211 +      if (p->numHashBytes > 3) p->fixedHashSize += kHash3Size;
  13.212 +      if (p->numHashBytes > 4) p->fixedHashSize += kHash4Size;
  13.213 +      hs += p->fixedHashSize;
  13.214 +    }
  13.215 +
  13.216 +    {
  13.217 +      UInt32 prevSize = p->hashSizeSum + p->numSons;
  13.218 +      UInt32 newSize;
  13.219 +      p->historySize = historySize;
  13.220 +      p->hashSizeSum = hs;
  13.221 +      p->cyclicBufferSize = newCyclicBufferSize;
  13.222 +      p->numSons = (p->btMode ? newCyclicBufferSize * 2 : newCyclicBufferSize);
  13.223 +      newSize = p->hashSizeSum + p->numSons;
  13.224 +      if (p->hash != 0 && prevSize == newSize)
  13.225 +        return 1;
  13.226 +      MatchFinder_FreeThisClassMemory(p, alloc);
  13.227 +      p->hash = AllocRefs(newSize, alloc);
  13.228 +      if (p->hash != 0)
  13.229 +      {
  13.230 +        p->son = p->hash + p->hashSizeSum;
  13.231 +        return 1;
  13.232 +      }
  13.233 +    }
  13.234 +  }
  13.235 +  MatchFinder_Free(p, alloc);
  13.236 +  return 0;
  13.237 +}
  13.238 +
  13.239 +static void MatchFinder_SetLimits(CMatchFinder *p)
  13.240 +{
  13.241 +  UInt32 limit = kMaxValForNormalize - p->pos;
  13.242 +  UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
  13.243 +  if (limit2 < limit)
  13.244 +    limit = limit2;
  13.245 +  limit2 = p->streamPos - p->pos;
  13.246 +  if (limit2 <= p->keepSizeAfter)
  13.247 +  {
  13.248 +    if (limit2 > 0)
  13.249 +      limit2 = 1;
  13.250 +  }
  13.251 +  else
  13.252 +    limit2 -= p->keepSizeAfter;
  13.253 +  if (limit2 < limit)
  13.254 +    limit = limit2;
  13.255 +  {
  13.256 +    UInt32 lenLimit = p->streamPos - p->pos;
  13.257 +    if (lenLimit > p->matchMaxLen)
  13.258 +      lenLimit = p->matchMaxLen;
  13.259 +    p->lenLimit = lenLimit;
  13.260 +  }
  13.261 +  p->posLimit = p->pos + limit;
  13.262 +}
  13.263 +
  13.264 +void MatchFinder_Init(CMatchFinder *p)
  13.265 +{
  13.266 +  UInt32 i;
  13.267 +  for (i = 0; i < p->hashSizeSum; i++)
  13.268 +    p->hash[i] = kEmptyHashValue;
  13.269 +  p->cyclicBufferPos = 0;
  13.270 +  p->buffer = p->bufferBase;
  13.271 +  p->pos = p->streamPos = p->cyclicBufferSize;
  13.272 +  p->result = SZ_OK;
  13.273 +  p->streamEndWasReached = 0;
  13.274 +  MatchFinder_ReadBlock(p);
  13.275 +  MatchFinder_SetLimits(p);
  13.276 +}
  13.277 +
  13.278 +static UInt32 MatchFinder_GetSubValue(CMatchFinder *p)
  13.279 +{
  13.280 +  return (p->pos - p->historySize - 1) & kNormalizeMask;
  13.281 +}
  13.282 +
  13.283 +void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems)
  13.284 +{
  13.285 +  UInt32 i;
  13.286 +  for (i = 0; i < numItems; i++)
  13.287 +  {
  13.288 +    UInt32 value = items[i];
  13.289 +    if (value <= subValue)
  13.290 +      value = kEmptyHashValue;
  13.291 +    else
  13.292 +      value -= subValue;
  13.293 +    items[i] = value;
  13.294 +  }
  13.295 +}
  13.296 +
  13.297 +static void MatchFinder_Normalize(CMatchFinder *p)
  13.298 +{
  13.299 +  UInt32 subValue = MatchFinder_GetSubValue(p);
  13.300 +  MatchFinder_Normalize3(subValue, p->hash, p->hashSizeSum + p->numSons);
  13.301 +  MatchFinder_ReduceOffsets(p, subValue);
  13.302 +}
  13.303 +
  13.304 +static void MatchFinder_CheckLimits(CMatchFinder *p)
  13.305 +{
  13.306 +  if (p->pos == kMaxValForNormalize)
  13.307 +    MatchFinder_Normalize(p);
  13.308 +  if (!p->streamEndWasReached && p->keepSizeAfter == p->streamPos - p->pos)
  13.309 +    MatchFinder_CheckAndMoveAndRead(p);
  13.310 +  if (p->cyclicBufferPos == p->cyclicBufferSize)
  13.311 +    p->cyclicBufferPos = 0;
  13.312 +  MatchFinder_SetLimits(p);
  13.313 +}
  13.314 +
  13.315 +static UInt32 * Hc_GetMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
  13.316 +    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
  13.317 +    UInt32 *distances, UInt32 maxLen)
  13.318 +{
  13.319 +  son[_cyclicBufferPos] = curMatch;
  13.320 +  for (;;)
  13.321 +  {
  13.322 +    UInt32 delta = pos - curMatch;
  13.323 +    if (cutValue-- == 0 || delta >= _cyclicBufferSize)
  13.324 +      return distances;
  13.325 +    {
  13.326 +      const Byte *pb = cur - delta;
  13.327 +      curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
  13.328 +      if (pb[maxLen] == cur[maxLen] && *pb == *cur)
  13.329 +      {
  13.330 +        UInt32 len = 0;
  13.331 +        while (++len != lenLimit)
  13.332 +          if (pb[len] != cur[len])
  13.333 +            break;
  13.334 +        if (maxLen < len)
  13.335 +        {
  13.336 +          *distances++ = maxLen = len;
  13.337 +          *distances++ = delta - 1;
  13.338 +          if (len == lenLimit)
  13.339 +            return distances;
  13.340 +        }
  13.341 +      }
  13.342 +    }
  13.343 +  }
  13.344 +}
  13.345 +
  13.346 +UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
  13.347 +    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
  13.348 +    UInt32 *distances, UInt32 maxLen)
  13.349 +{
  13.350 +  CLzRef *ptr0 = son + (_cyclicBufferPos << 1) + 1;
  13.351 +  CLzRef *ptr1 = son + (_cyclicBufferPos << 1);
  13.352 +  UInt32 len0 = 0, len1 = 0;
  13.353 +  for (;;)
  13.354 +  {
  13.355 +    UInt32 delta = pos - curMatch;
  13.356 +    if (cutValue-- == 0 || delta >= _cyclicBufferSize)
  13.357 +    {
  13.358 +      *ptr0 = *ptr1 = kEmptyHashValue;
  13.359 +      return distances;
  13.360 +    }
  13.361 +    {
  13.362 +      CLzRef *pair = son + ((_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
  13.363 +      const Byte *pb = cur - delta;
  13.364 +      UInt32 len = (len0 < len1 ? len0 : len1);
  13.365 +      if (pb[len] == cur[len])
  13.366 +      {
  13.367 +        if (++len != lenLimit && pb[len] == cur[len])
  13.368 +          while (++len != lenLimit)
  13.369 +            if (pb[len] != cur[len])
  13.370 +              break;
  13.371 +        if (maxLen < len)
  13.372 +        {
  13.373 +          *distances++ = maxLen = len;
  13.374 +          *distances++ = delta - 1;
  13.375 +          if (len == lenLimit)
  13.376 +          {
  13.377 +            *ptr1 = pair[0];
  13.378 +            *ptr0 = pair[1];
  13.379 +            return distances;
  13.380 +          }
  13.381 +        }
  13.382 +      }
  13.383 +      if (pb[len] < cur[len])
  13.384 +      {
  13.385 +        *ptr1 = curMatch;
  13.386 +        ptr1 = pair + 1;
  13.387 +        curMatch = *ptr1;
  13.388 +        len1 = len;
  13.389 +      }
  13.390 +      else
  13.391 +      {
  13.392 +        *ptr0 = curMatch;
  13.393 +        ptr0 = pair;
  13.394 +        curMatch = *ptr0;
  13.395 +        len0 = len;
  13.396 +      }
  13.397 +    }
  13.398 +  }
  13.399 +}
  13.400 +
  13.401 +static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
  13.402 +    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue)
  13.403 +{
  13.404 +  CLzRef *ptr0 = son + (_cyclicBufferPos << 1) + 1;
  13.405 +  CLzRef *ptr1 = son + (_cyclicBufferPos << 1);
  13.406 +  UInt32 len0 = 0, len1 = 0;
  13.407 +  for (;;)
  13.408 +  {
  13.409 +    UInt32 delta = pos - curMatch;
  13.410 +    if (cutValue-- == 0 || delta >= _cyclicBufferSize)
  13.411 +    {
  13.412 +      *ptr0 = *ptr1 = kEmptyHashValue;
  13.413 +      return;
  13.414 +    }
  13.415 +    {
  13.416 +      CLzRef *pair = son + ((_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
  13.417 +      const Byte *pb = cur - delta;
  13.418 +      UInt32 len = (len0 < len1 ? len0 : len1);
  13.419 +      if (pb[len] == cur[len])
  13.420 +      {
  13.421 +        while (++len != lenLimit)
  13.422 +          if (pb[len] != cur[len])
  13.423 +            break;
  13.424 +        {
  13.425 +          if (len == lenLimit)
  13.426 +          {
  13.427 +            *ptr1 = pair[0];
  13.428 +            *ptr0 = pair[1];
  13.429 +            return;
  13.430 +          }
  13.431 +        }
  13.432 +      }
  13.433 +      if (pb[len] < cur[len])
  13.434 +      {
  13.435 +        *ptr1 = curMatch;
  13.436 +        ptr1 = pair + 1;
  13.437 +        curMatch = *ptr1;
  13.438 +        len1 = len;
  13.439 +      }
  13.440 +      else
  13.441 +      {
  13.442 +        *ptr0 = curMatch;
  13.443 +        ptr0 = pair;
  13.444 +        curMatch = *ptr0;
  13.445 +        len0 = len;
  13.446 +      }
  13.447 +    }
  13.448 +  }
  13.449 +}
  13.450 +
  13.451 +#define MOVE_POS \
  13.452 +  ++p->cyclicBufferPos; \
  13.453 +  p->buffer++; \
  13.454 +  if (++p->pos == p->posLimit) MatchFinder_CheckLimits(p);
  13.455 +
  13.456 +#define MOVE_POS_RET MOVE_POS return offset;
  13.457 +
  13.458 +static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; }
  13.459 +
  13.460 +#define GET_MATCHES_HEADER2(minLen, ret_op) \
  13.461 +  UInt32 lenLimit; UInt32 hashValue; const Byte *cur; UInt32 curMatch; \
  13.462 +  lenLimit = p->lenLimit; { if (lenLimit < minLen) { MatchFinder_MovePos(p); ret_op; }} \
  13.463 +  cur = p->buffer;
  13.464 +
  13.465 +#define GET_MATCHES_HEADER(minLen) GET_MATCHES_HEADER2(minLen, return 0)
  13.466 +#define SKIP_HEADER(minLen)        GET_MATCHES_HEADER2(minLen, continue)
  13.467 +
  13.468 +#define MF_PARAMS(p) p->pos, p->buffer, p->son, p->cyclicBufferPos, p->cyclicBufferSize, p->cutValue
  13.469 +
  13.470 +#define GET_MATCHES_FOOTER(offset, maxLen) \
  13.471 +  offset = (UInt32)(GetMatchesSpec1(lenLimit, curMatch, MF_PARAMS(p), \
  13.472 +  distances + offset, maxLen) - distances); MOVE_POS_RET;
  13.473 +
  13.474 +#define SKIP_FOOTER \
  13.475 +  SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p)); MOVE_POS;
  13.476 +
  13.477 +static UInt32 Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
  13.478 +{
  13.479 +  UInt32 offset;
  13.480 +  GET_MATCHES_HEADER(2)
  13.481 +  HASH2_CALC;
  13.482 +  curMatch = p->hash[hashValue];
  13.483 +  p->hash[hashValue] = p->pos;
  13.484 +  offset = 0;
  13.485 +  GET_MATCHES_FOOTER(offset, 1)
  13.486 +}
  13.487 +
  13.488 +UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
  13.489 +{
  13.490 +  UInt32 offset;
  13.491 +  GET_MATCHES_HEADER(3)
  13.492 +  HASH_ZIP_CALC;
  13.493 +  curMatch = p->hash[hashValue];
  13.494 +  p->hash[hashValue] = p->pos;
  13.495 +  offset = 0;
  13.496 +  GET_MATCHES_FOOTER(offset, 2)
  13.497 +}
  13.498 +
  13.499 +static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
  13.500 +{
  13.501 +  UInt32 hash2Value, delta2, maxLen, offset;
  13.502 +  GET_MATCHES_HEADER(3)
  13.503 +
  13.504 +  HASH3_CALC;
  13.505 +
  13.506 +  delta2 = p->pos - p->hash[hash2Value];
  13.507 +  curMatch = p->hash[kFix3HashSize + hashValue];
  13.508 +  
  13.509 +  p->hash[hash2Value] =
  13.510 +  p->hash[kFix3HashSize + hashValue] = p->pos;
  13.511 +
  13.512 +
  13.513 +  maxLen = 2;
  13.514 +  offset = 0;
  13.515 +  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
  13.516 +  {
  13.517 +    for (; maxLen != lenLimit; maxLen++)
  13.518 +      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
  13.519 +        break;
  13.520 +    distances[0] = maxLen;
  13.521 +    distances[1] = delta2 - 1;
  13.522 +    offset = 2;
  13.523 +    if (maxLen == lenLimit)
  13.524 +    {
  13.525 +      SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p));
  13.526 +      MOVE_POS_RET;
  13.527 +    }
  13.528 +  }
  13.529 +  GET_MATCHES_FOOTER(offset, maxLen)
  13.530 +}
  13.531 +
  13.532 +static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
  13.533 +{
  13.534 +  UInt32 hash2Value, hash3Value, delta2, delta3, maxLen, offset;
  13.535 +  GET_MATCHES_HEADER(4)
  13.536 +
  13.537 +  HASH4_CALC;
  13.538 +
  13.539 +  delta2 = p->pos - p->hash[                hash2Value];
  13.540 +  delta3 = p->pos - p->hash[kFix3HashSize + hash3Value];
  13.541 +  curMatch = p->hash[kFix4HashSize + hashValue];
  13.542 +  
  13.543 +  p->hash[                hash2Value] =
  13.544 +  p->hash[kFix3HashSize + hash3Value] =
  13.545 +  p->hash[kFix4HashSize + hashValue] = p->pos;
  13.546 +
  13.547 +  maxLen = 1;
  13.548 +  offset = 0;
  13.549 +  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
  13.550 +  {
  13.551 +    distances[0] = maxLen = 2;
  13.552 +    distances[1] = delta2 - 1;
  13.553 +    offset = 2;
  13.554 +  }
  13.555 +  if (delta2 != delta3 && delta3 < p->cyclicBufferSize && *(cur - delta3) == *cur)
  13.556 +  {
  13.557 +    maxLen = 3;
  13.558 +    distances[offset + 1] = delta3 - 1;
  13.559 +    offset += 2;
  13.560 +    delta2 = delta3;
  13.561 +  }
  13.562 +  if (offset != 0)
  13.563 +  {
  13.564 +    for (; maxLen != lenLimit; maxLen++)
  13.565 +      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
  13.566 +        break;
  13.567 +    distances[offset - 2] = maxLen;
  13.568 +    if (maxLen == lenLimit)
  13.569 +    {
  13.570 +      SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p));
  13.571 +      MOVE_POS_RET;
  13.572 +    }
  13.573 +  }
  13.574 +  if (maxLen < 3)
  13.575 +    maxLen = 3;
  13.576 +  GET_MATCHES_FOOTER(offset, maxLen)
  13.577 +}
  13.578 +
  13.579 +static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
  13.580 +{
  13.581 +  UInt32 hash2Value, hash3Value, delta2, delta3, maxLen, offset;
  13.582 +  GET_MATCHES_HEADER(4)
  13.583 +
  13.584 +  HASH4_CALC;
  13.585 +
  13.586 +  delta2 = p->pos - p->hash[                hash2Value];
  13.587 +  delta3 = p->pos - p->hash[kFix3HashSize + hash3Value];
  13.588 +  curMatch = p->hash[kFix4HashSize + hashValue];
  13.589 +
  13.590 +  p->hash[                hash2Value] =
  13.591 +  p->hash[kFix3HashSize + hash3Value] =
  13.592 +  p->hash[kFix4HashSize + hashValue] = p->pos;
  13.593 +
  13.594 +  maxLen = 1;
  13.595 +  offset = 0;
  13.596 +  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
  13.597 +  {
  13.598 +    distances[0] = maxLen = 2;
  13.599 +    distances[1] = delta2 - 1;
  13.600 +    offset = 2;
  13.601 +  }
  13.602 +  if (delta2 != delta3 && delta3 < p->cyclicBufferSize && *(cur - delta3) == *cur)
  13.603 +  {
  13.604 +    maxLen = 3;
  13.605 +    distances[offset + 1] = delta3 - 1;
  13.606 +    offset += 2;
  13.607 +    delta2 = delta3;
  13.608 +  }
  13.609 +  if (offset != 0)
  13.610 +  {
  13.611 +    for (; maxLen != lenLimit; maxLen++)
  13.612 +      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
  13.613 +        break;
  13.614 +    distances[offset - 2] = maxLen;
  13.615 +    if (maxLen == lenLimit)
  13.616 +    {
  13.617 +      p->son[p->cyclicBufferPos] = curMatch;
  13.618 +      MOVE_POS_RET;
  13.619 +    }
  13.620 +  }
  13.621 +  if (maxLen < 3)
  13.622 +    maxLen = 3;
  13.623 +  offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
  13.624 +    distances + offset, maxLen) - (distances));
  13.625 +  MOVE_POS_RET
  13.626 +}
  13.627 +
  13.628 +UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
  13.629 +{
  13.630 +  UInt32 offset;
  13.631 +  GET_MATCHES_HEADER(3)
  13.632 +  HASH_ZIP_CALC;
  13.633 +  curMatch = p->hash[hashValue];
  13.634 +  p->hash[hashValue] = p->pos;
  13.635 +  offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
  13.636 +    distances, 2) - (distances));
  13.637 +  MOVE_POS_RET
  13.638 +}
  13.639 +
  13.640 +static void Bt2_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
  13.641 +{
  13.642 +  do
  13.643 +  {
  13.644 +    SKIP_HEADER(2)
  13.645 +    HASH2_CALC;
  13.646 +    curMatch = p->hash[hashValue];
  13.647 +    p->hash[hashValue] = p->pos;
  13.648 +    SKIP_FOOTER
  13.649 +  }
  13.650 +  while (--num != 0);
  13.651 +}
  13.652 +
  13.653 +void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
  13.654 +{
  13.655 +  do
  13.656 +  {
  13.657 +    SKIP_HEADER(3)
  13.658 +    HASH_ZIP_CALC;
  13.659 +    curMatch = p->hash[hashValue];
  13.660 +    p->hash[hashValue] = p->pos;
  13.661 +    SKIP_FOOTER
  13.662 +  }
  13.663 +  while (--num != 0);
  13.664 +}
  13.665 +
  13.666 +static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
  13.667 +{
  13.668 +  do
  13.669 +  {
  13.670 +    UInt32 hash2Value;
  13.671 +    SKIP_HEADER(3)
  13.672 +    HASH3_CALC;
  13.673 +    curMatch = p->hash[kFix3HashSize + hashValue];
  13.674 +    p->hash[hash2Value] =
  13.675 +    p->hash[kFix3HashSize + hashValue] = p->pos;
  13.676 +    SKIP_FOOTER
  13.677 +  }
  13.678 +  while (--num != 0);
  13.679 +}
  13.680 +
  13.681 +static void Bt4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
  13.682 +{
  13.683 +  do
  13.684 +  {
  13.685 +    UInt32 hash2Value, hash3Value;
  13.686 +    SKIP_HEADER(4)
  13.687 +    HASH4_CALC;
  13.688 +    curMatch = p->hash[kFix4HashSize + hashValue];
  13.689 +    p->hash[                hash2Value] =
  13.690 +    p->hash[kFix3HashSize + hash3Value] = p->pos;
  13.691 +    p->hash[kFix4HashSize + hashValue] = p->pos;
  13.692 +    SKIP_FOOTER
  13.693 +  }
  13.694 +  while (--num != 0);
  13.695 +}
  13.696 +
  13.697 +static void Hc4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
  13.698 +{
  13.699 +  do
  13.700 +  {
  13.701 +    UInt32 hash2Value, hash3Value;
  13.702 +    SKIP_HEADER(4)
  13.703 +    HASH4_CALC;
  13.704 +    curMatch = p->hash[kFix4HashSize + hashValue];
  13.705 +    p->hash[                hash2Value] =
  13.706 +    p->hash[kFix3HashSize + hash3Value] =
  13.707 +    p->hash[kFix4HashSize + hashValue] = p->pos;
  13.708 +    p->son[p->cyclicBufferPos] = curMatch;
  13.709 +    MOVE_POS
  13.710 +  }
  13.711 +  while (--num != 0);
  13.712 +}
  13.713 +
  13.714 +void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
  13.715 +{
  13.716 +  do
  13.717 +  {
  13.718 +    SKIP_HEADER(3)
  13.719 +    HASH_ZIP_CALC;
  13.720 +    curMatch = p->hash[hashValue];
  13.721 +    p->hash[hashValue] = p->pos;
  13.722 +    p->son[p->cyclicBufferPos] = curMatch;
  13.723 +    MOVE_POS
  13.724 +  }
  13.725 +  while (--num != 0);
  13.726 +}
  13.727 +
  13.728 +void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable)
  13.729 +{
  13.730 +  vTable->Init = (Mf_Init_Func)MatchFinder_Init;
  13.731 +  vTable->GetIndexByte = (Mf_GetIndexByte_Func)MatchFinder_GetIndexByte;
  13.732 +  vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinder_GetNumAvailableBytes;
  13.733 +  vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinder_GetPointerToCurrentPos;
  13.734 +  if (!p->btMode)
  13.735 +  {
  13.736 +    vTable->GetMatches = (Mf_GetMatches_Func)Hc4_MatchFinder_GetMatches;
  13.737 +    vTable->Skip = (Mf_Skip_Func)Hc4_MatchFinder_Skip;
  13.738 +  }
  13.739 +  else if (p->numHashBytes == 2)
  13.740 +  {
  13.741 +    vTable->GetMatches = (Mf_GetMatches_Func)Bt2_MatchFinder_GetMatches;
  13.742 +    vTable->Skip = (Mf_Skip_Func)Bt2_MatchFinder_Skip;
  13.743 +  }
  13.744 +  else if (p->numHashBytes == 3)
  13.745 +  {
  13.746 +    vTable->GetMatches = (Mf_GetMatches_Func)Bt3_MatchFinder_GetMatches;
  13.747 +    vTable->Skip = (Mf_Skip_Func)Bt3_MatchFinder_Skip;
  13.748 +  }
  13.749 +  else
  13.750 +  {
  13.751 +    vTable->GetMatches = (Mf_GetMatches_Func)Bt4_MatchFinder_GetMatches;
  13.752 +    vTable->Skip = (Mf_Skip_Func)Bt4_MatchFinder_Skip;
  13.753 +  }
  13.754 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/libs/openctm/liblzma/LzFind.h	Thu Sep 26 04:47:05 2013 +0300
    14.3 @@ -0,0 +1,107 @@
    14.4 +/* LzFind.h -- Match finder for LZ algorithms
    14.5 +2008-10-04 : Igor Pavlov : Public domain */
    14.6 +
    14.7 +#ifndef __LZFIND_H
    14.8 +#define __LZFIND_H
    14.9 +
   14.10 +#include "Types.h"
   14.11 +
   14.12 +typedef UInt32 CLzRef;
   14.13 +
   14.14 +typedef struct _CMatchFinder
   14.15 +{
   14.16 +  Byte *buffer;
   14.17 +  UInt32 pos;
   14.18 +  UInt32 posLimit;
   14.19 +  UInt32 streamPos;
   14.20 +  UInt32 lenLimit;
   14.21 +
   14.22 +  UInt32 cyclicBufferPos;
   14.23 +  UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
   14.24 +
   14.25 +  UInt32 matchMaxLen;
   14.26 +  CLzRef *hash;
   14.27 +  CLzRef *son;
   14.28 +  UInt32 hashMask;
   14.29 +  UInt32 cutValue;
   14.30 +
   14.31 +  Byte *bufferBase;
   14.32 +  ISeqInStream *stream;
   14.33 +  int streamEndWasReached;
   14.34 +
   14.35 +  UInt32 blockSize;
   14.36 +  UInt32 keepSizeBefore;
   14.37 +  UInt32 keepSizeAfter;
   14.38 +
   14.39 +  UInt32 numHashBytes;
   14.40 +  int directInput;
   14.41 +  int btMode;
   14.42 +  /* int skipModeBits; */
   14.43 +  int bigHash;
   14.44 +  UInt32 historySize;
   14.45 +  UInt32 fixedHashSize;
   14.46 +  UInt32 hashSizeSum;
   14.47 +  UInt32 numSons;
   14.48 +  SRes result;
   14.49 +  UInt32 crc[256];
   14.50 +} CMatchFinder;
   14.51 +
   14.52 +#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((p)->buffer)
   14.53 +#define Inline_MatchFinder_GetIndexByte(p, index) ((p)->buffer[(Int32)(index)])
   14.54 +
   14.55 +#define Inline_MatchFinder_GetNumAvailableBytes(p) ((p)->streamPos - (p)->pos)
   14.56 +
   14.57 +int MatchFinder_NeedMove(CMatchFinder *p);
   14.58 +Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
   14.59 +void MatchFinder_MoveBlock(CMatchFinder *p);
   14.60 +void MatchFinder_ReadIfRequired(CMatchFinder *p);
   14.61 +
   14.62 +void MatchFinder_Construct(CMatchFinder *p);
   14.63 +
   14.64 +/* Conditions:
   14.65 +     historySize <= 3 GB
   14.66 +     keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB
   14.67 +*/
   14.68 +int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
   14.69 +    UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
   14.70 +    ISzAlloc *alloc);
   14.71 +void MatchFinder_Free(CMatchFinder *p, ISzAlloc *alloc);
   14.72 +void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems);
   14.73 +void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
   14.74 +
   14.75 +UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
   14.76 +    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
   14.77 +    UInt32 *distances, UInt32 maxLen);
   14.78 +
   14.79 +/*
   14.80 +Conditions:
   14.81 +  Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func.
   14.82 +  Mf_GetPointerToCurrentPos_Func's result must be used only before any other function
   14.83 +*/
   14.84 +
   14.85 +typedef void (*Mf_Init_Func)(void *object);
   14.86 +typedef Byte (*Mf_GetIndexByte_Func)(void *object, Int32 index);
   14.87 +typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
   14.88 +typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
   14.89 +typedef UInt32 (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
   14.90 +typedef void (*Mf_Skip_Func)(void *object, UInt32);
   14.91 +
   14.92 +typedef struct _IMatchFinder
   14.93 +{
   14.94 +  Mf_Init_Func Init;
   14.95 +  Mf_GetIndexByte_Func GetIndexByte;
   14.96 +  Mf_GetNumAvailableBytes_Func GetNumAvailableBytes;
   14.97 +  Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos;
   14.98 +  Mf_GetMatches_Func GetMatches;
   14.99 +  Mf_Skip_Func Skip;
  14.100 +} IMatchFinder;
  14.101 +
  14.102 +void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable);
  14.103 +
  14.104 +void MatchFinder_Init(CMatchFinder *p);
  14.105 +UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
  14.106 +UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
  14.107 +void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
  14.108 +void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
  14.109 +
  14.110 +#endif

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/libs/openctm/liblzma/LzHash.h	Thu Sep 26 04:47:05 2013 +0300
    15.3 @@ -0,0 +1,54 @@
    15.4 +/* LzHash.h -- HASH functions for LZ algorithms
    15.5 +2008-10-04 : Igor Pavlov : Public domain */
    15.6 +
    15.7 +#ifndef __LZHASH_H
    15.8 +#define __LZHASH_H
    15.9 +
   15.10 +#define kHash2Size (1 << 10)
   15.11 +#define kHash3Size (1 << 16)
   15.12 +#define kHash4Size (1 << 20)
   15.13 +
   15.14 +#define kFix3HashSize (kHash2Size)
   15.15 +#define kFix4HashSize (kHash2Size + kHash3Size)
   15.16 +#define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
   15.17 +
   15.18 +#define HASH2_CALC hashValue = cur[0] | ((UInt32)cur[1] << 8);
   15.19 +
   15.20 +#define HASH3_CALC { \
   15.21 +  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
   15.22 +  hash2Value = temp & (kHash2Size - 1); \
   15.23 +  hashValue = (temp ^ ((UInt32)cur[2] << 8)) & p->hashMask; }
   15.24 +
   15.25 +#define HASH4_CALC { \
   15.26 +  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
   15.27 +  hash2Value = temp & (kHash2Size - 1); \
   15.28 +  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
   15.29 +  hashValue = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & p->hashMask; }
   15.30 +
   15.31 +#define HASH5_CALC { \
   15.32 +  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
   15.33 +  hash2Value = temp & (kHash2Size - 1); \
   15.34 +  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
   15.35 +  hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)); \
   15.36 +  hashValue = (hash4Value ^ (p->crc[cur[4]] << 3)) & p->hashMask; \
   15.37 +  hash4Value &= (kHash4Size - 1); }
   15.38 +
   15.39 +/* #define HASH_ZIP_CALC hashValue = ((cur[0] | ((UInt32)cur[1] << 8)) ^ p->crc[cur[2]]) & 0xFFFF; */
   15.40 +#define HASH_ZIP_CALC hashValue = ((cur[2] | ((UInt32)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF;
   15.41 +
   15.42 +
   15.43 +#define MT_HASH2_CALC \
   15.44 +  hash2Value = (p->crc[cur[0]] ^ cur[1]) & (kHash2Size - 1);
   15.45 +
   15.46 +#define MT_HASH3_CALC { \
   15.47 +  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
   15.48 +  hash2Value = temp & (kHash2Size - 1); \
   15.49 +  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); }
   15.50 +
   15.51 +#define MT_HASH4_CALC { \
   15.52 +  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
   15.53 +  hash2Value = temp & (kHash2Size - 1); \
   15.54 +  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
   15.55 +  hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & (kHash4Size - 1); }
   15.56 +
   15.57 +#endif

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/libs/openctm/liblzma/LzmaDec.c	Thu Sep 26 04:47:05 2013 +0300
    16.3 @@ -0,0 +1,1007 @@
    16.4 +/* LzmaDec.c -- LZMA Decoder
    16.5 +2008-11-06 : Igor Pavlov : Public domain */
    16.6 +
    16.7 +#include "LzmaDec.h"
    16.8 +
    16.9 +#include <string.h>
   16.10 +
   16.11 +#define kNumTopBits 24
   16.12 +#define kTopValue ((UInt32)1 << kNumTopBits)
   16.13 +
   16.14 +#define kNumBitModelTotalBits 11
   16.15 +#define kBitModelTotal (1 << kNumBitModelTotalBits)
   16.16 +#define kNumMoveBits 5
   16.17 +
   16.18 +#define RC_INIT_SIZE 5
   16.19 +
   16.20 +#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
   16.21 +
   16.22 +#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
   16.23 +#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
   16.24 +#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));
   16.25 +#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \
   16.26 +  { UPDATE_0(p); i = (i + i); A0; } else \
   16.27 +  { UPDATE_1(p); i = (i + i) + 1; A1; }
   16.28 +#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;)
   16.29 +
   16.30 +#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); }
   16.31 +#define TREE_DECODE(probs, limit, i) \
   16.32 +  { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }
   16.33 +
   16.34 +/* #define _LZMA_SIZE_OPT */
   16.35 +
   16.36 +#ifdef _LZMA_SIZE_OPT
   16.37 +#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)
   16.38 +#else
   16.39 +#define TREE_6_DECODE(probs, i) \
   16.40 +  { i = 1; \
   16.41 +  TREE_GET_BIT(probs, i); \
   16.42 +  TREE_GET_BIT(probs, i); \
   16.43 +  TREE_GET_BIT(probs, i); \
   16.44 +  TREE_GET_BIT(probs, i); \
   16.45 +  TREE_GET_BIT(probs, i); \
   16.46 +  TREE_GET_BIT(probs, i); \
   16.47 +  i -= 0x40; }
   16.48 +#endif
   16.49 +
   16.50 +#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }
   16.51 +
   16.52 +#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
   16.53 +#define UPDATE_0_CHECK range = bound;
   16.54 +#define UPDATE_1_CHECK range -= bound; code -= bound;
   16.55 +#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
   16.56 +  { UPDATE_0_CHECK; i = (i + i); A0; } else \
   16.57 +  { UPDATE_1_CHECK; i = (i + i) + 1; A1; }
   16.58 +#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)
   16.59 +#define TREE_DECODE_CHECK(probs, limit, i) \
   16.60 +  { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }
   16.61 +
   16.62 +
   16.63 +#define kNumPosBitsMax 4
   16.64 +#define kNumPosStatesMax (1 << kNumPosBitsMax)
   16.65 +
   16.66 +#define kLenNumLowBits 3
   16.67 +#define kLenNumLowSymbols (1 << kLenNumLowBits)
   16.68 +#define kLenNumMidBits 3
   16.69 +#define kLenNumMidSymbols (1 << kLenNumMidBits)
   16.70 +#define kLenNumHighBits 8
   16.71 +#define kLenNumHighSymbols (1 << kLenNumHighBits)
   16.72 +
   16.73 +#define LenChoice 0
   16.74 +#define LenChoice2 (LenChoice + 1)
   16.75 +#define LenLow (LenChoice2 + 1)
   16.76 +#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
   16.77 +#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
   16.78 +#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
   16.79 +
   16.80 +
   16.81 +#define kNumStates 12
   16.82 +#define kNumLitStates 7
   16.83 +
   16.84 +#define kStartPosModelIndex 4
   16.85 +#define kEndPosModelIndex 14
   16.86 +#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
   16.87 +
   16.88 +#define kNumPosSlotBits 6
   16.89 +#define kNumLenToPosStates 4
   16.90 +
   16.91 +#define kNumAlignBits 4
   16.92 +#define kAlignTableSize (1 << kNumAlignBits)
   16.93 +
   16.94 +#define kMatchMinLen 2
   16.95 +#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)
   16.96 +
   16.97 +#define IsMatch 0
   16.98 +#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
   16.99 +#define IsRepG0 (IsRep + kNumStates)
  16.100 +#define IsRepG1 (IsRepG0 + kNumStates)
  16.101 +#define IsRepG2 (IsRepG1 + kNumStates)
  16.102 +#define IsRep0Long (IsRepG2 + kNumStates)
  16.103 +#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
  16.104 +#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
  16.105 +#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
  16.106 +#define LenCoder (Align + kAlignTableSize)
  16.107 +#define RepLenCoder (LenCoder + kNumLenProbs)
  16.108 +#define Literal (RepLenCoder + kNumLenProbs)
  16.109 +
  16.110 +#define LZMA_BASE_SIZE 1846
  16.111 +#define LZMA_LIT_SIZE 768
  16.112 +
  16.113 +#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
  16.114 +
  16.115 +#if Literal != LZMA_BASE_SIZE
  16.116 +StopCompilingDueBUG
  16.117 +#endif
  16.118 +
  16.119 +static const Byte kLiteralNextStates[kNumStates * 2] =
  16.120 +{
  16.121 +  0, 0, 0, 0, 1, 2, 3,  4,  5,  6,  4,  5,
  16.122 +  7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10
  16.123 +};
  16.124 +
  16.125 +#define LZMA_DIC_MIN (1 << 12)
  16.126 +
  16.127 +/* First LZMA-symbol is always decoded.
  16.128 +And it decodes new LZMA-symbols while (buf < bufLimit), but "buf" is without last normalization
  16.129 +Out:
  16.130 +  Result:
  16.131 +    SZ_OK - OK
  16.132 +    SZ_ERROR_DATA - Error
  16.133 +  p->remainLen:
  16.134 +    < kMatchSpecLenStart : normal remain
  16.135 +    = kMatchSpecLenStart : finished
  16.136 +    = kMatchSpecLenStart + 1 : Flush marker
  16.137 +    = kMatchSpecLenStart + 2 : State Init Marker
  16.138 +*/
  16.139 +
  16.140 +static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
  16.141 +{
  16.142 +  CLzmaProb *probs = p->probs;
  16.143 +
  16.144 +  unsigned state = p->state;
  16.145 +  UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
  16.146 +  unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
  16.147 +  unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
  16.148 +  unsigned lc = p->prop.lc;
  16.149 +
  16.150 +  Byte *dic = p->dic;
  16.151 +  SizeT dicBufSize = p->dicBufSize;
  16.152 +  SizeT dicPos = p->dicPos;
  16.153 +  
  16.154 +  UInt32 processedPos = p->processedPos;
  16.155 +  UInt32 checkDicSize = p->checkDicSize;
  16.156 +  unsigned len = 0;
  16.157 +
  16.158 +  const Byte *buf = p->buf;
  16.159 +  UInt32 range = p->range;
  16.160 +  UInt32 code = p->code;
  16.161 +
  16.162 +  do
  16.163 +  {
  16.164 +    CLzmaProb *prob;
  16.165 +    UInt32 bound;
  16.166 +    unsigned ttt;
  16.167 +    unsigned posState = processedPos & pbMask;
  16.168 +
  16.169 +    prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
  16.170 +    IF_BIT_0(prob)
  16.171 +    {
  16.172 +      unsigned symbol;
  16.173 +      UPDATE_0(prob);
  16.174 +      prob = probs + Literal;
  16.175 +      if (checkDicSize != 0 || processedPos != 0)
  16.176 +        prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) +
  16.177 +        (dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc))));
  16.178 +
  16.179 +      if (state < kNumLitStates)
  16.180 +      {
  16.181 +        symbol = 1;
  16.182 +        do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100);
  16.183 +      }
  16.184 +      else
  16.185 +      {
  16.186 +        unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
  16.187 +        unsigned offs = 0x100;
  16.188 +        symbol = 1;
  16.189 +        do
  16.190 +        {
  16.191 +          unsigned bit;
  16.192 +          CLzmaProb *probLit;
  16.193 +          matchByte <<= 1;
  16.194 +          bit = (matchByte & offs);
  16.195 +          probLit = prob + offs + bit + symbol;
  16.196 +          GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)
  16.197 +        }
  16.198 +        while (symbol < 0x100);
  16.199 +      }
  16.200 +      dic[dicPos++] = (Byte)symbol;
  16.201 +      processedPos++;
  16.202 +
  16.203 +      state = kLiteralNextStates[state];
  16.204 +      /* if (state < 4) state = 0; else if (state < 10) state -= 3; else state -= 6; */
  16.205 +      continue;
  16.206 +    }
  16.207 +    else
  16.208 +    {
  16.209 +      UPDATE_1(prob);
  16.210 +      prob = probs + IsRep + state;
  16.211 +      IF_BIT_0(prob)
  16.212 +      {
  16.213 +        UPDATE_0(prob);
  16.214 +        state += kNumStates;
  16.215 +        prob = probs + LenCoder;
  16.216 +      }
  16.217 +      else
  16.218 +      {
  16.219 +        UPDATE_1(prob);
  16.220 +        if (checkDicSize == 0 && processedPos == 0)
  16.221 +          return SZ_ERROR_DATA;
  16.222 +        prob = probs + IsRepG0 + state;
  16.223 +        IF_BIT_0(prob)
  16.224 +        {
  16.225 +          UPDATE_0(prob);
  16.226 +          prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
  16.227 +          IF_BIT_0(prob)
  16.228 +          {
  16.229 +            UPDATE_0(prob);
  16.230 +            dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
  16.231 +            dicPos++;
  16.232 +            processedPos++;
  16.233 +            state = state < kNumLitStates ? 9 : 11;
  16.234 +            continue;
  16.235 +          }
  16.236 +          UPDATE_1(prob);
  16.237 +        }
  16.238 +        else
  16.239 +        {
  16.240 +          UInt32 distance;
  16.241 +          UPDATE_1(prob);
  16.242 +          prob = probs + IsRepG1 + state;
  16.243 +          IF_BIT_0(prob)
  16.244 +          {
  16.245 +            UPDATE_0(prob);
  16.246 +            distance = rep1;
  16.247 +          }
  16.248 +          else
  16.249 +          {
  16.250 +            UPDATE_1(prob);
  16.251 +            prob = probs + IsRepG2 + state;
  16.252 +            IF_BIT_0(prob)
  16.253 +            {
  16.254 +              UPDATE_0(prob);
  16.255 +              distance = rep2;
  16.256 +            }
  16.257 +            else
  16.258 +            {
  16.259 +              UPDATE_1(prob);
  16.260 +              distance = rep3;
  16.261 +              rep3 = rep2;
  16.262 +            }
  16.263 +            rep2 = rep1;
  16.264 +          }
  16.265 +          rep1 = rep0;
  16.266 +          rep0 = distance;
  16.267 +        }
  16.268 +        state = state < kNumLitStates ? 8 : 11;
  16.269 +        prob = probs + RepLenCoder;
  16.270 +      }
  16.271 +      {
  16.272 +        unsigned limit, offset;
  16.273 +        CLzmaProb *probLen = prob + LenChoice;
  16.274 +        IF_BIT_0(probLen)
  16.275 +        {
  16.276 +          UPDATE_0(probLen);
  16.277 +          probLen = prob + LenLow + (posState << kLenNumLowBits);
  16.278 +          offset = 0;
  16.279 +          limit = (1 << kLenNumLowBits);
  16.280 +        }
  16.281 +        else
  16.282 +        {
  16.283 +          UPDATE_1(probLen);
  16.284 +          probLen = prob + LenChoice2;
  16.285 +          IF_BIT_0(probLen)
  16.286 +          {
  16.287 +            UPDATE_0(probLen);
  16.288 +            probLen = prob + LenMid + (posState << kLenNumMidBits);
  16.289 +            offset = kLenNumLowSymbols;
  16.290 +            limit = (1 << kLenNumMidBits);
  16.291 +          }
  16.292 +          else
  16.293 +          {
  16.294 +            UPDATE_1(probLen);
  16.295 +            probLen = prob + LenHigh;
  16.296 +            offset = kLenNumLowSymbols + kLenNumMidSymbols;
  16.297 +            limit = (1 << kLenNumHighBits);
  16.298 +          }
  16.299 +        }
  16.300 +        TREE_DECODE(probLen, limit, len);
  16.301 +        len += offset;
  16.302 +      }
  16.303 +
  16.304 +      if (state >= kNumStates)
  16.305 +      {
  16.306 +        UInt32 distance;
  16.307 +        prob = probs + PosSlot +
  16.308 +            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
  16.309 +        TREE_6_DECODE(prob, distance);
  16.310 +        if (distance >= kStartPosModelIndex)
  16.311 +        {
  16.312 +          unsigned posSlot = (unsigned)distance;
  16.313 +          int numDirectBits = (int)(((distance >> 1) - 1));
  16.314 +          distance = (2 | (distance & 1));
  16.315 +          if (posSlot < kEndPosModelIndex)
  16.316 +          {
  16.317 +            distance <<= numDirectBits;
  16.318 +            prob = probs + SpecPos + distance - posSlot - 1;
  16.319 +            {
  16.320 +              UInt32 mask = 1;
  16.321 +              unsigned i = 1;
  16.322 +              do
  16.323 +              {
  16.324 +                GET_BIT2(prob + i, i, ; , distance |= mask);
  16.325 +                mask <<= 1;
  16.326 +              }
  16.327 +              while (--numDirectBits != 0);
  16.328 +            }
  16.329 +          }
  16.330 +          else
  16.331 +          {
  16.332 +            numDirectBits -= kNumAlignBits;
  16.333 +            do
  16.334 +            {
  16.335 +              NORMALIZE
  16.336 +              range >>= 1;
  16.337 +              
  16.338 +              {
  16.339 +                UInt32 t;
  16.340 +                code -= range;
  16.341 +                t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */
  16.342 +                distance = (distance << 1) + (t + 1);
  16.343 +                code += range & t;
  16.344 +              }
  16.345 +              /*
  16.346 +              distance <<= 1;
  16.347 +              if (code >= range)
  16.348 +              {
  16.349 +                code -= range;
  16.350 +                distance |= 1;
  16.351 +              }
  16.352 +              */
  16.353 +            }
  16.354 +            while (--numDirectBits != 0);
  16.355 +            prob = probs + Align;
  16.356 +            distance <<= kNumAlignBits;
  16.357 +            {
  16.358 +              unsigned i = 1;
  16.359 +              GET_BIT2(prob + i, i, ; , distance |= 1);
  16.360 +              GET_BIT2(prob + i, i, ; , distance |= 2);
  16.361 +              GET_BIT2(prob + i, i, ; , distance |= 4);
  16.362 +              GET_BIT2(prob + i, i, ; , distance |= 8);
  16.363 +            }
  16.364 +            if (distance == (UInt32)0xFFFFFFFF)
  16.365 +            {
  16.366 +              len += kMatchSpecLenStart;
  16.367 +              state -= kNumStates;
  16.368 +              break;
  16.369 +            }
  16.370 +          }
  16.371 +        }
  16.372 +        rep3 = rep2;
  16.373 +        rep2 = rep1;
  16.374 +        rep1 = rep0;
  16.375 +        rep0 = distance + 1;
  16.376 +        if (checkDicSize == 0)
  16.377 +        {
  16.378 +          if (distance >= processedPos)
  16.379 +            return SZ_ERROR_DATA;
  16.380 +        }
  16.381 +        else if (distance >= checkDicSize)
  16.382 +          return SZ_ERROR_DATA;
  16.383 +        state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
  16.384 +        /* state = kLiteralNextStates[state]; */
  16.385 +      }
  16.386 +
  16.387 +      len += kMatchMinLen;
  16.388 +
  16.389 +      if (limit == dicPos)
  16.390 +        return SZ_ERROR_DATA;
  16.391 +      {
  16.392 +        SizeT rem = limit - dicPos;
  16.393 +        unsigned curLen = ((rem < len) ? (unsigned)rem : len);
  16.394 +        SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0);
  16.395 +
  16.396 +        processedPos += curLen;
  16.397 +
  16.398 +        len -= curLen;
  16.399 +        if (pos + curLen <= dicBufSize)
  16.400 +        {
  16.401 +          Byte *dest = dic + dicPos;
  16.402 +          ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
  16.403 +          const Byte *lim = dest + curLen;
  16.404 +          dicPos += curLen;
  16.405 +          do
  16.406 +            *(dest) = (Byte)*(dest + src);
  16.407 +          while (++dest != lim);
  16.408 +        }
  16.409 +        else
  16.410 +        {
  16.411 +          do
  16.412 +          {
  16.413 +            dic[dicPos++] = dic[pos];
  16.414 +            if (++pos == dicBufSize)
  16.415 +              pos = 0;
  16.416 +          }
  16.417 +          while (--curLen != 0);
  16.418 +        }
  16.419 +      }
  16.420 +    }
  16.421 +  }
  16.422 +  while (dicPos < limit && buf < bufLimit);
  16.423 +  NORMALIZE;
  16.424 +  p->buf = buf;
  16.425 +  p->range = range;
  16.426 +  p->code = code;
  16.427 +  p->remainLen = len;
  16.428 +  p->dicPos = dicPos;
  16.429 +  p->processedPos = processedPos;
  16.430 +  p->reps[0] = rep0;
  16.431 +  p->reps[1] = rep1;
  16.432 +  p->reps[2] = rep2;
  16.433 +  p->reps[3] = rep3;
  16.434 +  p->state = state;
  16.435 +
  16.436 +  return SZ_OK;
  16.437 +}
  16.438 +
  16.439 +static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
  16.440 +{
  16.441 +  if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
  16.442 +  {
  16.443 +    Byte *dic = p->dic;
  16.444 +    SizeT dicPos = p->dicPos;
  16.445 +    SizeT dicBufSize = p->dicBufSize;
  16.446 +    unsigned len = p->remainLen;
  16.447 +    UInt32 rep0 = p->reps[0];
  16.448 +    if (limit - dicPos < len)
  16.449 +      len = (unsigned)(limit - dicPos);
  16.450 +
  16.451 +    if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
  16.452 +      p->checkDicSize = p->prop.dicSize;
  16.453 +
  16.454 +    p->processedPos += len;
  16.455 +    p->remainLen -= len;
  16.456 +    while (len-- != 0)
  16.457 +    {
  16.458 +      dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
  16.459 +      dicPos++;
  16.460 +    }
  16.461 +    p->dicPos = dicPos;
  16.462 +  }
  16.463 +}
  16.464 +
  16.465 +static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
  16.466 +{
  16.467 +  do
  16.468 +  {
  16.469 +    SizeT limit2 = limit;
  16.470 +    if (p->checkDicSize == 0)
  16.471 +    {
  16.472 +      UInt32 rem = p->prop.dicSize - p->processedPos;
  16.473 +      if (limit - p->dicPos > rem)
  16.474 +        limit2 = p->dicPos + rem;
  16.475 +    }
  16.476 +    RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit));
  16.477 +    if (p->processedPos >= p->prop.dicSize)
  16.478 +      p->checkDicSize = p->prop.dicSize;
  16.479 +    LzmaDec_WriteRem(p, limit);
  16.480 +  }
  16.481 +  while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
  16.482 +
  16.483 +  if (p->remainLen > kMatchSpecLenStart)
  16.484 +  {
  16.485 +    p->remainLen = kMatchSpecLenStart;
  16.486 +  }
  16.487 +  return 0;
  16.488 +}
  16.489 +
  16.490 +typedef enum
  16.491 +{
  16.492 +  DUMMY_ERROR, /* unexpected end of input stream */
  16.493 +  DUMMY_LIT,
  16.494 +  DUMMY_MATCH,
  16.495 +  DUMMY_REP
  16.496 +} ELzmaDummy;
  16.497 +
  16.498 +static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
  16.499 +{
  16.500 +  UInt32 range = p->range;
  16.501 +  UInt32 code = p->code;
  16.502 +  const Byte *bufLimit = buf + inSize;
  16.503 +  CLzmaProb *probs = p->probs;
  16.504 +  unsigned state = p->state;
  16.505 +  ELzmaDummy res;
  16.506 +
  16.507 +  {
  16.508 +    CLzmaProb *prob;
  16.509 +    UInt32 bound;
  16.510 +    unsigned ttt;
  16.511 +    unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
  16.512 +
  16.513 +    prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
  16.514 +    IF_BIT_0_CHECK(prob)
  16.515 +    {
  16.516 +      UPDATE_0_CHECK
  16.517 +
  16.518 +      /* if (bufLimit - buf >= 7) return DUMMY_LIT; */
  16.519 +
  16.520 +      prob = probs + Literal;
  16.521 +      if (p->checkDicSize != 0 || p->processedPos != 0)
  16.522 +        prob += (LZMA_LIT_SIZE *
  16.523 +          ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
  16.524 +          (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
  16.525 +
  16.526 +      if (state < kNumLitStates)
  16.527 +      {
  16.528 +        unsigned symbol = 1;
  16.529 +        do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);
  16.530 +      }
  16.531 +      else
  16.532 +      {
  16.533 +        unsigned matchByte = p->dic[p->dicPos - p->reps[0] +
  16.534 +            ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];
  16.535 +        unsigned offs = 0x100;
  16.536 +        unsigned symbol = 1;
  16.537 +        do
  16.538 +        {
  16.539 +          unsigned bit;
  16.540 +          CLzmaProb *probLit;
  16.541 +          matchByte <<= 1;
  16.542 +          bit = (matchByte & offs);
  16.543 +          probLit = prob + offs + bit + symbol;
  16.544 +          GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit)
  16.545 +        }
  16.546 +        while (symbol < 0x100);
  16.547 +      }
  16.548 +      res = DUMMY_LIT;
  16.549 +    }
  16.550 +    else
  16.551 +    {
  16.552 +      unsigned len;
  16.553 +      UPDATE_1_CHECK;
  16.554 +
  16.555 +      prob = probs + IsRep + state;
  16.556 +      IF_BIT_0_CHECK(prob)
  16.557 +      {
  16.558 +        UPDATE_0_CHECK;
  16.559 +        state = 0;
  16.560 +        prob = probs + LenCoder;
  16.561 +        res = DUMMY_MATCH;
  16.562 +      }
  16.563 +      else
  16.564 +      {
  16.565 +        UPDATE_1_CHECK;
  16.566 +        res = DUMMY_REP;
  16.567 +        prob = probs + IsRepG0 + state;
  16.568 +        IF_BIT_0_CHECK(prob)
  16.569 +        {
  16.570 +          UPDATE_0_CHECK;
  16.571 +          prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
  16.572 +          IF_BIT_0_CHECK(prob)
  16.573 +          {
  16.574 +            UPDATE_0_CHECK;
  16.575 +            NORMALIZE_CHECK;
  16.576 +            return DUMMY_REP;
  16.577 +          }
  16.578 +          else
  16.579 +          {
  16.580 +            UPDATE_1_CHECK;
  16.581 +          }
  16.582 +        }
  16.583 +        else
  16.584 +        {
  16.585 +          UPDATE_1_CHECK;
  16.586 +          prob = probs + IsRepG1 + state;
  16.587 +          IF_BIT_0_CHECK(prob)
  16.588 +          {
  16.589 +            UPDATE_0_CHECK;
  16.590 +          }
  16.591 +          else
  16.592 +          {
  16.593 +            UPDATE_1_CHECK;
  16.594 +            prob = probs + IsRepG2 + state;
  16.595 +            IF_BIT_0_CHECK(prob)
  16.596 +            {
  16.597 +              UPDATE_0_CHECK;
  16.598 +            }
  16.599 +            else
  16.600 +            {
  16.601 +              UPDATE_1_CHECK;
  16.602 +            }
  16.603 +          }
  16.604 +        }
  16.605 +        state = kNumStates;
  16.606 +        prob = probs + RepLenCoder;
  16.607 +      }
  16.608 +      {
  16.609 +        unsigned limit, offset;
  16.610 +        CLzmaProb *probLen = prob + LenChoice;
  16.611 +        IF_BIT_0_CHECK(probLen)
  16.612 +        {
  16.613 +          UPDATE_0_CHECK;
  16.614 +          probLen = prob + LenLow + (posState << kLenNumLowBits);
  16.615 +          offset = 0;
  16.616 +          limit = 1 << kLenNumLowBits;
  16.617 +        }
  16.618 +        else
  16.619 +        {
  16.620 +          UPDATE_1_CHECK;
  16.621 +          probLen = prob + LenChoice2;
  16.622 +          IF_BIT_0_CHECK(probLen)
  16.623 +          {
  16.624 +            UPDATE_0_CHECK;
  16.625 +            probLen = prob + LenMid + (posState << kLenNumMidBits);
  16.626 +            offset = kLenNumLowSymbols;
  16.627 +            limit = 1 << kLenNumMidBits;
  16.628 +          }
  16.629 +          else
  16.630 +          {
  16.631 +            UPDATE_1_CHECK;
  16.632 +            probLen = prob + LenHigh;
  16.633 +            offset = kLenNumLowSymbols + kLenNumMidSymbols;
  16.634 +            limit = 1 << kLenNumHighBits;
  16.635 +          }
  16.636 +        }
  16.637 +        TREE_DECODE_CHECK(probLen, limit, len);
  16.638 +        len += offset;
  16.639 +      }
  16.640 +
  16.641 +      if (state < 4)
  16.642 +      {
  16.643 +        unsigned posSlot;
  16.644 +        prob = probs + PosSlot +
  16.645 +            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
  16.646 +            kNumPosSlotBits);
  16.647 +        TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot);
  16.648 +        if (posSlot >= kStartPosModelIndex)
  16.649 +        {
  16.650 +          int numDirectBits = ((posSlot >> 1) - 1);
  16.651 +
  16.652 +          /* if (bufLimit - buf >= 8) return DUMMY_MATCH; */
  16.653 +
  16.654 +          if (posSlot < kEndPosModelIndex)
  16.655 +          {
  16.656 +            prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1;
  16.657 +          }
  16.658 +          else
  16.659 +          {
  16.660 +            numDirectBits -= kNumAlignBits;
  16.661 +            do
  16.662 +            {
  16.663 +              NORMALIZE_CHECK
  16.664 +              range >>= 1;
  16.665 +              code -= range & (((code - range) >> 31) - 1);
  16.666 +              /* if (code >= range) code -= range; */
  16.667 +            }
  16.668 +            while (--numDirectBits != 0);
  16.669 +            prob = probs + Align;
  16.670 +            numDirectBits = kNumAlignBits;
  16.671 +          }
  16.672 +          {
  16.673 +            unsigned i = 1;
  16.674 +            do
  16.675 +            {
  16.676 +              GET_BIT_CHECK(prob + i, i);
  16.677 +            }
  16.678 +            while (--numDirectBits != 0);
  16.679 +          }
  16.680 +        }
  16.681 +      }
  16.682 +    }
  16.683 +  }
  16.684 +  NORMALIZE_CHECK;
  16.685 +  return res;
  16.686 +}
  16.687 +
  16.688 +
  16.689 +static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)
  16.690 +{
  16.691 +  p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);
  16.692 +  p->range = 0xFFFFFFFF;
  16.693 +  p->needFlush = 0;
  16.694 +}
  16.695 +
  16.696 +void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
  16.697 +{
  16.698 +  p->needFlush = 1;
  16.699 +  p->remainLen = 0;
  16.700 +  p->tempBufSize = 0;
  16.701 +
  16.702 +  if (initDic)
  16.703 +  {
  16.704 +    p->processedPos = 0;
  16.705 +    p->checkDicSize = 0;
  16.706 +    p->needInitState = 1;
  16.707 +  }
  16.708 +  if (initState)
  16.709 +    p->needInitState = 1;
  16.710 +}
  16.711 +
  16.712 +void LzmaDec_Init(CLzmaDec *p)
  16.713 +{
  16.714 +  p->dicPos = 0;
  16.715 +  LzmaDec_InitDicAndState(p, True, True);
  16.716 +}
  16.717 +
  16.718 +static void LzmaDec_InitStateReal(CLzmaDec *p)
  16.719 +{
  16.720 +  UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));
  16.721 +  UInt32 i;
  16.722 +  CLzmaProb *probs = p->probs;
  16.723 +  for (i = 0; i < numProbs; i++)
  16.724 +    probs[i] = kBitModelTotal >> 1;
  16.725 +  p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
  16.726 +  p->state = 0;
  16.727 +  p->needInitState = 0;
  16.728 +}
  16.729 +
  16.730 +SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
  16.731 +    ELzmaFinishMode finishMode, ELzmaStatus *status)
  16.732 +{
  16.733 +  SizeT inSize = *srcLen;
  16.734 +  (*srcLen) = 0;
  16.735 +  LzmaDec_WriteRem(p, dicLimit);
  16.736 +  
  16.737 +  *status = LZMA_STATUS_NOT_SPECIFIED;
  16.738 +
  16.739 +  while (p->remainLen != kMatchSpecLenStart)
  16.740 +  {
  16.741 +      int checkEndMarkNow;
  16.742 +
  16.743 +      if (p->needFlush != 0)
  16.744 +      {
  16.745 +        for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)
  16.746 +          p->tempBuf[p->tempBufSize++] = *src++;
  16.747 +        if (p->tempBufSize < RC_INIT_SIZE)
  16.748 +        {
  16.749 +          *status = LZMA_STATUS_NEEDS_MORE_INPUT;
  16.750 +          return SZ_OK;
  16.751 +        }
  16.752 +        if (p->tempBuf[0] != 0)
  16.753 +          return SZ_ERROR_DATA;
  16.754 +
  16.755 +        LzmaDec_InitRc(p, p->tempBuf);
  16.756 +        p->tempBufSize = 0;
  16.757 +      }
  16.758 +
  16.759 +      checkEndMarkNow = 0;
  16.760 +      if (p->dicPos >= dicLimit)
  16.761 +      {
  16.762 +        if (p->remainLen == 0 && p->code == 0)
  16.763 +        {
  16.764 +          *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK;
  16.765 +          return SZ_OK;
  16.766 +        }
  16.767 +        if (finishMode == LZMA_FINISH_ANY)
  16.768 +        {
  16.769 +          *status = LZMA_STATUS_NOT_FINISHED;
  16.770 +          return SZ_OK;
  16.771 +        }
  16.772 +        if (p->remainLen != 0)
  16.773 +        {
  16.774 +          *status = LZMA_STATUS_NOT_FINISHED;
  16.775 +          return SZ_ERROR_DATA;
  16.776 +        }
  16.777 +        checkEndMarkNow = 1;
  16.778 +      }
  16.779 +
  16.780 +      if (p->needInitState)
  16.781 +        LzmaDec_InitStateReal(p);
  16.782 +  
  16.783 +      if (p->tempBufSize == 0)
  16.784 +      {
  16.785 +        SizeT processed;
  16.786 +        const Byte *bufLimit;
  16.787 +        if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
  16.788 +        {
  16.789 +          int dummyRes = LzmaDec_TryDummy(p, src, inSize);
  16.790 +          if (dummyRes == DUMMY_ERROR)
  16.791 +          {
  16.792 +            memcpy(p->tempBuf, src, inSize);
  16.793 +            p->tempBufSize = (unsigned)inSize;
  16.794 +            (*srcLen) += inSize;
  16.795 +            *status = LZMA_STATUS_NEEDS_MORE_INPUT;
  16.796 +            return SZ_OK;
  16.797 +          }
  16.798 +          if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
  16.799 +          {
  16.800 +            *status = LZMA_STATUS_NOT_FINISHED;
  16.801 +            return SZ_ERROR_DATA;
  16.802 +          }
  16.803 +          bufLimit = src;
  16.804 +        }
  16.805 +        else
  16.806 +          bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;
  16.807 +        p->buf = src;
  16.808 +        if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
  16.809 +          return SZ_ERROR_DATA;
  16.810 +        processed = (SizeT)(p->buf - src);
  16.811 +        (*srcLen) += processed;
  16.812 +        src += processed;
  16.813 +        inSize -= processed;
  16.814 +      }
  16.815 +      else
  16.816 +      {
  16.817 +        unsigned rem = p->tempBufSize, lookAhead = 0;
  16.818 +        while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize)
  16.819 +          p->tempBuf[rem++] = src[lookAhead++];
  16.820 +        p->tempBufSize = rem;
  16.821 +        if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
  16.822 +        {
  16.823 +          int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem);
  16.824 +          if (dummyRes == DUMMY_ERROR)
  16.825 +          {
  16.826 +            (*srcLen) += lookAhead;
  16.827 +            *status = LZMA_STATUS_NEEDS_MORE_INPUT;
  16.828 +            return SZ_OK;
  16.829 +          }
  16.830 +          if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
  16.831 +          {
  16.832 +            *status = LZMA_STATUS_NOT_FINISHED;
  16.833 +            return SZ_ERROR_DATA;
  16.834 +          }
  16.835 +        }
  16.836 +        p->buf = p->tempBuf;
  16.837 +        if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
  16.838 +          return SZ_ERROR_DATA;
  16.839 +        lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf));
  16.840 +        (*srcLen) += lookAhead;
  16.841 +        src += lookAhead;
  16.842 +        inSize -= lookAhead;
  16.843 +        p->tempBufSize = 0;
  16.844 +      }
  16.845 +  }
  16.846 +  if (p->code == 0)
  16.847 +    *status = LZMA_STATUS_FINISHED_WITH_MARK;
  16.848 +  return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
  16.849 +}
  16.850 +
  16.851 +SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
  16.852 +{
  16.853 +  SizeT outSize = *destLen;
  16.854 +  SizeT inSize = *srcLen;
  16.855 +  *srcLen = *destLen = 0;
  16.856 +  for (;;)
  16.857 +  {
  16.858 +    SizeT inSizeCur = inSize, outSizeCur, dicPos;
  16.859 +    ELzmaFinishMode curFinishMode;
  16.860 +    SRes res;
  16.861 +    if (p->dicPos == p->dicBufSize)
  16.862 +      p->dicPos = 0;
  16.863 +    dicPos = p->dicPos;
  16.864 +    if (outSize > p->dicBufSize - dicPos)
  16.865 +    {
  16.866 +      outSizeCur = p->dicBufSize;
  16.867 +      curFinishMode = LZMA_FINISH_ANY;
  16.868 +    }
  16.869 +    else
  16.870 +    {
  16.871 +      outSizeCur = dicPos + outSize;
  16.872 +      curFinishMode = finishMode;
  16.873 +    }
  16.874 +
  16.875 +    res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);
  16.876 +    src += inSizeCur;
  16.877 +    inSize -= inSizeCur;
  16.878 +    *srcLen += inSizeCur;
  16.879 +    outSizeCur = p->dicPos - dicPos;
  16.880 +    memcpy(dest, p->dic + dicPos, outSizeCur);
  16.881 +    dest += outSizeCur;
  16.882 +    outSize -= outSizeCur;
  16.883 +    *destLen += outSizeCur;
  16.884 +    if (res != 0)
  16.885 +      return res;
  16.886 +    if (outSizeCur == 0 || outSize == 0)
  16.887 +      return SZ_OK;
  16.888 +  }
  16.889 +}
  16.890 +
  16.891 +void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
  16.892 +{
  16.893 +  alloc->Free(alloc, p->probs);
  16.894 +  p->probs = 0;
  16.895 +}
  16.896 +
  16.897 +static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)
  16.898 +{
  16.899 +  alloc->Free(alloc, p->dic);
  16.900 +  p->dic = 0;
  16.901 +}
  16.902 +
  16.903 +void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
  16.904 +{
  16.905 +  LzmaDec_FreeProbs(p, alloc);
  16.906 +  LzmaDec_FreeDict(p, alloc);
  16.907 +}
  16.908 +
  16.909 +SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
  16.910 +{
  16.911 +  UInt32 dicSize;
  16.912 +  Byte d;
  16.913 +  
  16.914 +  if (size < LZMA_PROPS_SIZE)
  16.915 +    return SZ_ERROR_UNSUPPORTED;
  16.916 +  else
  16.917 +    dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
  16.918 + 
  16.919 +  if (dicSize < LZMA_DIC_MIN)
  16.920 +    dicSize = LZMA_DIC_MIN;
  16.921 +  p->dicSize = dicSize;
  16.922 +
  16.923 +  d = data[0];
  16.924 +  if (d >= (9 * 5 * 5))
  16.925 +    return SZ_ERROR_UNSUPPORTED;
  16.926 +
  16.927 +  p->lc = d % 9;
  16.928 +  d /= 9;
  16.929 +  p->pb = d / 5;
  16.930 +  p->lp = d % 5;
  16.931 +
  16.932 +  return SZ_OK;
  16.933 +}
  16.934 +
  16.935 +static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)
  16.936 +{
  16.937 +  UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
  16.938 +  if (p->probs == 0 || numProbs != p->numProbs)
  16.939 +  {
  16.940 +    LzmaDec_FreeProbs(p, alloc);
  16.941 +    p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));
  16.942 +    p->numProbs = numProbs;
  16.943 +    if (p->probs == 0)
  16.944 +      return SZ_ERROR_MEM;
  16.945 +  }
  16.946 +  return SZ_OK;
  16.947 +}
  16.948 +
  16.949 +SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
  16.950 +{
  16.951 +  CLzmaProps propNew;
  16.952 +  RINOK(LzmaProps_Decode(&propNew, props, propsSize));
  16.953 +  RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
  16.954 +  p->prop = propNew;
  16.955 +  return SZ_OK;
  16.956 +}
  16.957 +
  16.958 +SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
  16.959 +{
  16.960 +  CLzmaProps propNew;
  16.961 +  SizeT dicBufSize;
  16.962 +  RINOK(LzmaProps_Decode(&propNew, props, propsSize));
  16.963 +  RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
  16.964 +  dicBufSize = propNew.dicSize;
  16.965 +  if (p->dic == 0 || dicBufSize != p->dicBufSize)
  16.966 +  {
  16.967 +    LzmaDec_FreeDict(p, alloc);
  16.968 +    p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);
  16.969 +    if (p->dic == 0)
  16.970 +    {
  16.971 +      LzmaDec_FreeProbs(p, alloc);
  16.972 +      return SZ_ERROR_MEM;
  16.973 +    }
  16.974 +  }
  16.975 +  p->dicBufSize = dicBufSize;
  16.976 +  p->prop = propNew;
  16.977 +  return SZ_OK;
  16.978 +}
  16.979 +
  16.980 +SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
  16.981 +    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
  16.982 +    ELzmaStatus *status, ISzAlloc *alloc)
  16.983 +{
  16.984 +  CLzmaDec p;
  16.985 +  SRes res;
  16.986 +  SizeT inSize = *srcLen;
  16.987 +  SizeT outSize = *destLen;
  16.988 +  *srcLen = *destLen = 0;
  16.989 +  if (inSize < RC_INIT_SIZE)
  16.990 +    return SZ_ERROR_INPUT_EOF;
  16.991 +
  16.992 +  LzmaDec_Construct(&p);
  16.993 +  res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);
  16.994 +  if (res != 0)
  16.995 +    return res;
  16.996 +  p.dic = dest;
  16.997 +  p.dicBufSize = outSize;
  16.998 +
  16.999 +  LzmaDec_Init(&p);
 16.1000 +  
 16.1001 +  *srcLen = inSize;
 16.1002 +  res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
 16.1003 +
 16.1004 +  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
 16.1005 +    res = SZ_ERROR_INPUT_EOF;
 16.1006 +
 16.1007 +  (*destLen) = p.dicPos;
 16.1008 +  LzmaDec_FreeProbs(&p, alloc);
 16.1009 +  return res;
 16.1010 +}