Fixing emscripten docs

Conflicts:
	README.md

.gitignore

@@ -0,0 +1,2 @@
+*.o
+crnlib/crunch

CHANGELOG.md

@@ -0,0 +1,17 @@
+# Change Log
+
+## [0.1.4] - 2012-11-24
+### Added
+* KTX file format
+* Basic ETC1 support
+* Simple makefile
+
+### Fixed
+* Various DDS format fixes
+
+## [0.1.3] - 2012-04-26
+### Added
+* Ported to Linux (tested on Ubuntu x86 w/Codeblocks). Note that a few features of the cmd line tool don't work yet (eg. -timestamp)
+
+[0.1.4]: https://github.com/BinomialLLC/crunch
+[0.1.3]: https://github.com/BinomialLLC/crunch

README.md

@@ -1,7 +1,7 @@
 crunch/crnlib v1.04 - Advanced DXTn texture compression library
-Copyright (C) 2010-2012 Rich Geldreich and Tenacious Software LLC
+Copyright (C) 2010-2017 Richard Geldreich, Jr. and Binomial LLC http://binomial.info 
 
-For bugs or support contact Rich Geldreich <richgel99@gmail.com>.
+For bugs or support contact Binomial <info@binomial.info>.
 
 This software uses the ZLIB license, which is located in license.txt.
 http://opensource.org/licenses/Zlib
@@ -12,31 +12,14 @@ written by Igor Pavlov (LZMA), RYG (crn_ryg_dxt*), and Sean Barrett (stb_image.c
 If you use this software in a product, an acknowledgment in the product 
 documentation would be highly appreciated but is not required.
 
-New for v1.04 [11/24/12]: KTX file format, basic ETC1 support, DDS format fixes, simple makefile
-------------------------------------------------
+Note: crunch originally used to live on Google Code: https://code.google.com/p/crunch/
 
-Lots of higher level changes to get crnlib into a state where I can carry it forward to
-support other file and texture compression formats. No major codec-level changes. 
-I've regression tested the codec writing .CRN and RDO .DDS files at various bitrates.
-Everything seems OK, but with all the changes I made to support KTX and other formats like ETC1 
-I'm still worried about bugs.
-
-New for v1.03 [4/26/12]: crnlib more portable, Linux Port
-------------------------------------------------
-
-v1.03 has been ported to Linux. It's still a work in progress. A few features 
-of the command line tool don't work under Linux yet (such as -timestamp), 
-but the core functionality (compression/decompression/transcoding) should work
-OK. I'm currently testing crnlib/crunch with Codeblocks 10.05 under Ubuntu x86.
-
-Overview
---------
+## Overview
 
 crnlib is a lossy texture compression library for developers that ship
 content using the DXT1/5/N or 3DC compressed color/normal map/cubemap
 mipmapped texture formats. It was written by the same author as the open
-source LZHAM lossless data compression library:
-http://code.google.com/p/lzham/
+source [LZHAM compression library](http://code.google.com/p/lzham/).
 
 It can compress mipmapped 2D textures, normal maps, and cubemaps to
 approx. 1-1.25 bits/texel, and normal maps to 1.75-2 bits/texel. The
@@ -65,21 +48,17 @@ It also supports several popular swizzled variants (several are
 also supported by AMD's Compressonator): 
 DXT5_XGBR, DXT5_xGxR, DXT5_AGBR, and DXT5_CCxY (experimental luma-chroma YCoCg).
 
-Recommended Software
---------------------
+## Recommended Software
 
-AMD's Compressonator tool is recommended to view the .DDS files created by
-the crunch tool and the included example projects:
-
-http://developer.amd.com/gpu/compressonator/pages/default.aspx
+AMD's [Compressonator tool](https://github.com/GPUOpen-Tools/Compressonator)
+is recommended to view the .DDS files created by the crunch tool and the included example projects.
 
 Note: Some of the swizzled DXTn .DDS output formats (such as DXT5_xGBR)
 read/written by the crunch tool or examples deviate from the DX9 DDS
 standard, so DXSDK tools such as DXTEX.EXE won't load them at all or
 they won't be properly displayed.
 
-Compression Algorithm Details
------------------------------
+## Compression Algorithm Details
 
 The compression process employed in creating both .CRN and
 clustered .DDS files utilizes a very high quality, scalable DXTn
@@ -100,8 +79,7 @@ version will also utilize adaptive binary arithmetic coding and higher
 order context modeling using already developed tech from the my LZHAM
 compression library.
 
-Supported File Formats
-----------------------
+## Supported File Formats
 
 crnlib supports two compressed texture file formats. The first
 format (clustered .DDS) is simple to integrate into an existing project
@@ -111,7 +89,8 @@ the second, higher quality custom format (.CRN) requires a few
 typically straightforward engine modifications to integrate the
 .CRN->DXTn transcoder header file library into your tools/engine.
 
-.DDS
+### .DDS
+
 crnlib can compress textures to standard DX9-style .DDS files using
 clustered DXTn compression, which is a subset of the approach used to
 create .CRN files.(For completeness, crnlib also supports vanilla, block
@@ -132,7 +111,8 @@ data.)
 Clustered .DDS files are intended to be the simplest/fastest way to
 integrate crnlib's tech into a project.
 
-.CRN
+### .CRN
+
 The second, better, option is to compress your textures to .CRN files
 using crnlib. To read the resulting .CRN data, you must add the .CRN
 transcoder library (located in the included single file, stand-alone
@@ -144,7 +124,7 @@ further lossless compression because they're already highly compressed.
 .CRN files are a bit more difficult/risky to integrate into a project, but
 the resulting compression ratio and quality is superior vs. clustered .DDS files.
 
-.KTX
+### .KTX
 
 crnlib and crunch can read/write the .KTX file format in various pixel formats.
 Rate distortion optimization (clustered DXTc compression) is not yet supported
@@ -156,8 +136,7 @@ found that support .KTX are fairly (to very) buggy, or are limited to only a han
 of pixel formats, so there's no guarantee that the .KTX files written by crnlib can
 be reliably read by other tools.
 
-Building the Examples
----------------------
+## Building the Examples
 
 This release contains the source code and projects for three simple
 example projects:
@@ -168,11 +147,14 @@ VS2005, VS2010, and gcc 4.5.0 (TDM GCC+MinGW).  A codeblocks 10.05
 workspace and project file is also included, but compiling crnlib this
 way hasn't been tested much.
 
-example1: Demonstrates how to use crnlib's high-level C-helper
+### example1
+
+Demonstrates how to use crnlib's high-level C-helper
 compression/decompression/transcoding functions in inc/crnlib.h. It's a
 fairly complete example of crnlib's functionality.
 
-example2: Shows how to transcodec .CRN files to .DDS using *only*
+### example2
+Shows how to transcodec .CRN files to .DDS using **only**
 the functionality in inc/crn_decomp.h. It does not link against against
 crnlib.lib or depend on it in any way. (Note: The complete source code,
 approx. 4800 lines, to the CRN transcoder is included in inc/crn_decomp.h.)
@@ -180,15 +162,15 @@ approx. 4800 lines, to the CRN transcoder is included in inc/crn_decomp.h.)
 example2 is intended to show how simple it is to integrate CRN textures
 into your application.
 
-example3: Shows how to use the regular, low-level DXTn block compressor
+### example3
+Shows how to use the regular, low-level DXTn block compressor
 functions in inc/crnlib.h. This functionality is included for
 completeness. (Your engine or toolchain most likely already has its own
 DXTn compressor. crnlib's compressor is typically very competitive or
 superior to most available closed and open source CPU-based
 compressors.)
 
-Creating Compressed Textures from the Command Line (crunch.exe)
----------------------------------------------------------------
+## Creating Compressed Textures from the Command Line (crunch.exe)
 
 The simplest way to create compressed textures using crnlib is to
 integrate the bin\crunch.exe or bin\crunch_x64.exe) command line tool
@@ -205,25 +187,25 @@ form under inc/crn_decomp.h.
 Here are a few example crunch.exe command lines:
 
 1. Compress blah.tga to blah.dds using normal DXT1 compression:
-crunch -file blah.tga -fileformat dds -dxt1
+  * `crunch -file blah.tga -fileformat dds -dxt1`
 
 2. Compress blah.tga to blah.dds using clustered DXT1 at an effective bitrate of 1.5 bits/texel, display image statistic:
-crunch -file blah.tga -fileformat dds -dxt1 -bitrate 1.5 -imagestats
+  * `crunch -file blah.tga -fileformat dds -dxt1 -bitrate 1.5 -imagestats`
 
 3. Compress blah.tga to blah.dds using clustered DXT1 at quality level 100 (from [0,255]), with no mipmaps, display LZMA statistics:
-crunch -file blah.tga -fileformat dds -dxt1 -quality 100 -mipmode none -lzmastats
+  * `crunch -file blah.tga -fileformat dds -dxt1 -quality 100 -mipmode none -lzmastats`
 
 3. Compress blah.tga to blah.crn using clustered DXT1 at a bitrate of 1.2 bits/texel, no mipmaps:
-crunch -file blah.tga -dxt1 -bitrate 1.2 -mipmode none
+  * `crunch -file blah.tga -dxt1 -bitrate 1.2 -mipmode none`
 
 4. Decompress blah.dds to a .tga file:
-crunch -file blah.dds -fileformat tga
+  * `crunch -file blah.dds -fileformat tga`
 
 5. Transcode blah.crn to a .dds file:
-crunch -file blah.crn
+  * `crunch -file blah.crn`
 
 6. Decompress blah.crn, writing each mipmap level to a separate .tga file:
-crunch -split -file blah.crn -fileformat tga
+  * `crunch -split -file blah.crn -fileformat tga`
 
 crunch.exe can do a lot more, like rescale/crop images before
 compression, convert images from one file format to another, compare
@@ -235,8 +217,7 @@ time to address. This version of crunch.exe has some reduced
 functionality compared to an earlier eval release. For example, XML file
 support is not included in this version.
 
-Using crnlib
-------------
+## Using crnlib
 
 The most flexible and powerful way of using crnlib is to integrate the
 library into your editor/toolchain/etc. and directly supply it your
@@ -245,30 +226,40 @@ inc/crnlib.h.
 
 To compress, you basically fill in a few structs in and call one function:
 
-  void *crn_compress(const crn_comp_params &comp_params, crn_uint32 &compressed_size, crn_uint32 *pActual_quality_level = NULL, float *pActual_bitrate = NULL);
+```c
+void *crn_compress( const crn_comp_params &comp_params,
+                    crn_uint32 &compressed_size,
+                    crn_uint32 *pActual_quality_level = NULL,
+                    float *pActual_bitrate = NULL);
+```
 
 Or, if you want crnlib to also generate mipmaps, you call this function:
 
-  void *crn_compress(const crn_comp_params &comp_params, const crn_mipmap_params &mip_params, crn_uint32 &compressed_size, crn_uint32 *pActual_quality_level = NULL, float *pActual_bitrate = NULL);
+```c
+void *crn_compress( const crn_comp_params &comp_params,
+                    const crn_mipmap_params &mip_params,
+                    crn_uint32 &compressed_size,
+                    crn_uint32 *pActual_quality_level = NULL,
+                    float *pActual_bitrate = NULL);
+```
 
 You can also transcode/uncompress .DDS/.CRN files to raw 32bpp images
-using crn_decompress_crn_to_dds() and crn_decompress_dds_to_images().
+using `crn_decompress_crn_to_dds()` and `crn_decompress_dds_to_images()`.
 
 Internally, crnlib just uses inc/crn_decomp.h to transcode textures to
 DXTn. If you only need to transcode .CRN format files to raw DXTn bits
 at runtime (and not compress), you don't actually need to compile or
 link against crnlib at all. Just include inc/crn_decomp.h, which
 contains a completely self-contained CRN transcoder in the "crnd"
-namespace. The crnd_get_texture_info(), crnd_unpack_begin(),
-crnd_unpack_level(), etc. functions are all you need to efficiently get
+namespace. The `crnd_get_texture_info()`, `crnd_unpack_begin()`,
+`crnd_unpack_level()`, etc. functions are all you need to efficiently get
 at the raw DXTn bits, which can be directly supplied to whatever API or
 GPU you're using. (See example2.)
 
 Important note: When compiling under native client, be sure to define
-the PLATFORM_NACL macro before including the inc/crn_decomp.h header file library.
+the `PLATFORM_NACL` macro before including the `inc/crn_decomp.h` header file library.
 
-Known Issues/Bugs
------------------
+## Known Issues/Bugs
 
 * crnlib currently assumes you'll be further losslessly compressing its
 output .DDS files using LZMA. However, some engines use weaker codecs
@@ -305,3 +296,12 @@ hasn't been tuned for max. quality yet.
 supported when writing to .DDS, not .KTX. Also, only plain block by block
 compression is supported when writing to ETC1, and .CRN does not support ETC1.
 
+## Compile to Javascript with Emscripten
+
+Download and install Emscripten:
+    http://kripken.github.io/emscripten-site/docs/getting_started/downloads.html
+
+From the root directory, run:
+```c
+    emcc -O3 emscripten/crn.cpp -I./inc -s EXPORTED_FUNCTIONS="['_malloc', '_free', '_crn_get_width', '_crn_get_height', '_crn_get_levels', '_crn_get_dxt_format', '_crn_get_bytes_per_block', '_crn_get_uncompressed_size', '_crn_decompress']" -s NO_EXIT_RUNTIME=1 -s NO_FILESYSTEM=1 -s ELIMINATE_DUPLICATE_FUNCTIONS=1 -s ALLOW_MEMORY_GROWTH=1 --memory-init-file 0 -o crunch.js
+```

crnlib/crn_core.cpp

@@ -8,7 +8,7 @@
 
 namespace crnlib
 {
-   const char *g_copyright_str = "Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC";
+   const char *g_copyright_str = "Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC";
    const char *g_sig_str = "C8cfRlaorj0wLtnMSxrBJxTC85rho2L9hUZKHcBL";
 
 } // namespace crnlib

crnlib/crn_dxt1.cpp

@@ -112,9 +112,9 @@ namespace crnlib
          uint weight = m_unique_colors[i].m_weight;
          total_weight += weight;
 
-         tot_r += m_unique_colors[i].m_color.r * weight;
-         tot_g += m_unique_colors[i].m_color.g * weight;
-         tot_b += m_unique_colors[i].m_color.b * weight;
+         tot_r += m_unique_colors[i].m_color.r * static_cast<uint64>(weight);
+         tot_g += m_unique_colors[i].m_color.g * static_cast<uint64>(weight);
+         tot_b += m_unique_colors[i].m_color.b * static_cast<uint64>(weight);
       }
 
       const uint half_total_weight = total_weight >> 1;
@@ -494,7 +494,7 @@ namespace crnlib
          ll[2] = (ll[0]*2+ll[1])/3;
          ll[3] = (ll[0]+ll[1]*2)/3;
 
-         uint error_to_beat = 0;
+         uint64 error_to_beat = 0;
          uint min_color_weight = 0;
          uint max_color_weight = 0;
          for (uint i = 0; i < m_unique_colors.size(); i++)
@@ -503,7 +503,7 @@ namespace crnlib
             uint w = m_unique_colors[i].m_weight;
 
             int delta = ll[m_best_solution.m_selectors[i]] - c;
-            error_to_beat += (int)w * (delta * delta);
+            error_to_beat += static_cast<int64>(w) * (delta * delta);
 
             if (c == min_color[comp_index])
                min_color_weight += w;
@@ -561,11 +561,11 @@ namespace crnlib
                   tl[2] = (tl[0]*2+tl[1])/3;
                   tl[3] = (tl[0]+tl[1]*2)/3;
 
-                  uint trial_error = 0;
+                  uint64 trial_error = 0;
                   for (uint i = 0; i < m_unique_colors.size(); i++)
                   {
                      int delta = tl[m_best_solution.m_selectors[i]] - m_unique_colors[i].m_color[comp_index];
-                     trial_error += m_unique_colors[i].m_weight * (delta * delta);
+                     trial_error += static_cast<int64>(m_unique_colors[i].m_weight) * (delta * delta);
                      if (trial_error >= error_to_beat)
                         break;
                   }
@@ -599,7 +599,7 @@ namespace crnlib
                         for (uint i = 0; i < m_unique_colors.size(); i++)
                         {
                            int delta = tl[m_best_solution.m_selectors[i]] - m_unique_colors[i].m_color[comp_index];
-                           error_to_beat += m_unique_colors[i].m_weight * (delta * delta);
+                           error_to_beat += static_cast<int64>(m_unique_colors[i].m_weight) * (delta * delta);
                         }
 
                      } // better
@@ -1582,7 +1582,7 @@ namespace crnlib
                   err = color_distance(true, c, colors[3], false);
                   if (err < best_error) { best_error = err; best_color_index = 3; }
 
-                  trial_error += best_error * m_unique_colors[unique_color_index].m_weight;
+                  trial_error += best_error * static_cast<uint64>(m_unique_colors[unique_color_index].m_weight);
                   if (trial_error >= solution.m_error)
                      break;
 
@@ -1607,7 +1607,7 @@ namespace crnlib
                   err = color_distance(false, c, colors[3], false);
                   if (err < best_error) { best_error = err; best_color_index = 3; }
 
-                  trial_error += best_error * m_unique_colors[unique_color_index].m_weight;
+                  trial_error += best_error * static_cast<uint64>(m_unique_colors[unique_color_index].m_weight);
                   if (trial_error >= solution.m_error)
                      break;
 
@@ -1634,7 +1634,7 @@ namespace crnlib
                   err = color_distance(true, c, colors[2], false);
                   if (err < best_error) { best_error = err; best_color_index = 2; }
 
-                  trial_error += best_error * m_unique_colors[unique_color_index].m_weight;
+                  trial_error += best_error * static_cast<uint64>(m_unique_colors[unique_color_index].m_weight);
                   if (trial_error >= solution.m_error)
                      break;
 
@@ -1656,7 +1656,7 @@ namespace crnlib
                   err = color_distance(false, c, colors[2], false);
                   if (err < best_error) { best_error = err; best_color_index = 2; }
 
-                  trial_error += best_error * m_unique_colors[unique_color_index].m_weight;
+                  trial_error += best_error * static_cast<uint64>(m_unique_colors[unique_color_index].m_weight);
                   if (trial_error >= solution.m_error)
                      break;
 
@@ -1781,7 +1781,7 @@ namespace crnlib
 
                uint best_error = color_distance(m_perceptual, c, colors[best_color_index], false);
 
-               trial_error += best_error * m_unique_colors[unique_color_index].m_weight;
+               trial_error += best_error * static_cast<uint64>(m_unique_colors[unique_color_index].m_weight);
                if (trial_error >= solution.m_error)
                   break;
 
@@ -1814,7 +1814,7 @@ namespace crnlib
 
                uint best_error = color_distance(m_perceptual, c, colors[best_color_index], false);
 
-               trial_error += best_error * m_unique_colors[unique_color_index].m_weight;
+               trial_error += best_error * static_cast<uint64>(m_unique_colors[unique_color_index].m_weight);
                if (trial_error >= solution.m_error)
                   break;
 

crnlib/crn_image_utils.cpp

@@ -1305,7 +1305,7 @@ namespace crnlib
          *pActualComps = 0;
 
          if ((req_comps < 1) || (req_comps > 4))
-            return false;
+            return NULL;
 
          mipmapped_texture tex;
 

crnlib/crn_sparse_array.h

@@ -355,7 +355,7 @@ namespace crnlib
 
       inline T* alloc_group(bool nofail = false)
       {
-         T* p = static_cast<T*>(alloc_space(N * sizeof(T)));
+         T* p = static_cast<T*>(sparse_array_traits<T, Log2N>::alloc_space(N * sizeof(T)));
 
          if (!p)
          {
@@ -365,7 +365,7 @@ namespace crnlib
             CRNLIB_FAIL("Out of memory");
          }
 
-         construct_group(p);
+         sparse_array_traits<T, Log2N>::construct_group(p);
 
          m_num_active_groups++;
 
@@ -379,20 +379,20 @@ namespace crnlib
             CRNLIB_ASSERT(m_num_active_groups);
             m_num_active_groups--;
 
-            destruct_group(p);
+            sparse_array_traits<T, Log2N>::destruct_group(p);
 
-            free_space(p);
+            sparse_array_traits<T, Log2N>::free_space(p);
          }
       }
 
       inline void init_default()
       {
-         construct_element(reinterpret_cast<T*>(m_default));
+         sparse_array_traits<T, Log2N>::construct_element(reinterpret_cast<T*>(m_default));
       }
 
       inline void deinit_default()
       {
-         destruct_element(reinterpret_cast<T*>(m_default));
+         sparse_array_traits<T, Log2N>::destruct_element(reinterpret_cast<T*>(m_default));
       }
    };
 

crnlib/crnlib.cpp

@@ -172,7 +172,7 @@ void *crn_compress(const crn_comp_params &comp_params, crn_uint32 &compressed_si
    if (pActual_bitrate) *pActual_bitrate = 0.0f;
 
    if (!comp_params.check())
-      return false;
+      return NULL;
 
    crnlib::vector<uint8> crn_file_data;
    if (!create_compressed_texture(comp_params, crn_file_data, pActual_quality_level, pActual_bitrate))
@@ -189,7 +189,7 @@ void *crn_compress(const crn_comp_params &comp_params, const crn_mipmap_params &
    if (pActual_bitrate) *pActual_bitrate = 0.0f;
 
    if ((!comp_params.check()) || (!mip_params.check()))
-      return false;
+      return NULL;
 
    crnlib::vector<uint8> crn_file_data;
    if (!create_compressed_texture(comp_params, mip_params, crn_file_data, pActual_quality_level, pActual_bitrate))

crunch/crunch.cpp

@@ -176,7 +176,7 @@ public:
          console::printf("-%s", pixel_format_helpers::get_pixel_format_string(fmt));
       }
 
-      console::printf("\nFor bugs, support, or feedback: richgel99@gmail.com");
+      console::printf("\nFor bugs, support, or feedback: info@binomial.info");
    }
 
    bool convert(const char* pCommand_line)
@@ -1253,8 +1253,8 @@ static bool check_for_option(int argc, char *argv[], const char *pOption)
 
 static void print_title()
 {
-   console::printf("crunch: Advanced DXTn Texture Compressor - http://code.google.com/p/crunch");
-   console::printf("Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC");
+   console::printf("crunch: Advanced DXTn Texture Compressor - https://github.com/BinomialLLC/crunch");
+   console::printf("Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC");
    console::printf("crnlib version v%u.%02u %s Built %s, %s", CRNLIB_VERSION / 100U, CRNLIB_VERSION % 100U, crnlib_is_x64() ? "x64" : "x86", __DATE__, __TIME__);
    console::printf("");
 }

emscripten/crunch_lib.cpp

@@ -0,0 +1,110 @@
+/* Copyright (c) 2013, Evan Parker, Brandon Jones. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+
+#define PLATFORM_NACL // This disables use of 64 bit integers, among other things.
+
+#include <stddef.h> // For NULL, size_t
+#include <cstring> // for malloc etc
+
+#include "crn_decomp.h"
+
+extern "C" {
+  unsigned int crn_get_width(void *src, unsigned int src_size);
+  unsigned int crn_get_height(void *src, unsigned int src_size);
+  unsigned int crn_get_levels(void *src, unsigned int src_size);
+  unsigned int crn_get_dxt_format(void *src, unsigned int src_size);
+  unsigned int crn_get_bytes_per_block(void *src, unsigned int src_size);
+  unsigned int crn_get_uncompressed_size(void *p, unsigned int size, unsigned int level);
+  void crn_decompress(void *src, unsigned int src_size, void *dst, unsigned int dst_size, unsigned int firstLevel, unsigned int levelCount);
+}
+
+unsigned int crn_get_width(void *src, unsigned int src_size) {
+  crnd::crn_texture_info tex_info;
+  crnd::crnd_get_texture_info(static_cast<crn_uint8*>(src), src_size, &tex_info);
+  return tex_info.m_width;
+}
+
+unsigned int crn_get_height(void *src, unsigned int src_size) {
+  crnd::crn_texture_info tex_info;
+  crnd::crnd_get_texture_info(static_cast<crn_uint8*>(src), src_size, &tex_info);
+  return tex_info.m_height;
+}
+
+unsigned int crn_get_levels(void *src, unsigned int src_size) {
+  crnd::crn_texture_info tex_info;
+  crnd::crnd_get_texture_info(static_cast<crn_uint8*>(src), src_size, &tex_info);
+  return tex_info.m_levels;
+}
+
+unsigned int crn_get_dxt_format(void *src, unsigned int src_size) {
+  crnd::crn_texture_info tex_info;
+  crnd::crnd_get_texture_info(static_cast<crn_uint8*>(src), src_size, &tex_info);
+  return tex_info.m_format;
+}
+
+unsigned int crn_get_bytes_per_block(void *src, unsigned int src_size) {
+  crnd::crn_texture_info tex_info;
+  crnd::crnd_get_texture_info(static_cast<crn_uint8*>(src), src_size, &tex_info);
+  return crnd::crnd_get_bytes_per_dxt_block(tex_info.m_format);
+}
+
+unsigned int crn_get_uncompressed_size(void *src, unsigned int src_size, unsigned int level) {
+  crnd::crn_texture_info tex_info;
+  crnd::crnd_get_texture_info(static_cast<crn_uint8*>(src), src_size, &tex_info);
+  const crn_uint32 width = tex_info.m_width >> level;
+  const crn_uint32 height = tex_info.m_height >> level;
+  const crn_uint32 blocks_x = (width + 3) >> 2;
+  const crn_uint32 blocks_y = (height + 3) >> 2;
+  const crn_uint32 row_pitch = blocks_x * crnd::crnd_get_bytes_per_dxt_block(tex_info.m_format);
+  const crn_uint32 total_face_size = row_pitch * blocks_y;
+  return total_face_size;
+}
+
+void crn_decompress(void *src, unsigned int src_size, void *dst, unsigned int dst_size, unsigned int firstLevel, unsigned int levelCount) {
+  crnd::crn_texture_info tex_info;
+  crnd::crnd_get_texture_info(static_cast<crn_uint8*>(src), src_size, &tex_info);
+
+  crn_uint32 width = tex_info.m_width >> firstLevel;
+  crn_uint32 height = tex_info.m_height >> firstLevel;
+  crn_uint32 bytes_per_block = crnd::crnd_get_bytes_per_dxt_block(tex_info.m_format);
+
+  void *pDecomp_images[1];
+  pDecomp_images[0] = dst;
+
+  crnd::crnd_unpack_context pContext =
+      crnd::crnd_unpack_begin(static_cast<crn_uint8*>(src), src_size);
+
+  for (int i = firstLevel; i < firstLevel + levelCount; ++i) {
+    crn_uint32 blocks_x = (width + 3) >> 2;
+    crn_uint32 blocks_y = (height + 3) >> 2;
+    crn_uint32 row_pitch = blocks_x * bytes_per_block;
+    crn_uint32 total_level_size = row_pitch * blocks_y;
+
+    crnd::crnd_unpack_level(pContext, pDecomp_images, total_level_size, row_pitch, i);
+    pDecomp_images[0] = (char*)pDecomp_images[0] + total_level_size;
+
+    width = width >> 1;
+    height = height >> 1;
+  }
+
+  crnd::crnd_unpack_end(pContext);
+}

example1/example1.cpp

@@ -33,7 +33,7 @@ const int cDefaultCRNQualityLevel = 128;
 static int print_usage()
 {
    printf("Description: Simple crnlib API example program.\n");
-   printf("Copyright (c) 2010-2011 Tenacious Software LLC\n");
+   printf("Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC\n");
    printf("Usage: example1 [mode: i/c/d] [source_file] [options]\n");
    printf("\nModes:\n");
    printf("c: Compress to .DDS or .CRN using the crn_compress() func. in crnlib.h\n");

example2/example2.cpp

@@ -24,7 +24,7 @@ using namespace crnlib;
 static int print_usage()
 {
    printf("Description: Transcodes .CRN to .DDS files using crn_decomp.h.\n");
-   printf("Copyright (c) 2010-2011 Tenacious Software LLC\n");
+   printf("Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC\n");
    printf("Usage: example2 [source_file] [options]\n");
    printf("\nOptions:\n");
    printf("-out filename - Force output filename.\n");

example3/example3.cpp

@@ -29,7 +29,7 @@ const uint cDXTBlockSize = 4;
 static int print_usage()
 {
    printf("Description: Simple .DDS DXTn block compression using crnlib.\n");
-   printf("Copyright (c) 2010-2011 Tenacious Software LLC\n");
+   printf("Copyright (c) 2010-2016 Binomial LLC\n");
    printf("Usage: example3 [source_file] [options]\n");
    printf("\n");
    printf("Note: This simple example is not multithreaded, so it's not going to be\n");

inc/crn_decomp.h

@@ -1,5 +1,5 @@
 // File: crn_decomp.h - Fast CRN->DXTc texture transcoder header file library
-// Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC
+// Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC
 // See Copyright Notice and license at the end of this file.
 //
 // This single header file contains *all* of the code necessary to unpack .CRN files to raw DXTn bits.
@@ -376,9 +376,13 @@ namespace crnd
 
 #ifdef _WIN64
    typedef uint64 ptr_bits;
+#else
+   #ifdef __x86_64__
+      typedef uint64 ptr_bits;
    #else
       typedef uint32 ptr_bits;
    #endif
+#endif
 
    template<typename T> struct int_traits { enum { cMin = crnd::cINT32_MIN, cMax = crnd::cINT32_MAX, cSigned = true }; };
 
@@ -2819,15 +2823,15 @@ namespace crnd
          *pSize = 0;
 
       if ((!pData) || (data_size < cCRNHeaderMinSize))
-         return false;
+         return NULL;
 
       crn_header tmp_header;
       const crn_header* pHeader = crnd_get_header(tmp_header, pData, data_size);
       if (!pHeader)
-         return false;
+         return NULL;
 
       if (level_index >= pHeader->m_levels)
-         return false;
+         return NULL;
 
       uint32 cur_level_ofs = pHeader->m_level_ofs[level_index];
 
@@ -4812,7 +4816,7 @@ namespace crnd
 // crn_decomp.h uses the ZLIB license:
 // http://opensource.org/licenses/Zlib
 //
-// Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC
+// Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC
 //
 // This software is provided 'as-is', without any express or implied
 // warranty.  In no event will the authors be held liable for any damages

inc/crnlib.h

@@ -1,5 +1,5 @@
 // File: crnlib.h - Advanced DXTn texture compression library.
-// Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC
+// Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC
 // See copyright notice and license at the end of this file.
 //
 // This header file contains the public crnlib declarations for DXTn,
@@ -619,7 +619,7 @@ bool crn_decompress_block(const void *pSrc_block, crn_uint32 *pDst_pixels, crn_f
 // crnlib uses the ZLIB license:
 // http://opensource.org/licenses/Zlib
 //
-// Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC
+// Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC
 //
 // This software is provided 'as-is', without any express or implied
 // warranty.  In no event will the authors be held liable for any damages

license.txt

@@ -1,7 +1,7 @@
 crunch/crnlib uses the ZLIB license:
 http://opensource.org/licenses/Zlib
 
-Copyright (c) 2010-2012 Rich Geldreich and Tenacious Software LLC
+Copyright (c) 2010-2016 Richard Geldreich, Jr. and Binomial LLC
 
 This software is provided 'as-is', without any express or implied
 warranty.  In no event will the authors be held liable for any damages