From bec996d6ae0ccd5ae8ae434cc0dae72124ede3cd Mon Sep 17 00:00:00 2001 From: Michael Campagnaro Date: Thu, 8 Jun 2023 17:43:14 -0400 Subject: [PATCH] Add generator --- .gitignore | 2 + LICENSE | 45 + README.md | 17 + generate.jai | 133 ++ module.jai | 13 + windows.jai | 3103 +++++++++++++++++++++++++++++++++++++++++++ windows/dr_libs.lib | Bin 0 -> 754930 bytes 7 files changed, 3313 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 generate.jai create mode 100644 module.jai create mode 100644 windows.jai create mode 100644 windows/dr_libs.lib diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9b26ab6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.exe +*.pdb diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7071a95 --- /dev/null +++ b/LICENSE @@ -0,0 +1,45 @@ +This software is available as a choice of the following licenses. Choose +whichever you prefer. + +=============================================================================== +ALTERNATIVE 1 - Public Domain (www.unlicense.org) +=============================================================================== +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. + +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. + +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 THE +AUTHORS 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. + +For more information, please refer to + +=============================================================================== +ALTERNATIVE 2 - MIT No Attribution +=============================================================================== +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. + +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 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..bb0a0a4 --- /dev/null +++ b/README.md @@ -0,0 +1,17 @@ +# dr_libs.jai + +Jai bindings for [dr_libs](https://github.com/mackron/dr_libs) + +## Initial setup + +If you want to build the lib then you'll need the source code. You can do this with: `git submodule update --init --recursive`. +In the future if you need to pull in the source submodule again (e.g. the folder got deleted), then run: `git submodule update --recursive` + +## Usage + +Simply import the module. If you're using a static library version then you're set. If you generated a DLL (and new bindings to load it) then you need to copy the DLL from the windows/ folder to the working directory of your exe. + +## TODO + +* Add support for other platforms. + diff --git a/generate.jai b/generate.jai new file mode 100644 index 0000000..813f04f --- /dev/null +++ b/generate.jai @@ -0,0 +1,133 @@ +#!/usr/bin/env jai + +libs_to_include: Libs = Libs.DR_WAV | Libs.DR_FLAC | Libs.DR_MP3; // @consider making this a metaprogram/command line arg? + +Libs :: enum_flags { + DR_WAV; + DR_FLAC; + DR_MP3; +} + +AT_COMPILE_TIME :: true; + +COMPILE :: true; // Enable to compile the dr_libs library from source before generating bindings. +COMPILE_DEBUG :: false; // Compile a debug or release version of dr_libs + +MAKE_STATIC_LIB :: true; +MAKE_DYNAMIC_LIB :: false; + +#assert (MAKE_STATIC_LIB || MAKE_DYNAMIC_LIB) && !(MAKE_STATIC_LIB && MAKE_DYNAMIC_LIB); + +SOURCE_PATH :: "source"; + +#if AT_COMPILE_TIME { + #run { + set_build_options_dc(.{do_output=false}); + if !generate_bindings() { + compiler_set_workspace_status(.FAILED); + } + } +} +else { + #import "System"; + + main :: () { + set_working_directory(path_strip_filename(get_path_of_running_executable())); + if !generate_bindings() { + exit(1); + } + } +} + +generate_bindings :: () -> bool { + if libs_to_include == 0 { + log_error("You need to specify at least one library for binding generation!\n"); + return true; + } + + // Prepare the source for our needs. + { + copy_file(tprint("%/dr_wav.h", SOURCE_PATH), tprint("%/dr_wav.c", SOURCE_PATH)); + copy_file(tprint("%/dr_flac.h", SOURCE_PATH), tprint("%/dr_flac.c", SOURCE_PATH)); + copy_file(tprint("%/dr_mp3.h", SOURCE_PATH), tprint("%/dr_mp3.c", SOURCE_PATH)); + } + + src_files: [..] string; + extra: [..] string; + + libs_info := type_info(Libs); + for libs_info.values { + if libs_to_include & cast(Libs)it { + name := libs_info.names[it_index]; + array_add(*src_files, tprint("%/%.c", SOURCE_PATH, to_lower_copy(name))); + array_add(*extra, tprint("/D%_IMPLEMENTATION", name)); + } + } + + #if COMPILE { + #import "BuildCpp"; + + success := false; + + #if OS == .WINDOWS { + make_directory_if_it_does_not_exist("windows"); + + #if MAKE_DYNAMIC_LIB { + success = build_cpp_dynamic_lib("windows/dr_libs", ..src_files, extra = extra, debug=COMPILE_DEBUG); + } + else { + success = build_cpp_static_lib("windows/dr_libs", ..src_files, extra = extra, debug=COMPILE_DEBUG); + if success { + // Remove existing DLL otherwise the bindings will have a "#library" directive that loads the DLL. The lib version is "#library,no_dll" + if file_exists("windows/dr_libs.dll") { + deleted := file_delete("windows/dr_libs.dll"); + if !deleted { + log_error("Failed to remove existing dr_libs.dll from the windows/ folder.\n\n"); + success = false; + } + } + } + } + } + else { + log_error("This OS isn't supported yet.\n"); + } + + if !success return false; + } + + output_filename: string; + opts: Generate_Bindings_Options; + { + using opts; + + #if OS == .WINDOWS { + array_add(*libpaths, "windows"); + output_filename = "windows.jai"; + } + else { + log_error("This OS isn't supported yet.\n"); + return false; + } + + array_add(*libnames, "dr_libs"); + array_add(*system_include_paths, GENERATOR_DEFAULT_SYSTEM_INCLUDE_PATH); + array_add(*include_paths, SOURCE_PATH); + + source_files = src_files; + + log_stripped_declarations = false; // Set to true if things aren't working... + generate_compile_time_struct_checks = true; + } + return generate_bindings(opts, output_filename); +} + +#scope_file + +#import "Basic"; +#import "Bindings_Generator"; +#import "Compiler"; +#import "File"; +#import "File_Utilities"; +#import "String"; + diff --git a/module.jai b/module.jai new file mode 100644 index 0000000..2d061a6 --- /dev/null +++ b/module.jai @@ -0,0 +1,13 @@ +#scope_module + +size_t :: u64; + +#import "Basic"; + +#if OS == .WINDOWS { + #load "windows.jai"; +} +else { + assert(false); +} + diff --git a/windows.jai b/windows.jai new file mode 100644 index 0000000..4147d8c --- /dev/null +++ b/windows.jai @@ -0,0 +1,3103 @@ +// +// This file was auto-generated using the following command: +// +// jai generate.jai -quiet +// + + + +DRWAV_VERSION_MAJOR :: 0; +DRWAV_VERSION_MINOR :: 13; +DRWAV_VERSION_REVISION :: 10; + +DRWAV_TRUE :: 1; +DRWAV_FALSE :: 0; + +DRWAV_SUCCESS :: 0; +DRWAV_ERROR :: -1; +DRWAV_INVALID_ARGS :: -2; +DRWAV_INVALID_OPERATION :: -3; +DRWAV_OUT_OF_MEMORY :: -4; +DRWAV_OUT_OF_RANGE :: -5; +DRWAV_ACCESS_DENIED :: -6; +DRWAV_DOES_NOT_EXIST :: -7; +DRWAV_ALREADY_EXISTS :: -8; +DRWAV_TOO_MANY_OPEN_FILES :: -9; +DRWAV_INVALID_FILE :: -10; +DRWAV_TOO_BIG :: -11; +DRWAV_PATH_TOO_LONG :: -12; +DRWAV_NAME_TOO_LONG :: -13; +DRWAV_NOT_DIRECTORY :: -14; +DRWAV_IS_DIRECTORY :: -15; +DRWAV_DIRECTORY_NOT_EMPTY :: -16; +DRWAV_END_OF_FILE :: -17; +DRWAV_NO_SPACE :: -18; +DRWAV_BUSY :: -19; +DRWAV_IO_ERROR :: -20; +DRWAV_INTERRUPT :: -21; +DRWAV_UNAVAILABLE :: -22; +DRWAV_ALREADY_IN_USE :: -23; +DRWAV_BAD_ADDRESS :: -24; +DRWAV_BAD_SEEK :: -25; +DRWAV_BAD_PIPE :: -26; +DRWAV_DEADLOCK :: -27; +DRWAV_TOO_MANY_LINKS :: -28; +DRWAV_NOT_IMPLEMENTED :: -29; +DRWAV_NO_MESSAGE :: -30; +DRWAV_BAD_MESSAGE :: -31; +DRWAV_NO_DATA_AVAILABLE :: -32; +DRWAV_INVALID_DATA :: -33; +DRWAV_TIMEOUT :: -34; +DRWAV_NO_NETWORK :: -35; +DRWAV_NOT_UNIQUE :: -36; +DRWAV_NOT_SOCKET :: -37; +DRWAV_NO_ADDRESS :: -38; +DRWAV_BAD_PROTOCOL :: -39; +DRWAV_PROTOCOL_UNAVAILABLE :: -40; +DRWAV_PROTOCOL_NOT_SUPPORTED :: -41; +DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED :: -42; +DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED :: -43; +DRWAV_SOCKET_NOT_SUPPORTED :: -44; +DRWAV_CONNECTION_RESET :: -45; +DRWAV_ALREADY_CONNECTED :: -46; +DRWAV_NOT_CONNECTED :: -47; +DRWAV_CONNECTION_REFUSED :: -48; +DRWAV_NO_HOST :: -49; +DRWAV_IN_PROGRESS :: -50; +DRWAV_CANCELLED :: -51; +DRWAV_MEMORY_ALREADY_MAPPED :: -52; +DRWAV_AT_END :: -53; + +DR_WAVE_FORMAT_PCM :: 0x1; +DR_WAVE_FORMAT_ADPCM :: 0x2; +DR_WAVE_FORMAT_IEEE_FLOAT :: 0x3; +DR_WAVE_FORMAT_ALAW :: 0x6; +DR_WAVE_FORMAT_MULAW :: 0x7; +DR_WAVE_FORMAT_DVI_ADPCM :: 0x11; +DR_WAVE_FORMAT_EXTENSIBLE :: 0xFFFE; + +DRWAV_SEQUENTIAL :: 0x00000001; +DRWAV_WITH_METADATA :: 0x00000002; + +DRFLAC_VERSION_MAJOR :: 0; +DRFLAC_VERSION_MINOR :: 12; +DRFLAC_VERSION_REVISION :: 40; + +DRFLAC_TRUE :: 1; +DRFLAC_FALSE :: 0; + +DR_FLAC_BUFFER_SIZE :: 4096; + +DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO :: 0; +DRFLAC_METADATA_BLOCK_TYPE_PADDING :: 1; +DRFLAC_METADATA_BLOCK_TYPE_APPLICATION :: 2; +DRFLAC_METADATA_BLOCK_TYPE_SEEKTABLE :: 3; +DRFLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT :: 4; +DRFLAC_METADATA_BLOCK_TYPE_CUESHEET :: 5; +DRFLAC_METADATA_BLOCK_TYPE_PICTURE :: 6; +DRFLAC_METADATA_BLOCK_TYPE_INVALID :: 127; + +DRFLAC_PICTURE_TYPE_OTHER :: 0; +DRFLAC_PICTURE_TYPE_FILE_ICON :: 1; +DRFLAC_PICTURE_TYPE_OTHER_FILE_ICON :: 2; +DRFLAC_PICTURE_TYPE_COVER_FRONT :: 3; +DRFLAC_PICTURE_TYPE_COVER_BACK :: 4; +DRFLAC_PICTURE_TYPE_LEAFLET_PAGE :: 5; +DRFLAC_PICTURE_TYPE_MEDIA :: 6; +DRFLAC_PICTURE_TYPE_LEAD_ARTIST :: 7; +DRFLAC_PICTURE_TYPE_ARTIST :: 8; +DRFLAC_PICTURE_TYPE_CONDUCTOR :: 9; +DRFLAC_PICTURE_TYPE_BAND :: 10; +DRFLAC_PICTURE_TYPE_COMPOSER :: 11; +DRFLAC_PICTURE_TYPE_LYRICIST :: 12; +DRFLAC_PICTURE_TYPE_RECORDING_LOCATION :: 13; +DRFLAC_PICTURE_TYPE_DURING_RECORDING :: 14; +DRFLAC_PICTURE_TYPE_DURING_PERFORMANCE :: 15; +DRFLAC_PICTURE_TYPE_SCREEN_CAPTURE :: 16; +DRFLAC_PICTURE_TYPE_BRIGHT_COLORED_FISH :: 17; +DRFLAC_PICTURE_TYPE_ILLUSTRATION :: 18; +DRFLAC_PICTURE_TYPE_BAND_LOGOTYPE :: 19; +DRFLAC_PICTURE_TYPE_PUBLISHER_LOGOTYPE :: 20; + +DRMP3_VERSION_MAJOR :: 0; +DRMP3_VERSION_MINOR :: 6; +DRMP3_VERSION_REVISION :: 35; + +DRMP3_TRUE :: 1; +DRMP3_FALSE :: 0; + +DRMP3_SUCCESS :: 0; +DRMP3_ERROR :: -1; +DRMP3_INVALID_ARGS :: -2; +DRMP3_INVALID_OPERATION :: -3; +DRMP3_OUT_OF_MEMORY :: -4; +DRMP3_OUT_OF_RANGE :: -5; +DRMP3_ACCESS_DENIED :: -6; +DRMP3_DOES_NOT_EXIST :: -7; +DRMP3_ALREADY_EXISTS :: -8; +DRMP3_TOO_MANY_OPEN_FILES :: -9; +DRMP3_INVALID_FILE :: -10; +DRMP3_TOO_BIG :: -11; +DRMP3_PATH_TOO_LONG :: -12; +DRMP3_NAME_TOO_LONG :: -13; +DRMP3_NOT_DIRECTORY :: -14; +DRMP3_IS_DIRECTORY :: -15; +DRMP3_DIRECTORY_NOT_EMPTY :: -16; +DRMP3_END_OF_FILE :: -17; +DRMP3_NO_SPACE :: -18; +DRMP3_BUSY :: -19; +DRMP3_IO_ERROR :: -20; +DRMP3_INTERRUPT :: -21; +DRMP3_UNAVAILABLE :: -22; +DRMP3_ALREADY_IN_USE :: -23; +DRMP3_BAD_ADDRESS :: -24; +DRMP3_BAD_SEEK :: -25; +DRMP3_BAD_PIPE :: -26; +DRMP3_DEADLOCK :: -27; +DRMP3_TOO_MANY_LINKS :: -28; +DRMP3_NOT_IMPLEMENTED :: -29; +DRMP3_NO_MESSAGE :: -30; +DRMP3_BAD_MESSAGE :: -31; +DRMP3_NO_DATA_AVAILABLE :: -32; +DRMP3_INVALID_DATA :: -33; +DRMP3_TIMEOUT :: -34; +DRMP3_NO_NETWORK :: -35; +DRMP3_NOT_UNIQUE :: -36; +DRMP3_NOT_SOCKET :: -37; +DRMP3_NO_ADDRESS :: -38; +DRMP3_BAD_PROTOCOL :: -39; +DRMP3_PROTOCOL_UNAVAILABLE :: -40; +DRMP3_PROTOCOL_NOT_SUPPORTED :: -41; +DRMP3_PROTOCOL_FAMILY_NOT_SUPPORTED :: -42; +DRMP3_ADDRESS_FAMILY_NOT_SUPPORTED :: -43; +DRMP3_SOCKET_NOT_SUPPORTED :: -44; +DRMP3_CONNECTION_RESET :: -45; +DRMP3_ALREADY_CONNECTED :: -46; +DRMP3_NOT_CONNECTED :: -47; +DRMP3_CONNECTION_REFUSED :: -48; +DRMP3_NO_HOST :: -49; +DRMP3_IN_PROGRESS :: -50; +DRMP3_CANCELLED :: -51; +DRMP3_MEMORY_ALREADY_MAPPED :: -52; +DRMP3_AT_END :: -53; + +DRMP3_MAX_PCM_FRAMES_PER_MP3_FRAME :: 1152; +DRMP3_MAX_SAMPLES_PER_FRAME :: DRMP3_MAX_PCM_FRAMES_PER_MP3_FRAME*2; + +/* Sized Types */ +drwav_int8 :: s8; +drwav_uint8 :: u8; +drwav_int16 :: s16; +drwav_uint16 :: u16; +drwav_int32 :: s32; +drwav_uint32 :: u32; + +drwav_int64 :: s64; +drwav_uint64 :: u64; + +drwav_uintptr :: drwav_uint64; + +drwav_bool8 :: drwav_uint8; +drwav_bool32 :: drwav_uint32; + +/* Result Codes */ +drwav_result :: drwav_int32; + +drwav_version :: (pMajor: *drwav_uint32, pMinor: *drwav_uint32, pRevision: *drwav_uint32) -> void #foreign dr_libs; +drwav_version_string :: () -> *u8 #foreign dr_libs; + +/* Allocation Callbacks */ +drwav_allocation_callbacks :: struct { + pUserData: *void; + onMalloc: #type (sz: size_t, pUserData: *void) -> *void #c_call; + onRealloc: #type (p: *void, sz: size_t, pUserData: *void) -> *void #c_call; + onFree: #type (p: *void, pUserData: *void) -> void #c_call; +} + +/* End Allocation Callbacks */ +drwav_seek_origin :: enum s32 { + start :: 0; + current :: 1; + + drwav_seek_origin_start :: start; + drwav_seek_origin_current :: current; +} + +drwav_container :: enum s32 { + riff :: 0; + rifx :: 1; + w64 :: 2; + rf64 :: 3; + aiff :: 4; + + drwav_container_riff :: riff; + drwav_container_rifx :: rifx; + drwav_container_w64 :: w64; + drwav_container_rf64 :: rf64; + drwav_container_aiff :: aiff; +} + +drwav_chunk_header :: struct { + id: union { + fourcc: [4] drwav_uint8; + guid: [16] drwav_uint8; + }; + + /* The size in bytes of the chunk. */ + sizeInBytes: drwav_uint64; + + /* + RIFF = 2 byte alignment. + W64 = 8 byte alignment. + */ + paddingSize: u32; +} + +drwav_fmt :: struct { + /* + The format tag exactly as specified in the wave file's "fmt" chunk. This can be used by applications + that require support for data formats not natively supported by dr_wav. + */ + formatTag: drwav_uint16; + + /* The number of channels making up the audio data. When this is set to 1 it is mono, 2 is stereo, etc. */ + channels: drwav_uint16; + + /* The sample rate. Usually set to something like 44100. */ + sampleRate: drwav_uint32; + + /* Average bytes per second. You probably don't need this, but it's left here for informational purposes. */ + avgBytesPerSec: drwav_uint32; + + /* Block align. This is equal to the number of channels * bytes per sample. */ + blockAlign: drwav_uint16; + + /* Bits per sample. */ + bitsPerSample: drwav_uint16; + + /* The size of the extended data. Only used internally for validation, but left here for informational purposes. */ + extendedSize: drwav_uint16; + + /* + The number of valid bits per sample. When is equal to WAVE_FORMAT_EXTENSIBLE, + is always rounded up to the nearest multiple of 8. This variable contains information about exactly how + many bits are valid per sample. Mainly used for informational purposes. + */ + validBitsPerSample: drwav_uint16; + + /* The channel mask. Not used at the moment. */ + channelMask: drwav_uint32; + + /* The sub-format, exactly as specified by the wave file. */ + subFormat: [16] drwav_uint8; +} + +drwav_fmt_get_format :: (pFMT: *drwav_fmt) -> drwav_uint16 #foreign dr_libs; + +/* +Callback for when data is read. Return value is the number of bytes actually read. + +pUserData [in] The user data that was passed to drwav_init() and family. +pBufferOut [out] The output buffer. +bytesToRead [in] The number of bytes to read. + +Returns the number of bytes actually read. + +A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until +either the entire bytesToRead is filled or you have reached the end of the stream. +*/ +drwav_read_proc :: #type (pUserData: *void, pBufferOut: *void, bytesToRead: size_t) -> size_t #c_call; + +/* +Callback for when data is written. Returns value is the number of bytes actually written. + +pUserData [in] The user data that was passed to drwav_init_write() and family. +pData [out] A pointer to the data to write. +bytesToWrite [in] The number of bytes to write. + +Returns the number of bytes actually written. + +If the return value differs from bytesToWrite, it indicates an error. +*/ +drwav_write_proc :: #type (pUserData: *void, pData: *void, bytesToWrite: size_t) -> size_t #c_call; + +/* +Callback for when data needs to be seeked. + +pUserData [in] The user data that was passed to drwav_init() and family. +offset [in] The number of bytes to move, relative to the origin. Will never be negative. +origin [in] The origin of the seek - the current position or the start of the stream. + +Returns whether or not the seek was successful. + +Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which will be either drwav_seek_origin_start or +drwav_seek_origin_current. +*/ +drwav_seek_proc :: #type (pUserData: *void, offset: s32, origin: drwav_seek_origin) -> drwav_bool32 #c_call; + +/* +Callback for when drwav_init_ex() finds a chunk. + +pChunkUserData [in] The user data that was passed to the pChunkUserData parameter of drwav_init_ex() and family. +onRead [in] A pointer to the function to call when reading. +onSeek [in] A pointer to the function to call when seeking. +pReadSeekUserData [in] The user data that was passed to the pReadSeekUserData parameter of drwav_init_ex() and family. +pChunkHeader [in] A pointer to an object containing basic header information about the chunk. Use this to identify the chunk. +container [in] Whether or not the WAV file is a RIFF or Wave64 container. If you're unsure of the difference, assume RIFF. +pFMT [in] A pointer to the object containing the contents of the "fmt" chunk. + +Returns the number of bytes read + seeked. + +To read data from the chunk, call onRead(), passing in pReadSeekUserData as the first parameter. Do the same for seeking with onSeek(). The return value must +be the total number of bytes you have read _plus_ seeked. + +Use the `container` argument to discriminate the fields in `pChunkHeader->id`. If the container is `drwav_container_riff` or `drwav_container_rf64` you should +use `id.fourcc`, otherwise you should use `id.guid`. + +The `pFMT` parameter can be used to determine the data format of the wave file. Use `drwav_fmt_get_format()` to get the sample format, which will be one of the +`DR_WAVE_FORMAT_*` identifiers. + +The read pointer will be sitting on the first byte after the chunk's header. You must not attempt to read beyond the boundary of the chunk. +*/ +drwav_chunk_proc :: #type (pChunkUserData: *void, onRead: drwav_read_proc, onSeek: drwav_seek_proc, pReadSeekUserData: *void, pChunkHeader: *drwav_chunk_header, container: drwav_container, pFMT: *drwav_fmt) -> drwav_uint64 #c_call; + +/* Structure for internal use. Only used for loaders opened with drwav_init_memory(). */ +drwav__memory_stream :: struct { + data: *drwav_uint8; + dataSize: size_t; + currentReadPos: size_t; +} + +/* Structure for internal use. Only used for writers opened with drwav_init_memory_write(). */ +drwav__memory_stream_write :: struct { + ppData: **void; + pDataSize: *size_t; + dataSize: size_t; + dataCapacity: size_t; + currentWritePos: size_t; +} + +drwav_data_format :: struct { + container: drwav_container; /* RIFF, W64. */ + format: drwav_uint32; /* DR_WAVE_FORMAT_* */ + channels: drwav_uint32; + sampleRate: drwav_uint32; + bitsPerSample: drwav_uint32; +} + +drwav_metadata_type :: enum s32 { + none :: 0; + + unknown :: 1; + + smpl :: 2; + inst :: 4; + cue :: 8; + acid :: 16; + bext :: 32; + + list_label :: 64; + list_note :: 128; + list_labelled_cue_region :: 256; + + list_info_software :: 512; + list_info_copyright :: 1024; + list_info_title :: 2048; + list_info_artist :: 4096; + list_info_comment :: 8192; + list_info_date :: 16384; + list_info_genre :: 32768; + list_info_album :: 65536; + list_info_tracknumber :: 131072; + + list_all_info_strings :: 261632; + + list_all_adtl :: 448; + + all :: -2; + all_including_unknown :: -1; + + drwav_metadata_type_none :: none; + + drwav_metadata_type_unknown :: unknown; + + drwav_metadata_type_smpl :: smpl; + drwav_metadata_type_inst :: inst; + drwav_metadata_type_cue :: cue; + drwav_metadata_type_acid :: acid; + drwav_metadata_type_bext :: bext; + + drwav_metadata_type_list_label :: list_label; + drwav_metadata_type_list_note :: list_note; + drwav_metadata_type_list_labelled_cue_region :: list_labelled_cue_region; + + drwav_metadata_type_list_info_software :: list_info_software; + drwav_metadata_type_list_info_copyright :: list_info_copyright; + drwav_metadata_type_list_info_title :: list_info_title; + drwav_metadata_type_list_info_artist :: list_info_artist; + drwav_metadata_type_list_info_comment :: list_info_comment; + drwav_metadata_type_list_info_date :: list_info_date; + drwav_metadata_type_list_info_genre :: list_info_genre; + drwav_metadata_type_list_info_album :: list_info_album; + drwav_metadata_type_list_info_tracknumber :: list_info_tracknumber; + + drwav_metadata_type_list_all_info_strings :: list_all_info_strings; + + drwav_metadata_type_list_all_adtl :: list_all_adtl; + + drwav_metadata_type_all :: all; + drwav_metadata_type_all_including_unknown :: all_including_unknown; +} + +/* +Sampler Metadata + +The sampler chunk contains information about how a sound should be played in the context of a whole +audio production, and when used in a sampler. See https://en.wikipedia.org/wiki/Sample-based_synthesis. +*/ +drwav_smpl_loop_type :: enum s32 { + forward :: 0; + pingpong :: 1; + backward :: 2; + + drwav_smpl_loop_type_forward :: forward; + drwav_smpl_loop_type_pingpong :: pingpong; + drwav_smpl_loop_type_backward :: backward; +} + +drwav_smpl_loop :: struct { + /* The ID of the associated cue point, see drwav_cue and drwav_cue_point. As with all cue point IDs, this can correspond to a label chunk to give this loop a name, see drwav_list_label_or_note. */ + cuePointId: drwav_uint32; + + /* See drwav_smpl_loop_type. */ + type: drwav_uint32; + + /* The byte offset of the first sample to be played in the loop. */ + firstSampleByteOffset: drwav_uint32; + + /* The byte offset into the audio data of the last sample to be played in the loop. */ + lastSampleByteOffset: drwav_uint32; + + /* A value to represent that playback should occur at a point between samples. This value ranges from 0 to UINT32_MAX. Where a value of 0 means no fraction, and a value of (UINT32_MAX / 2) would mean half a sample. */ + sampleFraction: drwav_uint32; + + /* Number of times to play the loop. 0 means loop infinitely. */ + playCount: drwav_uint32; +} + +drwav_smpl :: struct { + /* IDs for a particular MIDI manufacturer. 0 if not used. */ + manufacturerId: drwav_uint32; + productId: drwav_uint32; + + /* The period of 1 sample in nanoseconds. */ + samplePeriodNanoseconds: drwav_uint32; + + /* The MIDI root note of this file. 0 to 127. */ + midiUnityNote: drwav_uint32; + + /* The fraction of a semitone up from the given MIDI note. This is a value from 0 to UINT32_MAX, where 0 means no change and (UINT32_MAX / 2) is half a semitone (AKA 50 cents). */ + midiPitchFraction: drwav_uint32; + + /* Data relating to SMPTE standards which are used for syncing audio and video. 0 if not used. */ + smpteFormat: drwav_uint32; + smpteOffset: drwav_uint32; + + /* drwav_smpl_loop loops. */ + sampleLoopCount: drwav_uint32; + + /* Optional sampler-specific data. */ + samplerSpecificDataSizeInBytes: drwav_uint32; + + pLoops: *drwav_smpl_loop; + pSamplerSpecificData: *drwav_uint8; +} + +/* +Instrument Metadata + +The inst metadata contains data about how a sound should be played as part of an instrument. This +commonly read by samplers. See https://en.wikipedia.org/wiki/Sample-based_synthesis. +*/ +drwav_inst :: struct { + midiUnityNote: drwav_int8; /* The root note of the audio as a MIDI note number. 0 to 127. */ + fineTuneCents: drwav_int8; /* -50 to +50 */ + gainDecibels: drwav_int8; /* -64 to +64 */ + lowNote: drwav_int8; /* 0 to 127 */ + highNote: drwav_int8; /* 0 to 127 */ + lowVelocity: drwav_int8; /* 1 to 127 */ + highVelocity: drwav_int8; /* 1 to 127 */ +} + +/* +Cue Metadata + +Cue points are markers at specific points in the audio. They often come with an associated piece of +drwav_list_label_or_note metadata which contains the text for the marker. +*/ +drwav_cue_point :: struct { + /* Unique identification value. */ + id: drwav_uint32; + + /* Set to 0. This is only relevant if there is a 'playlist' chunk - which is not supported by dr_wav. */ + playOrderPosition: drwav_uint32; + + /* Should always be "data". This represents the fourcc value of the chunk that this cue point corresponds to. dr_wav only supports a single data chunk so this should always be "data". */ + dataChunkId: [4] drwav_uint8; + + /* Set to 0. This is only relevant if there is a wave list chunk. dr_wav, like lots of readers/writers, do not support this. */ + chunkStart: drwav_uint32; + + /* Set to 0 for uncompressed formats. Else the last byte in compressed wave data where decompression can begin to find the value of the corresponding sample value. */ + blockStart: drwav_uint32; + + /* For uncompressed formats this is the byte offset of the cue point into the audio data. For compressed formats this is relative to the block specified with blockStart. */ + sampleByteOffset: drwav_uint32; +} + +drwav_cue :: struct { + cuePointCount: drwav_uint32; + pCuePoints: *drwav_cue_point; +} + +/* +Acid Metadata + +This chunk contains some information about the time signature and the tempo of the audio. +*/ +drwav_acid_flag :: enum s32 { + one_shot :: 1; + root_note_set :: 2; + stretch :: 4; + disk_based :: 8; + acidizer :: 16; + + drwav_acid_flag_one_shot :: one_shot; + drwav_acid_flag_root_note_set :: root_note_set; + drwav_acid_flag_stretch :: stretch; + drwav_acid_flag_disk_based :: disk_based; + drwav_acid_flag_acidizer :: acidizer; +} + +drwav_acid :: struct { + /* A bit-field, see drwav_acid_flag. */ + flags: drwav_uint32; + + /* Valid if flags contains drwav_acid_flag_root_note_set. It represents the MIDI root note the file - a value from 0 to 127. */ + midiUnityNote: drwav_uint16; + + /* Reserved values that should probably be ignored. reserved1 seems to often be 128 and reserved2 is 0. */ + reserved1: drwav_uint16; + reserved2: float; + + /* Number of beats. */ + numBeats: drwav_uint32; + + /* The time signature of the audio. */ + meterDenominator: drwav_uint16; + meterNumerator: drwav_uint16; + + /* Beats per minute of the track. Setting a value of 0 suggests that there is no tempo. */ + tempo: float; +} + +/* +Cue Label or Note metadata + +These are 2 different types of metadata, but they have the exact same format. Labels tend to be the +more common and represent a short name for a cue point. Notes might be used to represent a longer +comment. +*/ +drwav_list_label_or_note :: struct { + /* The ID of a cue point that this label or note corresponds to. */ + cuePointId: drwav_uint32; + + /* Size of the string not including any null terminator. */ + stringLength: drwav_uint32; + + /* The string. The *init_with_metadata functions null terminate this for convenience. */ + pString: *u8; +} + +/* +BEXT metadata, also known as Broadcast Wave Format (BWF) + +This metadata adds some extra description to an audio file. You must check the version field to +determine if the UMID or the loudness fields are valid. +*/ +drwav_bext :: struct { + pDescription: *u8; /* Can be NULL or a null-terminated string, must be <= 256 characters. */ + pOriginatorName: *u8; /* Can be NULL or a null-terminated string, must be <= 32 characters. */ + pOriginatorReference: *u8; /* Can be NULL or a null-terminated string, must be <= 32 characters. */ + pOriginationDate: [10] u8; /* ASCII "yyyy:mm:dd". */ + pOriginationTime: [8] u8; /* ASCII "hh:mm:ss". */ + timeReference: drwav_uint64; /* First sample count since midnight. */ + version: drwav_uint16; /* Version of the BWF, check this to see if the fields below are valid. */ + + /* + Unrestricted ASCII characters containing a collection of strings terminated by CR/LF. Each + string shall contain a description of a coding process applied to the audio data. + */ + pCodingHistory: *u8; + codingHistorySize: drwav_uint32; + + pUMID: *drwav_uint8; /* Exactly 64 bytes of SMPTE UMID */ + + loudnessValue: drwav_uint16; /* Integrated Loudness Value of the file in LUFS (multiplied by 100). */ + loudnessRange: drwav_uint16; /* Loudness Range of the file in LU (multiplied by 100). */ + maxTruePeakLevel: drwav_uint16; /* Maximum True Peak Level of the file expressed as dBTP (multiplied by 100). */ + maxMomentaryLoudness: drwav_uint16; /* Highest value of the Momentary Loudness Level of the file in LUFS (multiplied by 100). */ + maxShortTermLoudness: drwav_uint16; /* Highest value of the Short-Term Loudness Level of the file in LUFS (multiplied by 100). */ +} + +/* +Info Text Metadata + +There a many different types of information text that can be saved in this format. This is where +things like the album name, the artists, the year it was produced, etc are saved. See +drwav_metadata_type for the full list of types that dr_wav supports. +*/ +drwav_list_info_text :: struct { + /* Size of the string not including any null terminator. */ + stringLength: drwav_uint32; + + /* The string. The *init_with_metadata functions null terminate this for convenience. */ + pString: *u8; +} + +/* +Labelled Cue Region Metadata + +The labelled cue region metadata is used to associate some region of audio with text. The region +starts at a cue point, and extends for the given number of samples. +*/ +drwav_list_labelled_cue_region :: struct { + /* The ID of a cue point that this object corresponds to. */ + cuePointId: drwav_uint32; + + /* The number of samples from the cue point forwards that should be considered this region */ + sampleLength: drwav_uint32; + + /* Four characters used to say what the purpose of this region is. */ + purposeId: [4] drwav_uint8; + + /* Unsure of the exact meanings of these. It appears to be acceptable to set them all to 0. */ + country: drwav_uint16; + language: drwav_uint16; + dialect: drwav_uint16; + codePage: drwav_uint16; + + /* Size of the string not including any null terminator. */ + stringLength: drwav_uint32; + + /* The string. The *init_with_metadata functions null terminate this for convenience. */ + pString: *u8; +} + +/* +Unknown Metadata + +This chunk just represents a type of chunk that dr_wav does not understand. + +Unknown metadata has a location attached to it. This is because wav files can have a LIST chunk +that contains subchunks. These LIST chunks can be one of two types. An adtl list, or an INFO +list. This enum is used to specify the location of a chunk that dr_wav currently doesn't support. +*/ +drwav_metadata_location :: enum s32 { + invalid :: 0; + top_level :: 1; + inside_info_list :: 2; + inside_adtl_list :: 3; + + drwav_metadata_location_invalid :: invalid; + drwav_metadata_location_top_level :: top_level; + drwav_metadata_location_inside_info_list :: inside_info_list; + drwav_metadata_location_inside_adtl_list :: inside_adtl_list; +} + +drwav_unknown_metadata :: struct { + id: [4] drwav_uint8; + chunkLocation: drwav_metadata_location; + dataSizeInBytes: drwav_uint32; + pData: *drwav_uint8; +} + +/* +Metadata is saved as a union of all the supported types. +*/ +drwav_metadata :: struct { + /* Determines which item in the union is valid. */ + type: drwav_metadata_type; + + data: union { + cue: drwav_cue; + smpl: drwav_smpl; + acid: drwav_acid; + inst: drwav_inst; + bext: drwav_bext; + labelOrNote: drwav_list_label_or_note; /* List label or list note. */ + labelledCueRegion: drwav_list_labelled_cue_region; + infoText: drwav_list_info_text; /* Any of the list info types. */ + unknown: drwav_unknown_metadata; + }; +} + +drwav :: struct { + /* A pointer to the function to call when more data is needed. */ + onRead: drwav_read_proc; + + /* A pointer to the function to call when data needs to be written. Only used when the drwav object is opened in write mode. */ + onWrite: drwav_write_proc; + + /* A pointer to the function to call when the wav file needs to be seeked. */ + onSeek: drwav_seek_proc; + + /* The user data to pass to callbacks. */ + pUserData: *void; + + /* Allocation callbacks. */ + allocationCallbacks: drwav_allocation_callbacks; + + /* Whether or not the WAV file is formatted as a standard RIFF file or W64. */ + container: drwav_container; + + /* Structure containing format information exactly as specified by the wav file. */ + fmt: drwav_fmt; + + /* The sample rate. Will be set to something like 44100. */ + sampleRate: drwav_uint32; + + /* The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc. */ + channels: drwav_uint16; + + /* The bits per sample. Will be set to something like 16, 24, etc. */ + bitsPerSample: drwav_uint16; + + /* Equal to fmt.formatTag, or the value specified by fmt.subFormat if fmt.formatTag is equal to 65534 (WAVE_FORMAT_EXTENSIBLE). */ + translatedFormatTag: drwav_uint16; + + /* The total number of PCM frames making up the audio data. */ + totalPCMFrameCount: drwav_uint64; + + /* The size in bytes of the data chunk. */ + dataChunkDataSize: drwav_uint64; + + /* The position in the stream of the first data byte of the data chunk. This is used for seeking. */ + dataChunkDataPos: drwav_uint64; + + /* The number of bytes remaining in the data chunk. */ + bytesRemaining: drwav_uint64; + + /* The current read position in PCM frames. */ + readCursorInPCMFrames: drwav_uint64; + + /* + Only used in sequential write mode. Keeps track of the desired size of the "data" chunk at the point of initialization time. Always + set to 0 for non-sequential writes and when the drwav object is opened in read mode. Used for validation. + */ + dataChunkDataSizeTargetWrite: drwav_uint64; + + /* Keeps track of whether or not the wav writer was initialized in sequential mode. */ + isSequentialWrite: drwav_bool32; + + /* A array of metadata. This is valid after the *init_with_metadata call returns. It will be valid until drwav_uninit() is called. You can take ownership of this data with drwav_take_ownership_of_metadata(). */ + pMetadata: *drwav_metadata; + metadataCount: drwav_uint32; + + /* A hack to avoid a DRWAV_MALLOC() when opening a decoder with drwav_init_memory(). */ + memoryStream: drwav__memory_stream; + memoryStreamWrite: drwav__memory_stream_write; + + msadpcm: struct { + bytesRemainingInBlock: drwav_uint32; + predictor: [2] drwav_uint16; + delta: [2] drwav_int32; + cachedFrames: [4] drwav_int32; /* Samples are stored in this cache during decoding. */ + cachedFrameCount: drwav_uint32; + prevFrames: [2] [2] drwav_int32; /* The previous 2 samples for each channel (2 channels at most). */ + }; + + ima: struct { + bytesRemainingInBlock: drwav_uint32; + predictor: [2] drwav_int32; + stepIndex: [2] drwav_int32; + cachedFrames: [16] drwav_int32; /* Samples are stored in this cache during decoding. */ + cachedFrameCount: drwav_uint32; + }; + + aiff: struct { + isLE: drwav_bool8; /* Will be set to true if the audio data is little-endian encoded. */ + }; +} + +/* +Initializes a pre-allocated drwav object for reading. + +pWav [out] A pointer to the drwav object being initialized. +onRead [in] The function to call when data needs to be read from the client. +onSeek [in] The function to call when the read position of the client data needs to move. +onChunk [in, optional] The function to call when a chunk is enumerated at initialized time. +pUserData, pReadSeekUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek. +pChunkUserData [in, optional] A pointer to application defined data that will be passed to onChunk. +flags [in, optional] A set of flags for controlling how things are loaded. + +Returns true if successful; false otherwise. + +Close the loader with drwav_uninit(). + +This is the lowest level function for initializing a WAV file. You can also use drwav_init_file() and drwav_init_memory() +to open the stream from a file or from a block of memory respectively. + +Possible values for flags: +DRWAV_SEQUENTIAL: Never perform a backwards seek while loading. This disables the chunk callback and will cause this function +to return as soon as the data chunk is found. Any chunks after the data chunk will be ignored. + +drwav_init() is equivalent to "drwav_init_ex(pWav, onRead, onSeek, NULL, pUserData, NULL, 0);". + +The onChunk callback is not called for the WAVE or FMT chunks. The contents of the FMT chunk can be read from pWav->fmt +after the function returns. + +See also: drwav_init_file(), drwav_init_memory(), drwav_uninit() +*/ +drwav_init :: (pWav: *drwav, onRead: drwav_read_proc, onSeek: drwav_seek_proc, pUserData: *void, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_ex :: (pWav: *drwav, onRead: drwav_read_proc, onSeek: drwav_seek_proc, onChunk: drwav_chunk_proc, pReadSeekUserData: *void, pChunkUserData: *void, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_with_metadata :: (pWav: *drwav, onRead: drwav_read_proc, onSeek: drwav_seek_proc, pUserData: *void, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; + +/* +Initializes a pre-allocated drwav object for writing. + +onWrite [in] The function to call when data needs to be written. +onSeek [in] The function to call when the write position needs to move. +pUserData [in, optional] A pointer to application defined data that will be passed to onWrite and onSeek. +metadata, numMetadata [in, optional] An array of metadata objects that should be written to the file. The array is not edited. You are responsible for this metadata memory and it must maintain valid until drwav_uninit() is called. + +Returns true if successful; false otherwise. + +Close the writer with drwav_uninit(). + +This is the lowest level function for initializing a WAV file. You can also use drwav_init_file_write() and drwav_init_memory_write() +to open the stream from a file or from a block of memory respectively. + +If the total sample count is known, you can use drwav_init_write_sequential(). This avoids the need for dr_wav to perform +a post-processing step for storing the total sample count and the size of the data chunk which requires a backwards seek. + +See also: drwav_init_file_write(), drwav_init_memory_write(), drwav_uninit() +*/ +drwav_init_write :: (pWav: *drwav, pFormat: *drwav_data_format, onWrite: drwav_write_proc, onSeek: drwav_seek_proc, pUserData: *void, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_write_sequential :: (pWav: *drwav, pFormat: *drwav_data_format, totalSampleCount: drwav_uint64, onWrite: drwav_write_proc, pUserData: *void, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_write_sequential_pcm_frames :: (pWav: *drwav, pFormat: *drwav_data_format, totalPCMFrameCount: drwav_uint64, onWrite: drwav_write_proc, pUserData: *void, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_write_with_metadata :: (pWav: *drwav, pFormat: *drwav_data_format, onWrite: drwav_write_proc, onSeek: drwav_seek_proc, pUserData: *void, pAllocationCallbacks: *drwav_allocation_callbacks, pMetadata: *drwav_metadata, metadataCount: drwav_uint32) -> drwav_bool32 #foreign dr_libs; + +/* +Utility function to determine the target size of the entire data to be written (including all headers and chunks). + +Returns the target size in bytes. + +The metadata argument can be NULL meaning no metadata exists. + +Useful if the application needs to know the size to allocate. + +Only writing to the RIFF chunk and one data chunk is currently supported. + +See also: drwav_init_write(), drwav_init_file_write(), drwav_init_memory_write() +*/ +drwav_target_write_size_bytes :: (pFormat: *drwav_data_format, totalFrameCount: drwav_uint64, pMetadata: *drwav_metadata, metadataCount: drwav_uint32) -> drwav_uint64 #foreign dr_libs; + +/* +Take ownership of the metadata objects that were allocated via one of the init_with_metadata() function calls. The init_with_metdata functions perform a single heap allocation for this metadata. + +Useful if you want the data to persist beyond the lifetime of the drwav object. + +You must free the data returned from this function using drwav_free(). +*/ +drwav_take_ownership_of_metadata :: (pWav: *drwav) -> *drwav_metadata #foreign dr_libs; + +/* +Uninitializes the given drwav object. + +Use this only for objects initialized with drwav_init*() functions (drwav_init(), drwav_init_ex(), drwav_init_write(), drwav_init_write_sequential()). +*/ +drwav_uninit :: (pWav: *drwav) -> drwav_result #foreign dr_libs; + +/* +Reads raw audio data. + +This is the lowest level function for reading audio data. It simply reads the given number of +bytes of the raw internal sample data. + +Consider using drwav_read_pcm_frames_s16(), drwav_read_pcm_frames_s32() or drwav_read_pcm_frames_f32() for +reading sample data in a consistent format. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of bytes actually read. +*/ +drwav_read_raw :: (pWav: *drwav, bytesToRead: size_t, pBufferOut: *void) -> size_t #foreign dr_libs; + +/* +Reads up to the specified number of PCM frames from the WAV file. + +The output data will be in the file's internal format, converted to native-endian byte order. Use +drwav_read_pcm_frames_s16/f32/s32() to read data in a specific format. + +If the return value is less than it means the end of the file has been reached or +you have requested more PCM frames than can possibly fit in the output buffer. + +This function will only work when sample data is of a fixed size and uncompressed. If you are +using a compressed format consider using drwav_read_raw() or drwav_read_pcm_frames_s16/s32/f32(). + +pBufferOut can be NULL in which case a seek will be performed. +*/ +drwav_read_pcm_frames :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *void) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_le :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *void) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_be :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *void) -> drwav_uint64 #foreign dr_libs; + +/* +Seeks to the given PCM frame. + +Returns true if successful; false otherwise. +*/ +drwav_seek_to_pcm_frame :: (pWav: *drwav, targetFrameIndex: drwav_uint64) -> drwav_bool32 #foreign dr_libs; + +/* +Retrieves the current read position in pcm frames. +*/ +drwav_get_cursor_in_pcm_frames :: (pWav: *drwav, pCursor: *drwav_uint64) -> drwav_result #foreign dr_libs; + +/* +Retrieves the length of the file. +*/ +drwav_get_length_in_pcm_frames :: (pWav: *drwav, pLength: *drwav_uint64) -> drwav_result #foreign dr_libs; + +/* +Writes raw audio data. + +Returns the number of bytes actually written. If this differs from bytesToWrite, it indicates an error. +*/ +drwav_write_raw :: (pWav: *drwav, bytesToWrite: size_t, pData: *void) -> size_t #foreign dr_libs; + +/* +Writes PCM frames. + +Returns the number of PCM frames written. + +Input samples need to be in native-endian byte order. On big-endian architectures the input data will be converted to +little-endian. Use drwav_write_raw() to write raw audio data without performing any conversion. +*/ +drwav_write_pcm_frames :: (pWav: *drwav, framesToWrite: drwav_uint64, pData: *void) -> drwav_uint64 #foreign dr_libs; +drwav_write_pcm_frames_le :: (pWav: *drwav, framesToWrite: drwav_uint64, pData: *void) -> drwav_uint64 #foreign dr_libs; +drwav_write_pcm_frames_be :: (pWav: *drwav, framesToWrite: drwav_uint64, pData: *void) -> drwav_uint64 #foreign dr_libs; + +/* +Reads a chunk of audio data and converts it to signed 16-bit PCM samples. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of PCM frames actually read. + +If the return value is less than it means the end of the file has been reached. +*/ +drwav_read_pcm_frames_s16 :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *drwav_int16) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_s16le :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *drwav_int16) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_s16be :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *drwav_int16) -> drwav_uint64 #foreign dr_libs; + +/* Low-level function for converting unsigned 8-bit PCM samples to signed 16-bit PCM samples. */ +drwav_u8_to_s16 :: (pOut: *drwav_int16, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting signed 24-bit PCM samples to signed 16-bit PCM samples. */ +drwav_s24_to_s16 :: (pOut: *drwav_int16, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting signed 32-bit PCM samples to signed 16-bit PCM samples. */ +drwav_s32_to_s16 :: (pOut: *drwav_int16, pIn: *drwav_int32, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting IEEE 32-bit floating point samples to signed 16-bit PCM samples. */ +drwav_f32_to_s16 :: (pOut: *drwav_int16, pIn: *float, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting IEEE 64-bit floating point samples to signed 16-bit PCM samples. */ +drwav_f64_to_s16 :: (pOut: *drwav_int16, pIn: *float64, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting A-law samples to signed 16-bit PCM samples. */ +drwav_alaw_to_s16 :: (pOut: *drwav_int16, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting u-law samples to signed 16-bit PCM samples. */ +drwav_mulaw_to_s16 :: (pOut: *drwav_int16, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* +Reads a chunk of audio data and converts it to IEEE 32-bit floating point samples. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of PCM frames actually read. + +If the return value is less than it means the end of the file has been reached. +*/ +drwav_read_pcm_frames_f32 :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *float) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_f32le :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *float) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_f32be :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *float) -> drwav_uint64 #foreign dr_libs; + +/* Low-level function for converting unsigned 8-bit PCM samples to IEEE 32-bit floating point samples. */ +drwav_u8_to_f32 :: (pOut: *float, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting signed 16-bit PCM samples to IEEE 32-bit floating point samples. */ +drwav_s16_to_f32 :: (pOut: *float, pIn: *drwav_int16, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting signed 24-bit PCM samples to IEEE 32-bit floating point samples. */ +drwav_s24_to_f32 :: (pOut: *float, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting signed 32-bit PCM samples to IEEE 32-bit floating point samples. */ +drwav_s32_to_f32 :: (pOut: *float, pIn: *drwav_int32, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting IEEE 64-bit floating point samples to IEEE 32-bit floating point samples. */ +drwav_f64_to_f32 :: (pOut: *float, pIn: *float64, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting A-law samples to IEEE 32-bit floating point samples. */ +drwav_alaw_to_f32 :: (pOut: *float, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting u-law samples to IEEE 32-bit floating point samples. */ +drwav_mulaw_to_f32 :: (pOut: *float, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* +Reads a chunk of audio data and converts it to signed 32-bit PCM samples. + +pBufferOut can be NULL in which case a seek will be performed. + +Returns the number of PCM frames actually read. + +If the return value is less than it means the end of the file has been reached. +*/ +drwav_read_pcm_frames_s32 :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *drwav_int32) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_s32le :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *drwav_int32) -> drwav_uint64 #foreign dr_libs; +drwav_read_pcm_frames_s32be :: (pWav: *drwav, framesToRead: drwav_uint64, pBufferOut: *drwav_int32) -> drwav_uint64 #foreign dr_libs; + +/* Low-level function for converting unsigned 8-bit PCM samples to signed 32-bit PCM samples. */ +drwav_u8_to_s32 :: (pOut: *drwav_int32, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting signed 16-bit PCM samples to signed 32-bit PCM samples. */ +drwav_s16_to_s32 :: (pOut: *drwav_int32, pIn: *drwav_int16, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting signed 24-bit PCM samples to signed 32-bit PCM samples. */ +drwav_s24_to_s32 :: (pOut: *drwav_int32, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting IEEE 32-bit floating point samples to signed 32-bit PCM samples. */ +drwav_f32_to_s32 :: (pOut: *drwav_int32, pIn: *float, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting IEEE 64-bit floating point samples to signed 32-bit PCM samples. */ +drwav_f64_to_s32 :: (pOut: *drwav_int32, pIn: *float64, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting A-law samples to signed 32-bit PCM samples. */ +drwav_alaw_to_s32 :: (pOut: *drwav_int32, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* Low-level function for converting u-law samples to signed 32-bit PCM samples. */ +drwav_mulaw_to_s32 :: (pOut: *drwav_int32, pIn: *drwav_uint8, sampleCount: size_t) -> void #foreign dr_libs; + +/* +Helper for initializing a wave file for reading using stdio. + +This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav +objects because the operating system may restrict the number of file handles an application can have open at +any given time. +*/ +drwav_init_file :: (pWav: *drwav, filename: *u8, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_ex :: (pWav: *drwav, filename: *u8, onChunk: drwav_chunk_proc, pChunkUserData: *void, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_w :: (pWav: *drwav, filename: *wchar_t, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_ex_w :: (pWav: *drwav, filename: *wchar_t, onChunk: drwav_chunk_proc, pChunkUserData: *void, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_with_metadata :: (pWav: *drwav, filename: *u8, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_with_metadata_w :: (pWav: *drwav, filename: *wchar_t, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; + +/* +Helper for initializing a wave file for writing using stdio. + +This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav +objects because the operating system may restrict the number of file handles an application can have open at +any given time. +*/ +drwav_init_file_write :: (pWav: *drwav, filename: *u8, pFormat: *drwav_data_format, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_write_sequential :: (pWav: *drwav, filename: *u8, pFormat: *drwav_data_format, totalSampleCount: drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_write_sequential_pcm_frames :: (pWav: *drwav, filename: *u8, pFormat: *drwav_data_format, totalPCMFrameCount: drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_write_w :: (pWav: *drwav, filename: *wchar_t, pFormat: *drwav_data_format, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_write_sequential_w :: (pWav: *drwav, filename: *wchar_t, pFormat: *drwav_data_format, totalSampleCount: drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_file_write_sequential_pcm_frames_w :: (pWav: *drwav, filename: *wchar_t, pFormat: *drwav_data_format, totalPCMFrameCount: drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; + +/* +Helper for initializing a loader from a pre-allocated memory buffer. + +This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for +the lifetime of the drwav object. + +The buffer should contain the contents of the entire wave file, not just the sample data. +*/ +drwav_init_memory :: (pWav: *drwav, data: *void, dataSize: size_t, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_memory_ex :: (pWav: *drwav, data: *void, dataSize: size_t, onChunk: drwav_chunk_proc, pChunkUserData: *void, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_memory_with_metadata :: (pWav: *drwav, data: *void, dataSize: size_t, flags: drwav_uint32, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; + +/* +Helper for initializing a writer which outputs data to a memory buffer. + +dr_wav will manage the memory allocations, however it is up to the caller to free the data with drwav_free(). + +The buffer will remain allocated even after drwav_uninit() is called. The buffer should not be considered valid +until after drwav_uninit() has been called. +*/ +drwav_init_memory_write :: (pWav: *drwav, ppData: **void, pDataSize: *size_t, pFormat: *drwav_data_format, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_memory_write_sequential :: (pWav: *drwav, ppData: **void, pDataSize: *size_t, pFormat: *drwav_data_format, totalSampleCount: drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; +drwav_init_memory_write_sequential_pcm_frames :: (pWav: *drwav, ppData: **void, pDataSize: *size_t, pFormat: *drwav_data_format, totalPCMFrameCount: drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> drwav_bool32 #foreign dr_libs; + +/* +Opens and reads an entire wav file in a single operation. + +The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer. +*/ +drwav_open_and_read_pcm_frames_s16 :: (onRead: drwav_read_proc, onSeek: drwav_seek_proc, pUserData: *void, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int16 #foreign dr_libs; +drwav_open_and_read_pcm_frames_f32 :: (onRead: drwav_read_proc, onSeek: drwav_seek_proc, pUserData: *void, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *float #foreign dr_libs; +drwav_open_and_read_pcm_frames_s32 :: (onRead: drwav_read_proc, onSeek: drwav_seek_proc, pUserData: *void, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int32 #foreign dr_libs; + +/* +Opens and decodes an entire wav file in a single operation. + +The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer. +*/ +drwav_open_file_and_read_pcm_frames_s16 :: (filename: *u8, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int16 #foreign dr_libs; +drwav_open_file_and_read_pcm_frames_f32 :: (filename: *u8, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *float #foreign dr_libs; +drwav_open_file_and_read_pcm_frames_s32 :: (filename: *u8, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int32 #foreign dr_libs; +drwav_open_file_and_read_pcm_frames_s16_w :: (filename: *wchar_t, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int16 #foreign dr_libs; +drwav_open_file_and_read_pcm_frames_f32_w :: (filename: *wchar_t, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *float #foreign dr_libs; +drwav_open_file_and_read_pcm_frames_s32_w :: (filename: *wchar_t, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int32 #foreign dr_libs; + +/* +Opens and decodes an entire wav file from a block of memory in a single operation. + +The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer. +*/ +drwav_open_memory_and_read_pcm_frames_s16 :: (data: *void, dataSize: size_t, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int16 #foreign dr_libs; +drwav_open_memory_and_read_pcm_frames_f32 :: (data: *void, dataSize: size_t, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *float #foreign dr_libs; +drwav_open_memory_and_read_pcm_frames_s32 :: (data: *void, dataSize: size_t, channelsOut: *u32, sampleRateOut: *u32, totalFrameCountOut: *drwav_uint64, pAllocationCallbacks: *drwav_allocation_callbacks) -> *drwav_int32 #foreign dr_libs; + +/* Frees data that was allocated internally by dr_wav. */ +drwav_free :: (p: *void, pAllocationCallbacks: *drwav_allocation_callbacks) -> void #foreign dr_libs; + +/* Converts bytes from a wav stream to a sized type of native endian. */ +drwav_bytes_to_u16 :: (data: *drwav_uint8) -> drwav_uint16 #foreign dr_libs; +drwav_bytes_to_s16 :: (data: *drwav_uint8) -> drwav_int16 #foreign dr_libs; +drwav_bytes_to_u32 :: (data: *drwav_uint8) -> drwav_uint32 #foreign dr_libs; +drwav_bytes_to_s32 :: (data: *drwav_uint8) -> drwav_int32 #foreign dr_libs; +drwav_bytes_to_u64 :: (data: *drwav_uint8) -> drwav_uint64 #foreign dr_libs; +drwav_bytes_to_s64 :: (data: *drwav_uint8) -> drwav_int64 #foreign dr_libs; +drwav_bytes_to_f32 :: (data: *drwav_uint8) -> float #foreign dr_libs; + +/* Compares a GUID for the purpose of checking the type of a Wave64 chunk. */ +drwav_guid_equal :: (a: *[16] drwav_uint8, b: *[16] drwav_uint8) -> drwav_bool32 #foreign dr_libs; + +/* Compares a four-character-code for the purpose of checking the type of a RIFF chunk. */ +drwav_fourcc_equal :: (a: *drwav_uint8, b: *u8) -> drwav_bool32 #foreign dr_libs; + +/* Sized Types */ +drflac_int8 :: s8; +drflac_uint8 :: u8; +drflac_int16 :: s16; +drflac_uint16 :: u16; +drflac_int32 :: s32; +drflac_uint32 :: u32; + +drflac_int64 :: s64; +drflac_uint64 :: u64; + +drflac_uintptr :: drflac_uint64; + +drflac_bool8 :: drflac_uint8; +drflac_bool32 :: drflac_uint32; + +drflac_version :: (pMajor: *drflac_uint32, pMinor: *drflac_uint32, pRevision: *drflac_uint32) -> void #foreign dr_libs; +drflac_version_string :: () -> *u8 #foreign dr_libs; + +/* Allocation Callbacks */ +drflac_allocation_callbacks :: struct { + pUserData: *void; + onMalloc: #type (sz: size_t, pUserData: *void) -> *void #c_call; + onRealloc: #type (p: *void, sz: size_t, pUserData: *void) -> *void #c_call; + onFree: #type (p: *void, pUserData: *void) -> void #c_call; +} + +drflac_cache_t :: drflac_uint64; + +drflac_container :: enum s32 { + native :: 0; + ogg :: 1; + unknown :: 2; + + drflac_container_native :: native; + drflac_container_ogg :: ogg; + drflac_container_unknown :: unknown; +} + +drflac_seek_origin :: enum s32 { + start :: 0; + current :: 1; + + drflac_seek_origin_start :: start; + drflac_seek_origin_current :: current; +} + +/* The order of members in this structure is important because we map this directly to the raw data within the SEEKTABLE metadata block. */ +drflac_seekpoint :: struct { + firstPCMFrame: drflac_uint64; + flacFrameOffset: drflac_uint64; /* The offset from the first byte of the header of the first frame. */ + pcmFrameCount: drflac_uint16; +} + +drflac_streaminfo :: struct { + minBlockSizeInPCMFrames: drflac_uint16; + maxBlockSizeInPCMFrames: drflac_uint16; + minFrameSizeInPCMFrames: drflac_uint32; + maxFrameSizeInPCMFrames: drflac_uint32; + sampleRate: drflac_uint32; + channels: drflac_uint8; + bitsPerSample: drflac_uint8; + totalPCMFrameCount: drflac_uint64; + md5: [16] drflac_uint8; +} + +drflac_metadata :: struct { + /* + The metadata type. Use this to know how to interpret the data below. Will be set to one of the + DRFLAC_METADATA_BLOCK_TYPE_* tokens. + */ + type: drflac_uint32; + + /* + A pointer to the raw data. This points to a temporary buffer so don't hold on to it. It's best to + not modify the contents of this buffer. Use the structures below for more meaningful and structured + information about the metadata. It's possible for this to be null. + */ + pRawData: *void; + + /* The size in bytes of the block and the buffer pointed to by pRawData if it's non-NULL. */ + rawDataSize: drflac_uint32; + + data: union { + streaminfo: drflac_streaminfo; + + padding: struct { + unused: s32; + }; + + application: struct { + id: drflac_uint32; + pData: *void; + dataSize: drflac_uint32; + }; + + seektable: struct { + seekpointCount: drflac_uint32; + pSeekpoints: *drflac_seekpoint; + }; + + vorbis_comment: struct { + vendorLength: drflac_uint32; + vendor: *u8; + commentCount: drflac_uint32; + pComments: *void; + }; + + cuesheet: struct { + catalog: [128] u8; + leadInSampleCount: drflac_uint64; + isCD: drflac_bool32; + trackCount: drflac_uint8; + pTrackData: *void; + }; + + picture: struct { + type: drflac_uint32; + mimeLength: drflac_uint32; + mime: *u8; + descriptionLength: drflac_uint32; + description: *u8; + width: drflac_uint32; + height: drflac_uint32; + colorDepth: drflac_uint32; + indexColorCount: drflac_uint32; + pictureDataSize: drflac_uint32; + pPictureData: *drflac_uint8; + }; + }; +} + +/* +Callback for when data needs to be read from the client. + + +Parameters +---------- +pUserData (in) +The user data that was passed to drflac_open() and family. + +pBufferOut (out) +The output buffer. + +bytesToRead (in) +The number of bytes to read. + + +Return Value +------------ +The number of bytes actually read. + + +Remarks +------- +A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until either the entire bytesToRead is filled or +you have reached the end of the stream. +*/ +drflac_read_proc :: #type (pUserData: *void, pBufferOut: *void, bytesToRead: size_t) -> size_t #c_call; + +/* +Callback for when data needs to be seeked. + + +Parameters +---------- +pUserData (in) +The user data that was passed to drflac_open() and family. + +offset (in) +The number of bytes to move, relative to the origin. Will never be negative. + +origin (in) +The origin of the seek - the current position or the start of the stream. + + +Return Value +------------ +Whether or not the seek was successful. + + +Remarks +------- +The offset will never be negative. Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which will be +either drflac_seek_origin_start or drflac_seek_origin_current. + +When seeking to a PCM frame using drflac_seek_to_pcm_frame(), dr_flac may call this with an offset beyond the end of the FLAC stream. This needs to be detected +and handled by returning DRFLAC_FALSE. +*/ +drflac_seek_proc :: #type (pUserData: *void, offset: s32, origin: drflac_seek_origin) -> drflac_bool32 #c_call; + +/* +Callback for when a metadata block is read. + + +Parameters +---------- +pUserData (in) +The user data that was passed to drflac_open() and family. + +pMetadata (in) +A pointer to a structure containing the data of the metadata block. + + +Remarks +------- +Use pMetadata->type to determine which metadata block is being handled and how to read the data. This +will be set to one of the DRFLAC_METADATA_BLOCK_TYPE_* tokens. +*/ +drflac_meta_proc :: #type (pUserData: *void, pMetadata: *drflac_metadata) -> void #c_call; + +/* Structure for internal use. Only used for decoders opened with drflac_open_memory. */ +drflac__memory_stream :: struct { + data: *drflac_uint8; + dataSize: size_t; + currentReadPos: size_t; +} + +/* Structure for internal use. Used for bit streaming. */ +drflac_bs :: struct { + /* The function to call when more data needs to be read. */ + onRead: drflac_read_proc; + + /* The function to call when the current read position needs to be moved. */ + onSeek: drflac_seek_proc; + + /* The user data to pass around to onRead and onSeek. */ + pUserData: *void; + + /* + The number of unaligned bytes in the L2 cache. This will always be 0 until the end of the stream is hit. At the end of the + stream there will be a number of bytes that don't cleanly fit in an L1 cache line, so we use this variable to know whether + or not the bistreamer needs to run on a slower path to read those last bytes. This will never be more than sizeof(drflac_cache_t). + */ + unalignedByteCount: size_t; + + /* The content of the unaligned bytes. */ + unalignedCache: drflac_cache_t; + + /* The index of the next valid cache line in the "L2" cache. */ + nextL2Line: drflac_uint32; + + /* The number of bits that have been consumed by the cache. This is used to determine how many valid bits are remaining. */ + consumedBits: drflac_uint32; + + /* + The cached data which was most recently read from the client. There are two levels of cache. Data flows as such: + Client -> L2 -> L1. The L2 -> L1 movement is aligned and runs on a fast path in just a few instructions. + */ + cacheL2: [512] drflac_cache_t; + cache: drflac_cache_t; + + /* + CRC-16. This is updated whenever bits are read from the bit stream. Manually set this to 0 to reset the CRC. For FLAC, this + is reset to 0 at the beginning of each frame. + */ + crc16: drflac_uint16; + crc16Cache: drflac_cache_t; /* A cache for optimizing CRC calculations. This is filled when when the L1 cache is reloaded. */ + crc16CacheIgnoredBytes: drflac_uint32; /* The number of bytes to ignore when updating the CRC-16 from the CRC-16 cache. */ +} + +drflac_subframe :: struct { + /* The type of the subframe: SUBFRAME_CONSTANT, SUBFRAME_VERBATIM, SUBFRAME_FIXED or SUBFRAME_LPC. */ + subframeType: drflac_uint8; + + /* The number of wasted bits per sample as specified by the sub-frame header. */ + wastedBitsPerSample: drflac_uint8; + + /* The order to use for the prediction stage for SUBFRAME_FIXED and SUBFRAME_LPC. */ + lpcOrder: drflac_uint8; + + /* A pointer to the buffer containing the decoded samples in the subframe. This pointer is an offset from drflac::pExtraData. */ + pSamplesS32: *drflac_int32; +} + +drflac_frame_header :: struct { + /* + If the stream uses variable block sizes, this will be set to the index of the first PCM frame. If fixed block sizes are used, this will + always be set to 0. This is 64-bit because the decoded PCM frame number will be 36 bits. + */ + pcmFrameNumber: drflac_uint64; + + /* + If the stream uses fixed block sizes, this will be set to the frame number. If variable block sizes are used, this will always be 0. This + is 32-bit because in fixed block sizes, the maximum frame number will be 31 bits. + */ + flacFrameNumber: drflac_uint32; + + /* The sample rate of this frame. */ + sampleRate: drflac_uint32; + + /* The number of PCM frames in each sub-frame within this frame. */ + blockSizeInPCMFrames: drflac_uint16; + + /* + The channel assignment of this frame. This is not always set to the channel count. If interchannel decorrelation is being used this + will be set to DRFLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE, DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE or DRFLAC_CHANNEL_ASSIGNMENT_MID_SIDE. + */ + channelAssignment: drflac_uint8; + + /* The number of bits per sample within this frame. */ + bitsPerSample: drflac_uint8; + + /* The frame's CRC. */ + crc8: drflac_uint8; +} + +drflac_frame :: struct { + /* The header. */ + header: drflac_frame_header; + + /* + The number of PCM frames left to be read in this FLAC frame. This is initially set to the block size. As PCM frames are read, + this will be decremented. When it reaches 0, the decoder will see this frame as fully consumed and load the next frame. + */ + pcmFramesRemaining: drflac_uint32; + + /* The list of sub-frames within the frame. There is one sub-frame for each channel, and there's a maximum of 8 channels. */ + subframes: [8] drflac_subframe; +} + +drflac :: struct { + /* The function to call when a metadata block is read. */ + onMeta: drflac_meta_proc; + + /* The user data posted to the metadata callback function. */ + pUserDataMD: *void; + + /* Memory allocation callbacks. */ + allocationCallbacks: drflac_allocation_callbacks; + + /* The sample rate. Will be set to something like 44100. */ + sampleRate: drflac_uint32; + + /* + The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc. Maximum 8. This is set based on the + value specified in the STREAMINFO block. + */ + channels: drflac_uint8; + + /* The bits per sample. Will be set to something like 16, 24, etc. */ + bitsPerSample: drflac_uint8; + + /* The maximum block size, in samples. This number represents the number of samples in each channel (not combined). */ + maxBlockSizeInPCMFrames: drflac_uint16; + + /* + The total number of PCM Frames making up the stream. Can be 0 in which case it's still a valid stream, but just means + the total PCM frame count is unknown. Likely the case with streams like internet radio. + */ + totalPCMFrameCount: drflac_uint64; + + /* The container type. This is set based on whether or not the decoder was opened from a native or Ogg stream. */ + container: drflac_container; + + /* The number of seekpoints in the seektable. */ + seekpointCount: drflac_uint32; + + /* Information about the frame the decoder is currently sitting on. */ + currentFLACFrame: drflac_frame; + + /* The index of the PCM frame the decoder is currently sitting on. This is only used for seeking. */ + currentPCMFrame: drflac_uint64; + + /* The position of the first FLAC frame in the stream. This is only ever used for seeking. */ + firstFLACFramePosInBytes: drflac_uint64; + + /* A hack to avoid a malloc() when opening a decoder with drflac_open_memory(). */ + memoryStream: drflac__memory_stream; + + /* A pointer to the decoded sample data. This is an offset of pExtraData. */ + pDecodedSamples: *drflac_int32; + + /* A pointer to the seek table. This is an offset of pExtraData, or NULL if there is no seek table. */ + pSeekpoints: *drflac_seekpoint; + + /* Internal use only. Only used with Ogg containers. Points to a drflac_oggbs object. This is an offset of pExtraData. */ + _oggbs: *void; + + /* Internal use only. Used for profiling and testing different seeking modes. */ + _noSeekTableSeek: drflac_bool32; + #place _noSeekTableSeek; /*bitfield 1*/ _noBinarySearchSeek: drflac_bool32; + #place _noSeekTableSeek; /*bitfield 2*/ _noBruteForceSeek: drflac_bool32; + + /* The bit streamer. The raw FLAC data is fed through this object. */ + bs: drflac_bs; + + /* Variable length extra data. We attach this to the end of the object so we can avoid unnecessary mallocs. */ + pExtraData: [1] drflac_uint8; +} + +/* +Opens a FLAC decoder. + + +Parameters +---------- +onRead (in) +The function to call when data needs to be read from the client. + +onSeek (in) +The function to call when the read position of the client data needs to move. + +pUserData (in, optional) +A pointer to application defined data that will be passed to onRead and onSeek. + +pAllocationCallbacks (in, optional) +A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +Returns a pointer to an object representing the decoder. + + +Remarks +------- +Close the decoder with `drflac_close()`. + +`pAllocationCallbacks` can be NULL in which case it will use `DRFLAC_MALLOC`, `DRFLAC_REALLOC` and `DRFLAC_FREE`. + +This function will automatically detect whether or not you are attempting to open a native or Ogg encapsulated FLAC, both of which should work seamlessly +without any manual intervention. Ogg encapsulation also works with multiplexed streams which basically means it can play FLAC encoded audio tracks in videos. + +This is the lowest level function for opening a FLAC stream. You can also use `drflac_open_file()` and `drflac_open_memory()` to open the stream from a file or +from a block of memory respectively. + +The STREAMINFO block must be present for this to succeed. Use `drflac_open_relaxed()` to open a FLAC stream where the header may not be present. + +Use `drflac_open_with_metadata()` if you need access to metadata. + + +Seek Also +--------- +drflac_open_file() +drflac_open_memory() +drflac_open_with_metadata() +drflac_close() +*/ +drflac_open :: (onRead: drflac_read_proc, onSeek: drflac_seek_proc, pUserData: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +Opens a FLAC stream with relaxed validation of the header block. + + +Parameters +---------- +onRead (in) +The function to call when data needs to be read from the client. + +onSeek (in) +The function to call when the read position of the client data needs to move. + +container (in) +Whether or not the FLAC stream is encapsulated using standard FLAC encapsulation or Ogg encapsulation. + +pUserData (in, optional) +A pointer to application defined data that will be passed to onRead and onSeek. + +pAllocationCallbacks (in, optional) +A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +The same as drflac_open(), except attempts to open the stream even when a header block is not present. + +Because the header is not necessarily available, the caller must explicitly define the container (Native or Ogg). Do not set this to `drflac_container_unknown` +as that is for internal use only. + +Opening in relaxed mode will continue reading data from onRead until it finds a valid frame. If a frame is never found it will continue forever. To abort, +force your `onRead` callback to return 0, which dr_flac will use as an indicator that the end of the stream was found. + +Use `drflac_open_with_metadata_relaxed()` if you need access to metadata. +*/ +drflac_open_relaxed :: (onRead: drflac_read_proc, onSeek: drflac_seek_proc, container: drflac_container, pUserData: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +Opens a FLAC decoder and notifies the caller of the metadata chunks (album art, etc.). + + +Parameters +---------- +onRead (in) +The function to call when data needs to be read from the client. + +onSeek (in) +The function to call when the read position of the client data needs to move. + +onMeta (in) +The function to call for every metadata block. + +pUserData (in, optional) +A pointer to application defined data that will be passed to onRead, onSeek and onMeta. + +pAllocationCallbacks (in, optional) +A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +Close the decoder with `drflac_close()`. + +`pAllocationCallbacks` can be NULL in which case it will use `DRFLAC_MALLOC`, `DRFLAC_REALLOC` and `DRFLAC_FREE`. + +This is slower than `drflac_open()`, so avoid this one if you don't need metadata. Internally, this will allocate and free memory on the heap for every +metadata block except for STREAMINFO and PADDING blocks. + +The caller is notified of the metadata via the `onMeta` callback. All metadata blocks will be handled before the function returns. This callback takes a +pointer to a `drflac_metadata` object which is a union containing the data of all relevant metadata blocks. Use the `type` member to discriminate against +the different metadata types. + +The STREAMINFO block must be present for this to succeed. Use `drflac_open_with_metadata_relaxed()` to open a FLAC stream where the header may not be present. + +Note that this will behave inconsistently with `drflac_open()` if the stream is an Ogg encapsulated stream and a metadata block is corrupted. This is due to +the way the Ogg stream recovers from corrupted pages. When `drflac_open_with_metadata()` is being used, the open routine will try to read the contents of the +metadata block, whereas `drflac_open()` will simply seek past it (for the sake of efficiency). This inconsistency can result in different samples being +returned depending on whether or not the stream is being opened with metadata. + + +Seek Also +--------- +drflac_open_file_with_metadata() +drflac_open_memory_with_metadata() +drflac_open() +drflac_close() +*/ +drflac_open_with_metadata :: (onRead: drflac_read_proc, onSeek: drflac_seek_proc, onMeta: drflac_meta_proc, pUserData: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +The same as drflac_open_with_metadata(), except attempts to open the stream even when a header block is not present. + +See Also +-------- +drflac_open_with_metadata() +drflac_open_relaxed() +*/ +drflac_open_with_metadata_relaxed :: (onRead: drflac_read_proc, onSeek: drflac_seek_proc, onMeta: drflac_meta_proc, container: drflac_container, pUserData: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +Closes the given FLAC decoder. + + +Parameters +---------- +pFlac (in) +The decoder to close. + + +Remarks +------- +This will destroy the decoder object. + + +See Also +-------- +drflac_open() +drflac_open_with_metadata() +drflac_open_file() +drflac_open_file_w() +drflac_open_file_with_metadata() +drflac_open_file_with_metadata_w() +drflac_open_memory() +drflac_open_memory_with_metadata() +*/ +drflac_close :: (pFlac: *drflac) -> void #foreign dr_libs; + +/* +Reads sample data from the given FLAC decoder, output as interleaved signed 32-bit PCM. + + +Parameters +---------- +pFlac (in) +The decoder. + +framesToRead (in) +The number of PCM frames to read. + +pBufferOut (out, optional) +A pointer to the buffer that will receive the decoded samples. + + +Return Value +------------ +Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end. + + +Remarks +------- +pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked. +*/ +drflac_read_pcm_frames_s32 :: (pFlac: *drflac, framesToRead: drflac_uint64, pBufferOut: *drflac_int32) -> drflac_uint64 #foreign dr_libs; + +/* +Reads sample data from the given FLAC decoder, output as interleaved signed 16-bit PCM. + + +Parameters +---------- +pFlac (in) +The decoder. + +framesToRead (in) +The number of PCM frames to read. + +pBufferOut (out, optional) +A pointer to the buffer that will receive the decoded samples. + + +Return Value +------------ +Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end. + + +Remarks +------- +pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked. + +Note that this is lossy for streams where the bits per sample is larger than 16. +*/ +drflac_read_pcm_frames_s16 :: (pFlac: *drflac, framesToRead: drflac_uint64, pBufferOut: *drflac_int16) -> drflac_uint64 #foreign dr_libs; + +/* +Reads sample data from the given FLAC decoder, output as interleaved 32-bit floating point PCM. + + +Parameters +---------- +pFlac (in) +The decoder. + +framesToRead (in) +The number of PCM frames to read. + +pBufferOut (out, optional) +A pointer to the buffer that will receive the decoded samples. + + +Return Value +------------ +Returns the number of PCM frames actually read. If the return value is less than `framesToRead` it has reached the end. + + +Remarks +------- +pBufferOut can be null, in which case the call will act as a seek, and the return value will be the number of frames seeked. + +Note that this should be considered lossy due to the nature of floating point numbers not being able to exactly represent every possible number. +*/ +drflac_read_pcm_frames_f32 :: (pFlac: *drflac, framesToRead: drflac_uint64, pBufferOut: *float) -> drflac_uint64 #foreign dr_libs; + +/* +Seeks to the PCM frame at the given index. + + +Parameters +---------- +pFlac (in) +The decoder. + +pcmFrameIndex (in) +The index of the PCM frame to seek to. See notes below. + + +Return Value +------------- +`DRFLAC_TRUE` if successful; `DRFLAC_FALSE` otherwise. +*/ +drflac_seek_to_pcm_frame :: (pFlac: *drflac, pcmFrameIndex: drflac_uint64) -> drflac_bool32 #foreign dr_libs; + +/* +Opens a FLAC decoder from the file at the given path. + + +Parameters +---------- +pFileName (in) +The path of the file to open, either absolute or relative to the current directory. + +pAllocationCallbacks (in, optional) +A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +Close the decoder with drflac_close(). + + +Remarks +------- +This will hold a handle to the file until the decoder is closed with drflac_close(). Some platforms will restrict the number of files a process can have open +at any given time, so keep this mind if you have many decoders open at the same time. + + +See Also +-------- +drflac_open_file_with_metadata() +drflac_open() +drflac_close() +*/ +drflac_open_file :: (pFileName: *u8, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; +drflac_open_file_w :: (pFileName: *wchar_t, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +Opens a FLAC decoder from the file at the given path and notifies the caller of the metadata chunks (album art, etc.) + + +Parameters +---------- +pFileName (in) +The path of the file to open, either absolute or relative to the current directory. + +pAllocationCallbacks (in, optional) +A pointer to application defined callbacks for managing memory allocations. + +onMeta (in) +The callback to fire for each metadata block. + +pUserData (in) +A pointer to the user data to pass to the metadata callback. + +pAllocationCallbacks (in) +A pointer to application defined callbacks for managing memory allocations. + + +Remarks +------- +Look at the documentation for drflac_open_with_metadata() for more information on how metadata is handled. + + +See Also +-------- +drflac_open_with_metadata() +drflac_open() +drflac_close() +*/ +drflac_open_file_with_metadata :: (pFileName: *u8, onMeta: drflac_meta_proc, pUserData: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; +drflac_open_file_with_metadata_w :: (pFileName: *wchar_t, onMeta: drflac_meta_proc, pUserData: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +Opens a FLAC decoder from a pre-allocated block of memory + + +Parameters +---------- +pData (in) +A pointer to the raw encoded FLAC data. + +dataSize (in) +The size in bytes of `data`. + +pAllocationCallbacks (in) +A pointer to application defined callbacks for managing memory allocations. + + +Return Value +------------ +A pointer to an object representing the decoder. + + +Remarks +------- +This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for the lifetime of the decoder. + + +See Also +-------- +drflac_open() +drflac_close() +*/ +drflac_open_memory :: (pData: *void, dataSize: size_t, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +Opens a FLAC decoder from a pre-allocated block of memory and notifies the caller of the metadata chunks (album art, etc.) + + +Parameters +---------- +pData (in) +A pointer to the raw encoded FLAC data. + +dataSize (in) +The size in bytes of `data`. + +onMeta (in) +The callback to fire for each metadata block. + +pUserData (in) +A pointer to the user data to pass to the metadata callback. + +pAllocationCallbacks (in) +A pointer to application defined callbacks for managing memory allocations. + + +Remarks +------- +Look at the documentation for drflac_open_with_metadata() for more information on how metadata is handled. + + +See Also +------- +drflac_open_with_metadata() +drflac_open() +drflac_close() +*/ +drflac_open_memory_with_metadata :: (pData: *void, dataSize: size_t, onMeta: drflac_meta_proc, pUserData: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac #foreign dr_libs; + +/* +Opens a FLAC stream from the given callbacks and fully decodes it in a single operation. The return value is a +pointer to the sample data as interleaved signed 32-bit PCM. The returned data must be freed with drflac_free(). + +You can pass in custom memory allocation callbacks via the pAllocationCallbacks parameter. This can be NULL in which +case it will use DRFLAC_MALLOC, DRFLAC_REALLOC and DRFLAC_FREE. + +Sometimes a FLAC file won't keep track of the total sample count. In this situation the function will continuously +read samples into a dynamically sized buffer on the heap until no samples are left. + +Do not call this function on a broadcast type of stream (like internet radio streams and whatnot). +*/ +drflac_open_and_read_pcm_frames_s32 :: (onRead: drflac_read_proc, onSeek: drflac_seek_proc, pUserData: *void, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac_int32 #foreign dr_libs; + +/* Same as drflac_open_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */ +drflac_open_and_read_pcm_frames_s16 :: (onRead: drflac_read_proc, onSeek: drflac_seek_proc, pUserData: *void, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac_int16 #foreign dr_libs; + +/* Same as drflac_open_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */ +drflac_open_and_read_pcm_frames_f32 :: (onRead: drflac_read_proc, onSeek: drflac_seek_proc, pUserData: *void, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *float #foreign dr_libs; + +/* Same as drflac_open_and_read_pcm_frames_s32() except opens the decoder from a file. */ +drflac_open_file_and_read_pcm_frames_s32 :: (filename: *u8, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac_int32 #foreign dr_libs; + +/* Same as drflac_open_file_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */ +drflac_open_file_and_read_pcm_frames_s16 :: (filename: *u8, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac_int16 #foreign dr_libs; + +/* Same as drflac_open_file_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */ +drflac_open_file_and_read_pcm_frames_f32 :: (filename: *u8, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *float #foreign dr_libs; + +/* Same as drflac_open_and_read_pcm_frames_s32() except opens the decoder from a block of memory. */ +drflac_open_memory_and_read_pcm_frames_s32 :: (data: *void, dataSize: size_t, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac_int32 #foreign dr_libs; + +/* Same as drflac_open_memory_and_read_pcm_frames_s32(), except returns signed 16-bit integer samples. */ +drflac_open_memory_and_read_pcm_frames_s16 :: (data: *void, dataSize: size_t, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *drflac_int16 #foreign dr_libs; + +/* Same as drflac_open_memory_and_read_pcm_frames_s32(), except returns 32-bit floating-point samples. */ +drflac_open_memory_and_read_pcm_frames_f32 :: (data: *void, dataSize: size_t, channels: *u32, sampleRate: *u32, totalPCMFrameCount: *drflac_uint64, pAllocationCallbacks: *drflac_allocation_callbacks) -> *float #foreign dr_libs; + +/* +Frees memory that was allocated internally by dr_flac. + +Set pAllocationCallbacks to the same object that was passed to drflac_open_*_and_read_pcm_frames_*(). If you originally passed in NULL, pass in NULL for this. +*/ +drflac_free :: (p: *void, pAllocationCallbacks: *drflac_allocation_callbacks) -> void #foreign dr_libs; + +/* Structure representing an iterator for vorbis comments in a VORBIS_COMMENT metadata block. */ +drflac_vorbis_comment_iterator :: struct { + countRemaining: drflac_uint32; + pRunningData: *u8; +} + +/* +Initializes a vorbis comment iterator. This can be used for iterating over the vorbis comments in a VORBIS_COMMENT +metadata block. +*/ +drflac_init_vorbis_comment_iterator :: (pIter: *drflac_vorbis_comment_iterator, commentCount: drflac_uint32, pComments: *void) -> void #foreign dr_libs; + +/* +Goes to the next vorbis comment in the given iterator. If null is returned it means there are no more comments. The +returned string is NOT null terminated. +*/ +drflac_next_vorbis_comment :: (pIter: *drflac_vorbis_comment_iterator, pCommentLengthOut: *drflac_uint32) -> *u8 #foreign dr_libs; + +/* Structure representing an iterator for cuesheet tracks in a CUESHEET metadata block. */ +drflac_cuesheet_track_iterator :: struct { + countRemaining: drflac_uint32; + pRunningData: *u8; +} + +/* The order of members here is important because we map this directly to the raw data within the CUESHEET metadata block. */ +drflac_cuesheet_track_index :: struct { + offset: drflac_uint64; + index: drflac_uint8; + reserved: [3] drflac_uint8; +} + +drflac_cuesheet_track :: struct { + offset: drflac_uint64; + trackNumber: drflac_uint8; + ISRC: [12] u8; + isAudio: drflac_bool8; + preEmphasis: drflac_bool8; + indexCount: drflac_uint8; + pIndexPoints: *drflac_cuesheet_track_index; +} + +/* +Initializes a cuesheet track iterator. This can be used for iterating over the cuesheet tracks in a CUESHEET metadata +block. +*/ +drflac_init_cuesheet_track_iterator :: (pIter: *drflac_cuesheet_track_iterator, trackCount: drflac_uint32, pTrackData: *void) -> void #foreign dr_libs; + +/* Goes to the next cuesheet track in the given iterator. If DRFLAC_FALSE is returned it means there are no more comments. */ +drflac_next_cuesheet_track :: (pIter: *drflac_cuesheet_track_iterator, pCuesheetTrack: *drflac_cuesheet_track) -> drflac_bool32 #foreign dr_libs; + +/* Sized Types */ +drmp3_int8 :: s8; +drmp3_uint8 :: u8; +drmp3_int16 :: s16; +drmp3_uint16 :: u16; +drmp3_int32 :: s32; +drmp3_uint32 :: u32; + +drmp3_int64 :: s64; +drmp3_uint64 :: u64; + +drmp3_uintptr :: drmp3_uint64; + +drmp3_bool8 :: drmp3_uint8; +drmp3_bool32 :: drmp3_uint32; + +/* Result Codes */ +drmp3_result :: drmp3_int32; + +/* End Inline */ +drmp3_version :: (pMajor: *drmp3_uint32, pMinor: *drmp3_uint32, pRevision: *drmp3_uint32) -> void #foreign dr_libs; +drmp3_version_string :: () -> *u8 #foreign dr_libs; + +/* Allocation Callbacks */ +drmp3_allocation_callbacks :: struct { + pUserData: *void; + onMalloc: #type (sz: size_t, pUserData: *void) -> *void #c_call; + onRealloc: #type (p: *void, sz: size_t, pUserData: *void) -> *void #c_call; + onFree: #type (p: *void, pUserData: *void) -> void #c_call; +} + +/* +Low Level Push API +================== +*/ +drmp3dec_frame_info :: struct { + frame_bytes: s32; + channels: s32; + hz: s32; + layer: s32; + bitrate_kbps: s32; +} + +drmp3dec :: struct { + mdct_overlap: [2] [288] float; + qmf_state: [960] float; + reserv: s32; + free_format_bytes: s32; + header: [4] drmp3_uint8; + reserv_buf: [511] drmp3_uint8; +} + +/* Initializes a low level decoder. */ +drmp3dec_init :: (dec: *drmp3dec) -> void #foreign dr_libs; + +/* Reads a frame from a low level decoder. */ +drmp3dec_decode_frame :: (dec: *drmp3dec, mp3: *drmp3_uint8, mp3_bytes: s32, pcm: *void, info: *drmp3dec_frame_info) -> s32 #foreign dr_libs; + +/* Helper for converting between f32 and s16. */ +drmp3dec_f32_to_s16 :: (in: *float, out: *drmp3_int16, num_samples: size_t) -> void #foreign dr_libs; + +/* +Main API (Pull API) +=================== +*/ +drmp3_seek_origin :: enum s32 { + start :: 0; + current :: 1; + + drmp3_seek_origin_start :: start; + drmp3_seek_origin_current :: current; +} + +drmp3_seek_point :: struct { + seekPosInBytes: drmp3_uint64; /* Points to the first byte of an MP3 frame. */ + pcmFrameIndex: drmp3_uint64; /* The index of the PCM frame this seek point targets. */ + mp3FramesToDiscard: drmp3_uint16; /* The number of whole MP3 frames to be discarded before pcmFramesToDiscard. */ + pcmFramesToDiscard: drmp3_uint16; /* The number of leading samples to read and discard. These are discarded after mp3FramesToDiscard. */ +} + +/* +Callback for when data is read. Return value is the number of bytes actually read. + +pUserData [in] The user data that was passed to drmp3_init(), drmp3_open() and family. +pBufferOut [out] The output buffer. +bytesToRead [in] The number of bytes to read. + +Returns the number of bytes actually read. + +A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until +either the entire bytesToRead is filled or you have reached the end of the stream. +*/ +drmp3_read_proc :: #type (pUserData: *void, pBufferOut: *void, bytesToRead: size_t) -> size_t #c_call; + +/* +Callback for when data needs to be seeked. + +pUserData [in] The user data that was passed to drmp3_init(), drmp3_open() and family. +offset [in] The number of bytes to move, relative to the origin. Will never be negative. +origin [in] The origin of the seek - the current position or the start of the stream. + +Returns whether or not the seek was successful. + +Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which +will be either drmp3_seek_origin_start or drmp3_seek_origin_current. +*/ +drmp3_seek_proc :: #type (pUserData: *void, offset: s32, origin: drmp3_seek_origin) -> drmp3_bool32 #c_call; + +drmp3_config :: struct { + channels: drmp3_uint32; + sampleRate: drmp3_uint32; +} + +drmp3 :: struct { + decoder: drmp3dec; + channels: drmp3_uint32; + sampleRate: drmp3_uint32; + onRead: drmp3_read_proc; + onSeek: drmp3_seek_proc; + pUserData: *void; + allocationCallbacks: drmp3_allocation_callbacks; + mp3FrameChannels: drmp3_uint32; /* The number of channels in the currently loaded MP3 frame. Internal use only. */ + mp3FrameSampleRate: drmp3_uint32; /* The sample rate of the currently loaded MP3 frame. Internal use only. */ + pcmFramesConsumedInMP3Frame: drmp3_uint32; + pcmFramesRemainingInMP3Frame: drmp3_uint32; + pcmFrames: [9216] drmp3_uint8; /* <-- Multipled by sizeof(float) to ensure there's enough room for DR_MP3_FLOAT_OUTPUT. */ + currentPCMFrame: drmp3_uint64; /* The current PCM frame, globally, based on the output sample rate. Mainly used for seeking. */ + streamCursor: drmp3_uint64; /* The current byte the decoder is sitting on in the raw stream. */ + pSeekPoints: *drmp3_seek_point; /* NULL by default. Set with drmp3_bind_seek_table(). Memory is owned by the client. dr_mp3 will never attempt to free this pointer. */ + seekPointCount: drmp3_uint32; /* The number of items in pSeekPoints. When set to 0 assumes to no seek table. Defaults to zero. */ + dataSize: size_t; + dataCapacity: size_t; + dataConsumed: size_t; + pData: *drmp3_uint8; + atEnd: drmp3_bool32; + memory: struct { + pData: *drmp3_uint8; + dataSize: size_t; + currentReadPos: size_t; + }; /* Only used for decoders that were opened against a block of memory. */ +} + +/* +Initializes an MP3 decoder. + +onRead [in] The function to call when data needs to be read from the client. +onSeek [in] The function to call when the read position of the client data needs to move. +pUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek. + +Returns true if successful; false otherwise. + +Close the loader with drmp3_uninit(). + +See also: drmp3_init_file(), drmp3_init_memory(), drmp3_uninit() +*/ +drmp3_init :: (pMP3: *drmp3, onRead: drmp3_read_proc, onSeek: drmp3_seek_proc, pUserData: *void, pAllocationCallbacks: *drmp3_allocation_callbacks) -> drmp3_bool32 #foreign dr_libs; + +/* +Initializes an MP3 decoder from a block of memory. + +This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for +the lifetime of the drmp3 object. + +The buffer should contain the contents of the entire MP3 file. +*/ +drmp3_init_memory :: (pMP3: *drmp3, pData: *void, dataSize: size_t, pAllocationCallbacks: *drmp3_allocation_callbacks) -> drmp3_bool32 #foreign dr_libs; + +/* +Initializes an MP3 decoder from a file. + +This holds the internal FILE object until drmp3_uninit() is called. Keep this in mind if you're caching drmp3 +objects because the operating system may restrict the number of file handles an application can have open at +any given time. +*/ +drmp3_init_file :: (pMP3: *drmp3, pFilePath: *u8, pAllocationCallbacks: *drmp3_allocation_callbacks) -> drmp3_bool32 #foreign dr_libs; +drmp3_init_file_w :: (pMP3: *drmp3, pFilePath: *wchar_t, pAllocationCallbacks: *drmp3_allocation_callbacks) -> drmp3_bool32 #foreign dr_libs; + +/* +Uninitializes an MP3 decoder. +*/ +drmp3_uninit :: (pMP3: *drmp3) -> void #foreign dr_libs; + +/* +Reads PCM frames as interleaved 32-bit IEEE floating point PCM. + +Note that framesToRead specifies the number of PCM frames to read, _not_ the number of MP3 frames. +*/ +drmp3_read_pcm_frames_f32 :: (pMP3: *drmp3, framesToRead: drmp3_uint64, pBufferOut: *float) -> drmp3_uint64 #foreign dr_libs; + +/* +Reads PCM frames as interleaved signed 16-bit integer PCM. + +Note that framesToRead specifies the number of PCM frames to read, _not_ the number of MP3 frames. +*/ +drmp3_read_pcm_frames_s16 :: (pMP3: *drmp3, framesToRead: drmp3_uint64, pBufferOut: *drmp3_int16) -> drmp3_uint64 #foreign dr_libs; + +/* +Seeks to a specific frame. + +Note that this is _not_ an MP3 frame, but rather a PCM frame. +*/ +drmp3_seek_to_pcm_frame :: (pMP3: *drmp3, frameIndex: drmp3_uint64) -> drmp3_bool32 #foreign dr_libs; + +/* +Calculates the total number of PCM frames in the MP3 stream. Cannot be used for infinite streams such as internet +radio. Runs in linear time. Returns 0 on error. +*/ +drmp3_get_pcm_frame_count :: (pMP3: *drmp3) -> drmp3_uint64 #foreign dr_libs; + +/* +Calculates the total number of MP3 frames in the MP3 stream. Cannot be used for infinite streams such as internet +radio. Runs in linear time. Returns 0 on error. +*/ +drmp3_get_mp3_frame_count :: (pMP3: *drmp3) -> drmp3_uint64 #foreign dr_libs; + +/* +Calculates the total number of MP3 and PCM frames in the MP3 stream. Cannot be used for infinite streams such as internet +radio. Runs in linear time. Returns 0 on error. + +This is equivalent to calling drmp3_get_mp3_frame_count() and drmp3_get_pcm_frame_count() except that it's more efficient. +*/ +drmp3_get_mp3_and_pcm_frame_count :: (pMP3: *drmp3, pMP3FrameCount: *drmp3_uint64, pPCMFrameCount: *drmp3_uint64) -> drmp3_bool32 #foreign dr_libs; + +/* +Calculates the seekpoints based on PCM frames. This is slow. + +pSeekpoint count is a pointer to a uint32 containing the seekpoint count. On input it contains the desired count. +On output it contains the actual count. The reason for this design is that the client may request too many +seekpoints, in which case dr_mp3 will return a corrected count. + +Note that seektable seeking is not quite sample exact when the MP3 stream contains inconsistent sample rates. +*/ +drmp3_calculate_seek_points :: (pMP3: *drmp3, pSeekPointCount: *drmp3_uint32, pSeekPoints: *drmp3_seek_point) -> drmp3_bool32 #foreign dr_libs; + +/* +Binds a seek table to the decoder. + +This does _not_ make a copy of pSeekPoints - it only references it. It is up to the application to ensure this +remains valid while it is bound to the decoder. + +Use drmp3_calculate_seek_points() to calculate the seek points. +*/ +drmp3_bind_seek_table :: (pMP3: *drmp3, seekPointCount: drmp3_uint32, pSeekPoints: *drmp3_seek_point) -> drmp3_bool32 #foreign dr_libs; + +/* +Opens an decodes an entire MP3 stream as a single operation. + +On output pConfig will receive the channel count and sample rate of the stream. + +Free the returned pointer with drmp3_free(). +*/ +drmp3_open_and_read_pcm_frames_f32 :: (onRead: drmp3_read_proc, onSeek: drmp3_seek_proc, pUserData: *void, pConfig: *drmp3_config, pTotalFrameCount: *drmp3_uint64, pAllocationCallbacks: *drmp3_allocation_callbacks) -> *float #foreign dr_libs; +drmp3_open_and_read_pcm_frames_s16 :: (onRead: drmp3_read_proc, onSeek: drmp3_seek_proc, pUserData: *void, pConfig: *drmp3_config, pTotalFrameCount: *drmp3_uint64, pAllocationCallbacks: *drmp3_allocation_callbacks) -> *drmp3_int16 #foreign dr_libs; + +drmp3_open_memory_and_read_pcm_frames_f32 :: (pData: *void, dataSize: size_t, pConfig: *drmp3_config, pTotalFrameCount: *drmp3_uint64, pAllocationCallbacks: *drmp3_allocation_callbacks) -> *float #foreign dr_libs; +drmp3_open_memory_and_read_pcm_frames_s16 :: (pData: *void, dataSize: size_t, pConfig: *drmp3_config, pTotalFrameCount: *drmp3_uint64, pAllocationCallbacks: *drmp3_allocation_callbacks) -> *drmp3_int16 #foreign dr_libs; + +drmp3_open_file_and_read_pcm_frames_f32 :: (filePath: *u8, pConfig: *drmp3_config, pTotalFrameCount: *drmp3_uint64, pAllocationCallbacks: *drmp3_allocation_callbacks) -> *float #foreign dr_libs; +drmp3_open_file_and_read_pcm_frames_s16 :: (filePath: *u8, pConfig: *drmp3_config, pTotalFrameCount: *drmp3_uint64, pAllocationCallbacks: *drmp3_allocation_callbacks) -> *drmp3_int16 #foreign dr_libs; + +/* +Allocates a block of memory on the heap. +*/ +drmp3_malloc :: (sz: size_t, pAllocationCallbacks: *drmp3_allocation_callbacks) -> *void #foreign dr_libs; + +/* +Frees any memory that was allocated by a public drmp3 API. +*/ +drmp3_free :: (p: *void, pAllocationCallbacks: *drmp3_allocation_callbacks) -> void #foreign dr_libs; + +#scope_file + +#import "Basic"; // For assert + +dr_libs :: #library,no_dll "windows/dr_libs"; + +#run { + { + instance: drwav_allocation_callbacks; + assert(((cast(*void)(*instance.pUserData)) - cast(*void)(*instance)) == 0, "drwav_allocation_callbacks.pUserData has unexpected offset % instead of 0", ((cast(*void)(*instance.pUserData)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_allocation_callbacks.pUserData)) == 8, "drwav_allocation_callbacks.pUserData has unexpected size % instead of 8", size_of(type_of(drwav_allocation_callbacks.pUserData))); + assert(((cast(*void)(*instance.onMalloc)) - cast(*void)(*instance)) == 8, "drwav_allocation_callbacks.onMalloc has unexpected offset % instead of 8", ((cast(*void)(*instance.onMalloc)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_allocation_callbacks.onMalloc)) == 8, "drwav_allocation_callbacks.onMalloc has unexpected size % instead of 8", size_of(type_of(drwav_allocation_callbacks.onMalloc))); + assert(((cast(*void)(*instance.onRealloc)) - cast(*void)(*instance)) == 16, "drwav_allocation_callbacks.onRealloc has unexpected offset % instead of 16", ((cast(*void)(*instance.onRealloc)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_allocation_callbacks.onRealloc)) == 8, "drwav_allocation_callbacks.onRealloc has unexpected size % instead of 8", size_of(type_of(drwav_allocation_callbacks.onRealloc))); + assert(((cast(*void)(*instance.onFree)) - cast(*void)(*instance)) == 24, "drwav_allocation_callbacks.onFree has unexpected offset % instead of 24", ((cast(*void)(*instance.onFree)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_allocation_callbacks.onFree)) == 8, "drwav_allocation_callbacks.onFree has unexpected size % instead of 8", size_of(type_of(drwav_allocation_callbacks.onFree))); + assert(size_of(drwav_allocation_callbacks) == 32, "drwav_allocation_callbacks has size % instead of 32", size_of(drwav_allocation_callbacks)); + } + + { + instance: drwav_chunk_header; + assert(((cast(*void)(*instance.id)) - cast(*void)(*instance)) == 0, "drwav_chunk_header.id has unexpected offset % instead of 0", ((cast(*void)(*instance.id)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_chunk_header.id)) == 16, "drwav_chunk_header.id has unexpected size % instead of 16", size_of(type_of(drwav_chunk_header.id))); + assert(((cast(*void)(*instance.sizeInBytes)) - cast(*void)(*instance)) == 16, "drwav_chunk_header.sizeInBytes has unexpected offset % instead of 16", ((cast(*void)(*instance.sizeInBytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_chunk_header.sizeInBytes)) == 8, "drwav_chunk_header.sizeInBytes has unexpected size % instead of 8", size_of(type_of(drwav_chunk_header.sizeInBytes))); + assert(((cast(*void)(*instance.paddingSize)) - cast(*void)(*instance)) == 24, "drwav_chunk_header.paddingSize has unexpected offset % instead of 24", ((cast(*void)(*instance.paddingSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_chunk_header.paddingSize)) == 4, "drwav_chunk_header.paddingSize has unexpected size % instead of 4", size_of(type_of(drwav_chunk_header.paddingSize))); + assert(size_of(drwav_chunk_header) == 32, "drwav_chunk_header has size % instead of 32", size_of(drwav_chunk_header)); + } + + { + instance: drwav_fmt; + assert(((cast(*void)(*instance.formatTag)) - cast(*void)(*instance)) == 0, "drwav_fmt.formatTag has unexpected offset % instead of 0", ((cast(*void)(*instance.formatTag)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.formatTag)) == 2, "drwav_fmt.formatTag has unexpected size % instead of 2", size_of(type_of(drwav_fmt.formatTag))); + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 2, "drwav_fmt.channels has unexpected offset % instead of 2", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.channels)) == 2, "drwav_fmt.channels has unexpected size % instead of 2", size_of(type_of(drwav_fmt.channels))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 4, "drwav_fmt.sampleRate has unexpected offset % instead of 4", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.sampleRate)) == 4, "drwav_fmt.sampleRate has unexpected size % instead of 4", size_of(type_of(drwav_fmt.sampleRate))); + assert(((cast(*void)(*instance.avgBytesPerSec)) - cast(*void)(*instance)) == 8, "drwav_fmt.avgBytesPerSec has unexpected offset % instead of 8", ((cast(*void)(*instance.avgBytesPerSec)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.avgBytesPerSec)) == 4, "drwav_fmt.avgBytesPerSec has unexpected size % instead of 4", size_of(type_of(drwav_fmt.avgBytesPerSec))); + assert(((cast(*void)(*instance.blockAlign)) - cast(*void)(*instance)) == 12, "drwav_fmt.blockAlign has unexpected offset % instead of 12", ((cast(*void)(*instance.blockAlign)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.blockAlign)) == 2, "drwav_fmt.blockAlign has unexpected size % instead of 2", size_of(type_of(drwav_fmt.blockAlign))); + assert(((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance)) == 14, "drwav_fmt.bitsPerSample has unexpected offset % instead of 14", ((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.bitsPerSample)) == 2, "drwav_fmt.bitsPerSample has unexpected size % instead of 2", size_of(type_of(drwav_fmt.bitsPerSample))); + assert(((cast(*void)(*instance.extendedSize)) - cast(*void)(*instance)) == 16, "drwav_fmt.extendedSize has unexpected offset % instead of 16", ((cast(*void)(*instance.extendedSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.extendedSize)) == 2, "drwav_fmt.extendedSize has unexpected size % instead of 2", size_of(type_of(drwav_fmt.extendedSize))); + assert(((cast(*void)(*instance.validBitsPerSample)) - cast(*void)(*instance)) == 18, "drwav_fmt.validBitsPerSample has unexpected offset % instead of 18", ((cast(*void)(*instance.validBitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.validBitsPerSample)) == 2, "drwav_fmt.validBitsPerSample has unexpected size % instead of 2", size_of(type_of(drwav_fmt.validBitsPerSample))); + assert(((cast(*void)(*instance.channelMask)) - cast(*void)(*instance)) == 20, "drwav_fmt.channelMask has unexpected offset % instead of 20", ((cast(*void)(*instance.channelMask)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.channelMask)) == 4, "drwav_fmt.channelMask has unexpected size % instead of 4", size_of(type_of(drwav_fmt.channelMask))); + assert(((cast(*void)(*instance.subFormat)) - cast(*void)(*instance)) == 24, "drwav_fmt.subFormat has unexpected offset % instead of 24", ((cast(*void)(*instance.subFormat)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_fmt.subFormat)) == 16, "drwav_fmt.subFormat has unexpected size % instead of 16", size_of(type_of(drwav_fmt.subFormat))); + assert(size_of(drwav_fmt) == 40, "drwav_fmt has size % instead of 40", size_of(drwav_fmt)); + } + + { + instance: drwav__memory_stream; + assert(((cast(*void)(*instance.data)) - cast(*void)(*instance)) == 0, "drwav__memory_stream.data has unexpected offset % instead of 0", ((cast(*void)(*instance.data)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream.data)) == 8, "drwav__memory_stream.data has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream.data))); + assert(((cast(*void)(*instance.dataSize)) - cast(*void)(*instance)) == 8, "drwav__memory_stream.dataSize has unexpected offset % instead of 8", ((cast(*void)(*instance.dataSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream.dataSize)) == 8, "drwav__memory_stream.dataSize has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream.dataSize))); + assert(((cast(*void)(*instance.currentReadPos)) - cast(*void)(*instance)) == 16, "drwav__memory_stream.currentReadPos has unexpected offset % instead of 16", ((cast(*void)(*instance.currentReadPos)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream.currentReadPos)) == 8, "drwav__memory_stream.currentReadPos has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream.currentReadPos))); + assert(size_of(drwav__memory_stream) == 24, "drwav__memory_stream has size % instead of 24", size_of(drwav__memory_stream)); + } + + { + instance: drwav__memory_stream_write; + assert(((cast(*void)(*instance.ppData)) - cast(*void)(*instance)) == 0, "drwav__memory_stream_write.ppData has unexpected offset % instead of 0", ((cast(*void)(*instance.ppData)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream_write.ppData)) == 8, "drwav__memory_stream_write.ppData has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream_write.ppData))); + assert(((cast(*void)(*instance.pDataSize)) - cast(*void)(*instance)) == 8, "drwav__memory_stream_write.pDataSize has unexpected offset % instead of 8", ((cast(*void)(*instance.pDataSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream_write.pDataSize)) == 8, "drwav__memory_stream_write.pDataSize has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream_write.pDataSize))); + assert(((cast(*void)(*instance.dataSize)) - cast(*void)(*instance)) == 16, "drwav__memory_stream_write.dataSize has unexpected offset % instead of 16", ((cast(*void)(*instance.dataSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream_write.dataSize)) == 8, "drwav__memory_stream_write.dataSize has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream_write.dataSize))); + assert(((cast(*void)(*instance.dataCapacity)) - cast(*void)(*instance)) == 24, "drwav__memory_stream_write.dataCapacity has unexpected offset % instead of 24", ((cast(*void)(*instance.dataCapacity)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream_write.dataCapacity)) == 8, "drwav__memory_stream_write.dataCapacity has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream_write.dataCapacity))); + assert(((cast(*void)(*instance.currentWritePos)) - cast(*void)(*instance)) == 32, "drwav__memory_stream_write.currentWritePos has unexpected offset % instead of 32", ((cast(*void)(*instance.currentWritePos)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav__memory_stream_write.currentWritePos)) == 8, "drwav__memory_stream_write.currentWritePos has unexpected size % instead of 8", size_of(type_of(drwav__memory_stream_write.currentWritePos))); + assert(size_of(drwav__memory_stream_write) == 40, "drwav__memory_stream_write has size % instead of 40", size_of(drwav__memory_stream_write)); + } + + { + instance: drwav_data_format; + assert(((cast(*void)(*instance.container)) - cast(*void)(*instance)) == 0, "drwav_data_format.container has unexpected offset % instead of 0", ((cast(*void)(*instance.container)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_data_format.container)) == 4, "drwav_data_format.container has unexpected size % instead of 4", size_of(type_of(drwav_data_format.container))); + assert(((cast(*void)(*instance.format)) - cast(*void)(*instance)) == 4, "drwav_data_format.format has unexpected offset % instead of 4", ((cast(*void)(*instance.format)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_data_format.format)) == 4, "drwav_data_format.format has unexpected size % instead of 4", size_of(type_of(drwav_data_format.format))); + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 8, "drwav_data_format.channels has unexpected offset % instead of 8", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_data_format.channels)) == 4, "drwav_data_format.channels has unexpected size % instead of 4", size_of(type_of(drwav_data_format.channels))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 12, "drwav_data_format.sampleRate has unexpected offset % instead of 12", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_data_format.sampleRate)) == 4, "drwav_data_format.sampleRate has unexpected size % instead of 4", size_of(type_of(drwav_data_format.sampleRate))); + assert(((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance)) == 16, "drwav_data_format.bitsPerSample has unexpected offset % instead of 16", ((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_data_format.bitsPerSample)) == 4, "drwav_data_format.bitsPerSample has unexpected size % instead of 4", size_of(type_of(drwav_data_format.bitsPerSample))); + assert(size_of(drwav_data_format) == 20, "drwav_data_format has size % instead of 20", size_of(drwav_data_format)); + } + + { + instance: drwav_smpl_loop; + assert(((cast(*void)(*instance.cuePointId)) - cast(*void)(*instance)) == 0, "drwav_smpl_loop.cuePointId has unexpected offset % instead of 0", ((cast(*void)(*instance.cuePointId)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl_loop.cuePointId)) == 4, "drwav_smpl_loop.cuePointId has unexpected size % instead of 4", size_of(type_of(drwav_smpl_loop.cuePointId))); + assert(((cast(*void)(*instance.type)) - cast(*void)(*instance)) == 4, "drwav_smpl_loop.type has unexpected offset % instead of 4", ((cast(*void)(*instance.type)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl_loop.type)) == 4, "drwav_smpl_loop.type has unexpected size % instead of 4", size_of(type_of(drwav_smpl_loop.type))); + assert(((cast(*void)(*instance.firstSampleByteOffset)) - cast(*void)(*instance)) == 8, "drwav_smpl_loop.firstSampleByteOffset has unexpected offset % instead of 8", ((cast(*void)(*instance.firstSampleByteOffset)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl_loop.firstSampleByteOffset)) == 4, "drwav_smpl_loop.firstSampleByteOffset has unexpected size % instead of 4", size_of(type_of(drwav_smpl_loop.firstSampleByteOffset))); + assert(((cast(*void)(*instance.lastSampleByteOffset)) - cast(*void)(*instance)) == 12, "drwav_smpl_loop.lastSampleByteOffset has unexpected offset % instead of 12", ((cast(*void)(*instance.lastSampleByteOffset)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl_loop.lastSampleByteOffset)) == 4, "drwav_smpl_loop.lastSampleByteOffset has unexpected size % instead of 4", size_of(type_of(drwav_smpl_loop.lastSampleByteOffset))); + assert(((cast(*void)(*instance.sampleFraction)) - cast(*void)(*instance)) == 16, "drwav_smpl_loop.sampleFraction has unexpected offset % instead of 16", ((cast(*void)(*instance.sampleFraction)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl_loop.sampleFraction)) == 4, "drwav_smpl_loop.sampleFraction has unexpected size % instead of 4", size_of(type_of(drwav_smpl_loop.sampleFraction))); + assert(((cast(*void)(*instance.playCount)) - cast(*void)(*instance)) == 20, "drwav_smpl_loop.playCount has unexpected offset % instead of 20", ((cast(*void)(*instance.playCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl_loop.playCount)) == 4, "drwav_smpl_loop.playCount has unexpected size % instead of 4", size_of(type_of(drwav_smpl_loop.playCount))); + assert(size_of(drwav_smpl_loop) == 24, "drwav_smpl_loop has size % instead of 24", size_of(drwav_smpl_loop)); + } + + { + instance: drwav_smpl; + assert(((cast(*void)(*instance.manufacturerId)) - cast(*void)(*instance)) == 0, "drwav_smpl.manufacturerId has unexpected offset % instead of 0", ((cast(*void)(*instance.manufacturerId)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.manufacturerId)) == 4, "drwav_smpl.manufacturerId has unexpected size % instead of 4", size_of(type_of(drwav_smpl.manufacturerId))); + assert(((cast(*void)(*instance.productId)) - cast(*void)(*instance)) == 4, "drwav_smpl.productId has unexpected offset % instead of 4", ((cast(*void)(*instance.productId)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.productId)) == 4, "drwav_smpl.productId has unexpected size % instead of 4", size_of(type_of(drwav_smpl.productId))); + assert(((cast(*void)(*instance.samplePeriodNanoseconds)) - cast(*void)(*instance)) == 8, "drwav_smpl.samplePeriodNanoseconds has unexpected offset % instead of 8", ((cast(*void)(*instance.samplePeriodNanoseconds)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.samplePeriodNanoseconds)) == 4, "drwav_smpl.samplePeriodNanoseconds has unexpected size % instead of 4", size_of(type_of(drwav_smpl.samplePeriodNanoseconds))); + assert(((cast(*void)(*instance.midiUnityNote)) - cast(*void)(*instance)) == 12, "drwav_smpl.midiUnityNote has unexpected offset % instead of 12", ((cast(*void)(*instance.midiUnityNote)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.midiUnityNote)) == 4, "drwav_smpl.midiUnityNote has unexpected size % instead of 4", size_of(type_of(drwav_smpl.midiUnityNote))); + assert(((cast(*void)(*instance.midiPitchFraction)) - cast(*void)(*instance)) == 16, "drwav_smpl.midiPitchFraction has unexpected offset % instead of 16", ((cast(*void)(*instance.midiPitchFraction)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.midiPitchFraction)) == 4, "drwav_smpl.midiPitchFraction has unexpected size % instead of 4", size_of(type_of(drwav_smpl.midiPitchFraction))); + assert(((cast(*void)(*instance.smpteFormat)) - cast(*void)(*instance)) == 20, "drwav_smpl.smpteFormat has unexpected offset % instead of 20", ((cast(*void)(*instance.smpteFormat)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.smpteFormat)) == 4, "drwav_smpl.smpteFormat has unexpected size % instead of 4", size_of(type_of(drwav_smpl.smpteFormat))); + assert(((cast(*void)(*instance.smpteOffset)) - cast(*void)(*instance)) == 24, "drwav_smpl.smpteOffset has unexpected offset % instead of 24", ((cast(*void)(*instance.smpteOffset)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.smpteOffset)) == 4, "drwav_smpl.smpteOffset has unexpected size % instead of 4", size_of(type_of(drwav_smpl.smpteOffset))); + assert(((cast(*void)(*instance.sampleLoopCount)) - cast(*void)(*instance)) == 28, "drwav_smpl.sampleLoopCount has unexpected offset % instead of 28", ((cast(*void)(*instance.sampleLoopCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.sampleLoopCount)) == 4, "drwav_smpl.sampleLoopCount has unexpected size % instead of 4", size_of(type_of(drwav_smpl.sampleLoopCount))); + assert(((cast(*void)(*instance.samplerSpecificDataSizeInBytes)) - cast(*void)(*instance)) == 32, "drwav_smpl.samplerSpecificDataSizeInBytes has unexpected offset % instead of 32", ((cast(*void)(*instance.samplerSpecificDataSizeInBytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.samplerSpecificDataSizeInBytes)) == 4, "drwav_smpl.samplerSpecificDataSizeInBytes has unexpected size % instead of 4", size_of(type_of(drwav_smpl.samplerSpecificDataSizeInBytes))); + assert(((cast(*void)(*instance.pLoops)) - cast(*void)(*instance)) == 40, "drwav_smpl.pLoops has unexpected offset % instead of 40", ((cast(*void)(*instance.pLoops)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.pLoops)) == 8, "drwav_smpl.pLoops has unexpected size % instead of 8", size_of(type_of(drwav_smpl.pLoops))); + assert(((cast(*void)(*instance.pSamplerSpecificData)) - cast(*void)(*instance)) == 48, "drwav_smpl.pSamplerSpecificData has unexpected offset % instead of 48", ((cast(*void)(*instance.pSamplerSpecificData)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_smpl.pSamplerSpecificData)) == 8, "drwav_smpl.pSamplerSpecificData has unexpected size % instead of 8", size_of(type_of(drwav_smpl.pSamplerSpecificData))); + assert(size_of(drwav_smpl) == 56, "drwav_smpl has size % instead of 56", size_of(drwav_smpl)); + } + + { + instance: drwav_inst; + assert(((cast(*void)(*instance.midiUnityNote)) - cast(*void)(*instance)) == 0, "drwav_inst.midiUnityNote has unexpected offset % instead of 0", ((cast(*void)(*instance.midiUnityNote)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_inst.midiUnityNote)) == 1, "drwav_inst.midiUnityNote has unexpected size % instead of 1", size_of(type_of(drwav_inst.midiUnityNote))); + assert(((cast(*void)(*instance.fineTuneCents)) - cast(*void)(*instance)) == 1, "drwav_inst.fineTuneCents has unexpected offset % instead of 1", ((cast(*void)(*instance.fineTuneCents)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_inst.fineTuneCents)) == 1, "drwav_inst.fineTuneCents has unexpected size % instead of 1", size_of(type_of(drwav_inst.fineTuneCents))); + assert(((cast(*void)(*instance.gainDecibels)) - cast(*void)(*instance)) == 2, "drwav_inst.gainDecibels has unexpected offset % instead of 2", ((cast(*void)(*instance.gainDecibels)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_inst.gainDecibels)) == 1, "drwav_inst.gainDecibels has unexpected size % instead of 1", size_of(type_of(drwav_inst.gainDecibels))); + assert(((cast(*void)(*instance.lowNote)) - cast(*void)(*instance)) == 3, "drwav_inst.lowNote has unexpected offset % instead of 3", ((cast(*void)(*instance.lowNote)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_inst.lowNote)) == 1, "drwav_inst.lowNote has unexpected size % instead of 1", size_of(type_of(drwav_inst.lowNote))); + assert(((cast(*void)(*instance.highNote)) - cast(*void)(*instance)) == 4, "drwav_inst.highNote has unexpected offset % instead of 4", ((cast(*void)(*instance.highNote)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_inst.highNote)) == 1, "drwav_inst.highNote has unexpected size % instead of 1", size_of(type_of(drwav_inst.highNote))); + assert(((cast(*void)(*instance.lowVelocity)) - cast(*void)(*instance)) == 5, "drwav_inst.lowVelocity has unexpected offset % instead of 5", ((cast(*void)(*instance.lowVelocity)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_inst.lowVelocity)) == 1, "drwav_inst.lowVelocity has unexpected size % instead of 1", size_of(type_of(drwav_inst.lowVelocity))); + assert(((cast(*void)(*instance.highVelocity)) - cast(*void)(*instance)) == 6, "drwav_inst.highVelocity has unexpected offset % instead of 6", ((cast(*void)(*instance.highVelocity)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_inst.highVelocity)) == 1, "drwav_inst.highVelocity has unexpected size % instead of 1", size_of(type_of(drwav_inst.highVelocity))); + assert(size_of(drwav_inst) == 7, "drwav_inst has size % instead of 7", size_of(drwav_inst)); + } + + { + instance: drwav_cue_point; + assert(((cast(*void)(*instance.id)) - cast(*void)(*instance)) == 0, "drwav_cue_point.id has unexpected offset % instead of 0", ((cast(*void)(*instance.id)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue_point.id)) == 4, "drwav_cue_point.id has unexpected size % instead of 4", size_of(type_of(drwav_cue_point.id))); + assert(((cast(*void)(*instance.playOrderPosition)) - cast(*void)(*instance)) == 4, "drwav_cue_point.playOrderPosition has unexpected offset % instead of 4", ((cast(*void)(*instance.playOrderPosition)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue_point.playOrderPosition)) == 4, "drwav_cue_point.playOrderPosition has unexpected size % instead of 4", size_of(type_of(drwav_cue_point.playOrderPosition))); + assert(((cast(*void)(*instance.dataChunkId)) - cast(*void)(*instance)) == 8, "drwav_cue_point.dataChunkId has unexpected offset % instead of 8", ((cast(*void)(*instance.dataChunkId)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue_point.dataChunkId)) == 4, "drwav_cue_point.dataChunkId has unexpected size % instead of 4", size_of(type_of(drwav_cue_point.dataChunkId))); + assert(((cast(*void)(*instance.chunkStart)) - cast(*void)(*instance)) == 12, "drwav_cue_point.chunkStart has unexpected offset % instead of 12", ((cast(*void)(*instance.chunkStart)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue_point.chunkStart)) == 4, "drwav_cue_point.chunkStart has unexpected size % instead of 4", size_of(type_of(drwav_cue_point.chunkStart))); + assert(((cast(*void)(*instance.blockStart)) - cast(*void)(*instance)) == 16, "drwav_cue_point.blockStart has unexpected offset % instead of 16", ((cast(*void)(*instance.blockStart)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue_point.blockStart)) == 4, "drwav_cue_point.blockStart has unexpected size % instead of 4", size_of(type_of(drwav_cue_point.blockStart))); + assert(((cast(*void)(*instance.sampleByteOffset)) - cast(*void)(*instance)) == 20, "drwav_cue_point.sampleByteOffset has unexpected offset % instead of 20", ((cast(*void)(*instance.sampleByteOffset)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue_point.sampleByteOffset)) == 4, "drwav_cue_point.sampleByteOffset has unexpected size % instead of 4", size_of(type_of(drwav_cue_point.sampleByteOffset))); + assert(size_of(drwav_cue_point) == 24, "drwav_cue_point has size % instead of 24", size_of(drwav_cue_point)); + } + + { + instance: drwav_cue; + assert(((cast(*void)(*instance.cuePointCount)) - cast(*void)(*instance)) == 0, "drwav_cue.cuePointCount has unexpected offset % instead of 0", ((cast(*void)(*instance.cuePointCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue.cuePointCount)) == 4, "drwav_cue.cuePointCount has unexpected size % instead of 4", size_of(type_of(drwav_cue.cuePointCount))); + assert(((cast(*void)(*instance.pCuePoints)) - cast(*void)(*instance)) == 8, "drwav_cue.pCuePoints has unexpected offset % instead of 8", ((cast(*void)(*instance.pCuePoints)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_cue.pCuePoints)) == 8, "drwav_cue.pCuePoints has unexpected size % instead of 8", size_of(type_of(drwav_cue.pCuePoints))); + assert(size_of(drwav_cue) == 16, "drwav_cue has size % instead of 16", size_of(drwav_cue)); + } + + { + instance: drwav_acid; + assert(((cast(*void)(*instance.flags)) - cast(*void)(*instance)) == 0, "drwav_acid.flags has unexpected offset % instead of 0", ((cast(*void)(*instance.flags)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.flags)) == 4, "drwav_acid.flags has unexpected size % instead of 4", size_of(type_of(drwav_acid.flags))); + assert(((cast(*void)(*instance.midiUnityNote)) - cast(*void)(*instance)) == 4, "drwav_acid.midiUnityNote has unexpected offset % instead of 4", ((cast(*void)(*instance.midiUnityNote)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.midiUnityNote)) == 2, "drwav_acid.midiUnityNote has unexpected size % instead of 2", size_of(type_of(drwav_acid.midiUnityNote))); + assert(((cast(*void)(*instance.reserved1)) - cast(*void)(*instance)) == 6, "drwav_acid.reserved1 has unexpected offset % instead of 6", ((cast(*void)(*instance.reserved1)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.reserved1)) == 2, "drwav_acid.reserved1 has unexpected size % instead of 2", size_of(type_of(drwav_acid.reserved1))); + assert(((cast(*void)(*instance.reserved2)) - cast(*void)(*instance)) == 8, "drwav_acid.reserved2 has unexpected offset % instead of 8", ((cast(*void)(*instance.reserved2)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.reserved2)) == 4, "drwav_acid.reserved2 has unexpected size % instead of 4", size_of(type_of(drwav_acid.reserved2))); + assert(((cast(*void)(*instance.numBeats)) - cast(*void)(*instance)) == 12, "drwav_acid.numBeats has unexpected offset % instead of 12", ((cast(*void)(*instance.numBeats)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.numBeats)) == 4, "drwav_acid.numBeats has unexpected size % instead of 4", size_of(type_of(drwav_acid.numBeats))); + assert(((cast(*void)(*instance.meterDenominator)) - cast(*void)(*instance)) == 16, "drwav_acid.meterDenominator has unexpected offset % instead of 16", ((cast(*void)(*instance.meterDenominator)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.meterDenominator)) == 2, "drwav_acid.meterDenominator has unexpected size % instead of 2", size_of(type_of(drwav_acid.meterDenominator))); + assert(((cast(*void)(*instance.meterNumerator)) - cast(*void)(*instance)) == 18, "drwav_acid.meterNumerator has unexpected offset % instead of 18", ((cast(*void)(*instance.meterNumerator)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.meterNumerator)) == 2, "drwav_acid.meterNumerator has unexpected size % instead of 2", size_of(type_of(drwav_acid.meterNumerator))); + assert(((cast(*void)(*instance.tempo)) - cast(*void)(*instance)) == 20, "drwav_acid.tempo has unexpected offset % instead of 20", ((cast(*void)(*instance.tempo)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_acid.tempo)) == 4, "drwav_acid.tempo has unexpected size % instead of 4", size_of(type_of(drwav_acid.tempo))); + assert(size_of(drwav_acid) == 24, "drwav_acid has size % instead of 24", size_of(drwav_acid)); + } + + { + instance: drwav_list_label_or_note; + assert(((cast(*void)(*instance.cuePointId)) - cast(*void)(*instance)) == 0, "drwav_list_label_or_note.cuePointId has unexpected offset % instead of 0", ((cast(*void)(*instance.cuePointId)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_label_or_note.cuePointId)) == 4, "drwav_list_label_or_note.cuePointId has unexpected size % instead of 4", size_of(type_of(drwav_list_label_or_note.cuePointId))); + assert(((cast(*void)(*instance.stringLength)) - cast(*void)(*instance)) == 4, "drwav_list_label_or_note.stringLength has unexpected offset % instead of 4", ((cast(*void)(*instance.stringLength)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_label_or_note.stringLength)) == 4, "drwav_list_label_or_note.stringLength has unexpected size % instead of 4", size_of(type_of(drwav_list_label_or_note.stringLength))); + assert(((cast(*void)(*instance.pString)) - cast(*void)(*instance)) == 8, "drwav_list_label_or_note.pString has unexpected offset % instead of 8", ((cast(*void)(*instance.pString)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_label_or_note.pString)) == 8, "drwav_list_label_or_note.pString has unexpected size % instead of 8", size_of(type_of(drwav_list_label_or_note.pString))); + assert(size_of(drwav_list_label_or_note) == 16, "drwav_list_label_or_note has size % instead of 16", size_of(drwav_list_label_or_note)); + } + + { + instance: drwav_bext; + assert(((cast(*void)(*instance.pDescription)) - cast(*void)(*instance)) == 0, "drwav_bext.pDescription has unexpected offset % instead of 0", ((cast(*void)(*instance.pDescription)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.pDescription)) == 8, "drwav_bext.pDescription has unexpected size % instead of 8", size_of(type_of(drwav_bext.pDescription))); + assert(((cast(*void)(*instance.pOriginatorName)) - cast(*void)(*instance)) == 8, "drwav_bext.pOriginatorName has unexpected offset % instead of 8", ((cast(*void)(*instance.pOriginatorName)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.pOriginatorName)) == 8, "drwav_bext.pOriginatorName has unexpected size % instead of 8", size_of(type_of(drwav_bext.pOriginatorName))); + assert(((cast(*void)(*instance.pOriginatorReference)) - cast(*void)(*instance)) == 16, "drwav_bext.pOriginatorReference has unexpected offset % instead of 16", ((cast(*void)(*instance.pOriginatorReference)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.pOriginatorReference)) == 8, "drwav_bext.pOriginatorReference has unexpected size % instead of 8", size_of(type_of(drwav_bext.pOriginatorReference))); + assert(((cast(*void)(*instance.pOriginationDate)) - cast(*void)(*instance)) == 24, "drwav_bext.pOriginationDate has unexpected offset % instead of 24", ((cast(*void)(*instance.pOriginationDate)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.pOriginationDate)) == 10, "drwav_bext.pOriginationDate has unexpected size % instead of 10", size_of(type_of(drwav_bext.pOriginationDate))); + assert(((cast(*void)(*instance.pOriginationTime)) - cast(*void)(*instance)) == 34, "drwav_bext.pOriginationTime has unexpected offset % instead of 34", ((cast(*void)(*instance.pOriginationTime)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.pOriginationTime)) == 8, "drwav_bext.pOriginationTime has unexpected size % instead of 8", size_of(type_of(drwav_bext.pOriginationTime))); + assert(((cast(*void)(*instance.timeReference)) - cast(*void)(*instance)) == 48, "drwav_bext.timeReference has unexpected offset % instead of 48", ((cast(*void)(*instance.timeReference)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.timeReference)) == 8, "drwav_bext.timeReference has unexpected size % instead of 8", size_of(type_of(drwav_bext.timeReference))); + assert(((cast(*void)(*instance.version)) - cast(*void)(*instance)) == 56, "drwav_bext.version has unexpected offset % instead of 56", ((cast(*void)(*instance.version)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.version)) == 2, "drwav_bext.version has unexpected size % instead of 2", size_of(type_of(drwav_bext.version))); + assert(((cast(*void)(*instance.pCodingHistory)) - cast(*void)(*instance)) == 64, "drwav_bext.pCodingHistory has unexpected offset % instead of 64", ((cast(*void)(*instance.pCodingHistory)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.pCodingHistory)) == 8, "drwav_bext.pCodingHistory has unexpected size % instead of 8", size_of(type_of(drwav_bext.pCodingHistory))); + assert(((cast(*void)(*instance.codingHistorySize)) - cast(*void)(*instance)) == 72, "drwav_bext.codingHistorySize has unexpected offset % instead of 72", ((cast(*void)(*instance.codingHistorySize)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.codingHistorySize)) == 4, "drwav_bext.codingHistorySize has unexpected size % instead of 4", size_of(type_of(drwav_bext.codingHistorySize))); + assert(((cast(*void)(*instance.pUMID)) - cast(*void)(*instance)) == 80, "drwav_bext.pUMID has unexpected offset % instead of 80", ((cast(*void)(*instance.pUMID)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.pUMID)) == 8, "drwav_bext.pUMID has unexpected size % instead of 8", size_of(type_of(drwav_bext.pUMID))); + assert(((cast(*void)(*instance.loudnessValue)) - cast(*void)(*instance)) == 88, "drwav_bext.loudnessValue has unexpected offset % instead of 88", ((cast(*void)(*instance.loudnessValue)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.loudnessValue)) == 2, "drwav_bext.loudnessValue has unexpected size % instead of 2", size_of(type_of(drwav_bext.loudnessValue))); + assert(((cast(*void)(*instance.loudnessRange)) - cast(*void)(*instance)) == 90, "drwav_bext.loudnessRange has unexpected offset % instead of 90", ((cast(*void)(*instance.loudnessRange)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.loudnessRange)) == 2, "drwav_bext.loudnessRange has unexpected size % instead of 2", size_of(type_of(drwav_bext.loudnessRange))); + assert(((cast(*void)(*instance.maxTruePeakLevel)) - cast(*void)(*instance)) == 92, "drwav_bext.maxTruePeakLevel has unexpected offset % instead of 92", ((cast(*void)(*instance.maxTruePeakLevel)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.maxTruePeakLevel)) == 2, "drwav_bext.maxTruePeakLevel has unexpected size % instead of 2", size_of(type_of(drwav_bext.maxTruePeakLevel))); + assert(((cast(*void)(*instance.maxMomentaryLoudness)) - cast(*void)(*instance)) == 94, "drwav_bext.maxMomentaryLoudness has unexpected offset % instead of 94", ((cast(*void)(*instance.maxMomentaryLoudness)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.maxMomentaryLoudness)) == 2, "drwav_bext.maxMomentaryLoudness has unexpected size % instead of 2", size_of(type_of(drwav_bext.maxMomentaryLoudness))); + assert(((cast(*void)(*instance.maxShortTermLoudness)) - cast(*void)(*instance)) == 96, "drwav_bext.maxShortTermLoudness has unexpected offset % instead of 96", ((cast(*void)(*instance.maxShortTermLoudness)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_bext.maxShortTermLoudness)) == 2, "drwav_bext.maxShortTermLoudness has unexpected size % instead of 2", size_of(type_of(drwav_bext.maxShortTermLoudness))); + assert(size_of(drwav_bext) == 104, "drwav_bext has size % instead of 104", size_of(drwav_bext)); + } + + { + instance: drwav_list_info_text; + assert(((cast(*void)(*instance.stringLength)) - cast(*void)(*instance)) == 0, "drwav_list_info_text.stringLength has unexpected offset % instead of 0", ((cast(*void)(*instance.stringLength)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_info_text.stringLength)) == 4, "drwav_list_info_text.stringLength has unexpected size % instead of 4", size_of(type_of(drwav_list_info_text.stringLength))); + assert(((cast(*void)(*instance.pString)) - cast(*void)(*instance)) == 8, "drwav_list_info_text.pString has unexpected offset % instead of 8", ((cast(*void)(*instance.pString)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_info_text.pString)) == 8, "drwav_list_info_text.pString has unexpected size % instead of 8", size_of(type_of(drwav_list_info_text.pString))); + assert(size_of(drwav_list_info_text) == 16, "drwav_list_info_text has size % instead of 16", size_of(drwav_list_info_text)); + } + + { + instance: drwav_list_labelled_cue_region; + assert(((cast(*void)(*instance.cuePointId)) - cast(*void)(*instance)) == 0, "drwav_list_labelled_cue_region.cuePointId has unexpected offset % instead of 0", ((cast(*void)(*instance.cuePointId)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.cuePointId)) == 4, "drwav_list_labelled_cue_region.cuePointId has unexpected size % instead of 4", size_of(type_of(drwav_list_labelled_cue_region.cuePointId))); + assert(((cast(*void)(*instance.sampleLength)) - cast(*void)(*instance)) == 4, "drwav_list_labelled_cue_region.sampleLength has unexpected offset % instead of 4", ((cast(*void)(*instance.sampleLength)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.sampleLength)) == 4, "drwav_list_labelled_cue_region.sampleLength has unexpected size % instead of 4", size_of(type_of(drwav_list_labelled_cue_region.sampleLength))); + assert(((cast(*void)(*instance.purposeId)) - cast(*void)(*instance)) == 8, "drwav_list_labelled_cue_region.purposeId has unexpected offset % instead of 8", ((cast(*void)(*instance.purposeId)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.purposeId)) == 4, "drwav_list_labelled_cue_region.purposeId has unexpected size % instead of 4", size_of(type_of(drwav_list_labelled_cue_region.purposeId))); + assert(((cast(*void)(*instance.country)) - cast(*void)(*instance)) == 12, "drwav_list_labelled_cue_region.country has unexpected offset % instead of 12", ((cast(*void)(*instance.country)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.country)) == 2, "drwav_list_labelled_cue_region.country has unexpected size % instead of 2", size_of(type_of(drwav_list_labelled_cue_region.country))); + assert(((cast(*void)(*instance.language)) - cast(*void)(*instance)) == 14, "drwav_list_labelled_cue_region.language has unexpected offset % instead of 14", ((cast(*void)(*instance.language)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.language)) == 2, "drwav_list_labelled_cue_region.language has unexpected size % instead of 2", size_of(type_of(drwav_list_labelled_cue_region.language))); + assert(((cast(*void)(*instance.dialect)) - cast(*void)(*instance)) == 16, "drwav_list_labelled_cue_region.dialect has unexpected offset % instead of 16", ((cast(*void)(*instance.dialect)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.dialect)) == 2, "drwav_list_labelled_cue_region.dialect has unexpected size % instead of 2", size_of(type_of(drwav_list_labelled_cue_region.dialect))); + assert(((cast(*void)(*instance.codePage)) - cast(*void)(*instance)) == 18, "drwav_list_labelled_cue_region.codePage has unexpected offset % instead of 18", ((cast(*void)(*instance.codePage)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.codePage)) == 2, "drwav_list_labelled_cue_region.codePage has unexpected size % instead of 2", size_of(type_of(drwav_list_labelled_cue_region.codePage))); + assert(((cast(*void)(*instance.stringLength)) - cast(*void)(*instance)) == 20, "drwav_list_labelled_cue_region.stringLength has unexpected offset % instead of 20", ((cast(*void)(*instance.stringLength)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.stringLength)) == 4, "drwav_list_labelled_cue_region.stringLength has unexpected size % instead of 4", size_of(type_of(drwav_list_labelled_cue_region.stringLength))); + assert(((cast(*void)(*instance.pString)) - cast(*void)(*instance)) == 24, "drwav_list_labelled_cue_region.pString has unexpected offset % instead of 24", ((cast(*void)(*instance.pString)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_list_labelled_cue_region.pString)) == 8, "drwav_list_labelled_cue_region.pString has unexpected size % instead of 8", size_of(type_of(drwav_list_labelled_cue_region.pString))); + assert(size_of(drwav_list_labelled_cue_region) == 32, "drwav_list_labelled_cue_region has size % instead of 32", size_of(drwav_list_labelled_cue_region)); + } + + { + instance: drwav_unknown_metadata; + assert(((cast(*void)(*instance.id)) - cast(*void)(*instance)) == 0, "drwav_unknown_metadata.id has unexpected offset % instead of 0", ((cast(*void)(*instance.id)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_unknown_metadata.id)) == 4, "drwav_unknown_metadata.id has unexpected size % instead of 4", size_of(type_of(drwav_unknown_metadata.id))); + assert(((cast(*void)(*instance.chunkLocation)) - cast(*void)(*instance)) == 4, "drwav_unknown_metadata.chunkLocation has unexpected offset % instead of 4", ((cast(*void)(*instance.chunkLocation)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_unknown_metadata.chunkLocation)) == 4, "drwav_unknown_metadata.chunkLocation has unexpected size % instead of 4", size_of(type_of(drwav_unknown_metadata.chunkLocation))); + assert(((cast(*void)(*instance.dataSizeInBytes)) - cast(*void)(*instance)) == 8, "drwav_unknown_metadata.dataSizeInBytes has unexpected offset % instead of 8", ((cast(*void)(*instance.dataSizeInBytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_unknown_metadata.dataSizeInBytes)) == 4, "drwav_unknown_metadata.dataSizeInBytes has unexpected size % instead of 4", size_of(type_of(drwav_unknown_metadata.dataSizeInBytes))); + assert(((cast(*void)(*instance.pData)) - cast(*void)(*instance)) == 16, "drwav_unknown_metadata.pData has unexpected offset % instead of 16", ((cast(*void)(*instance.pData)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_unknown_metadata.pData)) == 8, "drwav_unknown_metadata.pData has unexpected size % instead of 8", size_of(type_of(drwav_unknown_metadata.pData))); + assert(size_of(drwav_unknown_metadata) == 24, "drwav_unknown_metadata has size % instead of 24", size_of(drwav_unknown_metadata)); + } + + { + instance: drwav_metadata; + assert(((cast(*void)(*instance.type)) - cast(*void)(*instance)) == 0, "drwav_metadata.type has unexpected offset % instead of 0", ((cast(*void)(*instance.type)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_metadata.type)) == 4, "drwav_metadata.type has unexpected size % instead of 4", size_of(type_of(drwav_metadata.type))); + assert(((cast(*void)(*instance.data)) - cast(*void)(*instance)) == 8, "drwav_metadata.data has unexpected offset % instead of 8", ((cast(*void)(*instance.data)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav_metadata.data)) == 104, "drwav_metadata.data has unexpected size % instead of 104", size_of(type_of(drwav_metadata.data))); + assert(size_of(drwav_metadata) == 112, "drwav_metadata has size % instead of 112", size_of(drwav_metadata)); + } + + { + instance: drwav; + assert(((cast(*void)(*instance.onRead)) - cast(*void)(*instance)) == 0, "drwav.onRead has unexpected offset % instead of 0", ((cast(*void)(*instance.onRead)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.onRead)) == 8, "drwav.onRead has unexpected size % instead of 8", size_of(type_of(drwav.onRead))); + assert(((cast(*void)(*instance.onWrite)) - cast(*void)(*instance)) == 8, "drwav.onWrite has unexpected offset % instead of 8", ((cast(*void)(*instance.onWrite)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.onWrite)) == 8, "drwav.onWrite has unexpected size % instead of 8", size_of(type_of(drwav.onWrite))); + assert(((cast(*void)(*instance.onSeek)) - cast(*void)(*instance)) == 16, "drwav.onSeek has unexpected offset % instead of 16", ((cast(*void)(*instance.onSeek)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.onSeek)) == 8, "drwav.onSeek has unexpected size % instead of 8", size_of(type_of(drwav.onSeek))); + assert(((cast(*void)(*instance.pUserData)) - cast(*void)(*instance)) == 24, "drwav.pUserData has unexpected offset % instead of 24", ((cast(*void)(*instance.pUserData)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.pUserData)) == 8, "drwav.pUserData has unexpected size % instead of 8", size_of(type_of(drwav.pUserData))); + assert(((cast(*void)(*instance.allocationCallbacks)) - cast(*void)(*instance)) == 32, "drwav.allocationCallbacks has unexpected offset % instead of 32", ((cast(*void)(*instance.allocationCallbacks)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.allocationCallbacks)) == 32, "drwav.allocationCallbacks has unexpected size % instead of 32", size_of(type_of(drwav.allocationCallbacks))); + assert(((cast(*void)(*instance.container)) - cast(*void)(*instance)) == 64, "drwav.container has unexpected offset % instead of 64", ((cast(*void)(*instance.container)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.container)) == 4, "drwav.container has unexpected size % instead of 4", size_of(type_of(drwav.container))); + assert(((cast(*void)(*instance.fmt)) - cast(*void)(*instance)) == 68, "drwav.fmt has unexpected offset % instead of 68", ((cast(*void)(*instance.fmt)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.fmt)) == 40, "drwav.fmt has unexpected size % instead of 40", size_of(type_of(drwav.fmt))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 108, "drwav.sampleRate has unexpected offset % instead of 108", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.sampleRate)) == 4, "drwav.sampleRate has unexpected size % instead of 4", size_of(type_of(drwav.sampleRate))); + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 112, "drwav.channels has unexpected offset % instead of 112", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.channels)) == 2, "drwav.channels has unexpected size % instead of 2", size_of(type_of(drwav.channels))); + assert(((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance)) == 114, "drwav.bitsPerSample has unexpected offset % instead of 114", ((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.bitsPerSample)) == 2, "drwav.bitsPerSample has unexpected size % instead of 2", size_of(type_of(drwav.bitsPerSample))); + assert(((cast(*void)(*instance.translatedFormatTag)) - cast(*void)(*instance)) == 116, "drwav.translatedFormatTag has unexpected offset % instead of 116", ((cast(*void)(*instance.translatedFormatTag)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.translatedFormatTag)) == 2, "drwav.translatedFormatTag has unexpected size % instead of 2", size_of(type_of(drwav.translatedFormatTag))); + assert(((cast(*void)(*instance.totalPCMFrameCount)) - cast(*void)(*instance)) == 120, "drwav.totalPCMFrameCount has unexpected offset % instead of 120", ((cast(*void)(*instance.totalPCMFrameCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.totalPCMFrameCount)) == 8, "drwav.totalPCMFrameCount has unexpected size % instead of 8", size_of(type_of(drwav.totalPCMFrameCount))); + assert(((cast(*void)(*instance.dataChunkDataSize)) - cast(*void)(*instance)) == 128, "drwav.dataChunkDataSize has unexpected offset % instead of 128", ((cast(*void)(*instance.dataChunkDataSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.dataChunkDataSize)) == 8, "drwav.dataChunkDataSize has unexpected size % instead of 8", size_of(type_of(drwav.dataChunkDataSize))); + assert(((cast(*void)(*instance.dataChunkDataPos)) - cast(*void)(*instance)) == 136, "drwav.dataChunkDataPos has unexpected offset % instead of 136", ((cast(*void)(*instance.dataChunkDataPos)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.dataChunkDataPos)) == 8, "drwav.dataChunkDataPos has unexpected size % instead of 8", size_of(type_of(drwav.dataChunkDataPos))); + assert(((cast(*void)(*instance.bytesRemaining)) - cast(*void)(*instance)) == 144, "drwav.bytesRemaining has unexpected offset % instead of 144", ((cast(*void)(*instance.bytesRemaining)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.bytesRemaining)) == 8, "drwav.bytesRemaining has unexpected size % instead of 8", size_of(type_of(drwav.bytesRemaining))); + assert(((cast(*void)(*instance.readCursorInPCMFrames)) - cast(*void)(*instance)) == 152, "drwav.readCursorInPCMFrames has unexpected offset % instead of 152", ((cast(*void)(*instance.readCursorInPCMFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.readCursorInPCMFrames)) == 8, "drwav.readCursorInPCMFrames has unexpected size % instead of 8", size_of(type_of(drwav.readCursorInPCMFrames))); + assert(((cast(*void)(*instance.dataChunkDataSizeTargetWrite)) - cast(*void)(*instance)) == 160, "drwav.dataChunkDataSizeTargetWrite has unexpected offset % instead of 160", ((cast(*void)(*instance.dataChunkDataSizeTargetWrite)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.dataChunkDataSizeTargetWrite)) == 8, "drwav.dataChunkDataSizeTargetWrite has unexpected size % instead of 8", size_of(type_of(drwav.dataChunkDataSizeTargetWrite))); + assert(((cast(*void)(*instance.isSequentialWrite)) - cast(*void)(*instance)) == 168, "drwav.isSequentialWrite has unexpected offset % instead of 168", ((cast(*void)(*instance.isSequentialWrite)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.isSequentialWrite)) == 4, "drwav.isSequentialWrite has unexpected size % instead of 4", size_of(type_of(drwav.isSequentialWrite))); + assert(((cast(*void)(*instance.pMetadata)) - cast(*void)(*instance)) == 176, "drwav.pMetadata has unexpected offset % instead of 176", ((cast(*void)(*instance.pMetadata)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.pMetadata)) == 8, "drwav.pMetadata has unexpected size % instead of 8", size_of(type_of(drwav.pMetadata))); + assert(((cast(*void)(*instance.metadataCount)) - cast(*void)(*instance)) == 184, "drwav.metadataCount has unexpected offset % instead of 184", ((cast(*void)(*instance.metadataCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.metadataCount)) == 4, "drwav.metadataCount has unexpected size % instead of 4", size_of(type_of(drwav.metadataCount))); + assert(((cast(*void)(*instance.memoryStream)) - cast(*void)(*instance)) == 192, "drwav.memoryStream has unexpected offset % instead of 192", ((cast(*void)(*instance.memoryStream)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.memoryStream)) == 24, "drwav.memoryStream has unexpected size % instead of 24", size_of(type_of(drwav.memoryStream))); + assert(((cast(*void)(*instance.memoryStreamWrite)) - cast(*void)(*instance)) == 216, "drwav.memoryStreamWrite has unexpected offset % instead of 216", ((cast(*void)(*instance.memoryStreamWrite)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.memoryStreamWrite)) == 40, "drwav.memoryStreamWrite has unexpected size % instead of 40", size_of(type_of(drwav.memoryStreamWrite))); + assert(((cast(*void)(*instance.msadpcm)) - cast(*void)(*instance)) == 256, "drwav.msadpcm has unexpected offset % instead of 256", ((cast(*void)(*instance.msadpcm)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.msadpcm)) == 52, "drwav.msadpcm has unexpected size % instead of 52", size_of(type_of(drwav.msadpcm))); + assert(((cast(*void)(*instance.ima)) - cast(*void)(*instance)) == 308, "drwav.ima has unexpected offset % instead of 308", ((cast(*void)(*instance.ima)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.ima)) == 88, "drwav.ima has unexpected size % instead of 88", size_of(type_of(drwav.ima))); + assert(((cast(*void)(*instance.aiff)) - cast(*void)(*instance)) == 396, "drwav.aiff has unexpected offset % instead of 396", ((cast(*void)(*instance.aiff)) - cast(*void)(*instance))); + assert(size_of(type_of(drwav.aiff)) == 1, "drwav.aiff has unexpected size % instead of 1", size_of(type_of(drwav.aiff))); + assert(size_of(drwav) == 400, "drwav has size % instead of 400", size_of(drwav)); + } + + { + instance: drflac_allocation_callbacks; + assert(((cast(*void)(*instance.pUserData)) - cast(*void)(*instance)) == 0, "drflac_allocation_callbacks.pUserData has unexpected offset % instead of 0", ((cast(*void)(*instance.pUserData)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_allocation_callbacks.pUserData)) == 8, "drflac_allocation_callbacks.pUserData has unexpected size % instead of 8", size_of(type_of(drflac_allocation_callbacks.pUserData))); + assert(((cast(*void)(*instance.onMalloc)) - cast(*void)(*instance)) == 8, "drflac_allocation_callbacks.onMalloc has unexpected offset % instead of 8", ((cast(*void)(*instance.onMalloc)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_allocation_callbacks.onMalloc)) == 8, "drflac_allocation_callbacks.onMalloc has unexpected size % instead of 8", size_of(type_of(drflac_allocation_callbacks.onMalloc))); + assert(((cast(*void)(*instance.onRealloc)) - cast(*void)(*instance)) == 16, "drflac_allocation_callbacks.onRealloc has unexpected offset % instead of 16", ((cast(*void)(*instance.onRealloc)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_allocation_callbacks.onRealloc)) == 8, "drflac_allocation_callbacks.onRealloc has unexpected size % instead of 8", size_of(type_of(drflac_allocation_callbacks.onRealloc))); + assert(((cast(*void)(*instance.onFree)) - cast(*void)(*instance)) == 24, "drflac_allocation_callbacks.onFree has unexpected offset % instead of 24", ((cast(*void)(*instance.onFree)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_allocation_callbacks.onFree)) == 8, "drflac_allocation_callbacks.onFree has unexpected size % instead of 8", size_of(type_of(drflac_allocation_callbacks.onFree))); + assert(size_of(drflac_allocation_callbacks) == 32, "drflac_allocation_callbacks has size % instead of 32", size_of(drflac_allocation_callbacks)); + } + + { + instance: drflac_seekpoint; + assert(((cast(*void)(*instance.firstPCMFrame)) - cast(*void)(*instance)) == 0, "drflac_seekpoint.firstPCMFrame has unexpected offset % instead of 0", ((cast(*void)(*instance.firstPCMFrame)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_seekpoint.firstPCMFrame)) == 8, "drflac_seekpoint.firstPCMFrame has unexpected size % instead of 8", size_of(type_of(drflac_seekpoint.firstPCMFrame))); + assert(((cast(*void)(*instance.flacFrameOffset)) - cast(*void)(*instance)) == 8, "drflac_seekpoint.flacFrameOffset has unexpected offset % instead of 8", ((cast(*void)(*instance.flacFrameOffset)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_seekpoint.flacFrameOffset)) == 8, "drflac_seekpoint.flacFrameOffset has unexpected size % instead of 8", size_of(type_of(drflac_seekpoint.flacFrameOffset))); + assert(((cast(*void)(*instance.pcmFrameCount)) - cast(*void)(*instance)) == 16, "drflac_seekpoint.pcmFrameCount has unexpected offset % instead of 16", ((cast(*void)(*instance.pcmFrameCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_seekpoint.pcmFrameCount)) == 2, "drflac_seekpoint.pcmFrameCount has unexpected size % instead of 2", size_of(type_of(drflac_seekpoint.pcmFrameCount))); + assert(size_of(drflac_seekpoint) == 24, "drflac_seekpoint has size % instead of 24", size_of(drflac_seekpoint)); + } + + { + instance: drflac_streaminfo; + assert(((cast(*void)(*instance.minBlockSizeInPCMFrames)) - cast(*void)(*instance)) == 0, "drflac_streaminfo.minBlockSizeInPCMFrames has unexpected offset % instead of 0", ((cast(*void)(*instance.minBlockSizeInPCMFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.minBlockSizeInPCMFrames)) == 2, "drflac_streaminfo.minBlockSizeInPCMFrames has unexpected size % instead of 2", size_of(type_of(drflac_streaminfo.minBlockSizeInPCMFrames))); + assert(((cast(*void)(*instance.maxBlockSizeInPCMFrames)) - cast(*void)(*instance)) == 2, "drflac_streaminfo.maxBlockSizeInPCMFrames has unexpected offset % instead of 2", ((cast(*void)(*instance.maxBlockSizeInPCMFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.maxBlockSizeInPCMFrames)) == 2, "drflac_streaminfo.maxBlockSizeInPCMFrames has unexpected size % instead of 2", size_of(type_of(drflac_streaminfo.maxBlockSizeInPCMFrames))); + assert(((cast(*void)(*instance.minFrameSizeInPCMFrames)) - cast(*void)(*instance)) == 4, "drflac_streaminfo.minFrameSizeInPCMFrames has unexpected offset % instead of 4", ((cast(*void)(*instance.minFrameSizeInPCMFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.minFrameSizeInPCMFrames)) == 4, "drflac_streaminfo.minFrameSizeInPCMFrames has unexpected size % instead of 4", size_of(type_of(drflac_streaminfo.minFrameSizeInPCMFrames))); + assert(((cast(*void)(*instance.maxFrameSizeInPCMFrames)) - cast(*void)(*instance)) == 8, "drflac_streaminfo.maxFrameSizeInPCMFrames has unexpected offset % instead of 8", ((cast(*void)(*instance.maxFrameSizeInPCMFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.maxFrameSizeInPCMFrames)) == 4, "drflac_streaminfo.maxFrameSizeInPCMFrames has unexpected size % instead of 4", size_of(type_of(drflac_streaminfo.maxFrameSizeInPCMFrames))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 12, "drflac_streaminfo.sampleRate has unexpected offset % instead of 12", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.sampleRate)) == 4, "drflac_streaminfo.sampleRate has unexpected size % instead of 4", size_of(type_of(drflac_streaminfo.sampleRate))); + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 16, "drflac_streaminfo.channels has unexpected offset % instead of 16", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.channels)) == 1, "drflac_streaminfo.channels has unexpected size % instead of 1", size_of(type_of(drflac_streaminfo.channels))); + assert(((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance)) == 17, "drflac_streaminfo.bitsPerSample has unexpected offset % instead of 17", ((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.bitsPerSample)) == 1, "drflac_streaminfo.bitsPerSample has unexpected size % instead of 1", size_of(type_of(drflac_streaminfo.bitsPerSample))); + assert(((cast(*void)(*instance.totalPCMFrameCount)) - cast(*void)(*instance)) == 24, "drflac_streaminfo.totalPCMFrameCount has unexpected offset % instead of 24", ((cast(*void)(*instance.totalPCMFrameCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.totalPCMFrameCount)) == 8, "drflac_streaminfo.totalPCMFrameCount has unexpected size % instead of 8", size_of(type_of(drflac_streaminfo.totalPCMFrameCount))); + assert(((cast(*void)(*instance.md5)) - cast(*void)(*instance)) == 32, "drflac_streaminfo.md5 has unexpected offset % instead of 32", ((cast(*void)(*instance.md5)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_streaminfo.md5)) == 16, "drflac_streaminfo.md5 has unexpected size % instead of 16", size_of(type_of(drflac_streaminfo.md5))); + assert(size_of(drflac_streaminfo) == 48, "drflac_streaminfo has size % instead of 48", size_of(drflac_streaminfo)); + } + + { + instance: drflac_metadata; + assert(((cast(*void)(*instance.type)) - cast(*void)(*instance)) == 0, "drflac_metadata.type has unexpected offset % instead of 0", ((cast(*void)(*instance.type)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_metadata.type)) == 4, "drflac_metadata.type has unexpected size % instead of 4", size_of(type_of(drflac_metadata.type))); + assert(((cast(*void)(*instance.pRawData)) - cast(*void)(*instance)) == 8, "drflac_metadata.pRawData has unexpected offset % instead of 8", ((cast(*void)(*instance.pRawData)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_metadata.pRawData)) == 8, "drflac_metadata.pRawData has unexpected size % instead of 8", size_of(type_of(drflac_metadata.pRawData))); + assert(((cast(*void)(*instance.rawDataSize)) - cast(*void)(*instance)) == 16, "drflac_metadata.rawDataSize has unexpected offset % instead of 16", ((cast(*void)(*instance.rawDataSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_metadata.rawDataSize)) == 4, "drflac_metadata.rawDataSize has unexpected size % instead of 4", size_of(type_of(drflac_metadata.rawDataSize))); + assert(((cast(*void)(*instance.data)) - cast(*void)(*instance)) == 24, "drflac_metadata.data has unexpected offset % instead of 24", ((cast(*void)(*instance.data)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_metadata.data)) == 152, "drflac_metadata.data has unexpected size % instead of 152", size_of(type_of(drflac_metadata.data))); + assert(size_of(drflac_metadata) == 176, "drflac_metadata has size % instead of 176", size_of(drflac_metadata)); + } + + { + instance: drflac__memory_stream; + assert(((cast(*void)(*instance.data)) - cast(*void)(*instance)) == 0, "drflac__memory_stream.data has unexpected offset % instead of 0", ((cast(*void)(*instance.data)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac__memory_stream.data)) == 8, "drflac__memory_stream.data has unexpected size % instead of 8", size_of(type_of(drflac__memory_stream.data))); + assert(((cast(*void)(*instance.dataSize)) - cast(*void)(*instance)) == 8, "drflac__memory_stream.dataSize has unexpected offset % instead of 8", ((cast(*void)(*instance.dataSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac__memory_stream.dataSize)) == 8, "drflac__memory_stream.dataSize has unexpected size % instead of 8", size_of(type_of(drflac__memory_stream.dataSize))); + assert(((cast(*void)(*instance.currentReadPos)) - cast(*void)(*instance)) == 16, "drflac__memory_stream.currentReadPos has unexpected offset % instead of 16", ((cast(*void)(*instance.currentReadPos)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac__memory_stream.currentReadPos)) == 8, "drflac__memory_stream.currentReadPos has unexpected size % instead of 8", size_of(type_of(drflac__memory_stream.currentReadPos))); + assert(size_of(drflac__memory_stream) == 24, "drflac__memory_stream has size % instead of 24", size_of(drflac__memory_stream)); + } + + { + instance: drflac_bs; + assert(((cast(*void)(*instance.onRead)) - cast(*void)(*instance)) == 0, "drflac_bs.onRead has unexpected offset % instead of 0", ((cast(*void)(*instance.onRead)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.onRead)) == 8, "drflac_bs.onRead has unexpected size % instead of 8", size_of(type_of(drflac_bs.onRead))); + assert(((cast(*void)(*instance.onSeek)) - cast(*void)(*instance)) == 8, "drflac_bs.onSeek has unexpected offset % instead of 8", ((cast(*void)(*instance.onSeek)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.onSeek)) == 8, "drflac_bs.onSeek has unexpected size % instead of 8", size_of(type_of(drflac_bs.onSeek))); + assert(((cast(*void)(*instance.pUserData)) - cast(*void)(*instance)) == 16, "drflac_bs.pUserData has unexpected offset % instead of 16", ((cast(*void)(*instance.pUserData)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.pUserData)) == 8, "drflac_bs.pUserData has unexpected size % instead of 8", size_of(type_of(drflac_bs.pUserData))); + assert(((cast(*void)(*instance.unalignedByteCount)) - cast(*void)(*instance)) == 24, "drflac_bs.unalignedByteCount has unexpected offset % instead of 24", ((cast(*void)(*instance.unalignedByteCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.unalignedByteCount)) == 8, "drflac_bs.unalignedByteCount has unexpected size % instead of 8", size_of(type_of(drflac_bs.unalignedByteCount))); + assert(((cast(*void)(*instance.unalignedCache)) - cast(*void)(*instance)) == 32, "drflac_bs.unalignedCache has unexpected offset % instead of 32", ((cast(*void)(*instance.unalignedCache)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.unalignedCache)) == 8, "drflac_bs.unalignedCache has unexpected size % instead of 8", size_of(type_of(drflac_bs.unalignedCache))); + assert(((cast(*void)(*instance.nextL2Line)) - cast(*void)(*instance)) == 40, "drflac_bs.nextL2Line has unexpected offset % instead of 40", ((cast(*void)(*instance.nextL2Line)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.nextL2Line)) == 4, "drflac_bs.nextL2Line has unexpected size % instead of 4", size_of(type_of(drflac_bs.nextL2Line))); + assert(((cast(*void)(*instance.consumedBits)) - cast(*void)(*instance)) == 44, "drflac_bs.consumedBits has unexpected offset % instead of 44", ((cast(*void)(*instance.consumedBits)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.consumedBits)) == 4, "drflac_bs.consumedBits has unexpected size % instead of 4", size_of(type_of(drflac_bs.consumedBits))); + assert(((cast(*void)(*instance.cacheL2)) - cast(*void)(*instance)) == 48, "drflac_bs.cacheL2 has unexpected offset % instead of 48", ((cast(*void)(*instance.cacheL2)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.cacheL2)) == 4096, "drflac_bs.cacheL2 has unexpected size % instead of 4096", size_of(type_of(drflac_bs.cacheL2))); + assert(((cast(*void)(*instance.cache)) - cast(*void)(*instance)) == 4144, "drflac_bs.cache has unexpected offset % instead of 4144", ((cast(*void)(*instance.cache)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.cache)) == 8, "drflac_bs.cache has unexpected size % instead of 8", size_of(type_of(drflac_bs.cache))); + assert(((cast(*void)(*instance.crc16)) - cast(*void)(*instance)) == 4152, "drflac_bs.crc16 has unexpected offset % instead of 4152", ((cast(*void)(*instance.crc16)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.crc16)) == 2, "drflac_bs.crc16 has unexpected size % instead of 2", size_of(type_of(drflac_bs.crc16))); + assert(((cast(*void)(*instance.crc16Cache)) - cast(*void)(*instance)) == 4160, "drflac_bs.crc16Cache has unexpected offset % instead of 4160", ((cast(*void)(*instance.crc16Cache)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.crc16Cache)) == 8, "drflac_bs.crc16Cache has unexpected size % instead of 8", size_of(type_of(drflac_bs.crc16Cache))); + assert(((cast(*void)(*instance.crc16CacheIgnoredBytes)) - cast(*void)(*instance)) == 4168, "drflac_bs.crc16CacheIgnoredBytes has unexpected offset % instead of 4168", ((cast(*void)(*instance.crc16CacheIgnoredBytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_bs.crc16CacheIgnoredBytes)) == 4, "drflac_bs.crc16CacheIgnoredBytes has unexpected size % instead of 4", size_of(type_of(drflac_bs.crc16CacheIgnoredBytes))); + assert(size_of(drflac_bs) == 4176, "drflac_bs has size % instead of 4176", size_of(drflac_bs)); + } + + { + instance: drflac_subframe; + assert(((cast(*void)(*instance.subframeType)) - cast(*void)(*instance)) == 0, "drflac_subframe.subframeType has unexpected offset % instead of 0", ((cast(*void)(*instance.subframeType)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_subframe.subframeType)) == 1, "drflac_subframe.subframeType has unexpected size % instead of 1", size_of(type_of(drflac_subframe.subframeType))); + assert(((cast(*void)(*instance.wastedBitsPerSample)) - cast(*void)(*instance)) == 1, "drflac_subframe.wastedBitsPerSample has unexpected offset % instead of 1", ((cast(*void)(*instance.wastedBitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_subframe.wastedBitsPerSample)) == 1, "drflac_subframe.wastedBitsPerSample has unexpected size % instead of 1", size_of(type_of(drflac_subframe.wastedBitsPerSample))); + assert(((cast(*void)(*instance.lpcOrder)) - cast(*void)(*instance)) == 2, "drflac_subframe.lpcOrder has unexpected offset % instead of 2", ((cast(*void)(*instance.lpcOrder)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_subframe.lpcOrder)) == 1, "drflac_subframe.lpcOrder has unexpected size % instead of 1", size_of(type_of(drflac_subframe.lpcOrder))); + assert(((cast(*void)(*instance.pSamplesS32)) - cast(*void)(*instance)) == 8, "drflac_subframe.pSamplesS32 has unexpected offset % instead of 8", ((cast(*void)(*instance.pSamplesS32)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_subframe.pSamplesS32)) == 8, "drflac_subframe.pSamplesS32 has unexpected size % instead of 8", size_of(type_of(drflac_subframe.pSamplesS32))); + assert(size_of(drflac_subframe) == 16, "drflac_subframe has size % instead of 16", size_of(drflac_subframe)); + } + + { + instance: drflac_frame_header; + assert(((cast(*void)(*instance.pcmFrameNumber)) - cast(*void)(*instance)) == 0, "drflac_frame_header.pcmFrameNumber has unexpected offset % instead of 0", ((cast(*void)(*instance.pcmFrameNumber)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame_header.pcmFrameNumber)) == 8, "drflac_frame_header.pcmFrameNumber has unexpected size % instead of 8", size_of(type_of(drflac_frame_header.pcmFrameNumber))); + assert(((cast(*void)(*instance.flacFrameNumber)) - cast(*void)(*instance)) == 8, "drflac_frame_header.flacFrameNumber has unexpected offset % instead of 8", ((cast(*void)(*instance.flacFrameNumber)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame_header.flacFrameNumber)) == 4, "drflac_frame_header.flacFrameNumber has unexpected size % instead of 4", size_of(type_of(drflac_frame_header.flacFrameNumber))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 12, "drflac_frame_header.sampleRate has unexpected offset % instead of 12", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame_header.sampleRate)) == 4, "drflac_frame_header.sampleRate has unexpected size % instead of 4", size_of(type_of(drflac_frame_header.sampleRate))); + assert(((cast(*void)(*instance.blockSizeInPCMFrames)) - cast(*void)(*instance)) == 16, "drflac_frame_header.blockSizeInPCMFrames has unexpected offset % instead of 16", ((cast(*void)(*instance.blockSizeInPCMFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame_header.blockSizeInPCMFrames)) == 2, "drflac_frame_header.blockSizeInPCMFrames has unexpected size % instead of 2", size_of(type_of(drflac_frame_header.blockSizeInPCMFrames))); + assert(((cast(*void)(*instance.channelAssignment)) - cast(*void)(*instance)) == 18, "drflac_frame_header.channelAssignment has unexpected offset % instead of 18", ((cast(*void)(*instance.channelAssignment)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame_header.channelAssignment)) == 1, "drflac_frame_header.channelAssignment has unexpected size % instead of 1", size_of(type_of(drflac_frame_header.channelAssignment))); + assert(((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance)) == 19, "drflac_frame_header.bitsPerSample has unexpected offset % instead of 19", ((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame_header.bitsPerSample)) == 1, "drflac_frame_header.bitsPerSample has unexpected size % instead of 1", size_of(type_of(drflac_frame_header.bitsPerSample))); + assert(((cast(*void)(*instance.crc8)) - cast(*void)(*instance)) == 20, "drflac_frame_header.crc8 has unexpected offset % instead of 20", ((cast(*void)(*instance.crc8)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame_header.crc8)) == 1, "drflac_frame_header.crc8 has unexpected size % instead of 1", size_of(type_of(drflac_frame_header.crc8))); + assert(size_of(drflac_frame_header) == 24, "drflac_frame_header has size % instead of 24", size_of(drflac_frame_header)); + } + + { + instance: drflac_frame; + assert(((cast(*void)(*instance.header)) - cast(*void)(*instance)) == 0, "drflac_frame.header has unexpected offset % instead of 0", ((cast(*void)(*instance.header)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame.header)) == 24, "drflac_frame.header has unexpected size % instead of 24", size_of(type_of(drflac_frame.header))); + assert(((cast(*void)(*instance.pcmFramesRemaining)) - cast(*void)(*instance)) == 24, "drflac_frame.pcmFramesRemaining has unexpected offset % instead of 24", ((cast(*void)(*instance.pcmFramesRemaining)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame.pcmFramesRemaining)) == 4, "drflac_frame.pcmFramesRemaining has unexpected size % instead of 4", size_of(type_of(drflac_frame.pcmFramesRemaining))); + assert(((cast(*void)(*instance.subframes)) - cast(*void)(*instance)) == 32, "drflac_frame.subframes has unexpected offset % instead of 32", ((cast(*void)(*instance.subframes)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_frame.subframes)) == 128, "drflac_frame.subframes has unexpected size % instead of 128", size_of(type_of(drflac_frame.subframes))); + assert(size_of(drflac_frame) == 160, "drflac_frame has size % instead of 160", size_of(drflac_frame)); + } + + { + instance: drflac; + assert(((cast(*void)(*instance.onMeta)) - cast(*void)(*instance)) == 0, "drflac.onMeta has unexpected offset % instead of 0", ((cast(*void)(*instance.onMeta)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.onMeta)) == 8, "drflac.onMeta has unexpected size % instead of 8", size_of(type_of(drflac.onMeta))); + assert(((cast(*void)(*instance.pUserDataMD)) - cast(*void)(*instance)) == 8, "drflac.pUserDataMD has unexpected offset % instead of 8", ((cast(*void)(*instance.pUserDataMD)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.pUserDataMD)) == 8, "drflac.pUserDataMD has unexpected size % instead of 8", size_of(type_of(drflac.pUserDataMD))); + assert(((cast(*void)(*instance.allocationCallbacks)) - cast(*void)(*instance)) == 16, "drflac.allocationCallbacks has unexpected offset % instead of 16", ((cast(*void)(*instance.allocationCallbacks)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.allocationCallbacks)) == 32, "drflac.allocationCallbacks has unexpected size % instead of 32", size_of(type_of(drflac.allocationCallbacks))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 48, "drflac.sampleRate has unexpected offset % instead of 48", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.sampleRate)) == 4, "drflac.sampleRate has unexpected size % instead of 4", size_of(type_of(drflac.sampleRate))); + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 52, "drflac.channels has unexpected offset % instead of 52", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.channels)) == 1, "drflac.channels has unexpected size % instead of 1", size_of(type_of(drflac.channels))); + assert(((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance)) == 53, "drflac.bitsPerSample has unexpected offset % instead of 53", ((cast(*void)(*instance.bitsPerSample)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.bitsPerSample)) == 1, "drflac.bitsPerSample has unexpected size % instead of 1", size_of(type_of(drflac.bitsPerSample))); + assert(((cast(*void)(*instance.maxBlockSizeInPCMFrames)) - cast(*void)(*instance)) == 54, "drflac.maxBlockSizeInPCMFrames has unexpected offset % instead of 54", ((cast(*void)(*instance.maxBlockSizeInPCMFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.maxBlockSizeInPCMFrames)) == 2, "drflac.maxBlockSizeInPCMFrames has unexpected size % instead of 2", size_of(type_of(drflac.maxBlockSizeInPCMFrames))); + assert(((cast(*void)(*instance.totalPCMFrameCount)) - cast(*void)(*instance)) == 56, "drflac.totalPCMFrameCount has unexpected offset % instead of 56", ((cast(*void)(*instance.totalPCMFrameCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.totalPCMFrameCount)) == 8, "drflac.totalPCMFrameCount has unexpected size % instead of 8", size_of(type_of(drflac.totalPCMFrameCount))); + assert(((cast(*void)(*instance.container)) - cast(*void)(*instance)) == 64, "drflac.container has unexpected offset % instead of 64", ((cast(*void)(*instance.container)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.container)) == 4, "drflac.container has unexpected size % instead of 4", size_of(type_of(drflac.container))); + assert(((cast(*void)(*instance.seekpointCount)) - cast(*void)(*instance)) == 68, "drflac.seekpointCount has unexpected offset % instead of 68", ((cast(*void)(*instance.seekpointCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.seekpointCount)) == 4, "drflac.seekpointCount has unexpected size % instead of 4", size_of(type_of(drflac.seekpointCount))); + assert(((cast(*void)(*instance.currentFLACFrame)) - cast(*void)(*instance)) == 72, "drflac.currentFLACFrame has unexpected offset % instead of 72", ((cast(*void)(*instance.currentFLACFrame)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.currentFLACFrame)) == 160, "drflac.currentFLACFrame has unexpected size % instead of 160", size_of(type_of(drflac.currentFLACFrame))); + assert(((cast(*void)(*instance.currentPCMFrame)) - cast(*void)(*instance)) == 232, "drflac.currentPCMFrame has unexpected offset % instead of 232", ((cast(*void)(*instance.currentPCMFrame)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.currentPCMFrame)) == 8, "drflac.currentPCMFrame has unexpected size % instead of 8", size_of(type_of(drflac.currentPCMFrame))); + assert(((cast(*void)(*instance.firstFLACFramePosInBytes)) - cast(*void)(*instance)) == 240, "drflac.firstFLACFramePosInBytes has unexpected offset % instead of 240", ((cast(*void)(*instance.firstFLACFramePosInBytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.firstFLACFramePosInBytes)) == 8, "drflac.firstFLACFramePosInBytes has unexpected size % instead of 8", size_of(type_of(drflac.firstFLACFramePosInBytes))); + assert(((cast(*void)(*instance.memoryStream)) - cast(*void)(*instance)) == 248, "drflac.memoryStream has unexpected offset % instead of 248", ((cast(*void)(*instance.memoryStream)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.memoryStream)) == 24, "drflac.memoryStream has unexpected size % instead of 24", size_of(type_of(drflac.memoryStream))); + assert(((cast(*void)(*instance.pDecodedSamples)) - cast(*void)(*instance)) == 272, "drflac.pDecodedSamples has unexpected offset % instead of 272", ((cast(*void)(*instance.pDecodedSamples)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.pDecodedSamples)) == 8, "drflac.pDecodedSamples has unexpected size % instead of 8", size_of(type_of(drflac.pDecodedSamples))); + assert(((cast(*void)(*instance.pSeekpoints)) - cast(*void)(*instance)) == 280, "drflac.pSeekpoints has unexpected offset % instead of 280", ((cast(*void)(*instance.pSeekpoints)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.pSeekpoints)) == 8, "drflac.pSeekpoints has unexpected size % instead of 8", size_of(type_of(drflac.pSeekpoints))); + assert(((cast(*void)(*instance._oggbs)) - cast(*void)(*instance)) == 288, "drflac._oggbs has unexpected offset % instead of 288", ((cast(*void)(*instance._oggbs)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac._oggbs)) == 8, "drflac._oggbs has unexpected size % instead of 8", size_of(type_of(drflac._oggbs))); + // Bitfields are currently not correctly aligned + // assert(((cast(*void)(*instance._noSeekTableSeek)) - cast(*void)(*instance)) == 296, "drflac._noSeekTableSeek has unexpected offset % instead of 296", ((cast(*void)(*instance._noSeekTableSeek)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac._noSeekTableSeek)) == 4, "drflac._noSeekTableSeek has unexpected size % instead of 4", size_of(type_of(drflac._noSeekTableSeek))); + // Bitfields are currently not correctly aligned + // assert(((cast(*void)(*instance._noBinarySearchSeek)) - cast(*void)(*instance)) == 296, "drflac._noBinarySearchSeek has unexpected offset % instead of 296", ((cast(*void)(*instance._noBinarySearchSeek)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac._noBinarySearchSeek)) == 4, "drflac._noBinarySearchSeek has unexpected size % instead of 4", size_of(type_of(drflac._noBinarySearchSeek))); + // Bitfields are currently not correctly aligned + // assert(((cast(*void)(*instance._noBruteForceSeek)) - cast(*void)(*instance)) == 296, "drflac._noBruteForceSeek has unexpected offset % instead of 296", ((cast(*void)(*instance._noBruteForceSeek)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac._noBruteForceSeek)) == 4, "drflac._noBruteForceSeek has unexpected size % instead of 4", size_of(type_of(drflac._noBruteForceSeek))); + assert(((cast(*void)(*instance.bs)) - cast(*void)(*instance)) == 304, "drflac.bs has unexpected offset % instead of 304", ((cast(*void)(*instance.bs)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.bs)) == 4176, "drflac.bs has unexpected size % instead of 4176", size_of(type_of(drflac.bs))); + assert(((cast(*void)(*instance.pExtraData)) - cast(*void)(*instance)) == 4480, "drflac.pExtraData has unexpected offset % instead of 4480", ((cast(*void)(*instance.pExtraData)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac.pExtraData)) == 1, "drflac.pExtraData has unexpected size % instead of 1", size_of(type_of(drflac.pExtraData))); + assert(size_of(drflac) == 4488, "drflac has size % instead of 4488", size_of(drflac)); + } + + { + instance: drflac_vorbis_comment_iterator; + assert(((cast(*void)(*instance.countRemaining)) - cast(*void)(*instance)) == 0, "drflac_vorbis_comment_iterator.countRemaining has unexpected offset % instead of 0", ((cast(*void)(*instance.countRemaining)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_vorbis_comment_iterator.countRemaining)) == 4, "drflac_vorbis_comment_iterator.countRemaining has unexpected size % instead of 4", size_of(type_of(drflac_vorbis_comment_iterator.countRemaining))); + assert(((cast(*void)(*instance.pRunningData)) - cast(*void)(*instance)) == 8, "drflac_vorbis_comment_iterator.pRunningData has unexpected offset % instead of 8", ((cast(*void)(*instance.pRunningData)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_vorbis_comment_iterator.pRunningData)) == 8, "drflac_vorbis_comment_iterator.pRunningData has unexpected size % instead of 8", size_of(type_of(drflac_vorbis_comment_iterator.pRunningData))); + assert(size_of(drflac_vorbis_comment_iterator) == 16, "drflac_vorbis_comment_iterator has size % instead of 16", size_of(drflac_vorbis_comment_iterator)); + } + + { + instance: drflac_cuesheet_track_iterator; + assert(((cast(*void)(*instance.countRemaining)) - cast(*void)(*instance)) == 0, "drflac_cuesheet_track_iterator.countRemaining has unexpected offset % instead of 0", ((cast(*void)(*instance.countRemaining)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track_iterator.countRemaining)) == 4, "drflac_cuesheet_track_iterator.countRemaining has unexpected size % instead of 4", size_of(type_of(drflac_cuesheet_track_iterator.countRemaining))); + assert(((cast(*void)(*instance.pRunningData)) - cast(*void)(*instance)) == 8, "drflac_cuesheet_track_iterator.pRunningData has unexpected offset % instead of 8", ((cast(*void)(*instance.pRunningData)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track_iterator.pRunningData)) == 8, "drflac_cuesheet_track_iterator.pRunningData has unexpected size % instead of 8", size_of(type_of(drflac_cuesheet_track_iterator.pRunningData))); + assert(size_of(drflac_cuesheet_track_iterator) == 16, "drflac_cuesheet_track_iterator has size % instead of 16", size_of(drflac_cuesheet_track_iterator)); + } + + { + instance: drflac_cuesheet_track_index; + assert(((cast(*void)(*instance.offset)) - cast(*void)(*instance)) == 0, "drflac_cuesheet_track_index.offset has unexpected offset % instead of 0", ((cast(*void)(*instance.offset)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track_index.offset)) == 8, "drflac_cuesheet_track_index.offset has unexpected size % instead of 8", size_of(type_of(drflac_cuesheet_track_index.offset))); + assert(((cast(*void)(*instance.index)) - cast(*void)(*instance)) == 8, "drflac_cuesheet_track_index.index has unexpected offset % instead of 8", ((cast(*void)(*instance.index)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track_index.index)) == 1, "drflac_cuesheet_track_index.index has unexpected size % instead of 1", size_of(type_of(drflac_cuesheet_track_index.index))); + assert(((cast(*void)(*instance.reserved)) - cast(*void)(*instance)) == 9, "drflac_cuesheet_track_index.reserved has unexpected offset % instead of 9", ((cast(*void)(*instance.reserved)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track_index.reserved)) == 3, "drflac_cuesheet_track_index.reserved has unexpected size % instead of 3", size_of(type_of(drflac_cuesheet_track_index.reserved))); + assert(size_of(drflac_cuesheet_track_index) == 16, "drflac_cuesheet_track_index has size % instead of 16", size_of(drflac_cuesheet_track_index)); + } + + { + instance: drflac_cuesheet_track; + assert(((cast(*void)(*instance.offset)) - cast(*void)(*instance)) == 0, "drflac_cuesheet_track.offset has unexpected offset % instead of 0", ((cast(*void)(*instance.offset)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track.offset)) == 8, "drflac_cuesheet_track.offset has unexpected size % instead of 8", size_of(type_of(drflac_cuesheet_track.offset))); + assert(((cast(*void)(*instance.trackNumber)) - cast(*void)(*instance)) == 8, "drflac_cuesheet_track.trackNumber has unexpected offset % instead of 8", ((cast(*void)(*instance.trackNumber)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track.trackNumber)) == 1, "drflac_cuesheet_track.trackNumber has unexpected size % instead of 1", size_of(type_of(drflac_cuesheet_track.trackNumber))); + assert(((cast(*void)(*instance.ISRC)) - cast(*void)(*instance)) == 9, "drflac_cuesheet_track.ISRC has unexpected offset % instead of 9", ((cast(*void)(*instance.ISRC)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track.ISRC)) == 12, "drflac_cuesheet_track.ISRC has unexpected size % instead of 12", size_of(type_of(drflac_cuesheet_track.ISRC))); + assert(((cast(*void)(*instance.isAudio)) - cast(*void)(*instance)) == 21, "drflac_cuesheet_track.isAudio has unexpected offset % instead of 21", ((cast(*void)(*instance.isAudio)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track.isAudio)) == 1, "drflac_cuesheet_track.isAudio has unexpected size % instead of 1", size_of(type_of(drflac_cuesheet_track.isAudio))); + assert(((cast(*void)(*instance.preEmphasis)) - cast(*void)(*instance)) == 22, "drflac_cuesheet_track.preEmphasis has unexpected offset % instead of 22", ((cast(*void)(*instance.preEmphasis)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track.preEmphasis)) == 1, "drflac_cuesheet_track.preEmphasis has unexpected size % instead of 1", size_of(type_of(drflac_cuesheet_track.preEmphasis))); + assert(((cast(*void)(*instance.indexCount)) - cast(*void)(*instance)) == 23, "drflac_cuesheet_track.indexCount has unexpected offset % instead of 23", ((cast(*void)(*instance.indexCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track.indexCount)) == 1, "drflac_cuesheet_track.indexCount has unexpected size % instead of 1", size_of(type_of(drflac_cuesheet_track.indexCount))); + assert(((cast(*void)(*instance.pIndexPoints)) - cast(*void)(*instance)) == 24, "drflac_cuesheet_track.pIndexPoints has unexpected offset % instead of 24", ((cast(*void)(*instance.pIndexPoints)) - cast(*void)(*instance))); + assert(size_of(type_of(drflac_cuesheet_track.pIndexPoints)) == 8, "drflac_cuesheet_track.pIndexPoints has unexpected size % instead of 8", size_of(type_of(drflac_cuesheet_track.pIndexPoints))); + assert(size_of(drflac_cuesheet_track) == 32, "drflac_cuesheet_track has size % instead of 32", size_of(drflac_cuesheet_track)); + } + + { + instance: drmp3_allocation_callbacks; + assert(((cast(*void)(*instance.pUserData)) - cast(*void)(*instance)) == 0, "drmp3_allocation_callbacks.pUserData has unexpected offset % instead of 0", ((cast(*void)(*instance.pUserData)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_allocation_callbacks.pUserData)) == 8, "drmp3_allocation_callbacks.pUserData has unexpected size % instead of 8", size_of(type_of(drmp3_allocation_callbacks.pUserData))); + assert(((cast(*void)(*instance.onMalloc)) - cast(*void)(*instance)) == 8, "drmp3_allocation_callbacks.onMalloc has unexpected offset % instead of 8", ((cast(*void)(*instance.onMalloc)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_allocation_callbacks.onMalloc)) == 8, "drmp3_allocation_callbacks.onMalloc has unexpected size % instead of 8", size_of(type_of(drmp3_allocation_callbacks.onMalloc))); + assert(((cast(*void)(*instance.onRealloc)) - cast(*void)(*instance)) == 16, "drmp3_allocation_callbacks.onRealloc has unexpected offset % instead of 16", ((cast(*void)(*instance.onRealloc)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_allocation_callbacks.onRealloc)) == 8, "drmp3_allocation_callbacks.onRealloc has unexpected size % instead of 8", size_of(type_of(drmp3_allocation_callbacks.onRealloc))); + assert(((cast(*void)(*instance.onFree)) - cast(*void)(*instance)) == 24, "drmp3_allocation_callbacks.onFree has unexpected offset % instead of 24", ((cast(*void)(*instance.onFree)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_allocation_callbacks.onFree)) == 8, "drmp3_allocation_callbacks.onFree has unexpected size % instead of 8", size_of(type_of(drmp3_allocation_callbacks.onFree))); + assert(size_of(drmp3_allocation_callbacks) == 32, "drmp3_allocation_callbacks has size % instead of 32", size_of(drmp3_allocation_callbacks)); + } + + { + instance: drmp3dec_frame_info; + assert(((cast(*void)(*instance.frame_bytes)) - cast(*void)(*instance)) == 0, "drmp3dec_frame_info.frame_bytes has unexpected offset % instead of 0", ((cast(*void)(*instance.frame_bytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec_frame_info.frame_bytes)) == 4, "drmp3dec_frame_info.frame_bytes has unexpected size % instead of 4", size_of(type_of(drmp3dec_frame_info.frame_bytes))); + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 4, "drmp3dec_frame_info.channels has unexpected offset % instead of 4", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec_frame_info.channels)) == 4, "drmp3dec_frame_info.channels has unexpected size % instead of 4", size_of(type_of(drmp3dec_frame_info.channels))); + assert(((cast(*void)(*instance.hz)) - cast(*void)(*instance)) == 8, "drmp3dec_frame_info.hz has unexpected offset % instead of 8", ((cast(*void)(*instance.hz)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec_frame_info.hz)) == 4, "drmp3dec_frame_info.hz has unexpected size % instead of 4", size_of(type_of(drmp3dec_frame_info.hz))); + assert(((cast(*void)(*instance.layer)) - cast(*void)(*instance)) == 12, "drmp3dec_frame_info.layer has unexpected offset % instead of 12", ((cast(*void)(*instance.layer)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec_frame_info.layer)) == 4, "drmp3dec_frame_info.layer has unexpected size % instead of 4", size_of(type_of(drmp3dec_frame_info.layer))); + assert(((cast(*void)(*instance.bitrate_kbps)) - cast(*void)(*instance)) == 16, "drmp3dec_frame_info.bitrate_kbps has unexpected offset % instead of 16", ((cast(*void)(*instance.bitrate_kbps)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec_frame_info.bitrate_kbps)) == 4, "drmp3dec_frame_info.bitrate_kbps has unexpected size % instead of 4", size_of(type_of(drmp3dec_frame_info.bitrate_kbps))); + assert(size_of(drmp3dec_frame_info) == 20, "drmp3dec_frame_info has size % instead of 20", size_of(drmp3dec_frame_info)); + } + + { + instance: drmp3dec; + assert(((cast(*void)(*instance.mdct_overlap)) - cast(*void)(*instance)) == 0, "drmp3dec.mdct_overlap has unexpected offset % instead of 0", ((cast(*void)(*instance.mdct_overlap)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec.mdct_overlap)) == 2304, "drmp3dec.mdct_overlap has unexpected size % instead of 2304", size_of(type_of(drmp3dec.mdct_overlap))); + assert(((cast(*void)(*instance.qmf_state)) - cast(*void)(*instance)) == 2304, "drmp3dec.qmf_state has unexpected offset % instead of 2304", ((cast(*void)(*instance.qmf_state)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec.qmf_state)) == 3840, "drmp3dec.qmf_state has unexpected size % instead of 3840", size_of(type_of(drmp3dec.qmf_state))); + assert(((cast(*void)(*instance.reserv)) - cast(*void)(*instance)) == 6144, "drmp3dec.reserv has unexpected offset % instead of 6144", ((cast(*void)(*instance.reserv)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec.reserv)) == 4, "drmp3dec.reserv has unexpected size % instead of 4", size_of(type_of(drmp3dec.reserv))); + assert(((cast(*void)(*instance.free_format_bytes)) - cast(*void)(*instance)) == 6148, "drmp3dec.free_format_bytes has unexpected offset % instead of 6148", ((cast(*void)(*instance.free_format_bytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec.free_format_bytes)) == 4, "drmp3dec.free_format_bytes has unexpected size % instead of 4", size_of(type_of(drmp3dec.free_format_bytes))); + assert(((cast(*void)(*instance.header)) - cast(*void)(*instance)) == 6152, "drmp3dec.header has unexpected offset % instead of 6152", ((cast(*void)(*instance.header)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec.header)) == 4, "drmp3dec.header has unexpected size % instead of 4", size_of(type_of(drmp3dec.header))); + assert(((cast(*void)(*instance.reserv_buf)) - cast(*void)(*instance)) == 6156, "drmp3dec.reserv_buf has unexpected offset % instead of 6156", ((cast(*void)(*instance.reserv_buf)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3dec.reserv_buf)) == 511, "drmp3dec.reserv_buf has unexpected size % instead of 511", size_of(type_of(drmp3dec.reserv_buf))); + assert(size_of(drmp3dec) == 6668, "drmp3dec has size % instead of 6668", size_of(drmp3dec)); + } + + { + instance: drmp3_seek_point; + assert(((cast(*void)(*instance.seekPosInBytes)) - cast(*void)(*instance)) == 0, "drmp3_seek_point.seekPosInBytes has unexpected offset % instead of 0", ((cast(*void)(*instance.seekPosInBytes)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_seek_point.seekPosInBytes)) == 8, "drmp3_seek_point.seekPosInBytes has unexpected size % instead of 8", size_of(type_of(drmp3_seek_point.seekPosInBytes))); + assert(((cast(*void)(*instance.pcmFrameIndex)) - cast(*void)(*instance)) == 8, "drmp3_seek_point.pcmFrameIndex has unexpected offset % instead of 8", ((cast(*void)(*instance.pcmFrameIndex)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_seek_point.pcmFrameIndex)) == 8, "drmp3_seek_point.pcmFrameIndex has unexpected size % instead of 8", size_of(type_of(drmp3_seek_point.pcmFrameIndex))); + assert(((cast(*void)(*instance.mp3FramesToDiscard)) - cast(*void)(*instance)) == 16, "drmp3_seek_point.mp3FramesToDiscard has unexpected offset % instead of 16", ((cast(*void)(*instance.mp3FramesToDiscard)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_seek_point.mp3FramesToDiscard)) == 2, "drmp3_seek_point.mp3FramesToDiscard has unexpected size % instead of 2", size_of(type_of(drmp3_seek_point.mp3FramesToDiscard))); + assert(((cast(*void)(*instance.pcmFramesToDiscard)) - cast(*void)(*instance)) == 18, "drmp3_seek_point.pcmFramesToDiscard has unexpected offset % instead of 18", ((cast(*void)(*instance.pcmFramesToDiscard)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_seek_point.pcmFramesToDiscard)) == 2, "drmp3_seek_point.pcmFramesToDiscard has unexpected size % instead of 2", size_of(type_of(drmp3_seek_point.pcmFramesToDiscard))); + assert(size_of(drmp3_seek_point) == 24, "drmp3_seek_point has size % instead of 24", size_of(drmp3_seek_point)); + } + + { + instance: drmp3_config; + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 0, "drmp3_config.channels has unexpected offset % instead of 0", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_config.channels)) == 4, "drmp3_config.channels has unexpected size % instead of 4", size_of(type_of(drmp3_config.channels))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 4, "drmp3_config.sampleRate has unexpected offset % instead of 4", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3_config.sampleRate)) == 4, "drmp3_config.sampleRate has unexpected size % instead of 4", size_of(type_of(drmp3_config.sampleRate))); + assert(size_of(drmp3_config) == 8, "drmp3_config has size % instead of 8", size_of(drmp3_config)); + } + + { + instance: drmp3; + assert(((cast(*void)(*instance.decoder)) - cast(*void)(*instance)) == 0, "drmp3.decoder has unexpected offset % instead of 0", ((cast(*void)(*instance.decoder)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.decoder)) == 6668, "drmp3.decoder has unexpected size % instead of 6668", size_of(type_of(drmp3.decoder))); + assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 6668, "drmp3.channels has unexpected offset % instead of 6668", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.channels)) == 4, "drmp3.channels has unexpected size % instead of 4", size_of(type_of(drmp3.channels))); + assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 6672, "drmp3.sampleRate has unexpected offset % instead of 6672", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.sampleRate)) == 4, "drmp3.sampleRate has unexpected size % instead of 4", size_of(type_of(drmp3.sampleRate))); + assert(((cast(*void)(*instance.onRead)) - cast(*void)(*instance)) == 6680, "drmp3.onRead has unexpected offset % instead of 6680", ((cast(*void)(*instance.onRead)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.onRead)) == 8, "drmp3.onRead has unexpected size % instead of 8", size_of(type_of(drmp3.onRead))); + assert(((cast(*void)(*instance.onSeek)) - cast(*void)(*instance)) == 6688, "drmp3.onSeek has unexpected offset % instead of 6688", ((cast(*void)(*instance.onSeek)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.onSeek)) == 8, "drmp3.onSeek has unexpected size % instead of 8", size_of(type_of(drmp3.onSeek))); + assert(((cast(*void)(*instance.pUserData)) - cast(*void)(*instance)) == 6696, "drmp3.pUserData has unexpected offset % instead of 6696", ((cast(*void)(*instance.pUserData)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.pUserData)) == 8, "drmp3.pUserData has unexpected size % instead of 8", size_of(type_of(drmp3.pUserData))); + assert(((cast(*void)(*instance.allocationCallbacks)) - cast(*void)(*instance)) == 6704, "drmp3.allocationCallbacks has unexpected offset % instead of 6704", ((cast(*void)(*instance.allocationCallbacks)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.allocationCallbacks)) == 32, "drmp3.allocationCallbacks has unexpected size % instead of 32", size_of(type_of(drmp3.allocationCallbacks))); + assert(((cast(*void)(*instance.mp3FrameChannels)) - cast(*void)(*instance)) == 6736, "drmp3.mp3FrameChannels has unexpected offset % instead of 6736", ((cast(*void)(*instance.mp3FrameChannels)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.mp3FrameChannels)) == 4, "drmp3.mp3FrameChannels has unexpected size % instead of 4", size_of(type_of(drmp3.mp3FrameChannels))); + assert(((cast(*void)(*instance.mp3FrameSampleRate)) - cast(*void)(*instance)) == 6740, "drmp3.mp3FrameSampleRate has unexpected offset % instead of 6740", ((cast(*void)(*instance.mp3FrameSampleRate)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.mp3FrameSampleRate)) == 4, "drmp3.mp3FrameSampleRate has unexpected size % instead of 4", size_of(type_of(drmp3.mp3FrameSampleRate))); + assert(((cast(*void)(*instance.pcmFramesConsumedInMP3Frame)) - cast(*void)(*instance)) == 6744, "drmp3.pcmFramesConsumedInMP3Frame has unexpected offset % instead of 6744", ((cast(*void)(*instance.pcmFramesConsumedInMP3Frame)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.pcmFramesConsumedInMP3Frame)) == 4, "drmp3.pcmFramesConsumedInMP3Frame has unexpected size % instead of 4", size_of(type_of(drmp3.pcmFramesConsumedInMP3Frame))); + assert(((cast(*void)(*instance.pcmFramesRemainingInMP3Frame)) - cast(*void)(*instance)) == 6748, "drmp3.pcmFramesRemainingInMP3Frame has unexpected offset % instead of 6748", ((cast(*void)(*instance.pcmFramesRemainingInMP3Frame)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.pcmFramesRemainingInMP3Frame)) == 4, "drmp3.pcmFramesRemainingInMP3Frame has unexpected size % instead of 4", size_of(type_of(drmp3.pcmFramesRemainingInMP3Frame))); + assert(((cast(*void)(*instance.pcmFrames)) - cast(*void)(*instance)) == 6752, "drmp3.pcmFrames has unexpected offset % instead of 6752", ((cast(*void)(*instance.pcmFrames)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.pcmFrames)) == 9216, "drmp3.pcmFrames has unexpected size % instead of 9216", size_of(type_of(drmp3.pcmFrames))); + assert(((cast(*void)(*instance.currentPCMFrame)) - cast(*void)(*instance)) == 15968, "drmp3.currentPCMFrame has unexpected offset % instead of 15968", ((cast(*void)(*instance.currentPCMFrame)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.currentPCMFrame)) == 8, "drmp3.currentPCMFrame has unexpected size % instead of 8", size_of(type_of(drmp3.currentPCMFrame))); + assert(((cast(*void)(*instance.streamCursor)) - cast(*void)(*instance)) == 15976, "drmp3.streamCursor has unexpected offset % instead of 15976", ((cast(*void)(*instance.streamCursor)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.streamCursor)) == 8, "drmp3.streamCursor has unexpected size % instead of 8", size_of(type_of(drmp3.streamCursor))); + assert(((cast(*void)(*instance.pSeekPoints)) - cast(*void)(*instance)) == 15984, "drmp3.pSeekPoints has unexpected offset % instead of 15984", ((cast(*void)(*instance.pSeekPoints)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.pSeekPoints)) == 8, "drmp3.pSeekPoints has unexpected size % instead of 8", size_of(type_of(drmp3.pSeekPoints))); + assert(((cast(*void)(*instance.seekPointCount)) - cast(*void)(*instance)) == 15992, "drmp3.seekPointCount has unexpected offset % instead of 15992", ((cast(*void)(*instance.seekPointCount)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.seekPointCount)) == 4, "drmp3.seekPointCount has unexpected size % instead of 4", size_of(type_of(drmp3.seekPointCount))); + assert(((cast(*void)(*instance.dataSize)) - cast(*void)(*instance)) == 16000, "drmp3.dataSize has unexpected offset % instead of 16000", ((cast(*void)(*instance.dataSize)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.dataSize)) == 8, "drmp3.dataSize has unexpected size % instead of 8", size_of(type_of(drmp3.dataSize))); + assert(((cast(*void)(*instance.dataCapacity)) - cast(*void)(*instance)) == 16008, "drmp3.dataCapacity has unexpected offset % instead of 16008", ((cast(*void)(*instance.dataCapacity)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.dataCapacity)) == 8, "drmp3.dataCapacity has unexpected size % instead of 8", size_of(type_of(drmp3.dataCapacity))); + assert(((cast(*void)(*instance.dataConsumed)) - cast(*void)(*instance)) == 16016, "drmp3.dataConsumed has unexpected offset % instead of 16016", ((cast(*void)(*instance.dataConsumed)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.dataConsumed)) == 8, "drmp3.dataConsumed has unexpected size % instead of 8", size_of(type_of(drmp3.dataConsumed))); + assert(((cast(*void)(*instance.pData)) - cast(*void)(*instance)) == 16024, "drmp3.pData has unexpected offset % instead of 16024", ((cast(*void)(*instance.pData)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.pData)) == 8, "drmp3.pData has unexpected size % instead of 8", size_of(type_of(drmp3.pData))); + // Bitfields are currently not correctly aligned + // assert(((cast(*void)(*instance.atEnd)) - cast(*void)(*instance)) == 16032, "drmp3.atEnd has unexpected offset % instead of 16032", ((cast(*void)(*instance.atEnd)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.atEnd)) == 4, "drmp3.atEnd has unexpected size % instead of 4", size_of(type_of(drmp3.atEnd))); + assert(((cast(*void)(*instance.memory)) - cast(*void)(*instance)) == 16040, "drmp3.memory has unexpected offset % instead of 16040", ((cast(*void)(*instance.memory)) - cast(*void)(*instance))); + assert(size_of(type_of(drmp3.memory)) == 24, "drmp3.memory has unexpected size % instead of 24", size_of(type_of(drmp3.memory))); + assert(size_of(drmp3) == 16064, "drmp3 has size % instead of 16064", size_of(drmp3)); + } +} + diff --git a/windows/dr_libs.lib b/windows/dr_libs.lib new file mode 100644 index 0000000000000000000000000000000000000000..5345955c31a3ebd4c073ddd05bcb90eab57407b3 GIT binary patch literal 754930 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

B`Z~R|5kb#QvNKQ5h8EK%Rm}8V+-^BPD^T?l zLXjNXIDu*b71FHAMY962xyluFDT*u6f+(!aG@=-z;fr0u5$$P$s(4UNsXcjug!O#y zM0?_n@=kOx6u1tMCktR=b$lj&|898P_J6b+%Fk>rU=3X~N?_avcs0}x z%+S8fPr?;%BJOm@5w>IBtnBt11zK9+`AS&7nvC}`XpdHA0-%ZgQ_jKX5d^fuw0>2C zCkgANL^}43goRWC34~)YD$YzNS0vJncQsyv^8;dN2DOTNrpfzBU(9fX=D{742IoiH z>y6PZ_u;E)`767h^tXS=2lxC0e;wydy5%80lRD{d|5D!5O~<2l(BzU23F_k3Q%S5N zq)@JaXOS6cy3pGwx~J+ZH|K|sz$$NfzoF46oe6)**hR*5ZHtU0JBk;X#;xm&(Fr7G zNjEkbqc6D67(F+9l`%TQPxJgv^EQkN<=1NYILh<;I8*d~{X1a!$XC!edhj*W;`d}LTccHiOd;%Lw>bXA}FP4V25AlQ}iTuAMEP8?l%xd)i}JZ zC)CG3{qT<@UqxUe-gUOUGy*enaWwNlC#t3Pz(%qUtwxqV@r|M)_Fb|EoZODz@ae?$xK0allc;(H&&`Zk#)B12cqhb_fEi-8naMQ4ElHlX@Hb$N z!1YDNiFAEwB8_cy%Tl~E)AeN@SZ=jkkB8~{3NurW32SPSv4Tsd1sYw`WR${qFxrFx z0mg&THTU87L--8?0*nWvYg+NU3%_ANpz)xl8^3qq_bymA#fSi#K>*K6(_gU-h`Im_qyDsj#%cJC#0~DNW^-A^L!}g z8CU9Hl8=;04xvE?Yg%18#XIDyJRZyGT|pAJw=j`4vpIj63lJ>hMXI8st%yc_OsFw- zUzFm^OudZFAq)ty9dz#)t7E$srEAZ$V%_Q532l5%12pnn;p~;5*o0Ifg>+0T1H>MxrnR@qbWpVGbXl~I~|(N?I_(DjOIn&L}_a3CcMNOY0KI52cL~sw?@{0 z1qOW0!drJlV;n^}k_ZBDtT5RljH4 z&VvhmB{UC6baA>Cdu$n*{eAlkfc6PJX*|>sX??>1$yqmK(Rjb%R=5iK8ju|mEofV* zThQg%ppc76i8xR@y4HjSm$?c*p~KBkMG97dDj0QPHf~%qKoIqPo)@AK)Y9IEpaO?} zKs+F!{%7dRP)U)nRC1VBhLX^+kebUMr^FP`2K_{If5t>5{1hOyPEw=~2N{F{4S<4x ziUTS8S#jVSfb_)wlYl}}ZUoSOxU@p+{s;I!6!<3o@{9*Ea^deDfu^I3Ddozrgf;%{ z(||_Fvz37MOSvj?Yk4*eP`yAKT&M?-)_ot4*1ZfeN<9~s1G-Ckbu}RMTr|0F?*Q~Q zdArhm`+opwD-XF4^G)eDMncFc#8dlP?oJna8jyN3{sc%p97TvW(r4!YvVCf{as+`) zc8Ya-y|Po6m5Rml7@$&Q!vXpC;V>CZ)Hu00+^xXMa2J3Zj*YC@hb^MR27EjOEc1-M5P}(a2v1b6 z$Rp*bf?uK|L@RsVi5jKAwrCR67Am4}Jx)m7vM|tCJmMx7coXpzu^Os{`EqTH03Rd8rOjfdldP+ zpB}@c$B*aGV>if-pCC={SOlsC{Vjf%L<#Eb{IT-f>?i@zz>ns$*6VjUViQ zNWo8KeU&8q6i9e2PX8|ce(#p!NEXi^+y}Y);l7Tw{LyIsB4{I$iSedf+_X!Uix>qM zklMvN}*65sub6`Ir3fNX%O0 z_U$io-au+Wkk|I^Xk|Ov!nx&j;QXUwK3=E~_SvNkyY!aG_Ltn!0Uv_2c*rh3)-L`G zy5|-b0%=pK*5V}|4e0~qP*Y}Xrf_RwQ8M#S<*c5}Tn;9{4!&o!v|-MBFXk#FmU+$$ zcP0s<-mQCpUgd)}dbjQ&dbjRz zF)%24S$a!k>j!S>!O_d&&qTKFb&DSidfiH6h+;u6BP)!Sb+Vv9&vegYb1r-G%VBmw z5EMdZVD(|*o`ng&=zg4=L7(XUE~X>_4(W()2yqeJ<1C(AhV+hC?iWGsNbe}sqU5q^ z z`Y9FH{Tm(O|CBNBNuO2L)YPK-!f0C10h~ zpOpzcZcBbJa${c-9g0{H{2MQ|HZoD>#_iqK#vrV$*KUAz>`mDgEXWQrIP*pRt=Yl) zyHI!6&}zLZwYpjBJ=A({Xtj1qtsd5b9E$9*Yi0Eh9os^d&Az?o^s)xHqWB#PI|;<0 zk!oXLH95x2Oz7*7x|4D7wFT){11geHXSJy!K*tRFNIVsKmxS|_EnFY#U5w_q?_jJL zsWK9Lf`T>{L_jl)GIPUXa*SfXG#MAoW4G{e?EJx@%HuFhLf)#MBx${wuzn~m6Eiby zU$XKo99SEM$T-+@uYoa}*UP`n!uLV*OjsWztX~RfWUl{5*lA`CB{RJKrTaAZ-3p|1TeTAs}d46*d7T&se36J+`=W# ziMKX;Q@`2a#fk7fzTZexN5gxRKJ1N&uMkD7l)-rjkdU|5d}SzCw`e=AR6t?*k}+?y zz7c_%2#>+gz;G6nM63m+7}*#Osss{pd?`nTpV9HyZDb7%JcpyhklHaS{#q+T^F}2c z2gf*^!LG%(H`{cS2#;e=WU%a&jF)nLvpX6*N`%8w3Zr!kRXBx2i;zN9b|Da{-O>aW zVxtJi#MsI(ws9C6R^n}8j%^&rR?e~EXLNj-J!crAOxr+XL;K$Fe7K$}a3@S@ z@wQh(ERYDkl&stpLyLQ;D^aD~XKjjDqAr8TO3SV=$A^T~Q8A z(5!5Spw{j3rzkOjv)PHvoT7NDT}?Phw^aFOicX5nWM+;81Hf57Omkejev zKp&*ugDo;JXmtXY*7^d{#9fioMS@PF1g(YytrZD6glZx}r%{9+3lUl?B6JAVM21eI z3_TVyv{qy&s%7=iN8Hn0q))SD=n+IZF?b7%eWH#bG0Zn0Lt%DVA8}MM8F^NtTrF5M z&QeLd7~;YVy$G8anp^y6?+E5AAPxuu60Y*ifXreBWku^JrIP*nJ z;b|Zks$4^>*Ddv4Wj$Nz8d|*`skamL4!6~=0`)Mj9X7MA*@Yj{RnsC zGd0k=?gGt>!0=qft3azNPME)Ki>h4w3;oO1ydLS@1LqJ_E~;LeX@iSV^Xi4_{RD#S zp>HjX(nEp&p?G}&#jBi(7oxdc#p^!Eqqy}J{Z0gNm~vmd@=aB|I-r{2s1g*fnAPKG zSIB`zEsctnU-7yNzZZG-vzT=uaJ4CB&4&VZOvJhs7S-sf*!NH`iCEjVzY??Bx4#~> zHbS=ot*+hPUD?GV`)K26jaZ>m36K&t@No!=IAu^}XU;mBB}!N)r>I_ZFcN-lnGioA zf^a0-&;^jS8fQ@h1Fdb6c4*4wWac(AM&6cUY*4`FLjju)Hh1e7_RrS1az^G1s>B{t z^wd%r6>E&)h%i779v|XB$s0K197`E~2xeq3crwdX!hixTQ!Zuf@v?|&U>vJcL^UuO zj_e6$IrlAV|uvt*RE`$O$9}3v~a*Pc!GkPjCt^>{5IE=s@W4SxVurn%m_GE06 z^TsxnLnkWSvDKhz-aJO7x+q)glbOewKyw&FGIIk2s$$%v~}}j*zwA!&h`h`DN!z^aj4zk0 zUUjLnzFS9~M|nH(T<5%pBgMCJ8+lJq1I1t`)UR8IrhbX^7qbyVjjX$6>qYgeBVH+4 z1WidJ7Nh#b%^I{Ts<R-l6^ljqPo-?X}_Y;Co2(=;>dtCo10&{R;uhuzqh}VxHlEwaM%hBRMgc`N-WS3&-a{c6 zU1uv`+)ocd0TVnE#hGy#kZeHIhtD8&fvo|n0=8QfF#2+-fYl610dwpr5KhPB=wF@G zzetn00#(+Sk4UG9K%Gv3dJI;BYG6aEC=zu#CF(?12OCmF5vkKDQjc-9u>6W#N%rEM zMwu#$ce*W84|VjgKf%{3GS$|@aI-t|huS8wLKt9^zTt;N0fjzhYhn-g{(#m)?8d1 z3zJu$ZSu0cur&c!9|H>;YwKf3;(9*B6f_gC8f<7OD8<%Qv%{K(<%nbNxi4O1b*#?< zb-Jx-@*=O!tJAFL>F*V+(_>AO7kPESucKpWLCx>mE^Atrg;{%Sn^2Dt{R>{}^~E-= zOo#n+nuQBj=_j=|*0 zn;aMAi? zx@c0cZC!K6(`Q0kR|#xgb7AYU>Y;pj#x4w4d{GuQyBJ}%b<^9VsEJFoE8D~cI?ff# ziLj?%sgbKtnG$mL4U|$a`C$p-tB_+^S{RI5`W`A)wtcIZqk)ktK_l1P@ld(yp>ZAj zaK>r-W$cSR4BK#l`-D{cK)>3_YuGn*Hes8!@YYeP5Jt%Y&H$v4s#P4J&9D$A#6sEx z)T(ToRvE_w!&ZWZt-0f&X4N}(Eyt)er0Ef3mOVXU%<{(No5U!`ChCK2&T;>1E;EwW&Dz zU^J{o6=!^cbTzARY%bEf?U|9ul|pJ*K_PEuM6zdn&)wxm!?tMuu}_8KwHPZ!IU2;4 z#Vr<;BE#w#vvF<;H~ z+@Vu})swKau{3Rs>VPZ4H)_vtD?Ew4@w>flZOcc33d4;OKlR|k3;{69Y7q&>@$cfizhzz7U5->tPm zhhv-}m2_FHQPM$vN3ulSI@%ecFT&2yo`7+xwf8PG#9YigdyobUT}yl}j{b>b1R~;g zLl!}bMXmKoNt`cAa7A?)Y<{p+sbHWs`_i}f2kkEt(uXX2xL+zh8wCT z65KS+8dECK5Aa32)`}EX^I8`fpB1JY=|TBtQP%7_K*60T_&N*1fIeu8yHId93+_5V z!S~`4fi(jZ45rY8@kXmZSbS*T=b-RiHnAUP{fq~HA4L{RTxEiLm~i>Y)rsH}2z&ch ztnv?WYc_`&vWHnJ-wGX}6PZ8Eef(DA2Kzhl{&n%x+7KcZjoVk!DU20ULABr^bRrSl zZx>5czHb)&st3;)?}CedPHvRoMI7hRqRCA7ZpomI;C!Ry{Ac?6qeg{>f@14OOAzBm z@l4}HjS3AMH7Ycal%dHCFf~z7quA{LR7(R=d1Vm!WhZ;!q&QptIKw^}w|rT9DPCx( z@&$l2UC3%c8UXw#p!*MF;Bh-34FG-`(1Y^q6+k}`=q*6M5{RA9&|Q8*LwA=0()LyW zx%S06iuU51S~o8GAG>_dXykH)X8z>~nzh8IL$=xt)OY z*{DhTk!8Z*=TU0 zsp_tlnaz zDxvx!2pIUH`4IMkHr>4*4IFd#5x4$;Fi;SGv9jP05+fmyBs1n-I|kHeD;#|5(MFY{ z(AGm=yjWo8p>GQ8JoLq@sFJ(!&^HA(9{OTufqjR*$=!G8Q=1PT2PPrt+K1@!8JRJ6 zTA{IpcN}f+P6Hp_lC$HGr_n78#6&ZTf#b((>>N?;AdJP!kOK>|09OtvU>B{m*Bh(8 zcr|RlVg&BtGM~(i1Y&`Hq8beL7wM9)T7&;X1gY*YFl(4AWR7PjdK8&Sz{YtYL8;h+ z`{Bli-cFW-vpCM)1BMO6@^xo_3b;vP48*9+;?zOEE^}$Zn^JJU%smXbKfEREcnwg znsKn?!jQ|+lyNlUIGS>fCT!I?n~sAU%^b@&Pmyz5{Dg1udIb{!Z^l{J5Y zb?YRKrh=n!_8iUtI5>CH!9h;4>MCG|boLzCM8{9K_~xENQ0b_{y64!y3G%iR+;im2 z3ilkG6|WHY967VnW9!7;_qgYJhUff3_8h;oz20a(gsA>tUP?xbBmURu3355s?SB%tUO%R=b~zsi>Z3}BpF^%F58D3L@}-21Oz&Y zkRs=rEUfotU@HODgy{1mm2)=RxSbL!iSv7z*`Z|R)?}u(IG%bV1pCmxGKOtd29m3C z7yNAu8iTnEv5$_t!etk>rOX!|Br|G@D_FDLErmXJrBz-Hl~(yRTw#@0Lxoj-4Odp> z)yS1q+9xQqII_}mqROfzvmDg)1u<~i$!wto!vuCWS&eevM&;Z zdlGq2X?D9NT#>|~aEQAmG|DivWMwZ;@RU;pTd478-?Rna3KWTF;v)F4{}vg?*fZ`( znNb}F10eW9;RFJ{{bH{SVoxJWuq}5ZOXe0_T-jEUg0>H}gSl*RrYHOAa(tRz8Bg+! z0PAE8*xVXB{{9kgpIK5{ScfW4hOp~J(n)?*NIH^%Y~;TsXvE$uQTd8)&xSd|Zq7i$&X#oGZ}86?CoUmt zv&y-AQKJr_Y?;8_+Ka49GgzJgw8dPO6k&~5L9%0L1k0;oi@CfSJNXTm!18MhNz6@y zWU~-vGKTvxnxeDY8Ioj6Jw5@uu}gVL8%{&oVvC74kTdsY@E_c#H4oAXhvSwlgMW~7 zHzC#Gx(tImm=I!e1ee&0l-kUsj4Ix~wfbIJii{lW8 znMwB|nd{R5pz!v)Fmb2tGhwC11$UVnU`e&MpmVk%75AErj_t7OXh!w96Xh|ThNqE8 za?5vHb$py#o+LsGYF_ystB#Lz%hOqS8VMw~{ax6S`c0?O8)!j2SaPR|W{GiAZ7Bt| zmeeLQp?hIJ#o?x!kc4PuwFlx2ZA0$-Ec2-t0ixUBQN}%#+p%w_IO0OBh|F(40n?yb z&yNAA){~{{Xr}bk&dK>UqNr;lI$Lc-^I#)-R!u}CFf|c@*6hO=Fbgq0fx2&m7NR%Q zLbR>nBGY<8EJQew0hLzvI6`H{bsr^KaJ3UCn5=#lrwr6cB<2ZGy=^)>nOrC{9Y&&l zoXUWO82Z;+2s90KF<=mi_MJ|^pkrRfe(xZ|1zlO{gbT6>TFnm-F6h;h;06bZx% zCl>la!wkK8J(S=k*wX>R1rhZnJ~;^&6tV9Q7Ze0GjSK{UmV03eA6lfK_5!A)=+gmO zloC%fR1j?~ei$nFWVIcEUC~Gc+mYCipgcQzG;K&Q98KItyV3On+l}`BHS9)+K5)Yi zq6inXHi;og%}9k~1-bpeZd`%|!T#-FLHO~#U_n044Hk5@GyBL!VSl!-l&4$g__KXw zBw|nl2B8@%KenT?e5E|I(uIhf@=QyGBL=zmMjRx^P$F?=guqe}2uWxRnOR=QphHK{ zX{l~yn=8iQQI1igTuS-P6?rPRdbkT&n&4}7;|A5m?U|Y`Ec2V23darR&Y&AO$nk05 zAR#Ak5HoFueR5Gn!;|wzI5mHSHI$h-d#XfOf(N5vCwfqiVqgu@I>hN?)3#Qe2tO&U zW{&NXSDWe-%dIAR(CUI-TX=FDC@kE8=2L?Nj;4gP966>X@h) z@@?818SZbymS>x&#<(UbDDIGx%(Y|sO;jQ$9XpJ1`*_Mr>kkRorjnJ zj7vxtPBYR()s92D|3^(!dGbY(+GWN#8oZ>N1qMfn%K@mwC8QFU(BKlcE>Gaj%#*iux#D){1}+(|P4w9ouDM|Z>F1ca zqE#?y6&POD+_~bGgHv%!sIa)L%agV<^Mq|(Az3?9L@kV46iT*T3gZxiRF0&b=?Pjy z+{yZ`bLH&Jr%0y=)W0;0&D^D7sP8w2-(!ah30s#;Mb@&^!3hc{cpNMyH+tNa0#5ii z%H+h4dqrG9krP4gl@LMUSi!zL6f2kn^}^+IAS>8KkfV&b&k6>`!DqF54NM&l%Er4W z8=oax#}}5Z{{twaU2M#Nb}>5-5M2%;SsC)d5D79p>_91G#pGYPHc|Py8aoM`2zp5!)C8rx>?H*ESs_Il={pvV7u&!pl3n_9`)drQVJnl%@S_g5;OaZW!x#G0Ifc?WQAWa{IG_9b`YypjC6_^$E_0VW0 zhs{dG=;T;H%2i?_H_X+`QtM#fxH-Hq^~4@{e&TI!;*cA{z@B5s3@&E40jb|UhSYck zQoq@@ka*=EXm7iUDM=BT4=WoIQaq#j61dVj$NVuW=dk1xLq9CJ21xo91{FwDcNnQA zP?oc^W}!kas#)u1=*;e&UGd;H-h4Nq0WtKX9&-%%%p#jYY0Oty!|osxrv~& zOJLxx!@oBSncixJ-e$lcJ9i@J4TiNLk!h{a+YA~%c(McbwV_oLdYeJp$3)N@%xs0K z`RJ_{EWAzp2;KUvq664VgzYVVwN;OjGEkk9L9jNd4M!PY#|`E(ftmP+USHv#ZbqPewcU> z&~*W>HJlr{K(01~chWZ4iT_beaX2_BAzr;k^H+vD@m(!|-0Xj|LDn0RmG5!xd5LGs z_n<{OVO(2HynavGM*XPivhb0bdUJ2 zMCPJmNdI0VkEWA+_PNs3`%pTB#hY&rb=cZ|zt!rUaB} zSq!Tyc7iLl+&)LA`wq^hCn~oXUJGrmUj9McKFkxskc83Ei@LNDo+7C^wX^J%;4bYUJ-tac+Z7a=P~Ca6&-mi}+UF z5U6}?%o+o!*bPhhe(wx?#v_0&w0rZwd?_wqGn&c5BAJ?ggnmde-reBI42-5DC7HPv z3BPf%b0Q2>gv0Sv2l(8>bf9nQPM~eZ;KGAO|l4OS>fyu^Q=?K9vDjr!oNRRQT#o zJy13~?CD}iXlFfn;DmO-!NB5pOr4K7*hSVa`Hx;aVZts8L|a3p6vTJlNjSRy2hPt(WPjxBfinEMTx8ezk?qSKD5Xba(JJ?seq{TS z2Ws1S$gaypcAblCNBq{$`sfp*+;VZDNhKw{Pa6iv>E2dh=}=-%VdWq zu5LA#o(Hm0g?c$4JzeoJP>QP7r@*YK&z=FK&z=Q;_5}iZI=3+1IoXTtSv)-&22+2SOnsq)?G^&u|K0-p(o&OI1f=6W+8!j7K;RM3Hc%>9NwzzQ z!t+E3&%9*2teJ)IzaBRqTy*Ag^K3SfD>`$zxiSbprt5PN?TJo@o7aPz-v(~Z6B?;M zV!=Nl?EGO3or9s{dL~6EwRyQN37607<`k^G1*=g{^c;mXfF+a2e0CX6^JG4Ib;3DU z$rRd9d^bVwXQ;G!QKeX%!Gd=Y(4lVhpWr{f!oYI5xHSOl2m0!`8Ye={9fwp z0;yri)F3*umE*d7m|C*16Ju5={9&5Rmai1A+Tz?3krfsz;ls2EKSWM9OPogGe!v2f zMjg(6Lpd|TV!DRN+3RvO3bF|dmkHc{V zEp?}m9>IZ`0c9zVC+bBAxT2^TFR-&bK?+zKVY4dqXlf zCe=XA$FZIKh_@hME1AJA@)7nSQN78)X-sbu!H6p77~G9mF$wGGcxDN9kvLRvD>jil zR4{3?9x9mn6?eJ#!(fb6GnV00%emMuT%@-m%(yyopj#2_1>;lfLEYF)&Va-Uog1-^ z1_9#N&>9-ymnmE&PM2W*xCncdp|>PXI@kJvrm%t3(ZTp}5nOQvoATd>AOpiWG=%li z_HkR*bqMm(UJ&GbG9444JwV;LQ@<3-x(J~#0pP$Uv3SJ&77r4oXSVf`XPD&avv>%3V$+Q zRC{Lw=NL~*}jpPYHY9yZnNOk%KK&rnp1%vAEC9Y2Y3sm~6x z!(5$MYKRMePD~B5QaLe{q~qCPuGd2^!qUnMb7d-3q&`3jfEWx${fuu#xT}*zmFLM0 z80Lz2W6j51FblcsQFgMBV?XVr#6*fDcq0qtF86A^D&aKUpk*h*bttv$Eaa?Z`xK>C zR>f~0AQ^lD%YK3{9cF&3x^}exu;wAS zm9aVqb+uz$>0M-u>t*6yv}0VInc*2R*!U8aZ`#4F2*w9REnYTpTMS{Z?wRP{fm$7t zlbN|tj)ooNnP`_kGOQKROxba*Kpc-phj2VPLG$0s{sSq&fs>Guwa$h0t z^a^Gn_m$zEqi_~-Up%51>X4`jLxc6g3uv9oW6}s#<)CnM+Kq38wN2BjgS&EYgXAC= zB7tWOK4cxMe3p|A)~HFyC6v|6FV3B&1iT7cl~NkZ>d$Je$H$zltQ67%WEia-ax!=% z>s+3hMszBNhI7;s*eXYeFn1DHH_*_~dchf!b7XejcsWSsDjdGqh&nT7=WOzJ8ooja zZ^}$(x9)erW3*n~1L@E zs`l_!pNBU4RJDgS1g&xf_>h)=s#>#I+NJ?7WR)iYG8(cfT$=}~>7S;h*p8{8c|MK< zLyo~<42t*zRtJo!p%BT6qXBN!&krC=qWF0~h^K(WV|2iQYUNA3q14Kkc&wGxJs)EI z0#D;pZGpEW#uyqs%aI*Klhu@eq?B^oMaqS?+d}R!IYyQx>Aa{^&&=vYr7nf)2cdtBo->*sjwD(1hvCK3#1Gs4^-wVf7>{cjg|b-Y8OYr5c}bfSR{<*ypE{ zddCM3QNPV|)V%i6mqDb=+b(HTDw0O$MWtr1FdtuHMv*~ervFf%%QiJ2Rrs$Sug+(` zGhKNphpP+lUYxGBrKMVdXuZqfymcZgXO7{p^21T*@^m#~P02HG;@XW)6@h6dN*Rj4 ztfRb?ar(uj7l`Vx5jzmo84A{r9f|7k5&NVy8HLSR?W5KnA31Ow>Rg_*MsO*|h11s( zmg-8&!NyfsTF&%@r5?I2Fj=ms)Fao<5E)s-$ZihR6_gs4T4=W1GuLx@c3KWolM<^K zKkl8tj#lxmjw-PFXch13sKQ+xa?aXS;}Bwg5d7XdfbC9HuAsEfU;E}MkKfzpuYL2B z$M2cASdrmGo@ONSRF^wN`URl0bw|RC*Jng^(bqND9SxjUXT@JSY}a z9>wygln0Q|L0ae?LJ71f6nM`y&mIkhN+q10)SjwU1+ap@W8HcqFjurI)(?|}ED!|maU*iEvMU0JDgtCN}Ho-9F^ivld zUP?EJYj|m#V{&T^FRh5b$Ns;D zmp+n|byO#3w>t6Y z!rR0+ZqZ`H_OU$P5YFk0ij0{bNB|dV&IVw)9()?ULS}K;&A+f5i!?a&F-H;mT)%nz zn;O~b`%mgxZC(@pJ-+i2@V9v7c9!yEMQ0%*R==kk_lh)?OTZ&mhvJWs_FFg#lonu} z8NBB^!f_&{oqk$DVfTCwh7sz#=R4VtcYN>3>#Y8Y+T}e>DDamQ-uBJe1aJFp6S!mt zzWxhejT^rg09H4Ce@dWD>fe5ER4MezZ!8AC5a}4%FL251aMI+x-x2l=Zzj~J5!+$} zjvWbX&o`E@hNj-Z&ELCG!y%L-5BS(;Sp zjL&W0kK^L=aQ*i*Ujn%P`))A+w;^_=`BN*T1G&lBsH2=DzXVVW!aU%QnsOv?3IoMe zqtX+GC4nkTALrN{XWtg!4}Yl1->3;NXmEr)mJ@K6;5h4@-&o~Rt6jL_M_sRc zmDelt&Tst>e7z)#A>YdC&O%!cWaxcT7Kz{FjQ8=sWW7%sc> zwv^0hJ?=LK{^;JZjuUa%qaSBK9%s*ubL@+?gXUvgpCi+_bZ>(m4^Zcva+SyJ&E9M7 z1h2UjJfvM_g8$!mNBZNeQ{<#(H+5);jF0pDGjIux-;S~Gi?uC22jVzcb$evpk!TT! zp7e^Wr#thkjW+BGQ%3(qx4Fo3i~|vQx`<=hI~(Yn+HA%rw`HvJfM(9VcTBe(Y!F;@9)%|75rx^jFU$%Utkjs`2;<9BN z!5d-U&3Z!?>z(6;zzm06XZ+t#eM)*}^kST-yl$*Kmz(?5R;8oF)N$T2Ug9(aJ3}P(-iBYnt8ltC8|Bgk71(Y?^H|47zr7n!(M7`|N zQNFrMz3_n2Vn-qW9^OB8TGlXk-BJN7&Q5}+L?>~oukZ7oMqZ}IKZTNr#^(r+)rM|Z zzuJz^-V-7{_i)EYq~{SH*gGi3u{qjtAjZB8o|tGmcO{8FrH;UL1f!L{!P&jk_g8at z&7tf@C>+t^R3pRj%~g9qd6b3nK;*(t&t`e4%^NW-Hw0$PzJo;=sPC+RsnK8!V;7Fc z^5U&vth-=yudXiC-58#0*;?ouN*fG`$V{m4H;>Cn*_9UuGOQ0y6WJcPWFo3{grl10 zU3TuCJOxQfw2xDw*;Z|EqL42{JIZk(&VH6xxpDo-6B(*6G}u+sw4IgO^LNLT$PEr$N|j9*&UT?Q#GOZslJNtdL?K` zCXR0yg6nA;T*MnEGYrX0XmA~1LWA>o_iAu?2wqo*WWL_uh6v(d^j9uA(j4Pi--x2^ zX^5UKhqN3-HkFhn)QG26ynr=!b-Vn2i-eBtAT99@njzM{M#-h#{%8-!PHS^uRnKe= z$erIkDiuFzj@_zT3}N_d;#%tv)(%ow5>l9FOZoO$ z{VH;p5`h^dQB;T@0@2=y<`A}CHz!Q_NBxx@!G%!AX1J4lvHhHzEYX1I{-J19NM$T+ zh__KxAdk{Dj}UIhFC^=UQ=?3Hs!@E$=DUfAwLk(iM*+ABO#s9v5-z^T1aO! z?zVI6LDW74O>L8>v@xk{uvOBCZ`fpu zYsJvD_>(%@O4W=*he&1wgz^T);sgk26yWoC_kx&WbcR$$07ei2e!YtK>kSY-z_pJa z7U`t1lggGC?f9TnDw&DIXd4=dVI^9L@&#|*?sS@cff)mCP-CoTTg5nzMT?I+}l zqDTL|(LQXOcA2q$RFDaNa0$bT*qK)eWK0El3?&l!(peo3MOq_T|NHnq8?NJRDy|P)214Nxjojtd4|Ko zdVV)`VrFD%*eQ`gkW2Ym5uFi&zAvv4Xs9YdH&RDZ=TkXSM^Zad3Pk|#q4K%_Lhh9K z**8Wx&btWSX-MJ>TvmtNFn7ham_A-O;J6u%+lER+xQw9^+bd~=Idoc`rLs-wMqId( z%TNNWTcDKCd5|xPq$omDHA0H03Mp^rl|)g}Vogb-)Lm5)cwI@It_@$Z$Xg^YOF`ux zE_WEhDRPiD*zT0Jov{c2wo2ReYf9SC0J^k6B_M+1LH?t}!PW-gcid$QS=*EM9f&l! zA2;Pv@=I#iiOs4!1+3O4?@n%u7Qwk~YjHusCJcg+(OFT$U{6KM1q~j!h5`PIB#uDaVwQ3!a0w=nh~D4@xiKyOO8Pd&aWAhuauW^wH1o~oB?w<3w`k`j z2s8uw_Fl)iwcLQfXd1ZzVKyL%wV4O#DpT{G2btoj3*kZDV`I`ApgzRo}^oD-!jSw~L4vWI-JG*lO z1oPnZ{3zHrBZJJ|4C4k14MuO?Rzz=BomtEnj1Dwz*q7CyK|ANFGH$NZ+R=ORNY#@^ z(3nx{0jLPA7COA*FL?abJx}K2vfEpfyna!hxhimt zwlgIR;@VF&z)4Ue_uItU5#htD3+(x^ne|Yq^Kq&X5PWO21h(j*oI9~w52xew_Tt_= z%s9~&m^(LscN?KPXbeuI%*Jq4tvico3>eQ)t?iX+ZL6B2y=soOsy*7P_Gl0II!&1d zHzcTkh~6O3l#x`bs9CIo6<}r1Do~!R6RKxvm1iLPGteq7o&cj|cCux*xosJ5r=$m| zZ9F*IbRGGJ7;hYj*+Y&q-Ob}n5oX5_Z603AX;>I;Ffls!%Q22E>J-r!9B$y)iX#qU z9MFX*O)8oL43`Ow&82_i{Iy5x-Zpe^^v31td`_d%F)eqGZA%{w&Pt4h$!6c}TvV2N zEBkRLYYpa>r$B1DK*DhBnL@e=rC`)OT1;QDa>!_1{XR|2EP2jUF6hKQ{wTI?V0bIYQLEP#obT)^M}^ zS2ax%yW00}2rO)F#q(`OKgH1<1vFrk=SfsmG+>k`Jk`1eJOf@R4T!TBV(gog28_uX zjY-fQRcU84LI1($15J1jTV)+7=xpeJRDH^A5#`vUE{ooCHqx<)_76-K%YV)Wn>qR67k85% zOzbfEp~j@%dLEtG5HaV+5Lafm>t|{%t#07hyfwQTa9V#B5GK( zG+AbB*xwWtZ|Nc1(L-D{Cp>o?;HW;8@JDpVL2#k^AcoUzph$80^Cg^RlTYn|%`(xB z!`vbBUM)JY%Ak4hL3>f72VA4~peJv{i;sp?J6w+Njjq_@H1JAtOf4#?4! zt(sO}ar_7R!~-j6aP|BrI;-AdmLR(21^O%YW90u9N-Wxb%n)(#OR>wQvkOzf2L#+h z33!l92C?N2Q*LVV=G3}vII2a1g`qel8MeM|+;#*cq37{{#JE-38GI*Kd9N13nIxLr zqNI6gJ?2mdZJIm|#;j=P5rCkWl|r6!30H|gGsfcTYvnZ5Pl|$?4xCKajYCb(1!OEb7APS#;cgTtkGK03IK7^-OQI^sGEtX25w0!MQas@7rfhyQII20Fd8 zTE$Fx%SERj_Cm?+2e2P$TCDv(bh@SKSv*;W2{e~sqPa8Du{qdSikk{shIN&xA)c@c}08kFy_$cHE6YVX#RM z_bEEHyTPuIQec;{3&vm<*~DcNvJCR6Hfmk7Vd)BsBNvPj&~@2_TrFbR1Z*oOY)f}x z+h>eavmeLaxv8=Czri*RM8Yo*>?Cm+Ab@^H_E=5 zzW!6n!4HE1nyIvMKb02V{pi9w?v^L-&^0M@`ide<3@$6;u!&27lcOPm5m|Bf5rVF` z%7DFSh-50za7a}o7D1xzzs5OE6U8^yehO>Bu{eso0Dmz6x4|Ya4x_YWQ((rXU`i2N zA5)5i`j}Gms*j~hWxk$u9LP9jql4fqDu~)RwxWutsH){=>|LyXU0kYBp1ULccf&l0 z@;rj&0mptgcz~)HayZg|4HRVCtPp<=xLavm!PCRllaO-!%K_srSUm};%D)^p{*n() zdPmte%3MbBB1>i6#B|S|$J~J1iq)FQ4Yg*%^^*j(e$q>=pCsVi*D3d~G?iBad{hj4 z5`dF|TVu(*TVP=f_(s+Z@MU{*g$cZRoy$z&HKL$^yc7$;vU+4$J+Q2DJ+*g-YfFv; zdrqU~g|N)ZEwIY5A4wzq55pR%2m6CelWx~GE5Lu(Z8A%oV`Nr9IsWB<@fR>Fpep}z z-1tjAI&0Yo`+lyR$Rf(!UAJlLAc4s$MUN{eTv#f|q}Y188RLo3kp_E^A(xTRzKME( zv|33~2j%FdBbQZRKaNeJD}&;Q<;7V0ZFCxRpR@wv{aq0 zS1q+@SxYTi)>4a>wbY_zEp$3B$dYr>vcBqc7LMs>iP+D@+H;l0O7s;Up3bj6=zM+9 z_gY6d#=($$;9wl_sk^s!8EcD^mK_LDSy z#$#dui&ejmEXomJQ#^$MW>~6}sRxFyg58h$L%cF@@_J#m>u(m*|6PI~6Z& z}hfo!C85r~cx^h7%QE3>OYY zNo-nBPSpLVzw+V0+Ze+Oec?z|?re;q4j4*3pvSRiqc2psius1qv^AZkt)bIf(?if2 z9s+C3H>S~I_WhG3deo$~@&dG0^Z(ZQtX1plu)Y&oE5AT%wH*4S@&&Zky{CPldZ}xp z^~PnD(9H3aD0ogE^k=s<{Mlx|MxR#eZDzj~CxB;;9!#M8+jIfwZtb0P+F*t*Zf%3t z!Qi17FveO+p&o7J$yOfi$QlqYajT*++Nj2$SW*?oKj_hp%^K=E1b#g_X|`FNG_GE3 zI$JC*8*VqDmqV>7{KE#(-7?~kQ4Ip;wK%xxs1X;9IA`<*>0>kq-P!1EsFsU68?Lkm z-Px^7=M0@(nkN%i8UAwsrV_u-d z)tJg2q~!M0BbhlVR?!!q!Mmkod#(bGr1+h~Pg)+mUT6TUKK_ImAjN*=BS$jd!Jz5J z@UTQOuM9;Vk@noECYQK|7bbzs_fjJD(W_fiY}=2H&dO4E%CkUp3ekJ?U>I|E*V zH?Iwo=#k9yAz31sxx{NkGBY4qMKW`g_jsg8=865FpnnP{Q3++<6!~T{W0_ahNX6d} z&a4Aa(ETD(|3*mjaevxZgA=2(!lxh!;KfWD!_Zn4-8__)M|5)tqMH$-L`UU#hQ!P* zu1QSuXe<<~nC9-q05GO`5`St%YFgmrd8n-faJ&l$OB={Ll!0wHB4rA9D5%q6rz0&4 zJ2VQ@?2EJSjmE+d4ly=dhm1$U#q^F{5gePQr1NbQ&*4Ko5YQ z=;f`~0w+aa$JC@4^c;9HXHo6MTMmOA+ZnUjx3Hzc&uGE2yiO8OnrW?M>9*epkq!&Gk3#+eq>f(ggu}g-$6MAS+vv=9S*#@gu~zbg<+zgqVarLvJyzn{5jVj52<{IcVJ4yavi0AO0vUdY=m7Ciz}lYxXZ8|PBs{X zO@Q{lVjY*UR>!lp;~<|e;${U`_Zm!`g6E4Gp|%)R*D);lEIdX)FEGP*J=Ap*5~4ni zjp}oAgbw5&Fu63A9qfBDvB@UO%ZHIfyEBoQ9WQ3K%MYB=1Oss1EeM6Gy1GdmfyV5!_6@P>1fX-#S$*Ku zIQc+(sKaa=FWz#zcF)ly(lM6NM|MUZ*%^>&M?j|C3p`Q_b_FZ1%63vY6LU~V{eabM z&)p8G`ewbx*-~}?9Mr1xu3J&|JrS85SoJ_PJI5E+-J4%F;>$TONE~B#=oq_==wbxu zX7;!qmD%HHRA%QhQJEbsA{{zDx9~MX<)K2MGnFKA8akfc6#lP4oR6ys0JRBAW9Y*BDpJlT8?#CK%Sw(gfYm6s!+JP=+DLqa=}<(s>PRKW(>e?;Yn?% z7Ncdsc%|Mu#q}4*3k+JIaL|+KLuQ~a){WrVEc%uyOgT8qfaY6A&9@FaqkxfgFwYw( zs^D~7OU&B=iFrH0{uRxbw>p$JC4bvd%@~XPjfLPr{&?;tJnx629C!7g0Y?f!C4B2|2=RUqwRJN%)0fe^DrK=BI9e zS>?s5Ke(Z30QJW%Lr$I(ImyON!1GZ6TrZ64?EXT8FFL{;%RB`B32fM5U>Lj;V0ES! znuK@eW=8JuQn%zDNIH_Y9*8J=95xeBd8j&w@;IO?4_udQO36~>SBR9{cBJr@6zB^L zEzi(8j8*kHR#_E>5nCtfg1Q0&s1aHRc@Y)S9g;8(lF;c4B;p(-0+P@NDnnNj@9An{ z3rCZ})dUL8iT!wy1;gd5*tG*;!ekek$+U+bjbF2Y+2n>gjc}GCBGIkrpHY)W#D!8D2AeqZKEYb9K+l-*ter7Ek#u7)`4Q+3(2{soJzN0M0=$qq8Si4 zc{_?FUO$e-XsqWEYAj{K0z?v;~#K5nyx6k*kI^L>Ug(^Oylxt zggvYKrh%DsSS_CQ?yJXXaoX5_0yj+#glvwS>G8diN3|PE;#%+9xKyN z>Eh^&dNpj)!TRVOth?F4BJ>WH@-CfsaHg@uY#@%bLF`BI7QZMW|C~%hySNyx=twYG z$S-zilq1s%OW4#rVAy`D9y06@vlz-@y&nhoP$&O_zzvZhXFy=L?s_z8dH72qAB^&2 zAkR77b%#5Y&w1eJ07mb(!R0>ci195Tq#Sp2p9V1uz&94>UK0hAzTDwv0)|dP4RHDO8qj00HNfXyxK$57 zK$Y=UJ^ZSchdD!2e0W`AjG)d`4Y1+~)}X8?In^DwFIHkq%Qa(LQt|b}sxVr?x+IJt z&4--lffZQ)&J5WY;fP1fWoE)guss{7Nk=W-Xz~VAuw({Hy{>|*Ro7#S*NJxAv~
n5{(Fj`zGp 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 EAK65RLI3~& literal 0 HcmV?d00001