xenia-canary/third_party/crunch/crnlib/crnlib.cpp

// File: crnlib.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "../inc/crnlib.h"
#include "crn_comp.h"
#include "crn_dds_comp.h"
#include "crn_dynamic_stream.h"
#include "crn_buffer_stream.h"
#include "crn_ryg_dxt.hpp"
#include "crn_etc.h"

#define CRND_HEADER_FILE_ONLY
#include "../inc/crn_decomp.h"

#include "crn_rg_etc1.h"

namespace crnlib
{
   static void* realloc_func(void* p, size_t size, size_t* pActual_size, bool movable, void* pUser_data)
   {
      pUser_data;
      return crnlib_realloc(p, size, pActual_size, movable);
   }

   static size_t msize_func(void* p, void* pUser_data)
   {
      pUser_data;
      return crnlib_msize(p);
   }

   class crnlib_global_initializer
   {
   public:
      crnlib_global_initializer()
      {
         crn_threading_init();
         
         crnlib_enable_fail_exceptions(true);

         // Redirect crn_decomp.h's memory allocations into crnlib, which may be further redirected by the outside caller.
         crnd::crnd_set_memory_callbacks(realloc_func, msize_func, NULL);

         ryg_dxt::sInitDXT();

         pack_etc1_block_init();

         rg_etc1::pack_etc1_block_init();
      }
   };

   crnlib_global_initializer g_crnlib_initializer;
} // namespace crnlib

using namespace crnlib;

const char* crn_get_format_string(crn_format fmt)
{
   return pixel_format_helpers::get_crn_format_string(fmt);
}

crn_uint32 crn_get_format_fourcc(crn_format fmt)
{
   return crnd::crnd_crn_format_to_fourcc(fmt);
}

crn_uint32 crn_get_format_bits_per_texel(crn_format fmt)
{
   return crnd::crnd_get_crn_format_bits_per_texel(fmt);
}

crn_uint32 crn_get_bytes_per_dxt_block(crn_format fmt)
{
   return crnd::crnd_get_bytes_per_dxt_block(fmt);
}

crn_format crn_get_fundamental_dxt_format(crn_format fmt)
{
   return crnd::crnd_get_fundamental_dxt_format(fmt);
}

const char* crn_get_file_type_ext(crn_file_type file_type)
{
   switch (file_type)
   {
      case cCRNFileTypeDDS: return "dds";
      case cCRNFileTypeCRN: return "crn";
      default: break;
   }
   return "?";
}

const char* crn_get_mip_mode_desc(crn_mip_mode m)
{
   switch (m)
   {
      case cCRNMipModeUseSourceOrGenerateMips:  return "Use source/generate if none";
      case cCRNMipModeUseSourceMips:            return "Only use source MIP maps (if any)";
      case cCRNMipModeGenerateMips:             return "Always generate new MIP maps";
      case cCRNMipModeNoMips:                   return "No MIP maps";
      default: break;
   }
   return "?";
}

const char* crn_get_mip_mode_name(crn_mip_mode m)
{
   switch (m)
   {
      case cCRNMipModeUseSourceOrGenerateMips:  return "UseSourceOrGenerate";
      case cCRNMipModeUseSourceMips:            return "UseSource";
      case cCRNMipModeGenerateMips:             return "Generate";
      case cCRNMipModeNoMips:                   return "None";
      default: break;
   }
   return "?";
}

const char* crn_get_mip_filter_name(crn_mip_filter f)
{
   switch (f)
   {
      case cCRNMipFilterBox:        return "box";
      case cCRNMipFilterTent:       return "tent";
      case cCRNMipFilterLanczos4:   return "lanczos4";
      case cCRNMipFilterMitchell:   return "mitchell";
      case cCRNMipFilterKaiser:     return "kaiser";
      default: break;
   }
   return "?";
}

const char* crn_get_scale_mode_desc(crn_scale_mode sm)
{
   switch (sm)
   {
      case cCRNSMDisabled:       return "disabled";
      case cCRNSMAbsolute:       return "absolute";
      case cCRNSMRelative:       return "relative";
      case cCRNSMLowerPow2:      return "lowerpow2";
      case cCRNSMNearestPow2:    return "nearestpow2";
      case cCRNSMNextPow2:       return "nextpow2";
      default: break;
   }
   return "?";
}

const char* crn_get_dxt_quality_string(crn_dxt_quality q)
{
   switch (q)
   {
      case cCRNDXTQualitySuperFast: return "SuperFast";
      case cCRNDXTQualityFast:      return "Fast";
      case cCRNDXTQualityNormal:    return "Normal";
      case cCRNDXTQualityBetter:    return "Better";
      case cCRNDXTQualityUber:      return "Uber";
      default: break;
   }
   CRNLIB_ASSERT(false);
   return "?";
}


void crn_free_block(void *pBlock)
{
   crnlib_free(pBlock);
}

void *crn_compress(const crn_comp_params &comp_params, crn_uint32 &compressed_size, crn_uint32 *pActual_quality_level, float *pActual_bitrate)
{
   compressed_size = 0;
   if (pActual_quality_level) *pActual_quality_level = 0;
   if (pActual_bitrate) *pActual_bitrate = 0.0f;

   if (!comp_params.check())
      return false;

   crnlib::vector<uint8> crn_file_data;
   if (!create_compressed_texture(comp_params, crn_file_data, pActual_quality_level, pActual_bitrate))
      return NULL;

   compressed_size = crn_file_data.size();
   return crn_file_data.assume_ownership();
}

void *crn_compress(const crn_comp_params &comp_params, const crn_mipmap_params &mip_params, crn_uint32 &compressed_size, crn_uint32 *pActual_quality_level, float *pActual_bitrate)
{
   compressed_size = 0;
   if (pActual_quality_level) *pActual_quality_level = 0;
   if (pActual_bitrate) *pActual_bitrate = 0.0f;

   if ((!comp_params.check()) || (!mip_params.check()))
      return false;

   crnlib::vector<uint8> crn_file_data;
   if (!create_compressed_texture(comp_params, mip_params, crn_file_data, pActual_quality_level, pActual_bitrate))
      return NULL;

   compressed_size = crn_file_data.size();
   return crn_file_data.assume_ownership();
}

void *crn_decompress_crn_to_dds(const void *pCRN_file_data, crn_uint32 &file_size)
{
   mipmapped_texture tex;
   if (!tex.read_crn_from_memory(pCRN_file_data, file_size, "from_memory.crn"))
   {
      file_size = 0;
      return NULL;
   }

   file_size = 0;

   dynamic_stream dds_file_data;
   dds_file_data.reserve(128*1024);
   data_stream_serializer serializer(dds_file_data);
   if (!tex.write_dds(serializer))
      return NULL;
   dds_file_data.reserve(0);

   file_size = static_cast<crn_uint32>(dds_file_data.get_size());
   return dds_file_data.get_buf().assume_ownership();
}

bool crn_decompress_dds_to_images(const void *pDDS_file_data, crn_uint32 dds_file_size, crn_uint32 **ppImages, crn_texture_desc &tex_desc)
{
   memset(&tex_desc, 0, sizeof(tex_desc));

   mipmapped_texture tex;
   buffer_stream in_stream(pDDS_file_data, dds_file_size);
   data_stream_serializer in_serializer(in_stream);
   if (!tex.read_dds(in_serializer))
      return false;

   if (tex.is_packed())
   {
      // TODO: Allow the user to disable uncooking of swizzled DXT5 formats?
      bool uncook = true;

      if (!tex.unpack_from_dxt(uncook))
         return false;
   }

   tex_desc.m_faces = tex.get_num_faces();
   tex_desc.m_width = tex.get_width();
   tex_desc.m_height = tex.get_height();
   tex_desc.m_levels = tex.get_num_levels();
   tex_desc.m_fmt_fourcc = (crn_uint32)tex.get_format();

   for (uint32 f = 0; f < tex.get_num_faces(); f++)
   {
      for (uint32 l = 0; l < tex.get_num_levels(); l++)
      {
         mip_level *pLevel = tex.get_level(f, l);
         image_u8 *pImg = pLevel->get_image();
         ppImages[l + tex.get_num_levels() * f] = static_cast<crn_uint32*>(pImg->get_pixel_buf().assume_ownership());
      }
   }

   return true;
}

void crn_free_all_images(crn_uint32 **ppImages, const crn_texture_desc &desc)
{
   for (uint32 f = 0; f < desc.m_faces; f++)
      for (uint32 l = 0; l < desc.m_levels; l++)
         crn_free_block(ppImages[l + desc.m_levels * f]);
}

// Simple low-level DXTn 4x4 block compressor API.
// Basically just a basic wrapper over the crnlib::dxt_image class.

namespace crnlib
{
   class crn_block_compressor
   {
      CRNLIB_NO_COPY_OR_ASSIGNMENT_OP(crn_block_compressor);

   public:
      crn_block_compressor()
      {
      }

      bool init(const crn_comp_params &params)
      {
         m_comp_params = params;

         m_pack_params.init(params);

         crn_format basic_crn_fmt = crnd::crnd_get_fundamental_dxt_format(params.m_format);
         pixel_format basic_pixel_fmt = pixel_format_helpers::convert_crn_format_to_pixel_format(basic_crn_fmt);

         if ((params.get_flag(cCRNCompFlagDXT1AForTransparency)) && (basic_pixel_fmt == PIXEL_FMT_DXT1))
            basic_pixel_fmt = PIXEL_FMT_DXT1A;

         if (!m_image.init(pixel_format_helpers::get_dxt_format(basic_pixel_fmt), cDXTBlockSize, cDXTBlockSize, false))
            return false;

         return true;
      }

      void compress_block(const crn_uint32 *pPixels, void *pDst_block)
      {
         if (m_image.is_valid())
         {
            m_image.set_block_pixels(0, 0, reinterpret_cast<const color_quad_u8 *>(pPixels), m_pack_params, m_set_block_pixels_context);
            memcpy(pDst_block, &m_image.get_element(0, 0, 0), m_image.get_bytes_per_block());
         }
      }

   private:
      dxt_image m_image;
      crn_comp_params m_comp_params;
      dxt_image::pack_params m_pack_params;
      dxt_image::set_block_pixels_context m_set_block_pixels_context;
   };
}

crn_block_compressor_context_t crn_create_block_compressor(const crn_comp_params &params)
{
   crn_block_compressor *pComp = crnlib_new<crn_block_compressor>();
   if (!pComp->init(params))
   {
      crnlib_delete(pComp);
      return NULL;
   }
   return pComp;
}

void crn_compress_block(crn_block_compressor_context_t pContext, const crn_uint32 *pPixels, void *pDst_block)
{
   crn_block_compressor *pComp = static_cast<crn_block_compressor *>(pContext);
   pComp->compress_block(pPixels, pDst_block);
}

void crn_free_block_compressor(crn_block_compressor_context_t pContext)
{
   crnlib_delete(static_cast<crn_block_compressor *>(pContext));
}

bool crn_decompress_block(const void *pSrc_block, crn_uint32 *pDst_pixels_u32, crn_format crn_fmt)
{
   color_quad_u8* pDst_pixels = reinterpret_cast<color_quad_u8*>(pDst_pixels_u32);

   switch (crn_get_fundamental_dxt_format(crn_fmt))
   {
      case cCRNFmtETC1:
      {
         const etc1_block& block = *reinterpret_cast<const etc1_block*>(pSrc_block);
         unpack_etc1(block, pDst_pixels, false);
         break;
      }
      case cCRNFmtDXT1:
      {
         const dxt1_block* pDXT1_block = reinterpret_cast<const dxt1_block*>(pSrc_block);

         color_quad_u8 colors[cDXT1SelectorValues];
         pDXT1_block->get_block_colors(colors, static_cast<uint16>(pDXT1_block->get_low_color()), static_cast<uint16>(pDXT1_block->get_high_color()));

         for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
         {
            const uint s = pDXT1_block->get_selector(i & 3, i >> 2);

            pDst_pixels[i] = colors[s];
         }

         break;
      }

      case cCRNFmtDXT3:
      {
         const dxt3_block* pDXT3_block = reinterpret_cast<const dxt3_block*>(pSrc_block);
         
         const dxt1_block* pDXT1_block = reinterpret_cast<const dxt1_block*>(pSrc_block) + 1;
         color_quad_u8 colors[cDXT1SelectorValues];
         pDXT1_block->get_block_colors(colors, static_cast<uint16>(pDXT1_block->get_low_color()), static_cast<uint16>(pDXT1_block->get_high_color()));
                  
         for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
         {
            const uint s = pDXT1_block->get_selector(i & 3, i >> 2);
            const uint a = pDXT3_block->get_alpha(i & 3, i >> 2, true);

            pDst_pixels[i] = colors[s];
            pDst_pixels[i].a = static_cast<uint8>(a);
         }

         break;
      }

      case cCRNFmtDXT5:
      {
         const dxt5_block* pDXT5_block = reinterpret_cast<const dxt5_block*>(pSrc_block);

         const dxt1_block* pDXT1_block = reinterpret_cast<const dxt1_block*>(pSrc_block) + 1;
         color_quad_u8 colors[cDXT1SelectorValues];
         pDXT1_block->get_block_colors(colors, static_cast<uint16>(pDXT1_block->get_low_color()), static_cast<uint16>(pDXT1_block->get_high_color()));

         uint values[cDXT5SelectorValues];
         dxt5_block::get_block_values(values, pDXT5_block->get_low_alpha(), pDXT5_block->get_high_alpha());
         
         for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
         {
            const uint s = pDXT1_block->get_selector(i & 3, i >> 2);
            const uint a = pDXT5_block->get_selector(i & 3, i >> 2);

            pDst_pixels[i] = colors[s];
            pDst_pixels[i].a = static_cast<uint8>(values[a]);
         }
      }

      case cCRNFmtDXN_XY:
      case cCRNFmtDXN_YX:
      {
         const dxt5_block* pDXT5_block0 = reinterpret_cast<const dxt5_block*>(pSrc_block);
         const dxt5_block* pDXT5_block1 = reinterpret_cast<const dxt5_block*>(pSrc_block) + 1;

         uint values0[cDXT5SelectorValues];
         dxt5_block::get_block_values(values0, pDXT5_block0->get_low_alpha(), pDXT5_block0->get_high_alpha());

         uint values1[cDXT5SelectorValues];
         dxt5_block::get_block_values(values1, pDXT5_block1->get_low_alpha(), pDXT5_block1->get_high_alpha());

         for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
         {
            const uint s0 = pDXT5_block0->get_selector(i & 3, i >> 2);
            const uint s1 = pDXT5_block1->get_selector(i & 3, i >> 2);

            if (crn_fmt == cCRNFmtDXN_XY)
               pDst_pixels[i].set_noclamp_rgba(values0[s0], values1[s1], 255, 255);
            else
               pDst_pixels[i].set_noclamp_rgba(values1[s1], values0[s0], 255, 255);
         }

         break;
      }
      
      case cCRNFmtDXT5A:
      {
         const dxt5_block* pDXT5_block = reinterpret_cast<const dxt5_block*>(pSrc_block);

         uint values[cDXT5SelectorValues];
         dxt5_block::get_block_values(values, pDXT5_block->get_low_alpha(), pDXT5_block->get_high_alpha());

         for (uint i = 0; i < cDXTBlockSize * cDXTBlockSize; i++)
         {
            const uint s = pDXT5_block->get_selector(i & 3, i >> 2);

            pDst_pixels[i].set_noclamp_rgba(255, 255, 255, values[s]);
         }

         break;
      }
      default:
      {
         return false;
      }
   }

   return true;
}