Convert Figma logo to code with AI

ARM-software logoastc-encoder

The Arm ASTC Encoder, a compressor for the Adaptive Scalable Texture Compression data format.

1,037
234
1,037
16
View on GitHub

Top Related Projects

GPUOpen-Tools's avatar

compressonator

1,289

Tool suite for Texture and 3D Model Compression, Optimization and Analysis using CPUs, GPUs and APUs

BinomialLLC's avatar

basis_universal

2,661

Basis Universal GPU Texture Codec

microsoft's avatar

DirectXTex

1,790

DirectXTex texture processing library

Quick Overview

The ARM-software/astc-encoder is an open-source implementation of the Adaptive Scalable Texture Compression (ASTC) algorithm. It provides a command-line tool and library for compressing images into ASTC format, which is widely supported in modern GPUs and mobile devices. This encoder aims to provide high-quality texture compression with flexible bitrate control.

Pros

  • High-quality texture compression with support for various block sizes
  • Flexible bitrate control, allowing for a balance between image quality and file size
  • Wide platform support, including desktop and mobile GPUs
  • Active development and maintenance by ARM

Cons

  • Slower compression times compared to some other texture compression formats
  • Limited support for older hardware and software
  • Steeper learning curve for optimal usage due to numerous configuration options

Code Examples

  1. Basic image compression:
#include "astcenc.h"

// Initialize compressor context
astcenc_config config;
astcenc_context* context;
astcenc_config_init(ASTCENC_PRF_LDR, 6, 6, 1, ASTCENC_PRE_MEDIUM, 0, &config);
astcenc_context_alloc(&config, 1, &context);

// Compress image
astcenc_image input_image;
uint8_t* output_buffer;
size_t output_size;
astcenc_compress_image(context, &input_image, &config, &output_buffer, &output_size);
  1. Decompression:
#include "astcenc.h"

// Initialize decompressor context
astcenc_config config;
astcenc_context* context;
astcenc_config_init(ASTCENC_PRF_LDR, 6, 6, 1, ASTCENC_PRE_MEDIUM, 0, &config);
astcenc_context_alloc(&config, 1, &context);

// Decompress image
astcenc_image output_image;
astcenc_decompress_image(context, compressed_data, data_len, &output_image, &config);
  1. Setting custom compression options:
#include "astcenc.h"

astcenc_config config;
astcenc_config_init(ASTCENC_PRF_LDR, 8, 8, 1, ASTCENC_PRE_THOROUGH, 0, &config);

// Customize compression settings
config.tune_partition_limit = 32;
config.tune_block_mode_limit = 96;
config.tune_refinement_limit = 2;

astcenc_context* context;
astcenc_context_alloc(&config, 1, &context);

Getting Started

  1. Clone the repository:

    git clone https://github.com/ARM-software/astc-encoder.git

  2. Build the project:

    cd astc-encoder
mkdir build && cd build
cmake ..
make

  3. Use the command-line tool:

    ./astcenc -c input.png output.astc 6x6 -medium

  4. To use as a library, include the necessary headers and link against the built library in your project.

Competitor Comparisons

GPUOpen-Tools logo

compressonator

1,289

Tool suite for Texture and 3D Model Compression, Optimization and Analysis using CPUs, GPUs and APUs

Pros of Compressonator

  • Supports a wider range of texture compression formats, including BC, ETC, ASTC, and more
  • Offers a GUI tool for easier texture compression and analysis
  • Provides additional features like image processing and mipmap generation

Cons of Compressonator

  • May have slower compression speeds for ASTC format compared to astc-encoder
  • Larger codebase and dependencies, potentially more complex to integrate
  • Less specialized for ASTC, which could result in lower quality ASTC compression in some cases

Code Comparison

astc-encoder:

int main(int argc, char **argv)
{
    prepare_command_line(argc, argv, &cli_config);
    astcenc_config config;
    astcenc_context* context;
    // ... (compression logic)
}

Compressonator:

int main(int argc, char* argv[])
{
    CMP_CompressOptions options;
    CMP_InitCompressOptions(&options);
    // ... (compression setup)
    CMP_CompressTexture(&options, srcTexture, destTexture);
}

Both repositories focus on texture compression, but Compressonator offers a more comprehensive toolkit with support for multiple formats and additional features. astc-encoder, on the other hand, specializes in ASTC compression, potentially offering better performance and quality for that specific format.

BinomialLLC logo

basis_universal

2,661

Basis Universal GPU Texture Codec

Pros of basis_universal

  • Supports a wider range of texture formats, including ETC1S and UASTC
  • Offers better compression ratios for some use cases
  • Provides transcoding capabilities for various target platforms

Cons of basis_universal

  • Generally slower encoding times compared to astc-encoder
  • May have higher memory usage during compression
  • Less specialized for ASTC format specifically

Code Comparison

basis_universal:

basisu::basis_compressor_params params;
params.m_quality_level = 128;
params.m_compression_level = 1;
basisu::basis_compressor compressor;
compressor.init(params);

astc-encoder:

astcenc_config config;
astcenc_context* context;
astcenc_config_init(ASTCENC_PRF_LDR, 4, 4, 1, ASTCENC_PRE_FAST, 0, &config);
astcenc_context_alloc(&config, 1, &context);

Both libraries offer configuration options for compression quality and performance, but basis_universal provides more flexibility in terms of output formats and transcoding capabilities. astc-encoder is more focused on ASTC compression and may offer better performance for that specific format.

microsoft logo

DirectXTex

1,790

DirectXTex texture processing library

Pros of DirectXTex

  • Broader texture format support, including DirectX-specific formats
  • More comprehensive texture processing tools (resizing, filtering, etc.)
  • Better integration with DirectX ecosystem and Windows platforms

Cons of DirectXTex

  • Limited to Windows/DirectX environments, less cross-platform
  • Lacks specialized ASTC encoding capabilities
  • May have higher resource requirements for some operations

Code Comparison

DirectXTex (loading and saving a DDS texture):

DirectX::ScratchImage image;
DirectX::LoadFromDDSFile(L"input.dds", DirectX::DDS_FLAGS_NONE, nullptr, image);
DirectX::SaveToDDSFile(image.GetImages(), image.GetImageCount(), image.GetMetadata(), DirectX::DDS_FLAGS_NONE, L"output.dds");

ASTC-encoder (encoding a texture to ASTC format):

astcenc_config config;
astcenc_context* context;
astcenc_config_init(ASTCENC_PRF_LDR, 6, 6, 1, ASTCENC_PRE_FAST, 0, &config);
astcenc_context_alloc(&config, 1, &context);
astcenc_compress_image(context, image_data, image_size, &config, &output_data, &output_size, 0);

Both libraries offer efficient texture processing, but DirectXTex is more versatile for DirectX applications, while ASTC-encoder specializes in ASTC compression for broader platform support.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

About

The Arm® Adaptive Scalable Texture Compression (ASTC) Encoder, astcenc, is a command-line tool for compressing and decompressing images using the ASTC texture compression standard.

The ASTC format

The ASTC compressed data format, developed by Arm® and AMD, has been adopted as an official extension to the OpenGL®, OpenGL ES, and Vulkan® graphics APIs. It provides a major step forward in terms of both the image quality at a given bitrate, and the format and bitrate flexibility available to content creators. This allows more assets to use compression, often at a reduced bitrate compared to other formats, reducing memory storage and bandwidth requirements.

Read the ASTC Format Overview for a quick introduction to the format, or read the full Khronos Data Format Specification for all the details.

License

This project is licensed under the Apache 2.0 license. By downloading any component from this repository you acknowledge that you accept terms specified in the LICENSE.txt file.

Encoder feature support

The encoder supports compression of low dynamic range (BMP, JPEG, PNG, TGA) and high dynamic range (EXR, HDR) images, as well as a subset of image data wrapped in the DDS and KTX container formats, into ASTC or KTX format output images.

The decoder supports decompression of ASTC or KTX format input images into low dynamic range (BMP, PNG, TGA), high dynamic range (EXR, HDR), or DDS and KTX wrapped output images.

The encoder allows control over the compression time/quality tradeoff with exhaustive, verythorough, thorough, medium, fast, and fastest encoding quality presets.

The encoder allows compression time and quality analysis by reporting the compression time, and the Peak Signal-to-Noise Ratio (PSNR) between the input image and the compressed output.

ASTC format support

The astcenc compressor supports generation of images for all three profiles allowed by the ASTC specification:

  • 2D Low Dynamic Range (LDR profile)
  • 2D LDR and High Dynamic Range (HDR profile)
  • 2D and 3D, LDR and HDR (Full profile)

It also supports all of the ASTC block sizes and compression modes, allowing content creators to use the full spectrum of quality-to-bitrate options ranging from 0.89 bits/pixel up to 8 bits/pixel.

Prebuilt binaries

Release build binaries for the astcenc stable releases are provided in the GitHub Releases page.

Binaries are provided for 64-bit builds on Windows, macOS, and Linux.

Windows and Linux

For Windows and Linux the builds of the astcenc are provided as multiple binaries, each tuned for a specific SIMD instruction set.

For x86-64 we provide, in order of increasing performance:

  • astcenc-sse2 - uses SSE2
  • astcenc-sse4.1 - uses SSE4.1 and POPCNT
  • astcenc-avx2 - uses AVX2, SSE4.2, POPCNT, and F16C

The x86-64 SSE2 builds will work on all x86-64 machines, but it is the slowest of the three. The other two require extended CPU instruction set support which is not universally available, but each step gains ~15% more performance.

For Arm, if binaries are available, we provide:

  • astcenc-neon - uses NEON

macOS

For macOS devices we provide a single universal binary astcenc, which allows the OS to automatically use the correct binary variant for the current host machine. Support is provided for three architecture slices:

  • x86_64 - uses the astcenc-sse4.1 build defined above.
  • x86_64h - uses the astcenc-avx2 build defined above.
  • arm64 - uses the astcenc-neon build defined above.

Repository branches

The main branch is an active development branch for the compressor. It aims to be a stable branch for the latest major release series, but as it is used for ongoing development expect it to have some volatility. We recommend using the latest stable release tag for production development.

The 3.x branch is a stable branch for the 3.x release series. It is no longer under active development, but is a supported branch that continues to get backported bug fixes.

The 1.x and 2.x branches are stable branches for older releases. They are no longer under active development or getting bug fixes.

Any other branches you might find are development branches for new features or optimizations, so might be interesting to play with but should be considered transient and unstable.

Getting started

Open a terminal, change to the appropriate directory for your system, and run the astcenc encoder program, like this on Linux or macOS:

./astcenc

... or like this on Windows:

astcenc

Invoking astcenc -help gives an extensive help message, including usage instructions and details of all available command line options. A summary of the main encoder options are shown below.

Compressing an image

Compress an image using the -cl \ -cs \ -ch \ -cH modes. For example:

astcenc -cl example.png example.astc 6x6 -medium

This compresses example.png using the LDR color profile and a 6x6 block footprint (3.56 bits/pixel). The -medium quality preset gives a reasonable image quality for a relatively fast compression speed, so is a good starting point for compression. The output is stored to a linear color space compressed image, example.astc.

The modes available are:

  • -cl : use the linear LDR color profile.
  • -cs : use the sRGB LDR color profile.
  • -ch : use the HDR color profile, tuned for HDR RGB and LDR A.
  • -cH : use the HDR color profile, tuned for HDR RGBA.

If you intend to use the resulting image with the decode mode extensions to limit the decompressed precision to UNORM8, it is recommended that you also specify the -decode_unorm8 flag. This will ensure that the compressor uses the correct rounding rules when choosing encodings.

Decompressing an image

Decompress an image using the -dl \ -ds \ -dh \ -dH modes. For example:

astcenc -dh example.astc example.tga

This decompresses example.astc using the full HDR feature profile, storing the decompressed output to example.tga.

The modes available mirror the options used for compression, but use a d prefix. Note that for decompression there is no difference between the two HDR modes, they are both provided simply to maintain symmetry across operations.

Measuring image quality

Review the compression quality using the -tl \ -ts \ -th \ -tH modes. For example:

astcenc -tl example.png example.tga 5x5 -thorough

This is equivalent to using using the LDR color profile and a 5x5 block size to compress the image, using the -thorough quality preset, and then immediately decompressing the image and saving the result. This can be used to enable a visual inspection of the compressed image quality. In addition this mode also prints out some image quality metrics to the console.

The modes available mirror the options used for compression, but use a t prefix.

Experimenting

Efficient real-time graphics benefits from minimizing compressed texture size, as it reduces memory footprint, reduces memory bandwidth, saves energy, and can improve texture cache efficiency. However, like any lossy compression format there will come a point where the compressed image quality is unacceptable because there are simply not enough bits to represent the output with the precision needed. We recommend experimenting with the block footprint to find the optimum balance between size and quality, as the finely adjustable compression ratio is one of major strengths of the ASTC format.

The compression speed can be controlled from -fastest, through -fast, -medium and -thorough, up to -exhaustive. In general, the more time the encoder has to spend looking for good encodings the better the results, but it does result in increasingly small improvements for the amount of time required.

There are many other command line options for tuning the encoder parameters which can be used to fine tune the compression algorithm. See the command line help message for more details.

Documentation

The ASTC Format Overview page provides a high level introduction to the ASTC texture format, how it encodes data, and why it is both flexible and efficient.

The Effective ASTC Encoding page looks at some of the guidelines that should be followed when compressing data using astcenc. It covers:

  • How to efficiently encode data with fewer than 4 channels.
  • How to efficiently encode normal maps, sRGB data, and HDR data.
  • Coding equivalents to other compression formats.

The ASTC Developer Guide document (external link) provides a more detailed guide for developers using the astcenc compressor.

The .astc File Format page provides a light-weight specification for the .astc file format and how to read or write it.

The Building ASTC Encoder page provides instructions on how to build astcenc from the sources in this repository.

The Testing ASTC Encoder page provides instructions on how to test any modifications to the source code in this repository.

Support

If you have issues with the astcenc encoder, or questions about the ASTC texture format itself, please raise them in the GitHub issue tracker.

If you have any questions about Arm GPUs, application development for Arm GPUs, or general mobile graphics development or technology please submit them on the Arm Community graphics forums.

Copyright © 2013-2024, Arm Limited and contributors. All rights reserved.