Remove unused dependencies.

extern/CMakeLists.txt

@@ -5,8 +5,6 @@ ADD_SUBDIRECTORY(EtcLib)
 ADD_SUBDIRECTORY(rg_etc1_v104)
 #ADD_SUBDIRECTORY(etcpack)
 
-#ADD_SUBDIRECTORY(butteraugli)
-
 ADD_SUBDIRECTORY(libsquish-1.15)
 
 ADD_SUBDIRECTORY(CMP_Core)

extern/atitc/ATI_Compress.h

@@ -1,175 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-//  Advanced Micro Devices, Inc.
-//  1 AMD Place
-//  Sunnyvale, CA
-//  USA 94088
-//
-//  File Name:   ATI_Compress.h
-//  Description: A library to compress/decompress textures
-//
-//  Copyright (c) 2007,2008 Advanced Micro Devices, Inc.
-//  Copyright (c) 2004-2006 ATI Technologies Inc.
-//
-//  Version:	1.7
-//
-//  Developer:	Seth Sowerby	
-//  Email:		gputools.support@amd.com
-//
-//////////////////////////////////////////////////////////////////////////////
-
-/// \file
-/// ATI_Compress.h declares the interface to the ATI_Compress library.
-
-#ifndef ATI_COMPRESS
-#define ATI_COMPRESS
-
-#define ATI_COMPRESS_VERSION_MAJOR 1         ///< The major version number of this release.
-#define ATI_COMPRESS_VERSION_MINOR 7         ///< The minor version number of this release.
-
-typedef unsigned long ATI_TC_DWORD;          ///< A 32-bit integer format.
-typedef unsigned short ATI_TC_WORD;          ///< A 16-bit integer format.
-typedef unsigned char ATI_TC_BYTE;           ///< An 8-bit integer format.
-
-#if defined(WIN32) || defined(_WIN64)
-#   define ATI_TC_API __cdecl
-#else
-#   define ATI_TC_API 
-#endif
-
-#ifdef ATI_COMPRESS_INTERNAL_BUILD
-#   include "ATI_Compress_Internal.h"
-#else // ATI_COMPRESS_INTERNAL_BUILD
-
-/// Texture format.
-typedef enum
-{
-   ATI_TC_FORMAT_Unknown,                    ///< An undefined texture format.
-   ATI_TC_FORMAT_ARGB_8888,                  ///< An ARGB format with 8-bit fixed channels.
-   ATI_TC_FORMAT_RGB_888,                    ///< A RGB format with 8-bit fixed channels.
-   ATI_TC_FORMAT_RG_8,                       ///< A two component format with 8-bit fixed channels.
-   ATI_TC_FORMAT_R_8,                        ///< A single component format with 8-bit fixed channels.
-   ATI_TC_FORMAT_ARGB_2101010,               ///< An ARGB format with 10-bit fixed channels for color & a 2-bit fixed channel for alpha.
-   ATI_TC_FORMAT_ARGB_16,                    ///< A ARGB format with 16-bit fixed channels.
-   ATI_TC_FORMAT_RG_16,                      ///< A two component format with 16-bit fixed channels.
-   ATI_TC_FORMAT_R_16,                       ///< A single component format with 16-bit fixed channels.
-   ATI_TC_FORMAT_ARGB_16F,                   ///< An ARGB format with 16-bit floating-point channels.
-   ATI_TC_FORMAT_RG_16F,                     ///< A two component format with 16-bit floating-point channels.
-   ATI_TC_FORMAT_R_16F,                      ///< A single component with 16-bit floating-point channels.
-   ATI_TC_FORMAT_ARGB_32F,                   ///< An ARGB format with 32-bit floating-point channels.
-   ATI_TC_FORMAT_RG_32F,                     ///< A two component format with 32-bit floating-point channels.
-   ATI_TC_FORMAT_R_32F,                      ///< A single component with 32-bit floating-point channels.
-   ATI_TC_FORMAT_DXT1,                       ///< An opaque (or 1-bit alpha) DXTC compressed texture format. Four bits per pixel.
-   ATI_TC_FORMAT_DXT3,                       ///< A DXTC compressed texture format with explicit alpha. Eight bits per pixel.
-   ATI_TC_FORMAT_DXT5,                       ///< A DXTC compressed texture format with interpolated alpha. Eight bits per pixel.
-   ATI_TC_FORMAT_DXT5_xGBR,                  ///< A DXT5 with the red component swizzled into the alpha channel. Eight bits per pixel.
-   ATI_TC_FORMAT_DXT5_RxBG,                  ///< A swizzled DXT5 format with the green component swizzled into the alpha channel. Eight bits per pixel.
-   ATI_TC_FORMAT_DXT5_RBxG,                  ///< A swizzled DXT5 format with the green component swizzled into the alpha channel & the blue component swizzled into the green channel. Eight bits per pixel.
-   ATI_TC_FORMAT_DXT5_xRBG,                  ///< A swizzled DXT5 format with the green component swizzled into the alpha channel & the red component swizzled into the green channel. Eight bits per pixel.
-   ATI_TC_FORMAT_DXT5_RGxB,                  ///< A swizzled DXT5 format with the blue component swizzled into the alpha channel. Eight bits per pixel.
-   ATI_TC_FORMAT_DXT5_xGxR,                  ///< A two-component swizzled DXT5 format with the red component swizzled into the alpha channel & the green component in the green channel. Eight bits per pixel.
-   ATI_TC_FORMAT_ATI1N,                      ///< A single component compression format using the same technique as DXT5 alpha. Four bits per pixel.
-   ATI_TC_FORMAT_ATI2N,                      ///< A two component compression format using the same technique as DXT5 alpha. Designed for compression object space normal maps. Eight bits per pixel.
-   ATI_TC_FORMAT_ATI2N_XY,                   ///< A two component compression format using the same technique as DXT5 alpha. The same as ATI2N but with the channels swizzled. Eight bits per pixel.
-   ATI_TC_FORMAT_ATI2N_DXT5,                 ///< An ATI2N like format using DXT5. Intended for use on GPUs that do not natively support ATI2N. Eight bits per pixel.
-   ATI_TC_FORMAT_BC1,                        ///< A four component opaque (or 1-bit alpha) compressed texture format for Microsoft DirectX10. Identical to DXT1.  Four bits per pixel.
-   ATI_TC_FORMAT_BC2,                        ///< A four component compressed texture format with explicit alpha for Microsoft DirectX10. Identical to DXT3. Eight bits per pixel.
-   ATI_TC_FORMAT_BC3,                        ///< A four component compressed texture format with interpolated alpha for Microsoft DirectX10. Identical to DXT5. Eight bits per pixel.
-   ATI_TC_FORMAT_BC4,                        ///< A single component compressed texture format for Microsoft DirectX10. Identical to ATI1N. Four bits per pixel.
-   ATI_TC_FORMAT_BC5,                        ///< A two component compressed texture format for Microsoft DirectX10. Identical to ATI2N. Eight bits per pixel.
-   ATI_TC_FORMAT_ATC_RGB,                    ///< ATI_TC - a compressed RGB format for cellphones & hand-held devices.
-   ATI_TC_FORMAT_ATC_RGBA_Explicit,          ///< ATI_TC - a compressed ARGB format with explicit alpha for cellphones & hand-held devices.  
-   ATI_TC_FORMAT_ATC_RGBA_Interpolated,      ///< ATI_TC - a compressed ARGB format with interpolated alpha for cellphones & hand-held devices. 
-   ATI_TC_FORMAT_ETC_RGB,                    ///< ETC (aka Ericsson Texture Compression) - a compressed RGB format for cellphones.
-   ATI_TC_FORMAT_MAX = ATI_TC_FORMAT_ETC_RGB
-} ATI_TC_FORMAT;
-
-/// An enum selecting the speed vs. quality trade-off.
-typedef enum
-{
-   ATI_TC_Speed_Normal,                      ///< Highest quality mode
-   ATI_TC_Speed_Fast,                        ///< Slightly lower quality but much faster compression mode - DXTn & ATInN only
-   ATI_TC_Speed_SuperFast,                   ///< Slightly lower quality but much, much faster compression mode - DXTn & ATInN only
-} ATI_TC_Speed;
-
-/// ATI_Compress error codes
-typedef enum
-{
-   ATI_TC_OK = 0,                            ///< Ok.
-   ATI_TC_ABORTED,                           ///< The conversion was aborted.
-   ATI_TC_ERR_INVALID_SOURCE_TEXTURE,        ///< The source texture is invalid.
-   ATI_TC_ERR_INVALID_DEST_TEXTURE,          ///< The destination texture is invalid.
-   ATI_TC_ERR_UNSUPPORTED_SOURCE_FORMAT,     ///< The source format is not a supported format.
-   ATI_TC_ERR_UNSUPPORTED_DEST_FORMAT,       ///< The destination format is not a supported format.
-   ATI_TC_ERR_SIZE_MISMATCH,                 ///< The source and destination texture sizes do not match.
-   ATI_TC_ERR_UNABLE_TO_INIT_CODEC,          ///< ATI_Compress was unable to initialize the codec needed for conversion.
-   ATI_TC_ERR_GENERIC                        ///< An unknown error occurred.
-} ATI_TC_ERROR;
-
-/// Options for the compression.
-/// Passing this structure is optional
-typedef struct
-{
-   ATI_TC_DWORD	dwSize;					      ///< The size of this structure.
-   BOOL			   bUseChannelWeighting;      ///< Use channel weightings. With swizzled formats the weighting applies to the data within the specified channel not the channel itself.
-   double			fWeightingRed;			      ///< The weighting of the Red or X Channel.
-   double			fWeightingGreen;		      ///< The weighting of the Green or Y Channel.
-   double			fWeightingBlue;		      ///< The weighting of the Blue or Z Channel.
-   BOOL			   bUseAdaptiveWeighting;     ///< Adapt weighting on a per-block basis.
-   BOOL			   bDXT1UseAlpha;             ///< Encode single-bit alpha data. Only valid when compressing to DXT1 & BC1.
-   ATI_TC_BYTE		nAlphaThreshold;           ///< The alpha threshold to use when compressing to DXT1 & BC1 with bDXT1UseAlpha. Texels with an alpha value less than the threshold are treated as transparent.
-   BOOL			   bDisableMultiThreading;    ///< Disable multi-threading of the compression. This will slow the compression but can be useful if you're managing threads in your application.
-   ATI_TC_Speed   nCompressionSpeed;         ///< The trade-off between compression speed & quality.
-} ATI_TC_CompressOptions;
-#endif // !ATI_COMPRESS_INTERNAL_BUILD
-
-/// The structure describing a texture.
-typedef struct
-{
-   ATI_TC_DWORD   dwSize;                    ///< Size of this structure.
-   ATI_TC_DWORD	dwWidth;                   ///< Width of the texture.
-   ATI_TC_DWORD	dwHeight;                  ///< Height of the texture.
-   ATI_TC_DWORD	dwPitch;                   ///< Distance to start of next line - necessary only for uncompressed textures.
-   ATI_TC_FORMAT	format;                    ///< Format of the texture.
-   ATI_TC_DWORD	dwDataSize;                ///< Size of the allocated texture data.
-   ATI_TC_BYTE*	pData;                     ///< Pointer to the texture data
-} ATI_TC_Texture;
-
-#define MINIMUM_WEIGHT_VALUE 0.01f
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-   /// ATI_TC_Feedback_Proc
-   /// Feedback function for conversion.
-   /// \param[in] fProgress The percentage progress of the texture compression.
-   /// \param[in] pUser1 User data as passed to ATI_TC_ConvertTexture.
-   /// \param[in] pUser2 User data as passed to ATI_TC_ConvertTexture.
-   /// \return non-NULL(true) value to abort conversion
-   typedef bool (ATI_TC_API * ATI_TC_Feedback_Proc)(float fProgress, DWORD_PTR pUser1, DWORD_PTR pUser2);
-
-   /// Calculates the required buffer size for the specified texture
-   /// \param[in] pTexture A pointer to the texture.
-   /// \return    The size of the buffer required to hold the texture data.
-   ATI_TC_DWORD ATI_TC_API ATI_TC_CalculateBufferSize(const ATI_TC_Texture* pTexture);
-
-   /// Converts the source texture to the destination texture
-   /// This can be compression, decompression or converting between two uncompressed formats.
-   /// \param[in] pSourceTexture A pointer to the source texture.
-   /// \param[in] pDestTexture A pointer to the destination texture.
-   /// \param[in] pOptions A pointer to the compression options - can be NULL.
-   /// \param[in] pFeedbackProc A pointer to the feedback function - can be NULL.
-   /// \param[in] pUser1 User data to pass to the feedback function.
-   /// \param[in] pUser2 User data to pass to the feedback function.
-   /// \return    ATI_TC_OK if successful, otherwise the error code.
-   ATI_TC_ERROR ATI_TC_API ATI_TC_ConvertTexture(const ATI_TC_Texture* pSourceTexture, ATI_TC_Texture* pDestTexture, 
-                                                 const ATI_TC_CompressOptions* pOptions, 
-                                                 ATI_TC_Feedback_Proc pFeedbackProc, DWORD_PTR pUser1, DWORD_PTR pUser2);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif // !ATI_COMPRESS

extern/butteraugli/CMakeLists.txt

@@ -1,7 +0,0 @@
-
-SET(BUTTERAUGLI_SRCS
-	butteraugli.cc
-	butteraugli.h)
-
-ADD_LIBRARY(butteraugli STATIC ${BUTTERAUGLI_SRCS})
-

extern/butteraugli/butteraugli.h

@@ -1,560 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Disclaimer: This is not an official Google product.
-//
-// Author: Jyrki Alakuijala (jyrki.alakuijala@gmail.com)
-
-#ifndef BUTTERAUGLI_BUTTERAUGLI_H_
-#define BUTTERAUGLI_BUTTERAUGLI_H_
-
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <memory>
-#include <vector>
-
-#ifndef PROFILER_ENABLED
-#define PROFILER_ENABLED 0
-#endif
-#if PROFILER_ENABLED
-#else
-#define PROFILER_FUNC
-#define PROFILER_ZONE(name)
-#endif
-
-#define BUTTERAUGLI_ENABLE_CHECKS 0
-
-// This is the main interface to butteraugli image similarity
-// analysis function.
-
-namespace butteraugli {
-
-template<typename T>
-class Image;
-
-using Image8 = Image<uint8_t>;
-using ImageF = Image<float>;
-using ImageD = Image<double>;
-
-// ButteraugliInterface defines the public interface for butteraugli.
-//
-// It calculates the difference between rgb0 and rgb1.
-//
-// rgb0 and rgb1 contain the images. rgb0[c][px] and rgb1[c][px] contains
-// the red image for c == 0, green for c == 1, blue for c == 2. Location index
-// px is calculated as y * xsize + x.
-//
-// Value of pixels of images rgb0 and rgb1 need to be represented as raw
-// intensity. Most image formats store gamma corrected intensity in pixel
-// values. This gamma correction has to be removed, by applying the following
-// function:
-// butteraugli_val = 255.0 * pow(png_val / 255.0, gamma);
-// A typical value of gamma is 2.2. It is usually stored in the image header.
-// Take care not to confuse that value with its inverse. The gamma value should
-// be always greater than one.
-// Butteraugli does not work as intended if the caller does not perform
-// gamma correction.
-//
-// diffmap will contain an image of the size xsize * ysize, containing
-// localized differences for values px (indexed with the px the same as rgb0
-// and rgb1). diffvalue will give a global score of similarity.
-//
-// A diffvalue smaller than kButteraugliGood indicates that images can be
-// observed as the same image.
-// diffvalue larger than kButteraugliBad indicates that a difference between
-// the images can be observed.
-// A diffvalue between kButteraugliGood and kButteraugliBad indicates that
-// a subtle difference can be observed between the images.
-//
-// Returns true on success.
-
-bool ButteraugliInterface(const std::vector<ImageF> &rgb0,
-                          const std::vector<ImageF> &rgb1,
-                          ImageF &diffmap,
-                          double &diffvalue);
-
-const double kButteraugliQuantLow = 0.26;
-const double kButteraugliQuantHigh = 1.454;
-
-// Converts the butteraugli score into fuzzy class values that are continuous
-// at the class boundary. The class boundary location is based on human
-// raters, but the slope is arbitrary. Particularly, it does not reflect
-// the expectation value of probabilities of the human raters. It is just
-// expected that a smoother class boundary will allow for higher-level
-// optimization algorithms to work faster.
-//
-// Returns 2.0 for a perfect match, and 1.0 for 'ok', 0.0 for bad. Because the
-// scoring is fuzzy, a butteraugli score of 0.96 would return a class of
-// around 1.9.
-double ButteraugliFuzzyClass(double score);
-
-// Input values should be in range 0 (bad) to 2 (good). Use
-// kButteraugliNormalization as normalization.
-double ButteraugliFuzzyInverse(double seek);
-
-// Returns a map which can be used for adaptive quantization. Values can
-// typically range from kButteraugliQuantLow to kButteraugliQuantHigh. Low
-// values require coarse quantization (e.g. near random noise), high values
-// require fine quantization (e.g. in smooth bright areas).
-bool ButteraugliAdaptiveQuantization(size_t xsize, size_t ysize,
-    const std::vector<std::vector<float> > &rgb, std::vector<float> &quant);
-
-// Implementation details, don't use anything below or your code will
-// break in the future.
-
-#ifdef _MSC_VER
-#define BUTTERAUGLI_RESTRICT __restrict
-#else
-#define BUTTERAUGLI_RESTRICT __restrict__
-#endif
-
-#ifdef _MSC_VER
-#define BUTTERAUGLI_CACHE_ALIGNED_RETURN /* not supported */
-#else
-#define BUTTERAUGLI_CACHE_ALIGNED_RETURN __attribute__((assume_aligned(64)))
-#endif
-
-// Alias for unchangeable, non-aliased pointers. T is a pointer type,
-// possibly to a const type. Example: ConstRestrict<uint8_t*> ptr = nullptr.
-// The conventional syntax uint8_t* const RESTRICT is more confusing - it is
-// not immediately obvious that the pointee is non-const.
-template <typename T>
-using ConstRestrict = T const BUTTERAUGLI_RESTRICT;
-
-// Functions that depend on the cache line size.
-class CacheAligned {
- public:
-  static constexpr size_t kPointerSize = sizeof(void *);
-  static constexpr size_t kCacheLineSize = 64;
-
-  // The aligned-return annotation is only allowed on function declarations.
-  static void *Allocate(const size_t bytes) BUTTERAUGLI_CACHE_ALIGNED_RETURN;
-  static void Free(void *aligned_pointer);
-};
-
-template <typename T>
-using CacheAlignedUniquePtrT = std::unique_ptr<T[], void (*)(void *)>;
-
-using CacheAlignedUniquePtr = CacheAlignedUniquePtrT<uint8_t>;
-
-template <typename T = uint8_t>
-static inline CacheAlignedUniquePtrT<T> Allocate(const size_t entries) {
-  return CacheAlignedUniquePtrT<T>(
-      static_cast<ConstRestrict<T *>>(
-          CacheAligned::Allocate(entries * sizeof(T))),
-      CacheAligned::Free);
-}
-
-// Returns the smallest integer not less than "amount" that is divisible by
-// "multiple", which must be a power of two.
-template <size_t multiple>
-static inline size_t Align(const size_t amount) {
-  static_assert(multiple != 0 && ((multiple & (multiple - 1)) == 0),
-                "Align<> argument must be a power of two");
-  return (amount + multiple - 1) & ~(multiple - 1);
-}
-
-// Single channel, contiguous (cache-aligned) rows separated by padding.
-// T must be POD.
-//
-// Rationale: vectorization benefits from aligned operands - unaligned loads and
-// especially stores are expensive when the address crosses cache line
-// boundaries. Introducing padding after each row ensures the start of a row is
-// aligned, and that row loops can process entire vectors (writes to the padding
-// are allowed and ignored).
-//
-// We prefer a planar representation, where channels are stored as separate
-// 2D arrays, because that simplifies vectorization (repeating the same
-// operation on multiple adjacent components) without the complexity of a
-// hybrid layout (8 R, 8 G, 8 B, ...). In particular, clients can easily iterate
-// over all components in a row and Image requires no knowledge of the pixel
-// format beyond the component type "T". The downside is that we duplicate the
-// xsize/ysize members for each channel.
-//
-// This image layout could also be achieved with a vector and a row accessor
-// function, but a class wrapper with support for "deleter" allows wrapping
-// existing memory allocated by clients without copying the pixels. It also
-// provides convenient accessors for xsize/ysize, which shortens function
-// argument lists. Supports move-construction so it can be stored in containers.
-template <typename ComponentType>
-class Image {
-  // Returns cache-aligned row stride, being careful to avoid 2K aliasing.
-  static size_t BytesPerRow(const size_t xsize) {
-    // Allow reading one extra AVX-2 vector on the right margin.
-    const size_t row_size = xsize * sizeof(T) + 32;
-    const size_t align = CacheAligned::kCacheLineSize;
-    size_t bytes_per_row = (row_size + align - 1) & ~(align - 1);
-    // During the lengthy window before writes are committed to memory, CPUs
-    // guard against read after write hazards by checking the address, but
-    // only the lower 11 bits. We avoid a false dependency between writes to
-    // consecutive rows by ensuring their sizes are not multiples of 2 KiB.
-    if (bytes_per_row % 2048 == 0) {
-      bytes_per_row += align;
-    }
-    return bytes_per_row;
-  }
-
- public:
-  using T = ComponentType;
-
-  Image() : xsize_(0), ysize_(0), bytes_per_row_(0), bytes_(nullptr, Ignore) {}
-
-  Image(const size_t xsize, const size_t ysize)
-      : xsize_(xsize),
-        ysize_(ysize),
-        bytes_per_row_(BytesPerRow(xsize)),
-        bytes_(Allocate(bytes_per_row_ * ysize)) {}
-
-  Image(const size_t xsize, const size_t ysize, ConstRestrict<uint8_t *> bytes,
-        const size_t bytes_per_row)
-      : xsize_(xsize),
-        ysize_(ysize),
-        bytes_per_row_(bytes_per_row),
-        bytes_(bytes, Ignore) {}
-
-  // Move constructor (required for returning Image from function)
-  Image(Image &&other)
-      : xsize_(other.xsize_),
-        ysize_(other.ysize_),
-        bytes_per_row_(other.bytes_per_row_),
-        bytes_(std::move(other.bytes_)) {}
-
-  // Move assignment (required for std::vector)
-  Image &operator=(Image &&other) {
-    xsize_ = other.xsize_;
-    ysize_ = other.ysize_;
-    bytes_per_row_ = other.bytes_per_row_;
-    bytes_ = std::move(other.bytes_);
-    return *this;
-  }
-
-  void Swap(Image &other) {
-    std::swap(xsize_, other.xsize_);
-    std::swap(ysize_, other.ysize_);
-    std::swap(bytes_per_row_, other.bytes_per_row_);
-    std::swap(bytes_, other.bytes_);
-  }
-
-  // How many pixels.
-  size_t xsize() const { return xsize_; }
-  size_t ysize() const { return ysize_; }
-
-  ConstRestrict<T *> Row(const size_t y) BUTTERAUGLI_CACHE_ALIGNED_RETURN {
-#ifdef BUTTERAUGLI_ENABLE_CHECKS
-    if (y >= ysize_) {
-      printf("Row %zu out of bounds (ysize=%zu)\n", y, ysize_);
-      abort();
-    }
-#endif
-    return reinterpret_cast<T *>(bytes_.get() + y * bytes_per_row_);
-  }
-
-  ConstRestrict<const T *> Row(const size_t y) const
-      BUTTERAUGLI_CACHE_ALIGNED_RETURN {
-#ifdef BUTTERAUGLI_ENABLE_CHECKS
-    if (y >= ysize_) {
-      printf("Const row %zu out of bounds (ysize=%zu)\n", y, ysize_);
-      abort();
-    }
-#endif
-    return reinterpret_cast<const T *>(bytes_.get() + y * bytes_per_row_);
-  }
-
-  // Raw access to byte contents, for interfacing with other libraries.
-  // Unsigned char instead of char to avoid surprises (sign extension).
-  ConstRestrict<uint8_t *> bytes() { return bytes_.get(); }
-  ConstRestrict<const uint8_t *> bytes() const { return bytes_.get(); }
-  size_t bytes_per_row() const { return bytes_per_row_; }
-
-  // Returns number of pixels (some of which are padding) per row. Useful for
-  // computing other rows via pointer arithmetic.
-  intptr_t PixelsPerRow() const {
-    static_assert(CacheAligned::kCacheLineSize % sizeof(T) == 0,
-                  "Padding must be divisible by the pixel size.");
-    return static_cast<intptr_t>(bytes_per_row_ / sizeof(T));
-  }
-
- private:
-  // Deleter used when bytes are not owned.
-  static void Ignore(void *ptr) {}
-
-  // (Members are non-const to enable assignment during move-assignment.)
-  size_t xsize_;  // original intended pixels, not including any padding.
-  size_t ysize_;
-  size_t bytes_per_row_;  // [bytes] including padding.
-  CacheAlignedUniquePtr bytes_;
-};
-
-// Returns newly allocated planes of the given dimensions.
-template <typename T>
-static inline std::vector<Image<T>> CreatePlanes(const size_t xsize,
-                                                 const size_t ysize,
-                                                 const size_t num_planes) {
-  std::vector<Image<T>> planes;
-  planes.reserve(num_planes);
-  for (size_t i = 0; i < num_planes; ++i) {
-    planes.emplace_back(xsize, ysize);
-  }
-  return planes;
-}
-
-// Returns a new image with the same dimensions and pixel values.
-template <typename T>
-static inline Image<T> CopyPixels(const Image<T> &other) {
-  Image<T> copy(other.xsize(), other.ysize());
-  const void *BUTTERAUGLI_RESTRICT from = other.bytes();
-  void *BUTTERAUGLI_RESTRICT to = copy.bytes();
-  memcpy(to, from, other.ysize() * other.bytes_per_row());
-  return copy;
-}
-
-// Returns new planes with the same dimensions and pixel values.
-template <typename T>
-static inline std::vector<Image<T>> CopyPlanes(
-    const std::vector<Image<T>> &planes) {
-  std::vector<Image<T>> copy;
-  copy.reserve(planes.size());
-  for (const Image<T> &plane : planes) {
-    copy.push_back(CopyPixels(plane));
-  }
-  return copy;
-}
-
-// Compacts a padded image into a preallocated packed vector.
-template <typename T>
-static inline void CopyToPacked(const Image<T> &from, std::vector<T> *to) {
-  const size_t xsize = from.xsize();
-  const size_t ysize = from.ysize();
-#if BUTTERAUGLI_ENABLE_CHECKS
-  if (to->size() < xsize * ysize) {
-    printf("%zu x %zu exceeds %zu capacity\n", xsize, ysize, to->size());
-    abort();
-  }
-#endif
-  for (size_t y = 0; y < ysize; ++y) {
-    ConstRestrict<const float*> row_from = from.Row(y);
-    ConstRestrict<float*> row_to = to->data() + y * xsize;
-    memcpy(row_to, row_from, xsize * sizeof(T));
-  }
-}
-
-// Expands a packed vector into a preallocated padded image.
-template <typename T>
-static inline void CopyFromPacked(const std::vector<T> &from, Image<T> *to) {
-  const size_t xsize = to->xsize();
-  const size_t ysize = to->ysize();
-  assert(from.size() == xsize * ysize);
-  for (size_t y = 0; y < ysize; ++y) {
-    ConstRestrict<const float*> row_from = from.data() + y * xsize;
-    ConstRestrict<float*> row_to = to->Row(y);
-    memcpy(row_to, row_from, xsize * sizeof(T));
-  }
-}
-
-template <typename T>
-static inline std::vector<Image<T>> PlanesFromPacked(
-    const size_t xsize, const size_t ysize,
-    const std::vector<std::vector<T>> &packed) {
-  std::vector<Image<T>> planes;
-  planes.reserve(packed.size());
-  for (const std::vector<T> &p : packed) {
-    planes.push_back(Image<T>(xsize, ysize));
-    CopyFromPacked(p, &planes.back());
-  }
-  return planes;
-}
-
-template <typename T>
-static inline std::vector<std::vector<T>> PackedFromPlanes(
-    const std::vector<Image<T>> &planes) {
-  assert(!planes.empty());
-  const size_t num_pixels = planes[0].xsize() * planes[0].ysize();
-  std::vector<std::vector<T>> packed;
-  packed.reserve(planes.size());
-  for (const Image<T> &image : planes) {
-    packed.push_back(std::vector<T>(num_pixels));
-    CopyToPacked(image, &packed.back());
-  }
-  return packed;
-}
-
-class ButteraugliComparator {
- public:
-  ButteraugliComparator(size_t xsize, size_t ysize, int step);
-
-  // Computes the butteraugli map between rgb0 and rgb1 and updates result.
-  void Diffmap(const std::vector<ImageF> &rgb0,
-               const std::vector<ImageF> &rgb1,
-               ImageF &result);
-
-  // Same as above, but OpsinDynamicsImage() was already applied to
-  // rgb0 and rgb1.
-  void DiffmapOpsinDynamicsImage(const std::vector<ImageF> &rgb0,
-                                 const std::vector<ImageF> &rgb1,
-                                 ImageF &result);
-
- private:
-  void BlockDiffMap(const std::vector<std::vector<float> > &rgb0,
-                    const std::vector<std::vector<float> > &rgb1,
-                    std::vector<float>* block_diff_dc,
-                    std::vector<float>* block_diff_ac);
-
-
-  void EdgeDetectorMap(const std::vector<std::vector<float> > &rgb0,
-                       const std::vector<std::vector<float> > &rgb1,
-                       std::vector<float>* edge_detector_map);
-
-  void EdgeDetectorLowFreq(const std::vector<std::vector<float> > &rgb0,
-                           const std::vector<std::vector<float> > &rgb1,
-                           std::vector<float>* block_diff_ac);
-
-  void CombineChannels(const std::vector<std::vector<float> >& scale_xyb,
-                       const std::vector<std::vector<float> >& scale_xyb_dc,
-                       const std::vector<float>& block_diff_dc,
-                       const std::vector<float>& block_diff_ac,
-                       const std::vector<float>& edge_detector_map,
-                       std::vector<float>* result);
-
-  const size_t xsize_;
-  const size_t ysize_;
-  const size_t num_pixels_;
-  const int step_;
-  const size_t res_xsize_;
-  const size_t res_ysize_;
-};
-
-void ButteraugliDiffmap(const std::vector<ImageF> &rgb0,
-                        const std::vector<ImageF> &rgb1,
-                        ImageF &diffmap);
-
-double ButteraugliScoreFromDiffmap(const ImageF& distmap);
-
-// Compute values of local frequency and dc masking based on the activity
-// in the two images.
-void Mask(const std::vector<std::vector<float> > &rgb0,
-          const std::vector<std::vector<float> > &rgb1,
-          size_t xsize, size_t ysize,
-          std::vector<std::vector<float> > *mask,
-          std::vector<std::vector<float> > *mask_dc);
-
-// Computes difference metrics for one 8x8 block.
-void ButteraugliBlockDiff(double rgb0[192],
-                          double rgb1[192],
-                          double diff_xyb_dc[3],
-                          double diff_xyb_ac[3],
-                          double diff_xyb_edge_dc[3]);
-
-void OpsinAbsorbance(const double in[3], double out[3]);
-
-void OpsinDynamicsImage(size_t xsize, size_t ysize,
-                        std::vector<std::vector<float> > &rgb);
-
-void MaskHighIntensityChange(
-    size_t xsize, size_t ysize,
-    const std::vector<std::vector<float> > &c0,
-    const std::vector<std::vector<float> > &c1,
-    std::vector<std::vector<float> > &rgb0,
-    std::vector<std::vector<float> > &rgb1);
-
-void Blur(size_t xsize, size_t ysize, float* channel, double sigma,
-          double border_ratio = 0.0);
-
-void RgbToXyb(double r, double g, double b,
-              double *valx, double *valy, double *valz);
-
-double SimpleGamma(double v);
-
-double GammaMinArg();
-double GammaMaxArg();
-
-// Polynomial evaluation via Clenshaw's scheme (similar to Horner's).
-// Template enables compile-time unrolling of the recursion, but must reside
-// outside of a class due to the specialization.
-template <int INDEX>
-static inline void ClenshawRecursion(const double x, const double *coefficients,
-                                     double *b1, double *b2) {
-  const double x_b1 = x * (*b1);
-  const double t = (x_b1 + x_b1) - (*b2) + coefficients[INDEX];
-  *b2 = *b1;
-  *b1 = t;
-
-  ClenshawRecursion<INDEX - 1>(x, coefficients, b1, b2);
-}
-
-// Base case
-template <>
-inline void ClenshawRecursion<0>(const double x, const double *coefficients,
-                                 double *b1, double *b2) {
-  const double x_b1 = x * (*b1);
-  // The final iteration differs - no 2 * x_b1 here.
-  *b1 = x_b1 - (*b2) + coefficients[0];
-}
-
-// Rational polynomial := dividing two polynomial evaluations. These are easier
-// to find than minimax polynomials.
-struct RationalPolynomial {
-  template <int N>
-  static double EvaluatePolynomial(const double x,
-                                   const double (&coefficients)[N]) {
-    double b1 = 0.0;
-    double b2 = 0.0;
-    ClenshawRecursion<N - 1>(x, coefficients, &b1, &b2);
-    return b1;
-  }
-
-  // Evaluates the polynomial at x (in [min_value, max_value]).
-  inline double operator()(const float x) const {
-    // First normalize to [0, 1].
-    const double x01 = (x - min_value) / (max_value - min_value);
-    // And then to [-1, 1] domain of Chebyshev polynomials.
-    const double xc = 2.0 * x01 - 1.0;
-
-    const double yp = EvaluatePolynomial(xc, p);
-    const double yq = EvaluatePolynomial(xc, q);
-    if (yq == 0.0) return 0.0;
-    return static_cast<float>(yp / yq);
-  }
-
-  // Domain of the polynomials; they are undefined elsewhere.
-  double min_value;
-  double max_value;
-
-  // Coefficients of T_n (Chebyshev polynomials of the first kind).
-  // Degree 5/5 is a compromise between accuracy (0.1%) and numerical stability.
-  double p[5 + 1];
-  double q[5 + 1];
-};
-
-static inline float GammaPolynomial(float value) {
-  // Generated by gamma_polynomial.m from equispaced x/gamma(x) samples.
-  static const RationalPolynomial r = {
-  0.770000000000000, 274.579999999999984,
-  {
-    881.979476556478289, 1496.058452015812463, 908.662212739659481,
-    373.566100223287378, 85.840860336314364, 6.683258861509244,
-  },
-  {
-    12.262350348616792, 20.557285797683576, 12.161463238367844,
-    4.711532733641639, 0.899112889751053, 0.035662329617191,
-  }};
-  return r(value);
-}
-
-}  // namespace butteraugli
-
-#endif  // BUTTERAUGLI_BUTTERAUGLI_H_

extern/glew/LICENSE.txt

@@ -1,73 +0,0 @@
-The OpenGL Extension Wrangler Library
-Copyright (C) 2002-2007, Milan Ikits <milan ikits[]ieee org>
-Copyright (C) 2002-2007, Marcelo E. Magallon <mmagallo[]debian org>
-Copyright (C) 2002, Lev Povalahev
-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.
-* The name of the author may be used to endorse or promote products 
-  derived from this software without specific prior written permission.
-
-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 OWNER 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.
-
-
-Mesa 3-D graphics library
-Version:  7.0
-
-Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-Copyright (c) 2007 The Khronos Group Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and/or associated documentation files (the
-"Materials"), to deal in the Materials without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Materials, and to
-permit persons to whom the Materials are furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Materials.
-
-THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

extern/glew/README.txt

@@ -1,18 +0,0 @@
-See doc/index.html for more information.
-
-If you downloaded the tarball from the GLEW website, you just need to:
-
-    Unix:
-
-        make
-
-    Windows:
-
-        use the project file in build/vc6/
-
-If you wish to build GLEW from scratch (update the extension data from
-the net or add your own extension information), you need a Unix
-environment (including wget, perl, and GNU make).  The extension data
-is regenerated from the top level source directory with:
-
-        make extensions