// File: crunch.cpp - Command line tool for DDS/CRN texture compression/decompression.
// This tool exposes all of crnlib's functionality. It also uses a bunch of internal crlib
// classes that aren't directly exposed in the main crnlib.h header. The actual tool is
// implemented as a single class "crunch" which in theory is reusable. Most of the heavy
// lifting is actually done by functions in the crnlib::texture_conversion namespace,
// which are mostly wrappers over the public crnlib.h functions.
// See Copyright Notice and license at the end of inc/crnlib.h
//
// Important: If compiling with gcc, be sure strict aliasing is disabled: -fno-strict-aliasing
#include "crn_core.h"
#include "crn_console.h"

#include "crn_colorized_console.h"

#include "crn_find_files.h"
#include "crn_file_utils.h"
#include "crn_command_line_params.h"

#include "crn_dxt.h"
#include "crn_cfile_stream.h"
#include "crn_texture_conversion.h"

#define CRND_HEADER_FILE_ONLY
#include "crn_decomp.h"

#include "corpus_gen.h"
#include "corpus_test.h"

using namespace crnlib;

const int cDefaultCRNQualityLevel = 128;

class crunch
{
   CRNLIB_NO_COPY_OR_ASSIGNMENT_OP(crunch);

   cfile_stream m_log_stream;

   uint32 m_num_processed;
   uint32 m_num_failed;
   uint32 m_num_succeeded;
   uint32 m_num_skipped;

public:
   crunch() :
      m_num_processed(0),
      m_num_failed(0),
      m_num_succeeded(0),
      m_num_skipped(0)
   {
   }

   ~crunch()
   {
   }

   enum convert_status
   {
      cCSFailed,
      cCSSucceeded,
      cCSSkipped,
      cCSBadParam,
   };

   inline uint32 get_num_processed() const { return m_num_processed; }
   inline uint32 get_num_failed() const { return m_num_failed; }
   inline uint32 get_num_succeeded() const { return m_num_succeeded; }
   inline uint32 get_num_skipped() const { return m_num_skipped; }

   static void print_usage()
   {
      //                -------------------------------------------------------------------------------
      console::message("\nCommand line usage:");
      console::printf("crunch [options] -file filename");
      console::printf("-file filename - Required input filename, wildcards, multiple -file params OK.");
      console::printf("-file @list.txt - List of files to convert.");
      console::printf("Supported source file formats: dds,ktx,crn,tga,bmp,png,jpg/jpeg,psd");
      console::printf("Note: Some file format variants are unsupported.");
      console::printf("See the docs for stb_image.c: http://www.nothings.org/stb_image.c");
      console::printf("Progressive JPEG files are supported, see: http://code.google.com/p/jpeg-compressor/");

      console::message("\nPath/file related parameters:");
      console::printf("-out filename - Output filename");
      console::printf("-outdir dir - Output directory");
      console::printf("-outsamedir - Write output file to input directory");
      console::printf("-deep - Recurse subdirectories, default=false");
      console::printf("-nooverwrite - Don't overwrite existing files");
      console::printf("-timestamp - Update only changed files");
      console::printf("-forcewrite - Overwrite read-only files");
      console::printf("-recreate - Recreate directory structure");
      console::printf("-fileformat [dds,ktx,crn,tga,bmp,png] - Output file format, default=crn or dds");

      console::message("\nModes:");
      console::printf("-compare - Compare input and output files (no output files are written).");
      console::printf("-info - Only display input file statistics (no output files are written).");

      console::message("\nMisc. options:");
      console::printf("-helperThreads # - Set number of helper threads, 0-16, default=(# of CPU's)-1");
      console::printf("-noprogress - Disable progress output");
      console::printf("-quiet - Disable all console output");
      console::printf("-ignoreerrors - Continue processing files after errors. Note: The default");
      console::printf("                behavior is to immediately exit whenever an error occurs.");
      console::printf("-logfile filename - Append output to log file");
      console::printf("-pause - Wait for keypress on error");
      console::printf("-window <left> <top> <right> <bottom> - Crop window before processing");
      console::printf("-clamp <width> <height> - Crop image if larger than width/height");
      console::printf("-clampscale <width> <height> - Scale image if larger than width/height");
      console::printf("-nostats - Disable all output file statistics (faster)");
      console::printf("-imagestats - Print various image qualilty statistics");
      console::printf("-mipstats - Print statistics for each mipmap, not just the top mip");
      console::printf("-lzmastats - Print size of output file compressed with LZMA codec");
      console::printf("-split - Write faces/mip levels to multiple separate output PNG files");
      console::printf("-yflip - Always flip texture on Y axis before processing");
      console::printf("-unflip - Unflip texture if read from source file as flipped");

      console::message("\nImage rescaling (mutually exclusive options)");
      console::printf("-rescale <int> <int> - Rescale image to specified resolution");
      console::printf("-relscale <float> <float> - Rescale image to specified relative resolution");
      console::printf("-rescalemode <nearest | hi | lo> - Auto-rescale non-power of two images");
      console::printf(" nearest - Use nearest power of 2, hi - Use next, lo - Use previous");

      console::message("\nDDS/CRN compression quality control:");
      console::printf("-quality # (or /q #) - Set Clustered DDS/CRN quality factor [0-255] 255=best");
      console::printf("       DDS default quality is best possible.");
      console::printf("       CRN default quality is %u.", cDefaultCRNQualityLevel);
      console::printf("-bitrate # - Set the desired output bitrate of DDS or CRN output files.");
      console::printf("             This option causes crunch to find the quality factor");
      console::printf("             closest to the desired bitrate using a binary search.");

      console::message("\nLow-level CRN specific options:");
      console::printf("-c # - Color endpoint palette size, 32-8192, default=3072");
      console::printf("-s # - Color selector palette size, 32-8192, default=3072");
      console::printf("-ca # - Alpha endpoint palette size, 32-8192, default=3072");
      console::printf("-sa # - Alpha selector palette size, 32-8192, default=3072");

      //                -------------------------------------------------------------------------------
      console::message("\nMipmap filtering options:");
      console::printf("-mipMode [UseSourceOrGenerate,UseSource,Generate,None]");
      console::printf("         Default mipMode is UseSourceOrGenerate");
      console::printf(" UseSourceOrGenerate: Use source mipmaps if possible, or create new mipmaps.");
      console::printf(" UseSource: Always use source mipmaps, if any (never generate new mipmaps)");
      console::printf(" Generate: Always generate a new mipmap chain (ignore source mipmaps)");
      console::printf(" None: Do not output any mipmaps");
      console::printf("-mipFilter [box,tent,lanczos4,mitchell,kaiser], default=kaiser");
      console::printf("-gamma # - Mipmap gamma correction value, default=2.2, use 1.0 for linear");
      console::printf("-blurriness # - Scale filter kernel, >1=blur, <1=sharpen, .01-8, default=.9");
      console::printf("-wrap - Assume texture is tiled when filtering, default=clamping");
      console::printf("-renormalize - Renormalize filtered normal map texels, default=disabled");
      console::printf("-maxmips # - Limit number of generated texture mipmap levels, 1-16, default=16");
      console::printf("-minmipsize # - Smallest allowable mipmap resolution, default=1");

      console::message("\nCompression options:");
      console::printf("-alphaThreshold # - Set DXT1A alpha threshold, 0-255, default=128");
      console::printf(" Note: -alphaThreshold also changes the compressor's behavior to");
      console::printf(" prefer DXT1A over DXT5 for images with alpha channels (.DDS only).");
      console::printf("-uniformMetrics - Use uniform color metrics, default=use perceptual metrics");
      console::printf("-noAdaptiveBlocks - Disable adaptive block sizes (i.e. disable macroblocks).");
#ifdef CRNLIB_SUPPORT_ATI_COMPRESS
      console::printf("-compressor [CRN,CRNF,RYG,ATI] - Set DXTn compressor, default=CRN");
#else
      console::printf("-compressor [CRN,CRNF,RYG] - Set DXTn compressor, default=CRN");
#endif
      console::printf("-dxtQuality [superfast,fast,normal,better,uber] - Endpoint optimizer speed.");
      console::printf("            Sets endpoint optimizer's max iteration depth. Default=uber.");
      console::printf("-noendpointcaching - Don't try reusing previous DXT endpoint solutions.");
      console::printf("-grayscalsampling - Assume shader will convert fetched results to luma (Y).");
      console::printf("-forceprimaryencoding - Only use DXT1 color4 and DXT5 alpha8 block encodings.");
      console::printf("-usetransparentindicesforblack - Try DXT1 transparent indices for dark pixels.");

      console::message("\nOuptut pixel format options:");
      console::printf("-usesourceformat - Use input file's format for output format (when possible).");
      console::message("\nAll supported texture formats (Note: .CRN only supports DXTn pixel formats):");
      for (uint32 i = 0; i < pixel_format_helpers::get_num_formats(); i++)
      {
         pixel_format fmt = pixel_format_helpers::get_pixel_format_by_index(i);
         console::printf("-%s", pixel_format_helpers::get_pixel_format_string(fmt));
      }

      console::printf("\nFor bugs, support, or feedback: info@binomial.info");
   }

   bool convert(const char* pCommand_line)
   {
      m_num_processed = 0;
      m_num_failed = 0;
      m_num_succeeded = 0;
      m_num_skipped = 0;

      command_line_params::param_desc std_params[] =
      {
         { "file", 1, true },

         { "out", 1, false },
         { "outdir", 1, false },
         { "outsamedir", 0, false },
         { "deep", 0, false },
         { "fileformat", 1, false },

         { "helperThreads", 1, false },
         { "noprogress", 0, false },
         { "quiet", 0, false },
         { "ignoreerrors", 0, false },
         { "logfile", 1, false },

         { "q", 1, false },
         { "quality", 1, false },

         { "c", 1, false },
         { "s", 1, false },
         { "ca", 1, false },
         { "sa", 1, false },

         { "mipMode", 1, false },
         { "mipFilter", 1, false },
         { "gamma", 1, false },
         { "blurriness", 1, false },
         { "wrap", 0, false },
         { "renormalize", 0, false },
         { "noprogress", 0, false },
         { "paramdebug", 0, false },
         { "debug", 0, false },
         { "quick", 0, false },
         { "imagestats", 0, false },
         { "nostats", 0, false },
         { "mipstats", 0, false },

         { "alphaThreshold", 1, false },
         { "uniformMetrics", 0, false },
         { "noAdaptiveBlocks", 0, false },
         { "compressor", 1, false },
         { "dxtQuality", 1, false },
         { "noendpointcaching", 0, false },
         { "grayscalesampling", 0, false  },
         { "converttoluma", 0, false  },
         { "setalphatoluma", 0, false  },
         { "pause", 0, false  },
         { "timestamp", 0, false  },
         { "nooverwrite", 0, false  },
         { "forcewrite", 0, false  },
         { "recreate", 0, false  },
         { "compare", 0, false  },
         { "info", 0, false  },
         { "forceprimaryencoding", 0, false },
         { "usetransparentindicesforblack", 0, false  },
         { "usesourceformat", 0, false  },

         { "rescalemode", 1, false },
         { "rescale", 2, false },
         { "relrescale", 2, false },
         { "clamp", 2, false },
         { "clampScale", 2, false },
         { "window", 4, false },

         { "maxmips", 1, false },
         { "minmipsize", 1, false },

         { "bitrate", 1, false },

         { "lzmastats", 0, false },
         { "split", 0, false },
         { "csvfile", 1, false },

         { "yflip", 0, false },
         { "unflip", 0, false },
      };

      crnlib::vector<command_line_params::param_desc> params;
      params.append(std_params, sizeof(std_params) / sizeof(std_params[0]));

      for (uint32 i = 0; i < pixel_format_helpers::get_num_formats(); i++)
      {
         pixel_format fmt = pixel_format_helpers::get_pixel_format_by_index(i);

         command_line_params::param_desc desc;
         desc.m_pName = pixel_format_helpers::get_pixel_format_string(fmt);
         desc.m_num_values = 0;
         desc.m_support_listing_file = false;
         params.push_back(desc);
      }

      if (!m_params.parse(pCommand_line, params.size(), params.get_ptr(), true))
      {
         return false;
      }

      if (!m_params.get_num_params())
      {
         console::error("No command line parameters specified!");

         print_usage();

         return false;
      }

#if 0
      if (m_params.get_count(""))
      {
         console::error("Unrecognized command line parameter: \"%s\"", m_params.get_value_as_string_or_empty("", 0).get_ptr());

         return false;
      }
#endif

      if (m_params.get_value_as_bool("debug"))
      {
         console::debug("Command line parameters:");
         for (command_line_params::param_map_const_iterator it = m_params.begin(); it != m_params.end(); ++it)
         {
            console::disable_crlf();
            console::debug("Key:\"%s\" Values (%u): ", it->first.get_ptr(), it->second.m_values.size());
            for (uint32 i = 0; i < it->second.m_values.size(); i++)
               console::debug("\"%s\" ", it->second.m_values[i].get_ptr());
            console::debug("\n");
            console::enable_crlf();
         }
      }

      dynamic_string log_filename;
      if (m_params.get_value_as_string("logfile", 0, log_filename))
      {
         if (!m_log_stream.open(log_filename.get_ptr(), cDataStreamWritable | cDataStreamSeekable, true))
         {
            console::error("Unable to open log file: \"%s\"", log_filename.get_ptr());
            return false;
         }

         console::printf("Appending output to log file \"%s\"", log_filename.get_ptr());

         console::set_log_stream(&m_log_stream);
      }

      bool status = convert();

      if (m_log_stream.is_opened())
      {
         console::set_log_stream(NULL);

         m_log_stream.close();
      }

      return status;
   }

private:
   command_line_params m_params;

   bool convert()
   {
      find_files::file_desc_vec files;

      uint32 total_input_specs = 0;

      for (uint32 phase = 0; phase < 2; phase++)
      {
         command_line_params::param_map_const_iterator begin, end;
         m_params.find(phase ? "" : "file", begin, end);
         for (command_line_params::param_map_const_iterator it = begin; it != end; ++it)
         {
            total_input_specs++;

            const dynamic_string_array& strings = it->second.m_values;
            for (uint32 i = 0; i < strings.size(); i++)
            {
               if (!process_input_spec(files, strings[i]))
               {
                  if (!m_params.get_value_as_bool("ignoreerrors"))
                     return false;
               }
            }
         }
      }

      if (!total_input_specs)
      {
         console::error("No input files specified!");
         return false;
      }

      if (files.empty())
      {
         console::error("No files found to process!");
         return false;
      }

      std::sort(files.begin(), files.end());
      files.resize((uint32)(std::unique(files.begin(), files.end()) - files.begin()));

      timer tm;
      tm.start();

      if (!process_files(files))
      {
         if (!m_params.get_value_as_bool("ignoreerrors"))
            return false;
      }

      double total_time = tm.get_elapsed_secs();

      console::printf("Total time: %3.3fs", total_time);

      console::printf(
         ((m_num_skipped) || (m_num_failed)) ? cWarningConsoleMessage : cInfoConsoleMessage,
         "%u total file(s) successfully processed, %u file(s) skipped, %u file(s) failed.", m_num_succeeded, m_num_skipped, m_num_failed);

      return true;
   }

   bool process_input_spec(find_files::file_desc_vec& files, const dynamic_string& input_spec)
   {
      dynamic_string find_name(input_spec);

      if ((find_name.get_len()) && (file_utils::does_dir_exist(find_name.get_ptr())))
      {
         file_utils::combine_path(find_name, find_name.get_ptr(), "*");
      }

      if ((find_name.is_empty()) || (!file_utils::full_path(find_name)))
      {
         console::error("Invalid input filename: %s", find_name.get_ptr());
         return false;
      }

      const bool deep_flag = m_params.get_value_as_bool("deep");

      dynamic_string find_drive, find_path, find_fname, find_ext;
      file_utils::split_path(find_name.get_ptr(), &find_drive, &find_path, &find_fname, &find_ext);

      dynamic_string find_pathname;
      file_utils::combine_path(find_pathname, find_drive.get_ptr(), find_path.get_ptr());
      dynamic_string find_filename;
      find_filename = find_fname + find_ext;

      find_files file_finder;
      bool success = file_finder.find(find_pathname.get_ptr(), find_filename.get_ptr(), find_files::cFlagAllowFiles | (deep_flag ? find_files::cFlagRecursive : 0));
      if (!success)
      {
         console::error("Failed finding files: %s", find_name.get_ptr());
         return false;
      }

      if (file_finder.get_files().empty())
      {
         console::warning("No files found: %s", find_name.get_ptr());
         return true;
      }

      files.append(file_finder.get_files());

      return true;
   }

   bool read_only_file_check(const char* pDst_filename)
   {
      if (!file_utils::is_read_only(pDst_filename))
         return true;

      if (m_params.get_value_as_bool("forcewrite"))
      {
         if (file_utils::disable_read_only(pDst_filename))
         {
            console::warning("Setting read-only file \"%s\" to writable", pDst_filename);
            return true;
         }
         else
         {
            console::error("Failed setting read-only file \"%s\" to writable!", pDst_filename);
            return false;
         }
      }

      console::error("Output file \"%s\" is read-only!", pDst_filename);

      return false;
   }

   bool process_files(find_files::file_desc_vec& files)
   {
      const bool compare_mode = m_params.get_value_as_bool("compare");
      const bool info_mode = m_params.get_value_as_bool("info");

      for (uint32 file_index = 0; file_index < files.size(); file_index++)
      {
         const find_files::file_desc& file_desc = files[file_index];
         const dynamic_string& in_filename = file_desc.m_fullname;

         dynamic_string in_drive, in_path, in_fname, in_ext;
         file_utils::split_path(in_filename.get_ptr(), &in_drive, &in_path, &in_fname, &in_ext);

         texture_file_types::format out_file_type = texture_file_types::cFormatCRN;
         dynamic_string fmt;
         if (m_params.get_value_as_string("fileformat", 0, fmt))
         {
            if (fmt == "tga")
               out_file_type = texture_file_types::cFormatTGA;
            else if (fmt == "bmp")
               out_file_type = texture_file_types::cFormatBMP;
            else if (fmt == "dds")
               out_file_type = texture_file_types::cFormatDDS;
            else if (fmt == "ktx")
               out_file_type = texture_file_types::cFormatKTX;
            else if (fmt == "crn")
               out_file_type = texture_file_types::cFormatCRN;
            else if (fmt == "png")
               out_file_type = texture_file_types::cFormatPNG;
            else
            {
               console::error("Unsupported output file type: %s", fmt.get_ptr());
               return false;
            }
         }

         // No explicit output format has been specified - try to determine something doable.
         if (!m_params.has_key("fileformat"))
         {
            if (m_params.has_key("split"))
            {
               out_file_type = texture_file_types::cFormatPNG;
            }
            else
            {
               texture_file_types::format input_file_type = texture_file_types::determine_file_format(in_filename.get_ptr());
               if (input_file_type == texture_file_types::cFormatCRN)
               {
                  // Automatically transcode CRN->DXTc and write to DDS files, unless the user specifies either the /fileformat or /split options.
                  out_file_type = texture_file_types::cFormatDDS;
               }
               else if (input_file_type == texture_file_types::cFormatKTX)
               {
                  // Default to converting KTX files to PNG
                  out_file_type = texture_file_types::cFormatPNG;
               }
            }
         }

         dynamic_string out_filename;
         if (m_params.get_value_as_bool("outsamedir"))
            out_filename.format("%s%s%s.%s", in_drive.get_ptr(), in_path.get_ptr(), in_fname.get_ptr(), texture_file_types::get_extension(out_file_type));
         else if (m_params.has_key("out"))
         {
            out_filename = m_params.get_value_as_string_or_empty("out");

            if (files.size() > 1)
            {
               dynamic_string out_drive, out_dir, out_name, out_ext;
               file_utils::split_path(out_filename.get_ptr(), &out_drive, &out_dir, &out_name, &out_ext);

               out_name.format("%s_%u", out_name.get_ptr(), file_index);

               out_filename.format("%s%s%s%s", out_drive.get_ptr(), out_dir.get_ptr(), out_name.get_ptr(), out_ext.get_ptr());
            }

            if (!m_params.has_key("fileformat"))
               out_file_type = texture_file_types::determine_file_format(out_filename.get_ptr());
         }
         else
         {
            dynamic_string out_dir(m_params.get_value_as_string_or_empty("outdir"));

            if (m_params.get_value_as_bool("recreate") && file_desc.m_rel.get_len())
            {
               file_utils::combine_path(out_dir, out_dir.get_ptr(), file_desc.m_rel.get_ptr());
            }

            if (out_dir.get_len())
            {
               if (file_utils::is_path_separator(out_dir.back()))
                  out_filename.format("%s%s.%s", out_dir.get_ptr(), in_fname.get_ptr(), texture_file_types::get_extension(out_file_type));
               else
                  out_filename.format("%s\\%s.%s", out_dir.get_ptr(), in_fname.get_ptr(), texture_file_types::get_extension(out_file_type));
            }
            else
            {
               out_filename.format("%s.%s", in_fname.get_ptr(), texture_file_types::get_extension(out_file_type));
            }

            if (m_params.get_value_as_bool("recreate"))
            {
               if (file_utils::full_path(out_filename))
               {
                  if ((!compare_mode) && (!info_mode))
                  {
                     dynamic_string out_drive, out_path;
                     file_utils::split_path(out_filename.get_ptr(), &out_drive, &out_path, NULL, NULL);
                     out_drive += out_path;
                     file_utils::create_path(out_drive.get_ptr());
                  }
               }
            }
         }

         if ((!compare_mode) && (!info_mode))
         {
            if (file_utils::does_file_exist(out_filename.get_ptr()))
            {
               if (m_params.get_value_as_bool("nooverwrite"))
               {
                  console::warning("Skipping already existing file: %s\n", out_filename.get_ptr());
                  m_num_skipped++;
                  continue;
               }

               if (m_params.get_value_as_bool("timestamp"))
               {
                  if (file_utils::is_older_than(in_filename.get_ptr(), out_filename.get_ptr()))
                  {
                     console::warning("Skipping up to date file: %s\n", out_filename.get_ptr());
                     m_num_skipped++;
                     continue;
                  }
               }
            }
         }

         convert_status status = cCSFailed;

         if (info_mode)
            status = display_file_info(file_index, files.size(), in_filename.get_ptr());
         else if (compare_mode)
            status = compare_file(file_index, files.size(), in_filename.get_ptr(), out_filename.get_ptr(), out_file_type);
         else if (read_only_file_check(out_filename.get_ptr()))
            status = convert_file(file_index, files.size(), in_filename.get_ptr(), out_filename.get_ptr(), out_file_type);

         m_num_processed++;

         switch (status)
         {
            case cCSSucceeded:
            {
               console::info("");
               m_num_succeeded++;
               break;
            }
            case cCSSkipped:
            {
               console::info("Skipping file.\n");
               m_num_skipped++;
               break;
            }
            case cCSBadParam:
            {
               return false;
            }
            default:
            {
               if (!m_params.get_value_as_bool("ignoreerrors"))
                  return false;

               console::info("");

               m_num_failed++;
               break;
            }
         }
      }

      return true;
   }

   void print_texture_info(const char* pTex_desc, texture_conversion::convert_params& params, mipmapped_texture& tex)
   {
      console::info("%s: %ux%u, Levels: %u, Faces: %u, Format: %s",
         pTex_desc,
         tex.get_width(),
         tex.get_height(),
         tex.get_num_levels(),
         tex.get_num_faces(),
         pixel_format_helpers::get_pixel_format_string(tex.get_format()));

      console::disable_crlf();
      console::info("Apparent type: %s, ", get_texture_type_desc(params.m_texture_type));

      console::info("Flags: ");
      if (tex.get_comp_flags() & pixel_format_helpers::cCompFlagRValid) console::info("R ");
      if (tex.get_comp_flags() & pixel_format_helpers::cCompFlagGValid) console::info("G ");
      if (tex.get_comp_flags() & pixel_format_helpers::cCompFlagBValid) console::info("B ");
      if (tex.get_comp_flags() & pixel_format_helpers::cCompFlagAValid) console::info("A ");
      if (tex.get_comp_flags() & pixel_format_helpers::cCompFlagGrayscale) console::info("Grayscale ");
      if (tex.get_comp_flags() & pixel_format_helpers::cCompFlagNormalMap) console::info("NormalMap ");
      if (tex.get_comp_flags() & pixel_format_helpers::cCompFlagLumaChroma) console::info("LumaChroma ");
      if (tex.is_flipped()) console::info("Flipped "); else console::info("Non-Flipped ");
      console::info("\n");
      console::enable_crlf();
   }

   static bool progress_callback_func(uint32 percentage_complete, void* pUser_data_ptr)
   {
      pUser_data_ptr;

      console::disable_crlf();

      char buf[8];
      for (uint32 i = 0; i < 7; i++)
         buf[i] = 8;
      buf[7] = '\0';

      for (uint32 i = 0; i < 130/8; i++)
         console::progress(buf);

      console::progress("Processing: %u%%", percentage_complete);

      for (uint32 i = 0; i < 7; i++)
         buf[i] = ' ';
      console::progress(buf);
      console::progress(buf);

      for (uint32 i = 0; i < 7; i++)
         buf[i] = 8;
      console::progress(buf);
      console::progress(buf);

      console::enable_crlf();

      return true;
   }

   bool parse_mipmap_params(crn_mipmap_params& mip_params)
   {
      dynamic_string val;

      if (m_params.get_value_as_string("mipMode", 0, val))
      {
         uint32 i;
         for (i = 0; i < cCRNMipModeTotal; i++)
         {
            if (val == crn_get_mip_mode_name( static_cast<crn_mip_mode>(i) ))
            {
               mip_params.m_mode = static_cast<crn_mip_mode>(i);
               break;
            }
         }
         if (i == cCRNMipModeTotal)
         {
            console::error("Invalid MipMode: \"%s\"", val.get_ptr());
            return false;
         }
      }

      if (m_params.get_value_as_string("mipFilter", 0, val))
      {
         uint32 i;
         for (i = 0; i < cCRNMipFilterTotal; i++)
         {
            if (val == dynamic_string(crn_get_mip_filter_name( static_cast<crn_mip_filter>(i) )) )
            {
               mip_params.m_filter = static_cast<crn_mip_filter>(i);
               break;
            }
         }

         if (i == cCRNMipFilterTotal)
         {
            console::error("Invalid MipFilter: \"%s\"", val.get_ptr());
            return false;
         }

         if (i == cCRNMipFilterBox)
            mip_params.m_blurriness = 1.0f;
      }

      mip_params.m_gamma = m_params.get_value_as_float("gamma", 0, mip_params.m_gamma, .1f, 8.0f);
      mip_params.m_gamma_filtering = (mip_params.m_gamma != 1.0f);

      mip_params.m_blurriness = m_params.get_value_as_float("blurriness", 0, mip_params.m_blurriness, .01f, 8.0f);

      mip_params.m_renormalize = m_params.get_value_as_bool("renormalize", 0, mip_params.m_renormalize != 0);
      mip_params.m_tiled = m_params.get_value_as_bool("wrap");

      mip_params.m_max_levels = m_params.get_value_as_int("maxmips", 0, cCRNMaxLevels, 1, cCRNMaxLevels);
      mip_params.m_min_mip_size = m_params.get_value_as_int("minmipsize", 0, 1, 1, cCRNMaxLevelResolution);

      return true;
   }

   bool parse_scale_params(crn_mipmap_params &mipmap_params)
   {
      if (m_params.has_key("rescale"))
      {
         int w = m_params.get_value_as_int("rescale", 0, -1, 1, cCRNMaxLevelResolution, 0);
         int h = m_params.get_value_as_int("rescale", 0, -1, 1, cCRNMaxLevelResolution, 1);

         mipmap_params.m_scale_mode = cCRNSMAbsolute;
         mipmap_params.m_scale_x = (float)w;
         mipmap_params.m_scale_y = (float)h;
      }
      else if (m_params.has_key("relrescale"))
      {
         float w = m_params.get_value_as_float("relrescale", 0, 1, 1, 256, 0);
         float h = m_params.get_value_as_float("relrescale", 0, 1, 1, 256, 1);

         mipmap_params.m_scale_mode = cCRNSMRelative;
         mipmap_params.m_scale_x = w;
         mipmap_params.m_scale_y = h;
      }
      else if (m_params.has_key("rescalemode"))
      {
         // nearest | hi | lo

         dynamic_string mode_str(m_params.get_value_as_string_or_empty("rescalemode"));
         if (mode_str == "nearest")
            mipmap_params.m_scale_mode = cCRNSMNearestPow2;
         else if (mode_str == "hi")
            mipmap_params.m_scale_mode = cCRNSMNextPow2;
         else if (mode_str == "lo")
            mipmap_params.m_scale_mode = cCRNSMLowerPow2;
         else
         {
            console::error("Invalid rescale mode: \"%s\"", mode_str.get_ptr());
            return false;
         }
      }

      if (m_params.has_key("clamp"))
      {
         uint32 w = m_params.get_value_as_int("clamp", 0, 1, 1, cCRNMaxLevelResolution, 0);
         uint32 h = m_params.get_value_as_int("clamp", 0, 1, 1, cCRNMaxLevelResolution, 1);

         mipmap_params.m_clamp_scale = false;
         mipmap_params.m_clamp_width = w;
         mipmap_params.m_clamp_height = h;
      }
      else if (m_params.has_key("clampScale"))
      {
         uint32 w = m_params.get_value_as_int("clampscale", 0, 1, 1, cCRNMaxLevelResolution, 0);
         uint32 h = m_params.get_value_as_int("clampscale", 0, 1, 1, cCRNMaxLevelResolution, 1);

         mipmap_params.m_clamp_scale = true;
         mipmap_params.m_clamp_width = w;
         mipmap_params.m_clamp_height = h;
      }

      if (m_params.has_key("window"))
      {
         uint32 xl = m_params.get_value_as_int("window", 0, 0, 0, cCRNMaxLevelResolution, 0);
         uint32 yl = m_params.get_value_as_int("window", 0, 0, 0, cCRNMaxLevelResolution, 1);
         uint32 xh = m_params.get_value_as_int("window", 0, 0, 0, cCRNMaxLevelResolution, 2);
         uint32 yh = m_params.get_value_as_int("window", 0, 0, 0, cCRNMaxLevelResolution, 3);

         mipmap_params.m_window_left = math::minimum(xl, xh);
         mipmap_params.m_window_top = math::minimum(yl, yh);
         mipmap_params.m_window_right = math::maximum(xl, xh);
         mipmap_params.m_window_bottom = math::maximum(yl, yh);
      }

      return true;
   }

   bool parse_comp_params(texture_file_types::format dst_file_format, crn_comp_params &comp_params)
   {
      if (dst_file_format == texture_file_types::cFormatCRN)
         comp_params.m_quality_level = cDefaultCRNQualityLevel;

      if (m_params.has_key("q") || m_params.has_key("quality"))
      {
         const char *pKeyName = m_params.has_key("q") ? "q" : "quality";

         if ((dst_file_format == texture_file_types::cFormatDDS) || (dst_file_format == texture_file_types::cFormatCRN) || (dst_file_format == texture_file_types::cFormatKTX))
         {
            uint32 i = m_params.get_value_as_int(pKeyName, 0, cDefaultCRNQualityLevel, 0, cCRNMaxQualityLevel);

            comp_params.m_quality_level = i;
         }
         else
         {
            console::error("/quality or /q option is only invalid when writing DDS, KTX or CRN files!");
            return false;
         }
      }
      else
      {
         float desired_bitrate = m_params.get_value_as_float("bitrate", 0, 0.0f, .1f, 30.0f);
         if (desired_bitrate > 0.0f)
         {
            comp_params.m_target_bitrate = desired_bitrate;
         }
      }

      int color_endpoints = m_params.get_value_as_int("c", 0, 0, cCRNMinPaletteSize, cCRNMaxPaletteSize);
      int color_selectors = m_params.get_value_as_int("s", 0, 0, cCRNMinPaletteSize, cCRNMaxPaletteSize);
      int alpha_endpoints = m_params.get_value_as_int("ca", 0, 0, cCRNMinPaletteSize, cCRNMaxPaletteSize);
      int alpha_selectors = m_params.get_value_as_int("sa", 0, 0, cCRNMinPaletteSize, cCRNMaxPaletteSize);
      if ( ((color_endpoints > 0) && (color_selectors > 0)) ||
           ((alpha_endpoints > 0) && (alpha_selectors > 0)) )
      {
         comp_params.set_flag(cCRNCompFlagManualPaletteSizes, true);
         comp_params.m_crn_color_endpoint_palette_size = color_endpoints;
         comp_params.m_crn_color_selector_palette_size = color_selectors;
         comp_params.m_crn_alpha_endpoint_palette_size = alpha_endpoints;
         comp_params.m_crn_alpha_selector_palette_size = alpha_selectors;
      }

      if (m_params.has_key("alphaThreshold"))
      {
         int dxt1a_alpha_threshold = m_params.get_value_as_int("alphaThreshold", 0, 128, 0, 255);
         comp_params.m_dxt1a_alpha_threshold = dxt1a_alpha_threshold;
         if (dxt1a_alpha_threshold > 0)
         {
            comp_params.set_flag(cCRNCompFlagDXT1AForTransparency, true);
         }
      }

      comp_params.set_flag(cCRNCompFlagPerceptual, !m_params.get_value_as_bool("uniformMetrics"));
      comp_params.set_flag(cCRNCompFlagHierarchical, !m_params.get_value_as_bool("noAdaptiveBlocks"));

      if (m_params.has_key("helperThreads"))
         comp_params.m_num_helper_threads = m_params.get_value_as_int("helperThreads", 0, cCRNMaxHelperThreads, 0, cCRNMaxHelperThreads);
      else if (g_number_of_processors > 1)
         comp_params.m_num_helper_threads = g_number_of_processors - 1;

      dynamic_string comp_name;
      if (m_params.get_value_as_string("compressor", 0, comp_name))
      {
         uint32 i;
         for (i = 0; i < cCRNTotalDXTCompressors; i++)
         {
            if (comp_name == get_dxt_compressor_name(static_cast<crn_dxt_compressor_type>(i)))
            {
               comp_params.m_dxt_compressor_type = static_cast<crn_dxt_compressor_type>(i);
               break;
            }
         }
         if (i == cCRNTotalDXTCompressors)
         {
            console::error("Invalid compressor: \"%s\"", comp_name.get_ptr());
            return false;
         }
      }

      dynamic_string dxt_quality_str;
      if (m_params.get_value_as_string("dxtquality", 0, dxt_quality_str))
      {
         uint32 i;
         for (i = 0; i < cCRNDXTQualityTotal; i++)
         {
            if (dxt_quality_str == crn_get_dxt_quality_string(static_cast<crn_dxt_quality>(i)))
            {
               comp_params.m_dxt_quality = static_cast<crn_dxt_quality>(i);
               break;
            }
         }
         if (i == cCRNDXTQualityTotal)
         {
            console::error("Invalid DXT quality: \"%s\"", dxt_quality_str.get_ptr());
            return false;
         }
      }
      else
      {
         comp_params.m_dxt_quality = cCRNDXTQualityUber;
      }

      comp_params.set_flag(cCRNCompFlagDisableEndpointCaching, m_params.get_value_as_bool("noendpointcaching"));
      comp_params.set_flag(cCRNCompFlagGrayscaleSampling, m_params.get_value_as_bool("grayscalesampling"));
      comp_params.set_flag(cCRNCompFlagUseBothBlockTypes, !m_params.get_value_as_bool("forceprimaryencoding"));
      if (comp_params.get_flag(cCRNCompFlagUseBothBlockTypes))
         comp_params.set_flag(cCRNCompFlagUseTransparentIndicesForBlack, m_params.get_value_as_bool("usetransparentindicesforblack"));
      else
         comp_params.set_flag(cCRNCompFlagUseTransparentIndicesForBlack, false);

      return true;
   }

   convert_status display_file_info(uint32 file_index, uint32 num_files, const char* pSrc_filename)
   {
      if (num_files > 1)
         console::message("[%u/%u] Source texture: \"%s\"", file_index + 1, num_files, pSrc_filename);
      else
         console::message("Source texture: \"%s\"", pSrc_filename);

      texture_file_types::format src_file_format = texture_file_types::determine_file_format(pSrc_filename);
      if (src_file_format == texture_file_types::cFormatInvalid)
      {
         console::error("Unrecognized file type: %s", pSrc_filename);
         return cCSFailed;
      }

      mipmapped_texture src_tex;
      if (!src_tex.read_from_file(pSrc_filename, src_file_format))
      {
         if (src_tex.get_last_error().is_empty())
            console::error("Failed reading source file: \"%s\"", pSrc_filename);
         else
            console::error("%s", src_tex.get_last_error().get_ptr());

         return cCSFailed;
      }

      uint64 input_file_size;
      file_utils::get_file_size(pSrc_filename, input_file_size);

      uint32 total_in_pixels = 0;
      for (uint32 i = 0; i < src_tex.get_num_levels(); i++)
      {
         uint32 width = math::maximum<uint32>(1, src_tex.get_width() >> i);
         uint32 height = math::maximum<uint32>(1, src_tex.get_height() >> i);
         total_in_pixels += width*height*src_tex.get_num_faces();
      }

      vector<uint8> src_tex_bytes;
      if (!cfile_stream::read_file_into_array(pSrc_filename, src_tex_bytes))
      {
         console::error("Failed loading source file: %s", pSrc_filename);
         return cCSFailed;
      }

      if (!src_tex_bytes.size())
      {
         console::warning("Source file is empty: %s", pSrc_filename);
         return cCSSkipped;
      }

      uint32 compressed_size = 0;
      if (m_params.has_key("lzmastats"))
      {
         lzma_codec lossless_codec;
         vector<uint8> cmp_tex_bytes;
         if (lossless_codec.pack(src_tex_bytes.get_ptr(), src_tex_bytes.size(), cmp_tex_bytes))
         {
            compressed_size = cmp_tex_bytes.size();
         }
      }
      console::info("Source texture dimensions: %ux%u, Levels: %u, Faces: %u, Format: %s\nPacked Format: %u, Apparent Type: %s, Flipped: %u, Can Unflip Without Unpacking: %u",
         src_tex.get_width(),
         src_tex.get_height(),
         src_tex.get_num_levels(),
         src_tex.get_num_faces(),
         pixel_format_helpers::get_pixel_format_string(src_tex.get_format()),
         src_tex.is_packed(), get_texture_type_desc(src_tex.determine_texture_type()),
         src_tex.is_flipped(), src_tex.can_unflip_without_unpacking());

      console::info("Total pixels: %u, Source file size: " CRNLIB_UINT64_FORMAT_SPECIFIER ", Source file bits/pixel: %1.3f",
         total_in_pixels, input_file_size, (input_file_size * 8.0f) / total_in_pixels);
      if (compressed_size)
      {
         console::info("LZMA compressed file size: %u bytes, %1.3f bits/pixel",
            compressed_size, compressed_size * 8.0f / total_in_pixels);
      }

      double entropy = math::compute_entropy(src_tex_bytes.get_ptr(), src_tex_bytes.size());
      console::info("Source file entropy: %3.6f bits per byte", entropy / src_tex_bytes.size());

      if (src_file_format == texture_file_types::cFormatCRN)
      {
         crnd::crn_texture_info tex_info;
         tex_info.m_struct_size = sizeof(crnd::crn_texture_info);
         crn_bool success = crnd::crnd_get_texture_info(src_tex_bytes.get_ptr(), src_tex_bytes.size(), &tex_info);
         if (!success)
            console::error("Failed retrieving CRN texture info!");
         else
         {
            console::info("CRN texture info:");

            console::info("Width: %u, Height: %u, Levels: %u, Faces: %u\nBytes per block: %u, User0: 0x%08X, User1: 0x%08X, CRN Format: %u",
               tex_info.m_width,
               tex_info.m_height,
               tex_info.m_levels,
               tex_info.m_faces,
               tex_info.m_bytes_per_block,
               tex_info.m_userdata0,
               tex_info.m_userdata1,
               tex_info.m_format);
         }
      }

      return cCSSucceeded;
   }

   void print_stats(texture_conversion::convert_stats &stats, bool force_image_stats = false)
   {
      dynamic_string csv_filename;
      const char *pCSVStatsFilename = m_params.get_value_as_string("csvfile", 0, csv_filename) ? csv_filename.get_ptr() : NULL;

      bool image_stats = force_image_stats || m_params.get_value_as_bool("imagestats") || m_params.get_value_as_bool("mipstats") || (pCSVStatsFilename != NULL);
      bool mip_stats = m_params.get_value_as_bool("mipstats");
      bool grayscale_sampling = m_params.get_value_as_bool("grayscalesampling");
      if (!stats.print(image_stats, mip_stats, grayscale_sampling, pCSVStatsFilename))
      {
         console::warning("Unable to compute/display full output file statistics.");
      }
   }

   convert_status compare_file(uint32 file_index, uint32 num_files, const char* pSrc_filename, const char* pDst_filename, texture_file_types::format out_file_type)
   {
      if (num_files > 1)
         console::message("[%u/%u] Comparing source texture \"%s\" to output texture \"%s\"", file_index + 1, num_files, pSrc_filename, pDst_filename);
      else
         console::message("Comparing source texture \"%s\" to output texture \"%s\"", pSrc_filename, pDst_filename);

      texture_file_types::format src_file_format = texture_file_types::determine_file_format(pSrc_filename);
      if (src_file_format == texture_file_types::cFormatInvalid)
      {
         console::error("Unrecognized file type: %s", pSrc_filename);
         return cCSFailed;
      }

      mipmapped_texture src_tex;

      if (!src_tex.read_from_file(pSrc_filename, src_file_format))
      {
         if (src_tex.get_last_error().is_empty())
            console::error("Failed reading source file: \"%s\"", pSrc_filename);
         else
            console::error("%s", src_tex.get_last_error().get_ptr());

         return cCSFailed;
      }

      texture_conversion::convert_stats stats;
      if (!stats.init(pSrc_filename, pDst_filename, src_tex, out_file_type, m_params.has_key("lzmastats")))
         return cCSFailed;

      print_stats(stats, true);

      return cCSSucceeded;
   }

   convert_status convert_file(uint32 file_index, uint32 num_files, const char* pSrc_filename, const char* pDst_filename, texture_file_types::format out_file_type)
   {
      timer tim;

      if (num_files > 1)
         console::message("[%u/%u] Reading source texture: \"%s\"", file_index + 1, num_files, pSrc_filename);
      else
         console::message("Reading source texture: \"%s\"", pSrc_filename);

      texture_file_types::format src_file_format = texture_file_types::determine_file_format(pSrc_filename);
      if (src_file_format == texture_file_types::cFormatInvalid)
      {
         console::error("Unrecognized file type: %s", pSrc_filename);
         return cCSFailed;
      }

      mipmapped_texture src_tex;
      tim.start();
      if (!src_tex.read_from_file(pSrc_filename, src_file_format))
      {
         if (src_tex.get_last_error().is_empty())
            console::error("Failed reading source file: \"%s\"", pSrc_filename);
         else
            console::error("%s", src_tex.get_last_error().get_ptr());

         return cCSFailed;
      }
      double total_time = tim.get_elapsed_secs();
      console::info("Texture successfully loaded in %3.3fs", total_time);

      if (m_params.get_value_as_bool("converttoluma"))
         src_tex.convert(image_utils::cConversion_Y_To_RGB);
      if (m_params.get_value_as_bool("setalphatoluma"))
         src_tex.convert(image_utils::cConversion_Y_To_A);

      texture_conversion::convert_params params;

      params.m_texture_type = src_tex.determine_texture_type();
      params.m_pInput_texture = &src_tex;
      params.m_dst_filename = pDst_filename;
      params.m_dst_file_type = out_file_type;
      params.m_lzma_stats = m_params.has_key("lzmastats");
      params.m_write_mipmaps_to_multiple_files = m_params.has_key("split");
      params.m_always_use_source_pixel_format = m_params.has_key("usesourceformat");
      params.m_y_flip = m_params.has_key("yflip");
      params.m_unflip = m_params.has_key("unflip");

      if ((!m_params.get_value_as_bool("noprogress")) && (!m_params.get_value_as_bool("quiet")))
         params.m_pProgress_func = progress_callback_func;

      if (m_params.get_value_as_bool("debug"))
      {
         params.m_debugging = true;
         params.m_comp_params.set_flag(cCRNCompFlagDebugging, true);
      }

      if (m_params.get_value_as_bool("paramdebug"))
         params.m_param_debugging = true;

      if (m_params.get_value_as_bool("quick"))
         params.m_quick = true;

      params.m_no_stats = m_params.get_value_as_bool("nostats");

      params.m_dst_format = PIXEL_FMT_INVALID;

      for (uint32 i = 0; i < pixel_format_helpers::get_num_formats(); i++)
      {
         pixel_format trial_fmt = pixel_format_helpers::get_pixel_format_by_index(i);
         if (m_params.has_key(pixel_format_helpers::get_pixel_format_string(trial_fmt)))
         {
            params.m_dst_format = trial_fmt;
            break;
         }
      }

      if (texture_file_types::supports_mipmaps(src_file_format))
      {
         params.m_mipmap_params.m_mode = cCRNMipModeUseSourceMips;
      }

      if (!parse_mipmap_params(params.m_mipmap_params))
         return cCSBadParam;

      if (!parse_comp_params(params.m_dst_file_type, params.m_comp_params))
         return cCSBadParam;

      if (!parse_scale_params(params.m_mipmap_params))
         return cCSBadParam;

      print_texture_info("Source texture", params, src_tex);

      if (params.m_texture_type == cTextureTypeNormalMap)
      {
         params.m_comp_params.set_flag(cCRNCompFlagPerceptual, false);
      }

      texture_conversion::convert_stats stats;

      tim.start();
      bool status = texture_conversion::process(params, stats);
      total_time = tim.get_elapsed_secs();

      if (!status)
      {
         if (params.m_error_message.is_empty())
            console::error("Failed writing output file: \"%s\"", pDst_filename);
         else
            console::error(params.m_error_message.get_ptr());
         return cCSFailed;
      }

      console::info("Texture successfully processed in %3.3fs", total_time);

      if (!m_params.get_value_as_bool("nostats"))
         print_stats(stats);

      return cCSSucceeded;
   }
};

//-----------------------------------------------------------------------------------------------------------------------

static bool check_for_option(int argc, char *argv[], const char *pOption)
{
   for (int i = 1; i < argc; i++)
   {
      if ((argv[i][0] == '/') || (argv[i][0] == '-'))
      {
         if (crn_stricmp(&argv[i][1], pOption) == 0)
            return true;
      }
   }
   return false;
}

//-----------------------------------------------------------------------------------------------------------------------

static void print_title()
{
   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("");
}

//-----------------------------------------------------------------------------------------------------------------------

static int main_internal(int argc, char *argv[])
{
   argc;
   argv;

   colorized_console::init();

   if (check_for_option(argc, argv, "quiet"))
      console::disable_output();

   print_title();

   dynamic_string cmd_line;
   get_command_line_as_single_string(cmd_line, argc, argv);

   bool status = false;
   if (check_for_option(argc, argv, "corpus_gen"))
   {
      corpus_gen generator;
      status = generator.generate(cmd_line.get_ptr());
   }
   else if (check_for_option(argc, argv, "corpus_test"))
   {
      corpus_tester tester;
      status = tester.test(cmd_line.get_ptr());
   }
   else
   {
      crunch converter;
      status = converter.convert(cmd_line.get_ptr());
   }

   colorized_console::deinit();

   crnlib_print_mem_stats();

   return status ? EXIT_SUCCESS : EXIT_FAILURE;
}

static void pause_and_wait(void)
{
   console::enable_output();

   console::message("\nPress a key to continue.");

   for ( ; ; )
   {
      if (crn_getch() != -1)
         break;
   }
}

//-----------------------------------------------------------------------------------------------------------------------

int main(int argc, char *argv[])
{
   int status = EXIT_FAILURE;

   if (crnlib_is_debugger_present())
   {
      status = main_internal(argc, argv);
   }
   else
   {
#ifdef _MSC_VER
      __try
      {
         status = main_internal(argc, argv);
      }
      __except(EXCEPTION_EXECUTE_HANDLER)
      {
         console::error("Uncached exception! crunch command line tool failed!");
      }
#else
      status = main_internal(argc, argv);
#endif
   }

   console::printf("\nExit status: %i", status);

   if (check_for_option(argc, argv, "pause"))
   {
      if ((status == EXIT_FAILURE) || (console::get_num_messages(cErrorConsoleMessage)))
         pause_and_wait();
   }

   return status;
}