Add support for the low-level UASTC transcoder

basis-universal-sys/generate_bindings.sh

@@ -7,12 +7,18 @@ bindgen vendor/transcoding_wrapper.cpp -o src/transcoding_bindings.rs \
  --whitelist-function basis_get_texture_type_name \
  \
  --whitelist-function basis_transcoder_format_is_uncompressed \
+ --whitelist-function basis_block_format_is_uncompressed \
  --whitelist-function basis_get_uncompressed_bytes_per_pixel \
  --whitelist-function basis_get_block_width \
  --whitelist-function basis_get_block_height \
  --whitelist-function basis_is_format_supported \
  --whitelist-function basis_validate_output_buffer_size \
  \
+ --whitelist-function low_level_uastc_transcoder_new \
+ --whitelist-function low_level_uastc_transcoder_delete \
+ \
+ --whitelist-function low_level_uastc_transcoder_transcode_slice \
+ \
  --whitelist-function transcoder_new \
  --whitelist-function transcoder_delete \
  \
@@ -37,6 +43,9 @@ bindgen vendor/transcoding_wrapper.cpp -o src/transcoding_bindings.rs \
  \
  --whitelist-function basisu_transcoder_init \
  \
+ --opaque-type LowLevelUastcTranscoder \
+ --opaque-type basist::block_format \
+ \
  --opaque-type Transcoder \
  --opaque-type basist::basisu_transcoder_state \
  \
@@ -115,4 +124,4 @@ bindgen vendor/encoding_wrapper.cpp -o src/encoding_bindings.rs \
  --opaque-type Compressor \
  --opaque-type basisu::image \
  \
- -- -x c++ -std=c++14
+ -- -x c++ -std=c++14

basis-universal-sys/src/transcoding_bindings.rs

@@ -881,6 +881,9 @@ extern "C" {
  tex_type: basist_transcoder_texture_format
  ) -> bool;
 }
+extern "C" {
+ pub fn basis_block_format_is_uncompressed(fmt: basist_block_format) -> bool;
+}
 extern "C" {
  pub fn basis_get_uncompressed_bytes_per_pixel(fmt: basist_transcoder_texture_format) -> u32;
 }
@@ -910,6 +913,53 @@ extern "C" {
 #[repr(C)]
 #[repr(align(8))]
 #[derive(Debug, Copy, Clone)]
+pub struct LowLevelUastcTranscoder {
+ pub _bindgen_opaque_blob: u64,
+}
+#[test]
+fn bindgen_test_layout_LowLevelUastcTranscoder() {
+ assert_eq!(
+ ::std::mem::size_of::<LowLevelUastcTranscoder>(),
+ 8usize,
+ concat!("Size of: ", stringify!(LowLevelUastcTranscoder))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<LowLevelUastcTranscoder>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(LowLevelUastcTranscoder))
+ );
+}
+extern "C" {
+ pub fn low_level_uastc_transcoder_new() -> *mut LowLevelUastcTranscoder;
+}
+extern "C" {
+ pub fn low_level_uastc_transcoder_delete(transcoder: *mut LowLevelUastcTranscoder);
+}
+extern "C" {
+ pub fn low_level_uastc_transcoder_transcode_slice(
+ transcoder: *mut LowLevelUastcTranscoder,
+ pDst_blocks: *mut ::std::os::raw::c_void,
+ num_blocks_x: u32,
+ num_blocks_y: u32,
+ pImage_data: *const u8,
+ image_data_size: u32,
+ fmt: basist_block_format,
+ output_block_or_pixel_stride_in_bytes: u32,
+ bc1_allow_threecolor_blocks: bool,
+ has_alpha: bool,
+ orig_width: u32,
+ orig_height: u32,
+ output_row_pitch_in_blocks_or_pixels: u32,
+ pState: *mut basist_basisu_transcoder_state,
+ output_rows_in_pixels: u32,
+ channel0: ::std::os::raw::c_int,
+ channel1: ::std::os::raw::c_int,
+ decode_flags: u32,
+ ) -> bool;
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
 pub struct Transcoder {
  pub _bindgen_opaque_blob: [u64; 2usize],
 }

basis-universal-sys/vendor/transcoding_wrapper.cpp

@@ -103,6 +103,11 @@ extern "C" {
  return basist::basis_transcoder_format_is_uncompressed(tex_type);
  }
 
+ // Returns true if the block format is an uncompressed (raw pixel) format.
+ bool basis_block_format_is_uncompressed(basist::block_format fmt) {
+ return basist::basis_block_format_is_uncompressed(fmt);
+ }
+
  // Returns the # of bytes per pixel for uncompressed formats, or 0 for block texture formats.
  uint32_t basis_get_uncompressed_bytes_per_pixel(basist::transcoder_texture_format fmt) {
  return basist::basis_get_uncompressed_bytes_per_pixel(fmt);
@@ -157,7 +162,61 @@ extern "C" {
  // basisu_lowlevel_uastc_transcoder
  //
 
- // Not implemented
+ struct LowLevelUastcTranscoder {
+ basist::basisu_lowlevel_uastc_transcoder *pTranscoder;
+ };
+
+ LowLevelUastcTranscoder *low_level_uastc_transcoder_new() {
+ LowLevelUastcTranscoder *transcoder = new LowLevelUastcTranscoder;
+ transcoder->pTranscoder = new basist::basisu_lowlevel_uastc_transcoder();
+ return transcoder;
+ }
+
+ void low_level_uastc_transcoder_delete(LowLevelUastcTranscoder *transcoder) {
+ delete transcoder->pTranscoder;
+ delete transcoder;
+ }
+
+ bool low_level_uastc_transcoder_transcode_slice(
+ LowLevelUastcTranscoder *transcoder,
+ void* pDst_blocks,
+ uint32_t num_blocks_x,
+ uint32_t num_blocks_y,
+ const uint8_t* pImage_data,
+ uint32_t image_data_size,
+ basist::block_format fmt,
+ uint32_t output_block_or_pixel_stride_in_bytes,
+ bool bc1_allow_threecolor_blocks,
+ bool has_alpha,
+ const uint32_t orig_width,
+ const uint32_t orig_height,
+ uint32_t output_row_pitch_in_blocks_or_pixels,
+ basist::basisu_transcoder_state* pState,
+ uint32_t output_rows_in_pixels,
+ int channel0,
+ int channel1,
+ uint32_t decode_flags
+ ) {
+ return transcoder->pTranscoder->transcode_slice(
+ pDst_blocks,
+ num_blocks_x,
+ num_blocks_y,
+ pImage_data,
+ image_data_size,
+ fmt,
+ output_block_or_pixel_stride_in_bytes,
+ bc1_allow_threecolor_blocks,
+ has_alpha,
+ orig_width,
+ orig_height,
+ output_row_pitch_in_blocks_or_pixels,
+ pState,
+ output_rows_in_pixels,
+ channel0,
+ channel1,
+ decode_flags
+ );
+ }
 
 
  //

basis-universal/src/transcoding/enums.rs

@@ -186,7 +186,7 @@ impl TranscoderTextureFormat {
  unsafe { sys::basis_transcoder_format_has_alpha(self.into()) }
  }
 
- /// Returns true if the transcoder texture type is an uncompressed (raw pixel) format.
+ /// Returns true if the transcoder texture type is a compressed format.
  pub fn is_compressed(self) -> bool {
  unsafe { !sys::basis_transcoder_format_is_uncompressed(self.into()) }
  }
@@ -324,3 +324,197 @@ bitflags::bitflags! {
  const HIGH_QULITY = sys::basist_basisu_decode_flags_cDecodeFlagsHighQuality;
  }
 }
+
+/// The block format to transcode universal texture data into
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(i32)]
+pub enum TranscoderBlockFormat {
+ /// ETC1S RGB
+ ETC1 = sys::basist_block_format_cETC1,
+ /// full ETC2 EAC RGBA8 block
+ ETC2_RGBA = sys::basist_block_format_cETC2_RGBA,
+ /// DXT1 RGB
+ BC1 = sys::basist_block_format_cBC1,
+ /// BC4 block followed by a four color BC1 block
+ BC3 = sys::basist_block_format_cBC3,
+ /// DXT5A (alpha block only)
+ BC4 = sys::basist_block_format_cBC4,
+ /// two BC4 blocks
+ BC5 = sys::basist_block_format_cBC5,
+ /// opaque-only PVRTC1 4bpp
+ PVRTC1_4_RGB = sys::basist_block_format_cPVRTC1_4_RGB,
+ /// PVRTC1 4bpp RGBA
+ PVRTC1_4_RGBA = sys::basist_block_format_cPVRTC1_4_RGBA,
+ /// Full BC7 block, any mode
+ BC7 = sys::basist_block_format_cBC7,
+ /// RGB BC7 mode 5 color (writes an opaque mode 5 block)
+ BC7_M5_COLOR = sys::basist_block_format_cBC7_M5_COLOR,
+ /// alpha portion of BC7 mode 5 (cBC7_M5_COLOR output data must have been written to the output buffer first to set the mode/rot fields etc.)
+ BC7_M5_ALPHA = sys::basist_block_format_cBC7_M5_ALPHA,
+ /// alpha block of ETC2 EAC (first 8 bytes of the 16-bit ETC2 EAC RGBA format)
+ ETC2_EAC_A8 = sys::basist_block_format_cETC2_EAC_A8,
+ /// ASTC 4x4 (either color-only or color+alpha). Note that the transcoder always currently assumes sRGB is not enabled when outputting ASTC
+ /// data. If you use a sRGB ASTC format you'll get ~1 LSB of additional error, because of the different way ASTC decoders scale 8-bit endpoints to 16-bits during unpacking.
+ ASTC_4x4 = sys::basist_block_format_cASTC_4x4,
+
+ ATC_RGB = sys::basist_block_format_cATC_RGB,
+ ATC_RGBA_INTERPOLATED_ALPHA = sys::basist_block_format_cATC_RGBA_INTERPOLATED_ALPHA,
+ /// Opaque-only, has oddball 8x4 pixel block size
+ FXT1_RGB = sys::basist_block_format_cFXT1_RGB,
+
+ PVRTC2_4_RGB = sys::basist_block_format_cPVRTC2_4_RGB,
+ PVRTC2_4_RGBA = sys::basist_block_format_cPVRTC2_4_RGBA,
+
+ ETC2_EAC_R11 = sys::basist_block_format_cETC2_EAC_R11,
+ ETC2_EAC_RG11 = sys::basist_block_format_cETC2_EAC_RG11,
+
+ /// Used internally: Write 16-bit endpoint and selector indices directly to output (output block must be at least 32-bits)
+ Indices = sys::basist_block_format_cIndices,
+
+ /// Writes RGB components to 32bpp output pixels
+ RGB32 = sys::basist_block_format_cRGB32,
+ /// Writes RGB255 components to 32bpp output pixels
+ RGBA32 = sys::basist_block_format_cRGBA32,
+ /// Writes alpha component to 32bpp output pixels
+ A32 = sys::basist_block_format_cA32,
+
+ RGB565 = sys::basist_block_format_cRGB565,
+ BGR565 = sys::basist_block_format_cBGR565,
+
+ RGBA4444_COLOR = sys::basist_block_format_cRGBA4444_COLOR,
+ RGBA4444_ALPHA = sys::basist_block_format_cRGBA4444_ALPHA,
+ RGBA4444_COLOR_OPAQUE = sys::basist_block_format_cRGBA4444_COLOR_OPAQUE,
+ RGBA4444 = sys::basist_block_format_cRGBA4444,
+}
+
+impl Into<sys::basist_block_format> for TranscoderBlockFormat {
+ fn into(self) -> sys::basist_block_format {
+ self as sys::basist_block_format
+ }
+}
+
+impl From<sys::basist_block_format> for TranscoderBlockFormat {
+ fn from(value: sys::basist_block_format) -> Self {
+ unsafe { std::mem::transmute(value as i32) }
+ }
+}
+
+impl TranscoderBlockFormat {
+ /// For compressed texture formats, this returns the # of bytes per block. For uncompressed, it returns the # of bytes per pixel.
+ pub fn bytes_per_block_or_pixel(self) -> u32 {
+ match self {
+ TranscoderBlockFormat::ETC1 => 8,
+ TranscoderBlockFormat::ETC2_RGBA => 16,
+ TranscoderBlockFormat::BC1 => 8,
+ TranscoderBlockFormat::BC3 => 16,
+ TranscoderBlockFormat::BC4 => 8,
+ TranscoderBlockFormat::BC5 => 16,
+ TranscoderBlockFormat::PVRTC1_4_RGB => 8,
+ TranscoderBlockFormat::PVRTC1_4_RGBA => 8,
+ TranscoderBlockFormat::BC7 => 16,
+ TranscoderBlockFormat::BC7_M5_COLOR => 16,
+ TranscoderBlockFormat::BC7_M5_ALPHA => 16,
+ TranscoderBlockFormat::ETC2_EAC_A8 => 8,
+ TranscoderBlockFormat::ASTC_4x4 => 16,
+ TranscoderBlockFormat::ATC_RGB => 8,
+ TranscoderBlockFormat::ATC_RGBA_INTERPOLATED_ALPHA => 16,
+ TranscoderBlockFormat::FXT1_RGB => 8,
+ TranscoderBlockFormat::PVRTC2_4_RGB => 8,
+ TranscoderBlockFormat::PVRTC2_4_RGBA => 8,
+ TranscoderBlockFormat::ETC2_EAC_R11 => 8,
+ TranscoderBlockFormat::ETC2_EAC_RG11 => 16,
+ TranscoderBlockFormat::Indices => 2,
+ TranscoderBlockFormat::RGB32 => 4,
+ TranscoderBlockFormat::RGBA32 => 4,
+ TranscoderBlockFormat::A32 => 4,
+ TranscoderBlockFormat::RGB565 => 2,
+ TranscoderBlockFormat::BGR565 => 2,
+ TranscoderBlockFormat::RGBA4444_COLOR => 2,
+ TranscoderBlockFormat::RGBA4444_ALPHA => 2,
+ TranscoderBlockFormat::RGBA4444_COLOR_OPAQUE => 2,
+ TranscoderBlockFormat::RGBA4444 => 2,
+ }
+ }
+
+ /// Returns format's name in ASCII
+ pub fn format_name(self) -> &'static str {
+ unsafe {
+ let value = sys::basis_get_block_format_name(self.into());
+ CStr::from_ptr(value).to_str().unwrap()
+ }
+ }
+
+ /// Returns true if the block format is a compressed format.
+ pub fn is_compressed(self) -> bool {
+ unsafe { !sys::basis_block_format_is_uncompressed(self.into()) }
+ }
+
+ /// Returns the block width for the specified texture format, which is currently either 4 or 8 for FXT1.
+ pub fn block_width(self) -> u32 {
+ match self {
+ TranscoderBlockFormat::FXT1_RGB => 8,
+ _ => 4,
+ }
+ }
+
+ /// Returns the block height for the specified texture format, which is currently always 4.
+ pub fn block_height(self) -> u32 {
+ 4
+ }
+
+ /// Calculate the minimum output buffer required to store transcoded data in blocks for
+ /// compressed formats and pixels for uncompressed formats
+ pub fn calculate_minimum_output_buffer_blocks_or_pixels(
+ self,
+ original_width: u32,
+ original_height: u32,
+ total_slice_blocks: u32,
+ output_row_pitch_in_blocks_or_pixels: Option<u32>,
+ output_rows_in_pixels: Option<u32>,
+ ) -> u32 {
+ // Default of 0 is fine for these values
+ let mut output_row_pitch_in_blocks_or_pixels =
+ output_row_pitch_in_blocks_or_pixels.unwrap_or(0);
+ let mut output_rows_in_pixels = output_rows_in_pixels.unwrap_or(0);
+
+ // Derived from implementation of basis_validate_output_buffer_size
+
+ if !self.is_compressed() {
+ // Assume the output buffer is orig_width by orig_height
+ if output_row_pitch_in_blocks_or_pixels == 0 {
+ output_row_pitch_in_blocks_or_pixels = original_width;
+ }
+
+ if output_rows_in_pixels == 0 {
+ output_rows_in_pixels = original_height;
+ }
+
+ output_rows_in_pixels * output_row_pitch_in_blocks_or_pixels
+ } else if self == TranscoderBlockFormat::FXT1_RGB {
+ let num_blocks_fxt1_x = (original_width + 7) / 8;
+ let num_blocks_fxt1_y = (original_height + 3) / 4;
+ num_blocks_fxt1_x * num_blocks_fxt1_y
+ } else {
+ total_slice_blocks
+ }
+ }
+
+ /// Calculate the minimum output buffer required to store transcoded data in bytes
+ pub fn calculate_minimum_output_buffer_bytes(
+ self,
+ original_width: u32,
+ original_height: u32,
+ total_slice_blocks: u32,
+ output_row_pitch_in_blocks_or_pixels: Option<u32>,
+ output_rows_in_pixels: Option<u32>,
+ ) -> u32 {
+ self.calculate_minimum_output_buffer_blocks_or_pixels(
+ original_width,
+ original_height,
+ total_slice_blocks,
+ output_row_pitch_in_blocks_or_pixels,
+ output_rows_in_pixels,
+ ) * self.bytes_per_block_or_pixel()
+ }
+}