1#[repr(C)]
4#[derive(Copy, Clone)]
5pub struct basisu_color_rgba {
6 pub __bindgen_anon_1: basisu_color_rgba__bindgen_ty_1,
7}
8#[repr(C)]
9#[derive(Copy, Clone)]
10pub union basisu_color_rgba__bindgen_ty_1 {
11 pub m_comps: [u8; 4usize],
12 pub __bindgen_anon_1: basisu_color_rgba__bindgen_ty_1__bindgen_ty_1,
13}
14#[repr(C)]
15#[derive(Debug, Copy, Clone)]
16pub struct basisu_color_rgba__bindgen_ty_1__bindgen_ty_1 {
17 pub r: u8,
18 pub g: u8,
19 pub b: u8,
20 pub a: u8,
21}
22#[test]
23fn bindgen_test_layout_basisu_color_rgba__bindgen_ty_1__bindgen_ty_1() {
24 const UNINIT: ::std::mem::MaybeUninit<basisu_color_rgba__bindgen_ty_1__bindgen_ty_1> =
25 ::std::mem::MaybeUninit::uninit();
26 let ptr = UNINIT.as_ptr();
27 assert_eq!(
28 ::std::mem::size_of::<basisu_color_rgba__bindgen_ty_1__bindgen_ty_1>(),
29 4usize,
30 concat!(
31 "Size of: ",
32 stringify!(basisu_color_rgba__bindgen_ty_1__bindgen_ty_1)
33 )
34 );
35 assert_eq!(
36 ::std::mem::align_of::<basisu_color_rgba__bindgen_ty_1__bindgen_ty_1>(),
37 1usize,
38 concat!(
39 "Alignment of ",
40 stringify!(basisu_color_rgba__bindgen_ty_1__bindgen_ty_1)
41 )
42 );
43 assert_eq!(
44 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
45 0usize,
46 concat!(
47 "Offset of field: ",
48 stringify!(basisu_color_rgba__bindgen_ty_1__bindgen_ty_1),
49 "::",
50 stringify!(r)
51 )
52 );
53 assert_eq!(
54 unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
55 1usize,
56 concat!(
57 "Offset of field: ",
58 stringify!(basisu_color_rgba__bindgen_ty_1__bindgen_ty_1),
59 "::",
60 stringify!(g)
61 )
62 );
63 assert_eq!(
64 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
65 2usize,
66 concat!(
67 "Offset of field: ",
68 stringify!(basisu_color_rgba__bindgen_ty_1__bindgen_ty_1),
69 "::",
70 stringify!(b)
71 )
72 );
73 assert_eq!(
74 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
75 3usize,
76 concat!(
77 "Offset of field: ",
78 stringify!(basisu_color_rgba__bindgen_ty_1__bindgen_ty_1),
79 "::",
80 stringify!(a)
81 )
82 );
83}
84#[test]
85fn bindgen_test_layout_basisu_color_rgba__bindgen_ty_1() {
86 const UNINIT: ::std::mem::MaybeUninit<basisu_color_rgba__bindgen_ty_1> =
87 ::std::mem::MaybeUninit::uninit();
88 let ptr = UNINIT.as_ptr();
89 assert_eq!(
90 ::std::mem::size_of::<basisu_color_rgba__bindgen_ty_1>(),
91 4usize,
92 concat!("Size of: ", stringify!(basisu_color_rgba__bindgen_ty_1))
93 );
94 assert_eq!(
95 ::std::mem::align_of::<basisu_color_rgba__bindgen_ty_1>(),
96 1usize,
97 concat!("Alignment of ", stringify!(basisu_color_rgba__bindgen_ty_1))
98 );
99 assert_eq!(
100 unsafe { ::std::ptr::addr_of!((*ptr).m_comps) as usize - ptr as usize },
101 0usize,
102 concat!(
103 "Offset of field: ",
104 stringify!(basisu_color_rgba__bindgen_ty_1),
105 "::",
106 stringify!(m_comps)
107 )
108 );
109}
110#[test]
111fn bindgen_test_layout_basisu_color_rgba() {
112 assert_eq!(
113 ::std::mem::size_of::<basisu_color_rgba>(),
114 4usize,
115 concat!("Size of: ", stringify!(basisu_color_rgba))
116 );
117 assert_eq!(
118 ::std::mem::align_of::<basisu_color_rgba>(),
119 1usize,
120 concat!("Alignment of ", stringify!(basisu_color_rgba))
121 );
122}
123#[repr(C)]
124#[repr(align(8))]
125#[derive(Debug, Copy, Clone)]
126pub struct basisu_image {
127 pub _bindgen_opaque_blob: [u64; 4usize],
128}
129#[test]
130fn bindgen_test_layout_basisu_image() {
131 assert_eq!(
132 ::std::mem::size_of::<basisu_image>(),
133 32usize,
134 concat!("Size of: ", stringify!(basisu_image))
135 );
136 assert_eq!(
137 ::std::mem::align_of::<basisu_image>(),
138 8usize,
139 concat!("Alignment of ", stringify!(basisu_image))
140 );
141}
142extern "C" {
143 #[link_name = "\u{1}?debug_text@image@basisu@@QEAAXIIIIAEBVcolor_rgba@2@PEBV32@_NPEBDZZ"]
144 pub fn basisu_image_debug_text(
145 this: *mut basisu_image,
146 x_ofs: u32,
147 y_ofs: u32,
148 x_scale: u32,
149 y_scale: u32,
150 fg: *const basisu_color_rgba,
151 pBG: *const basisu_color_rgba,
152 alpha_only: bool,
153 p: *const ::std::os::raw::c_char,
154 ...
155 );
156}
157pub const basisu_TOTAL_PACK_UASTC_LEVELS: u32 = 5;
158pub const basisu_BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION: u32 = 16384;
159pub const basisu_BASISU_DEFAULT_ENDPOINT_RDO_THRESH: f32 = 1.5;
160pub const basisu_BASISU_DEFAULT_SELECTOR_RDO_THRESH: f32 = 1.25;
161pub const basisu_BASISU_DEFAULT_QUALITY: ::std::os::raw::c_int = 128;
162pub const basisu_BASISU_DEFAULT_HYBRID_SEL_CB_QUALITY_THRESH: f32 = 2.0;
163pub const basisu_BASISU_MAX_IMAGE_DIMENSION: u32 = 16384;
164pub const basisu_BASISU_QUALITY_MIN: u32 = 1;
165pub const basisu_BASISU_QUALITY_MAX: u32 = 255;
166pub const basisu_BASISU_MAX_ENDPOINT_CLUSTERS: u32 = 16128;
167pub const basisu_BASISU_MAX_SELECTOR_CLUSTERS: u32 = 16128;
168pub const basisu_BASISU_MAX_SLICES: u32 = 16777215;
169pub const basisu_BASISU_RDO_UASTC_DICT_SIZE_DEFAULT: ::std::os::raw::c_int = 4096;
170pub const basisu_BASISU_RDO_UASTC_DICT_SIZE_MIN: ::std::os::raw::c_int = 64;
171pub const basisu_BASISU_RDO_UASTC_DICT_SIZE_MAX: ::std::os::raw::c_int = 65536;
172pub const basisu_basis_compressor_error_code_cECSuccess: basisu_basis_compressor_error_code = 0;
173pub const basisu_basis_compressor_error_code_cECFailedInitializing:
174 basisu_basis_compressor_error_code = 1;
175pub const basisu_basis_compressor_error_code_cECFailedReadingSourceImages:
176 basisu_basis_compressor_error_code = 2;
177pub const basisu_basis_compressor_error_code_cECFailedValidating:
178 basisu_basis_compressor_error_code = 3;
179pub const basisu_basis_compressor_error_code_cECFailedEncodeUASTC:
180 basisu_basis_compressor_error_code = 4;
181pub const basisu_basis_compressor_error_code_cECFailedFrontEnd: basisu_basis_compressor_error_code =
182 5;
183pub const basisu_basis_compressor_error_code_cECFailedFontendExtract:
184 basisu_basis_compressor_error_code = 6;
185pub const basisu_basis_compressor_error_code_cECFailedBackend: basisu_basis_compressor_error_code =
186 7;
187pub const basisu_basis_compressor_error_code_cECFailedCreateBasisFile:
188 basisu_basis_compressor_error_code = 8;
189pub const basisu_basis_compressor_error_code_cECFailedWritingOutput:
190 basisu_basis_compressor_error_code = 9;
191pub const basisu_basis_compressor_error_code_cECFailedUASTCRDOPostProcess:
192 basisu_basis_compressor_error_code = 10;
193pub const basisu_basis_compressor_error_code_cECFailedCreateKTX2File:
194 basisu_basis_compressor_error_code = 11;
195pub type basisu_basis_compressor_error_code = ::std::os::raw::c_int;
196#[repr(C)]
197#[derive(Copy, Clone)]
198pub union ColorU8 {
199 pub channels: ColorU8_Channels,
200 pub components: [u8; 4usize],
201 pub combined: u32,
202}
203#[repr(C)]
204#[derive(Debug, Copy, Clone)]
205pub struct ColorU8_Channels {
206 pub r: u8,
207 pub g: u8,
208 pub b: u8,
209 pub a: u8,
210}
211#[test]
212fn bindgen_test_layout_ColorU8_Channels() {
213 const UNINIT: ::std::mem::MaybeUninit<ColorU8_Channels> = ::std::mem::MaybeUninit::uninit();
214 let ptr = UNINIT.as_ptr();
215 assert_eq!(
216 ::std::mem::size_of::<ColorU8_Channels>(),
217 4usize,
218 concat!("Size of: ", stringify!(ColorU8_Channels))
219 );
220 assert_eq!(
221 ::std::mem::align_of::<ColorU8_Channels>(),
222 1usize,
223 concat!("Alignment of ", stringify!(ColorU8_Channels))
224 );
225 assert_eq!(
226 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
227 0usize,
228 concat!(
229 "Offset of field: ",
230 stringify!(ColorU8_Channels),
231 "::",
232 stringify!(r)
233 )
234 );
235 assert_eq!(
236 unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
237 1usize,
238 concat!(
239 "Offset of field: ",
240 stringify!(ColorU8_Channels),
241 "::",
242 stringify!(g)
243 )
244 );
245 assert_eq!(
246 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
247 2usize,
248 concat!(
249 "Offset of field: ",
250 stringify!(ColorU8_Channels),
251 "::",
252 stringify!(b)
253 )
254 );
255 assert_eq!(
256 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
257 3usize,
258 concat!(
259 "Offset of field: ",
260 stringify!(ColorU8_Channels),
261 "::",
262 stringify!(a)
263 )
264 );
265}
266#[test]
267fn bindgen_test_layout_ColorU8() {
268 const UNINIT: ::std::mem::MaybeUninit<ColorU8> = ::std::mem::MaybeUninit::uninit();
269 let ptr = UNINIT.as_ptr();
270 assert_eq!(
271 ::std::mem::size_of::<ColorU8>(),
272 4usize,
273 concat!("Size of: ", stringify!(ColorU8))
274 );
275 assert_eq!(
276 ::std::mem::align_of::<ColorU8>(),
277 4usize,
278 concat!("Alignment of ", stringify!(ColorU8))
279 );
280 assert_eq!(
281 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
282 0usize,
283 concat!(
284 "Offset of field: ",
285 stringify!(ColorU8),
286 "::",
287 stringify!(channels)
288 )
289 );
290 assert_eq!(
291 unsafe { ::std::ptr::addr_of!((*ptr).components) as usize - ptr as usize },
292 0usize,
293 concat!(
294 "Offset of field: ",
295 stringify!(ColorU8),
296 "::",
297 stringify!(components)
298 )
299 );
300 assert_eq!(
301 unsafe { ::std::ptr::addr_of!((*ptr).combined) as usize - ptr as usize },
302 0usize,
303 concat!(
304 "Offset of field: ",
305 stringify!(ColorU8),
306 "::",
307 stringify!(combined)
308 )
309 );
310}
311pub const UastcPackFlags_PackUASTCLevelFastest: UastcPackFlags = 0;
312pub const UastcPackFlags_PackUASTCLevelFaster: UastcPackFlags = 1;
313pub const UastcPackFlags_PackUASTCLevelDefault: UastcPackFlags = 2;
314pub const UastcPackFlags_PackUASTCLevelSlower: UastcPackFlags = 3;
315pub const UastcPackFlags_PackUASTCLevelVerySlow: UastcPackFlags = 4;
316pub const UastcPackFlags_PackUASTCLevelMask: UastcPackFlags = 15;
317pub const UastcPackFlags_PackUASTCFavorUASTCError: UastcPackFlags = 8;
318pub const UastcPackFlags_PackUASTCFavorBC7Error: UastcPackFlags = 16;
319pub const UastcPackFlags_PackUASTCETC1FasterHints: UastcPackFlags = 64;
320pub const UastcPackFlags_PackUASTCETC1FastestHints: UastcPackFlags = 128;
321pub const UastcPackFlags_PackUASTCETC1DisableFlipAndIndividual: UastcPackFlags = 256;
322pub type UastcPackFlags = ::std::os::raw::c_int;
323extern "C" {
324 pub fn image_clear(image: *mut basisu_image);
325}
326extern "C" {
327 pub fn image_resize_with_pitch(
328 image: *mut basisu_image,
329 w: u32,
330 h: u32,
331 p: u32,
332 );
333}
334extern "C" {
335 pub fn image_resize(
336 image: *mut basisu_image,
337 w: u32,
338 h: u32,
339 );
340}
341extern "C" {
342 pub fn image_init(
343 image: *mut basisu_image,
344 pData: *const u8,
345 width: u32,
346 height: u32,
347 comps: u32,
348 );
349}
350extern "C" {
351 pub fn image_get_pixel_at_checked(
352 image: *mut basisu_image,
353 x: u32,
354 y: u32,
355 pOutColor: *mut ColorU8,
356 ) -> bool;
357}
358extern "C" {
359 pub fn image_get_pixel_at_unchecked(
360 image: *mut basisu_image,
361 x: u32,
362 y: u32,
363 ) -> ColorU8;
364}
365extern "C" {
366 pub fn image_get_width(image: *mut basisu_image) -> u32;
367}
368extern "C" {
369 pub fn image_get_height(image: *mut basisu_image) -> u32;
370}
371extern "C" {
372 pub fn image_get_pitch(image: *mut basisu_image) -> u32;
373}
374extern "C" {
375 pub fn image_get_total_pixels(image: *mut basisu_image) -> u32;
376}
377extern "C" {
378 pub fn image_get_block_width(
379 image: *mut basisu_image,
380 w: u32,
381 ) -> u32;
382}
383extern "C" {
384 pub fn image_get_block_height(
385 image: *mut basisu_image,
386 h: u32,
387 ) -> u32;
388}
389extern "C" {
390 pub fn image_get_total_blocks(
391 image: *mut basisu_image,
392 w: u32,
393 h: u32,
394 ) -> u32;
395}
396#[repr(C)]
397#[derive(Debug, Copy, Clone)]
398pub struct PixelData {
399 pub pData: *mut ColorU8,
400 pub length: usize,
401}
402#[test]
403fn bindgen_test_layout_PixelData() {
404 const UNINIT: ::std::mem::MaybeUninit<PixelData> = ::std::mem::MaybeUninit::uninit();
405 let ptr = UNINIT.as_ptr();
406 assert_eq!(
407 ::std::mem::size_of::<PixelData>(),
408 16usize,
409 concat!("Size of: ", stringify!(PixelData))
410 );
411 assert_eq!(
412 ::std::mem::align_of::<PixelData>(),
413 8usize,
414 concat!("Alignment of ", stringify!(PixelData))
415 );
416 assert_eq!(
417 unsafe { ::std::ptr::addr_of!((*ptr).pData) as usize - ptr as usize },
418 0usize,
419 concat!(
420 "Offset of field: ",
421 stringify!(PixelData),
422 "::",
423 stringify!(pData)
424 )
425 );
426 assert_eq!(
427 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
428 8usize,
429 concat!(
430 "Offset of field: ",
431 stringify!(PixelData),
432 "::",
433 stringify!(length)
434 )
435 );
436}
437extern "C" {
438 pub fn image_get_pixel_data(image: *mut basisu_image) -> PixelData;
439}
440#[repr(C)]
441#[repr(align(8))]
442#[derive(Debug, Copy, Clone)]
443pub struct CompressorParams {
444 pub _bindgen_opaque_blob: u64,
445}
446#[test]
447fn bindgen_test_layout_CompressorParams() {
448 assert_eq!(
449 ::std::mem::size_of::<CompressorParams>(),
450 8usize,
451 concat!("Size of: ", stringify!(CompressorParams))
452 );
453 assert_eq!(
454 ::std::mem::align_of::<CompressorParams>(),
455 8usize,
456 concat!("Alignment of ", stringify!(CompressorParams))
457 );
458}
459extern "C" {
460 pub fn compressor_params_new() -> *mut CompressorParams;
461}
462extern "C" {
463 pub fn compressor_params_delete(params: *mut CompressorParams);
464}
465extern "C" {
466 pub fn compressor_params_clear(params: *mut CompressorParams);
467}
468extern "C" {
469 pub fn compressor_params_get_or_create_source_image(
470 params: *mut CompressorParams,
471 index: u32,
472 ) -> *mut basisu_image;
473}
474extern "C" {
475 pub fn compressor_params_resize_source_image_list(
476 params: *mut CompressorParams,
477 size: usize,
478 );
479}
480extern "C" {
481 pub fn compressor_params_clear_source_image_list(params: *mut CompressorParams);
482}
483extern "C" {
484 pub fn compressor_params_get_or_create_source_mipmap_image(
485 params: *mut CompressorParams,
486 index: u32,
487 level: u32,
488 ) -> *mut basisu_image;
489}
490extern "C" {
491 pub fn compressor_params_resize_source_mipmap_image_list(
492 params: *mut CompressorParams,
493 size: usize,
494 );
495}
496extern "C" {
497 pub fn compressor_params_resize_source_mipmap_image_level_list(
498 params: *mut CompressorParams,
499 level: usize,
500 size: usize,
501 );
502}
503extern "C" {
504 pub fn compressor_params_clear_source_mipmap_image_list(params: *mut CompressorParams);
505}
506extern "C" {
507 pub fn compressor_params_set_status_output(
508 params: *mut CompressorParams,
509 status_output: bool,
510 );
511}
512extern "C" {
513 pub fn compressor_params_set_quality_level(
514 params: *mut CompressorParams,
515 quality_level: ::std::os::raw::c_int,
516 );
517}
518extern "C" {
519 pub fn compressor_params_get_pack_uastc_flags(params: *mut CompressorParams) -> UastcPackFlags;
520}
521extern "C" {
522 pub fn compressor_params_set_pack_uastc_flags(
523 params: *mut CompressorParams,
524 pack_uastc_flags: UastcPackFlags,
525 );
526}
527extern "C" {
528 pub fn compressor_params_set_uastc(
529 params: *mut CompressorParams,
530 is_uastc: bool,
531 );
532}
533extern "C" {
534 pub fn compressor_params_set_perceptual(
535 params: *mut CompressorParams,
536 perceptual: bool,
537 );
538}
539extern "C" {
540 pub fn compressor_params_set_mip_srgb(
541 params: *mut CompressorParams,
542 mip_srgb: bool,
543 );
544}
545extern "C" {
546 pub fn compressor_params_set_no_selector_rdo(
547 params: *mut CompressorParams,
548 no_selector_rdo: bool,
549 );
550}
551extern "C" {
552 pub fn compressor_params_set_no_endpoint_rdo(
553 params: *mut CompressorParams,
554 no_endpoint_rdo: bool,
555 );
556}
557extern "C" {
558 pub fn compressor_params_set_rdo_uastc(
559 params: *mut CompressorParams,
560 rdo_uastc: bool,
561 );
562}
563extern "C" {
564 pub fn compressor_params_set_rdo_uastc_quality_scalar(
565 params: *mut CompressorParams,
566 rdo_uastc_quality_scalar: f32,
567 );
568}
569extern "C" {
570 pub fn compressor_params_set_generate_mipmaps(
571 params: *mut CompressorParams,
572 generate_mipmaps: bool,
573 );
574}
575extern "C" {
576 pub fn compressor_params_set_mip_smallest_dimension(
577 params: *mut CompressorParams,
578 mip_smallest_dimension: ::std::os::raw::c_int,
579 );
580}
581extern "C" {
582 pub fn compressor_params_set_userdata(
583 params: *mut CompressorParams,
584 userdata0: u32,
585 userdata1: u32,
586 );
587}
588#[repr(C)]
589#[repr(align(8))]
590#[derive(Debug, Copy, Clone)]
591pub struct Compressor {
592 pub _bindgen_opaque_blob: [u64; 2usize],
593}
594#[test]
595fn bindgen_test_layout_Compressor() {
596 assert_eq!(
597 ::std::mem::size_of::<Compressor>(),
598 16usize,
599 concat!("Size of: ", stringify!(Compressor))
600 );
601 assert_eq!(
602 ::std::mem::align_of::<Compressor>(),
603 8usize,
604 concat!("Alignment of ", stringify!(Compressor))
605 );
606}
607extern "C" {
608 pub fn compressor_new(num_threads: ::std::os::raw::c_int) -> *mut Compressor;
609}
610extern "C" {
611 pub fn compressor_delete(compressor: *mut Compressor);
612}
613extern "C" {
614 pub fn compressor_init(
615 compressor: *mut Compressor,
616 params: *const CompressorParams,
617 ) -> bool;
618}
619extern "C" {
620 pub fn compressor_process(compressor: *mut Compressor) -> basisu_basis_compressor_error_code;
621}
622#[repr(C)]
623#[derive(Debug, Copy, Clone)]
624pub struct CompressorBasisFile {
625 pub pData: *const u8,
626 pub length: usize,
627}
628#[test]
629fn bindgen_test_layout_CompressorBasisFile() {
630 const UNINIT: ::std::mem::MaybeUninit<CompressorBasisFile> = ::std::mem::MaybeUninit::uninit();
631 let ptr = UNINIT.as_ptr();
632 assert_eq!(
633 ::std::mem::size_of::<CompressorBasisFile>(),
634 16usize,
635 concat!("Size of: ", stringify!(CompressorBasisFile))
636 );
637 assert_eq!(
638 ::std::mem::align_of::<CompressorBasisFile>(),
639 8usize,
640 concat!("Alignment of ", stringify!(CompressorBasisFile))
641 );
642 assert_eq!(
643 unsafe { ::std::ptr::addr_of!((*ptr).pData) as usize - ptr as usize },
644 0usize,
645 concat!(
646 "Offset of field: ",
647 stringify!(CompressorBasisFile),
648 "::",
649 stringify!(pData)
650 )
651 );
652 assert_eq!(
653 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
654 8usize,
655 concat!(
656 "Offset of field: ",
657 stringify!(CompressorBasisFile),
658 "::",
659 stringify!(length)
660 )
661 );
662}
663extern "C" {
664 pub fn compressor_get_output_basis_file(compressor: *mut Compressor) -> CompressorBasisFile;
665}
666extern "C" {
667 pub fn compressor_get_basis_file_size(compressor: *const Compressor) -> u32;
668}
669extern "C" {
670 pub fn compressor_get_basis_bits_per_texel(compressor: *const Compressor) -> f64;
671}
672extern "C" {
673 pub fn compressor_get_any_source_image_has_alpha(compressor: *const Compressor) -> bool;
674}
675extern "C" {
676 pub fn basisu_encoder_init();
677}