diff options
Diffstat (limited to 'src/lpc10_enc_dec.h')
| -rw-r--r-- | src/lpc10_enc_dec.h | 1422 |
1 files changed, 1422 insertions, 0 deletions
diff --git a/src/lpc10_enc_dec.h b/src/lpc10_enc_dec.h new file mode 100644 index 0000000..404ad38 --- /dev/null +++ b/src/lpc10_enc_dec.h @@ -0,0 +1,1422 @@ +/* + LPC10 - simple audio encoder/decoder for tms5220. + + Language version C89/C99. + standard math library. + + define LPC_ENC_DEC_IMPLEMENTATION before including file to include implementation code. + + define LPC_STATIC_DECL to make all declarations static. + + + LICENSE: + + Copyright (C) 2025 Bogdan Masyutin (bonmas14) + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Bogdan Masyutin - bonmas14@gmail.com + + CHANGELOG: + v1.0 Init version. +*/ + +#if !defined(LPC_ENC_DEC_H) +#define LPC_ENC_DEC_H + +#if defined(LPC_STATIC_DECL) +#define LPC_API static +#else +#define LPC_API +#endif // LPC_STATIC_DECL + +#if !defined(CLITERAL) +#if defined(__cplusplus) +#define CLITERAL(type) type +#else +#define CLITERAL(type) (type) +#endif // __cplusplus +#endif // CLITERAL + +#include <stddef.h> +#include <stdint.h> +#include <stdbool.h> + +#include <math.h> +#include <string.h> +#include <float.h> + +#if defined(__cplusplus) +extern "C" { +#endif + +#define LPC_MAX(a, b) (a) > (b) ? (a) : (b) +#define LPC_MIN(a, b) (a) < (b) ? (a) : (b) + +#define LPC_PI 3.14159265358979323846f +#define LPC_TAU (LPC_PI * 2) + +#define LPC_SAMPLE_RATE 8000 +#define LPC_SAMPLES 200 +#define LPC_ENERGY_ZERO 0x0 +#define LPC_ENERGY_STOP 0xf + +#if !defined(LPC_ALLOC) +#include <stdlib.h> +#define LPC_ALLOC(size) calloc(1, size) +#else +#if !defined(LPC_FREE) +#error "LPC_ALLOC was redefined but not LPC_FREE" +#endif // LPC_FREE +#endif // LPC_ALLOC + +#if !defined(LPC_FREE) +#define LPC_FREE(ptr) free(ptr) +#else +#if !defined(LPC_FREE) +#error "LPC_FREE was redefined but not LPC_ALLOC" +#endif // LPC_ALLOC +#endif // LPC_FREE + +#if !defined(assert) +#include <stdio.h> + +#define assert(expr) if ((expr) == 0) {\ + fprintf(stderr, "Assert at %s:%d failed!", __FILE__, __LINE__); \ + *((int *)0) = 0; \ +} + +#endif + +// +// Type declarations +// + +typedef uint64_t lpc_u64; +typedef uint32_t lpc_u32; +typedef uint16_t lpc_u16; +typedef uint8_t lpc_u8; + +typedef int64_t lpc_s64; +typedef int32_t lpc_s32; +typedef int16_t lpc_s16; +typedef int8_t lpc_s8; + +typedef int32_t lpc_b32; +typedef float lpc_f32; + +typedef lpc_u8 lpc_u1; +typedef lpc_u8 lpc_u2; +typedef lpc_u8 lpc_u3; +typedef lpc_u8 lpc_u4; +typedef lpc_u8 lpc_u5; +typedef lpc_u8 lpc_u6; +typedef lpc_u8 lpc_u7; + +// Intermediate representation of tms5220 code, +// just before converting it into bit stream +// @todo, skip this step? +typedef lpc_u64 lpc_bitcode; + +typedef struct { + lpc_f32 pitch_low_cut, pitch_high_cut, pitch_q_factor; // filter settings that will be applied on pitch recognition + lpc_f32 processing_low_cut, processing_high_cut, processing_q_factor; // filter settings that will be applied on calculating K parameters + + lpc_f32 unvoiced_thresh; + lpc_f32 unvoiced_rms_multiply; + lpc_b32 do_pre_emphasis; + lpc_f32 pre_emphasis_alpha; + + lpc_u32 frame_size_ms; + lpc_u32 window_size_in_segments; +} Lpc_Encoder_Settings; + +#define LPC_DEFAULT_SETTINGS CLITERAL(Lpc_Encoder_Settings) {\ + 50.0f, 500.0f, 4.0f, \ + 50.0f, 4000.0f, 1.0f, \ + -0.1f, 2.0f, \ + true, -0.9373, \ + 25, 2 \ +} + +// +// @todo, fixed version +// +typedef struct { + lpc_u32 sample_rate; + lpc_u32 channels; + lpc_u32 frame_count; + lpc_f32 *samples; +} Lpc_Sample_Buffer; + +typedef struct { + lpc_u4 energy; + lpc_u1 repeat; + lpc_u6 pitch; + + union { + struct { + lpc_u5 k1, k2; + lpc_u4 k3, k4, k5, k6, k7; + lpc_u3 k8, k9, k10; + }; + + lpc_u8 k[10]; + }; + +} Lpc_Code; + +typedef struct { + lpc_u32 count; + // @note: I use offsets from buffer start instead of pointers because + // it allows me to use multiple buffers with same segment info. + // So the info is shared. @bonmas + lpc_u32 buffer_offset; + + lpc_u32 table_energy; + lpc_u32 table_pitch; + lpc_u32 table_k[10]; +} Lpc_Segment; + +typedef struct { + lpc_u32 count; + Lpc_Code *code; +} Lpc_Codes; + +typedef struct { + lpc_u32 count; + Lpc_Segment *data; +} Lpc_Segments; + +typedef struct { + lpc_u32 count; + lpc_u8 *bytes; +} Lpc_TMS5220_Buffer; + +typedef struct { + lpc_bitcode code; + lpc_u32 bits_count; + lpc_b32 not_enough_bits; +} Lpc_Bitcode_Info; + +typedef struct { + lpc_f32 energy; + lpc_u32 pitch; + lpc_f32 k[10]; +} Lpc_Synth; + +typedef struct { + lpc_f32 b0, b1, b2; + lpc_f32 a0, a1, a2; + + lpc_f32 x1, x2; + lpc_f32 y1, y2; +} Lpc_Biquad_Filter; + +typedef struct { + lpc_u64 count; + lpc_u64 capacity; + lpc_u64 element_size; + void *data; +} Lpc_List; + +// +// API +// + +// Helper function to make sure, codes are correct +LPC_API Lpc_Code lpc_code_clamp(Lpc_Code code); + +LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings settings); +LPC_API Lpc_Sample_Buffer lpc_decode(Lpc_Codes codes); + +LPC_API void lpc_codes_free(Lpc_Codes *codes); +LPC_API void lpc_buffer_free(Lpc_Sample_Buffer *buffer); + +LPC_API Lpc_TMS5220_Buffer lpc_tms5220_encode(Lpc_Codes codes); +LPC_API Lpc_Codes lpc_tms5220_decode(Lpc_TMS5220_Buffer buffer); +LPC_API void lpc_tms5220_buffer_free(Lpc_TMS5220_Buffer *buffer); + +LPC_API Lpc_List lpc_list_create(lpc_u64 init_size, lpc_u64 element_size); +LPC_API void lpc_list_destroy(Lpc_List *list); + +LPC_API void *lpc_list_get(Lpc_List *list, lpc_u64 index); +LPC_API lpc_b32 lpc_list_append(Lpc_List *list, void *data); + + +#if defined(__cplusplus) +} +#endif + +#if defined(LPC_ENC_DEC_IMPLEMENTATION) + +#define LPC_START_BIT 49LL +#define LPC_UNVOICED_STOP_BIT 21LL +#define LPC_REPEAT_STOP_BIT 38LL + +#define LPC_SIGNAL_BIT 46LL +#define LPC_REPEAT_BIT 45LL + +#define LPC_ENERGY_MASK 0x0FLL +#define LPC_REP_MASK 0x01LL +#define LPC_PITCH_MASK 0x3FLL + +#define LPC_K1_K2_MASK 0x1FLL +#define LPC_K3_K4_K5_K6_K7_MASK 0x0FLL +#define LPC_K8_K9_K10_MASK 0x07LL + +#define LPC_K10_OFFSET 0LL +#define LPC_K9_OFFSET 3LL +#define LPC_K8_OFFSET 6LL +#define LPC_K7_OFFSET 9LL +#define LPC_K6_OFFSET 13LL +#define LPC_K5_OFFSET 17LL +#define LPC_K4_OFFSET 21LL +#define LPC_K3_OFFSET 25LL +#define LPC_K2_OFFSET 29LL +#define LPC_K1_OFFSET 34LL +#define LPC_PITCH_OFFSET 39LL +#define LPC_REP_OFFSET 45LL +#define LPC_ENERGY_OFFSET 46LL + +#define LPC_INTEPR_SAMPLES 25 +#define LPC_BIT_FRAME_SIZE 50 +#define LPC_CHIRP_TABLE_SIZE 52 + +// LATER_CHIRP, from python_wizard: https://github.com/ptwz/python_wizard +static lpc_f32 chirp_table[LPC_CHIRP_TABLE_SIZE] = { + 0, 3, 15, 40, 76, 108, 113, 80, + 37, 38, 76, 68, 26, 50, 59, 19, + 55, 26, 37, 31, 29, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, +}; + +static lpc_f32 energy_table[LPC_ENERGY_MASK + 1] = { + 0, 52, 87, 123, + 174, 246, 348, 491, + 694, 981, 1385, 1957, + 2764, 3904, 5514, 7789 +}; + +static lpc_u32 pitch_table[LPC_PITCH_MASK + 1] = { + 0, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, + 50, 52, 53, 56, 58, 60, 62, 65, 68, 70, 72, 76, 78, 80, 84, 86, + 91, 94, 98, 101, 105, 109, 114, 118, 122, 127, 132, 137, 142, 148, 153, 159, +}; + +static lpc_f32 k1_table[LPC_K1_K2_MASK + 1] = { + -0.97850, -0.97270, -0.97070, -0.96680, + -0.96290, -0.95900, -0.95310, -0.94140, + -0.93360, -0.92580, -0.91600, -0.90620, + -0.89650, -0.88280, -0.86910, -0.85350, + + -0.80420, -0.74058, -0.66019, -0.56116, + -0.44296, -0.30706, -0.15735, -0.00005, + 0.15725, 0.30696, 0.44288, 0.56109, + 0.66013, 0.75054, 0.80416, 0.85350, +}; + +static lpc_f32 k2_table[LPC_K1_K2_MASK + 1] = { + -0.64000, -0.58999, -0.53500, -0.47507, + -0.41039, -0.34129, -0.26830, -0.19209, + -0.11350, -0.03345, 0.04702, 0.12690, + 0.20515, 0.28087, 0.35325, 0.42163, + + 0.48553, 0.54464, 0.59878, 0.64796, + 0.69227, 0.73190, 0.76714, 0.79828, + 0.82567, 0.84965, 0.87057, 0.88875, + 0.90451, 0.91813, 0.92988, 0.98830 +}; + +static lpc_f32 k3_table[LPC_K3_K4_K5_K6_K7_MASK + 1] = { + -0.86000, -0.75467, -0.64933, -0.54400, + -0.43867, -0.33333, -0.22800, -0.12267, + -0.01733, 0.08800, 0.19333, 0.29867, + 0.40400, 0.50933, 0.61467, 0.72000 +}; + +static lpc_f32 k4_table[LPC_K3_K4_K5_K6_K7_MASK + 1] = { + -0.64000, -0.53145, -0.42289, -0.31434, + -0.20579, -0.09723, 0.01132, 0.11987, + 0.22843, 0.33698, 0.44553, 0.55409, + 0.66264, 0.77119, 0.87975, 0.98830 +}; + +static lpc_f32 k5_table[LPC_K3_K4_K5_K6_K7_MASK + 1] = { + -0.64000, -0.54933, -0.45867, -0.36800, + -0.27733, -0.18667, -0.09600, -0.00533, + 0.08533, 0.17600, 0.26667, 0.35733, + 0.44800, 0.53867, 0.62933, 0.72000 +}; + +static lpc_f32 k6_table[LPC_K3_K4_K5_K6_K7_MASK + 1] = { + -0.50000, -0.41333, -0.32667, -0.24000, + -0.15333, -0.06667, 0.02000, 0.10667, + 0.19333, 0.28000, 0.36667, 0.45333, + 0.54000, 0.62667, 0.71333, 0.80000 +}; + +static lpc_f32 k7_table[LPC_K3_K4_K5_K6_K7_MASK + 1] = { + -0.60000, -0.50667, -0.41333, -0.32000, + -0.22667, -0.13333, -0.04000, 0.05333, + 0.14667, 0.24000, 0.33333, 0.42667, + 0.52000, 0.61333, 0.70667, 0.80000 +}; + +static lpc_f32 k8_table[LPC_K8_K9_K10_MASK + 1] = { + -0.50000, -0.31429, -0.12857, 0.05714, + 0.24286, 0.42857, 0.61429, 0.80000 +}; + +static lpc_f32 k9_table[LPC_K8_K9_K10_MASK + 1] = { + -0.50000, -0.34286, -0.18571, -0.02857, + 0.12857, 0.28571, 0.44286, 0.60000 +}; + +static lpc_f32 k10_table[LPC_K8_K9_K10_MASK + 1] = { + -0.40000, -0.25714, -0.11429, 0.02857, + 0.17143, 0.31429, 0.45714, 0.60000 +}; + + +// +// Filtering +// + +LPC_API Lpc_Biquad_Filter biquad_bandpass_design(lpc_u32 sample_rate, lpc_f32 low_cut, lpc_f32 high_cut, lpc_f32 q_factor, lpc_b32 q_amplify) { + lpc_f32 center, w, w_cos, w_sin, alpha; + Lpc_Biquad_Filter filter; + + center = (low_cut + high_cut) / 2.0f; + + w = LPC_TAU * (center / (lpc_f32)sample_rate); + + w_cos = cosf(w); + w_sin = sinf(w); + + alpha = w_sin / (2.0f * q_factor); + + if (q_amplify) { + filter.b0 = alpha * q_factor; + filter.b1 = 0.0f; + filter.b2 = -alpha * q_factor; + } else { + filter.b0 = alpha; + filter.b1 = 0.0f; + filter.b2 = -alpha; + } + + filter.a0 = 1.0f + alpha; + filter.a1 = -2.0f * w_cos; + filter.a2 = 1.0f - alpha; + + filter.b0 /= filter.a0; + filter.b1 /= filter.a0; + filter.b2 /= filter.a0; + filter.a1 /= filter.a0; + filter.a2 /= filter.a0; + filter.a0 = 1.0f; + + filter.x1 = filter.x2 = 0; + filter.y1 = filter.y2 = 0; + + return filter; +} + +LPC_API inline lpc_f32 biquad_process(Lpc_Biquad_Filter *filter, lpc_f32 input) { + lpc_f32 output; + + output = filter->b0 * input + filter->b1 * filter->x1 + filter->b2 * filter->x2 + - filter->a1 * filter->y1 - filter->a2 * filter->y2; + + filter->x2 = filter->x1; + filter->y2 = filter->y1; + filter->x1 = input; + filter->y1 = output; + + return output; +} + +// +// Helpers +// + +LPC_API lpc_f32 lpc_lerpf(lpc_f32 a, lpc_f32 b, lpc_f32 t) { + return (1.0f - t) * a + b * t; +} + +LPC_API Lpc_Code lpc_code_clamp(Lpc_Code code) { + Lpc_Code output; + + memset(&output, 0, sizeof(Lpc_Code)); + output.energy = ((lpc_u64)code.energy) & LPC_ENERGY_MASK; + + if (output.energy == LPC_ENERGY_ZERO || output.energy == LPC_ENERGY_STOP) { + return output; + } + + output.repeat = ((lpc_u64)code.repeat) & LPC_REP_MASK; + output.pitch = ((lpc_u64)code.pitch) & LPC_PITCH_MASK; + + if (output.repeat) { + return output; + } + + output.k1 = ((lpc_u64)code.k1) & LPC_K1_K2_MASK; + output.k2 = ((lpc_u64)code.k2) & LPC_K1_K2_MASK; + output.k3 = ((lpc_u64)code.k3) & LPC_K3_K4_K5_K6_K7_MASK; + output.k4 = ((lpc_u64)code.k4) & LPC_K3_K4_K5_K6_K7_MASK; + + if (!output.pitch) { + return output; + } + + output.k5 = ((lpc_u64)code.k5) & LPC_K3_K4_K5_K6_K7_MASK; + output.k6 = ((lpc_u64)code.k6) & LPC_K3_K4_K5_K6_K7_MASK; + output.k7 = ((lpc_u64)code.k7) & LPC_K3_K4_K5_K6_K7_MASK; + output.k8 = ((lpc_u64)code.k8) & LPC_K8_K9_K10_MASK; + output.k9 = ((lpc_u64)code.k9) & LPC_K8_K9_K10_MASK; + output.k10 = ((lpc_u64)code.k10) & LPC_K8_K9_K10_MASK; + + return output; +} + +LPC_API lpc_bitcode lpc_convert_to_bitcode_internal(Lpc_Code bitcode) { + lpc_bitcode output = 0; + + output |= (((lpc_u64)bitcode.energy) & 0x0FLL) << LPC_ENERGY_OFFSET; + output |= (((lpc_u64)bitcode.repeat) & 0x01LL) << LPC_REP_OFFSET; + output |= (((lpc_u64)bitcode.pitch) & 0x3FLL) << LPC_PITCH_OFFSET; + + output |= (((lpc_u64)bitcode.k1) & 0x1FLL) << LPC_K1_OFFSET; + output |= (((lpc_u64)bitcode.k2) & 0x1FLL) << LPC_K2_OFFSET; + output |= (((lpc_u64)bitcode.k3) & 0x0FLL) << LPC_K3_OFFSET; + output |= (((lpc_u64)bitcode.k4) & 0x0FLL) << LPC_K4_OFFSET; + output |= (((lpc_u64)bitcode.k5) & 0x0FLL) << LPC_K5_OFFSET; + output |= (((lpc_u64)bitcode.k6) & 0x0FLL) << LPC_K6_OFFSET; + output |= (((lpc_u64)bitcode.k7) & 0x0FLL) << LPC_K7_OFFSET; + output |= (((lpc_u64)bitcode.k8) & 0x07LL) << LPC_K8_OFFSET; + output |= (((lpc_u64)bitcode.k9) & 0x07LL) << LPC_K9_OFFSET; + output |= (((lpc_u64)bitcode.k10) & 0x07LL); + + return output; +} + +LPC_API Lpc_Code lpc_convert_from_bitcode_internal(lpc_bitcode bitcode) { + Lpc_Code output; + + memset(&output, 0, sizeof(output)); + output.energy = ((lpc_u64)bitcode & (0x0FLL << LPC_ENERGY_OFFSET)) >> LPC_ENERGY_OFFSET; + + if (output.energy == LPC_ENERGY_ZERO || output.energy == LPC_ENERGY_STOP) { + return output; + } + + output.repeat = ((lpc_u64)bitcode & (0x01LL << LPC_REP_OFFSET)) >> LPC_REP_OFFSET; + output.pitch = ((lpc_u64)bitcode & (0x3FLL << LPC_PITCH_OFFSET)) >> LPC_PITCH_OFFSET; + + if (output.repeat) { + return output; + } + + output.k1 = ((lpc_u64)bitcode & (0x1FLL << LPC_K1_OFFSET)) >> LPC_K1_OFFSET; + output.k2 = ((lpc_u64)bitcode & (0x1FLL << LPC_K2_OFFSET)) >> LPC_K2_OFFSET; + output.k3 = ((lpc_u64)bitcode & (0x0FLL << LPC_K3_OFFSET)) >> LPC_K3_OFFSET; + output.k4 = ((lpc_u64)bitcode & (0x0FLL << LPC_K4_OFFSET)) >> LPC_K4_OFFSET; + + if (!output.pitch) { + return output; + } + + output.k5 = ((lpc_u64)bitcode & (0x0FLL << LPC_K5_OFFSET)) >> LPC_K5_OFFSET; + output.k6 = ((lpc_u64)bitcode & (0x0FLL << LPC_K6_OFFSET)) >> LPC_K6_OFFSET; + output.k7 = ((lpc_u64)bitcode & (0x0FLL << LPC_K7_OFFSET)) >> LPC_K7_OFFSET; + output.k8 = ((lpc_u64)bitcode & (0x07LL << LPC_K8_OFFSET)) >> LPC_K8_OFFSET; + output.k9 = ((lpc_u64)bitcode & (0x07LL << LPC_K9_OFFSET)) >> LPC_K9_OFFSET; + output.k10 = ((lpc_u64)bitcode & 0x07LL); + + return output; +} + +// +// Encoding +// + +LPC_API Lpc_Sample_Buffer lpc_buffer_prepare_internal(Lpc_Sample_Buffer buffer) { + Lpc_Sample_Buffer converted; + lpc_u64 i, j, k; + lpc_f32 sum; + + assert(buffer.samples != NULL); + assert(buffer.channels <= 2); + assert(buffer.channels > 0); + + converted.sample_rate = LPC_SAMPLE_RATE; + converted.channels = 1; + converted.frame_count = roundf((lpc_f32)buffer.frame_count / ((lpc_f32)buffer.sample_rate / (lpc_f32)LPC_SAMPLE_RATE)); + converted.samples = (lpc_f32*)LPC_ALLOC((sizeof(lpc_f32) * converted.frame_count)); + + assert(converted.samples != NULL); // @todo, proper recovery if no memory + + for (i = 0; i < converted.frame_count; i++) { + j = roundf((lpc_f32)i * ((lpc_f32)buffer.sample_rate / (lpc_f32)LPC_SAMPLE_RATE)); + + if (j >= buffer.frame_count) { + converted.samples[i] = 0; + continue; + } + + if (buffer.channels == 1) { + if (j >= buffer.frame_count) { + converted.samples[i] = 0; + continue; + } + + converted.samples[i] = buffer.samples[j]; + } else { + sum = 0; + + for (k = 0; k < buffer.channels; k++) { + if ((j * buffer.channels + k) >= (buffer.frame_count * buffer.channels)) { + break; + } + + sum += buffer.samples[j * buffer.channels + k]; + } + + converted.samples[i] = sum / (lpc_f32)buffer.channels; + } + } + + return converted; +} + +LPC_API Lpc_Sample_Buffer lpc_buffer_copy_internal(Lpc_Sample_Buffer buffer) { + Lpc_Sample_Buffer new_buffer; + + assert(buffer.channels == 1); + assert(buffer.sample_rate == LPC_SAMPLE_RATE); + + new_buffer = buffer; + new_buffer.samples = (lpc_f32*)LPC_ALLOC((sizeof(lpc_f32) * buffer.frame_count)); + + assert(new_buffer.samples != NULL); // @todo, proper recovery + memcpy(new_buffer.samples, buffer.samples, sizeof(lpc_f32) * new_buffer.frame_count); + + return new_buffer; +} + + +LPC_API void lpc_buffer_normalize_internal(Lpc_Sample_Buffer buffer) { + lpc_u64 i; + lpc_f32 max, min; + + max = FLT_MIN; + min = FLT_MAX; + + assert(buffer.sample_rate == LPC_SAMPLE_RATE); + assert(buffer.channels == 1); + + for (i = 0; i < buffer.frame_count; i++) { + if (buffer.samples[i] < min) min = buffer.samples[i]; + if (buffer.samples[i] > max) max = buffer.samples[i]; + } + + for (i = 0; i < buffer.frame_count; i++) { + buffer.samples[i] = (buffer.samples[i] - min) / (max - min); + } +} + +LPC_API void lpc_buffer_filter_internal(Lpc_Sample_Buffer buffer, lpc_f32 low_cut_freq, lpc_f32 high_cut_freq, lpc_f32 q_factor, lpc_b32 amplify) { + Lpc_Biquad_Filter filter; + lpc_u64 i; + + assert(buffer.channels == 1); + assert(buffer.sample_rate == LPC_SAMPLE_RATE); + + filter = biquad_bandpass_design(buffer.sample_rate, low_cut_freq, high_cut_freq, q_factor, amplify); + + for (i = 0; i < buffer.frame_count; i++) { + buffer.samples[i] = biquad_process(&filter, buffer.samples[i]); + } +} + +// +// Pre emphasis +// + +LPC_API lpc_f32 lpc_buffer_energy_sqr_sum_internal(Lpc_Sample_Buffer buffer) { + lpc_u64 i; + lpc_f32 energy = 0; + + for (i = 0; i < buffer.frame_count; i++) { + energy += buffer.samples[i] * buffer.samples[i]; + } + + return energy / (buffer.frame_count - 1); +} + +LPC_API void lpc_buffer_pre_emphasis(Lpc_Sample_Buffer buffer, lpc_f32 alpha) { + lpc_u64 i; + lpc_f32 pre_energy, post_energy, scale; + pre_energy = lpc_buffer_energy_sqr_sum_internal(buffer); + + for (i = buffer.frame_count - 1; i > 0; i--) { + buffer.samples[i] = 1 - buffer.samples[i - 1] * alpha; + } + + post_energy = lpc_buffer_energy_sqr_sum_internal(buffer); + scale = sqrtf(pre_energy / post_energy); + + for (i = 0; i < buffer.frame_count; i++) { + buffer.samples[i] *= scale; + } +} + +// +// Segments +// + +LPC_API Lpc_Segments lpc_get_segments_internal(Lpc_Sample_Buffer buffer, lpc_u32 segment_size, lpc_u32 num_segments) { + lpc_u64 i; + Lpc_Segments segments; + + segments.count = num_segments; + segments.data = (Lpc_Segment *)LPC_ALLOC(sizeof(Lpc_Segment) * num_segments); + + assert(segments.data != NULL); // @todo, proper recovery from memory allocation errors + assert(buffer.frame_count < num_segments * segment_size); + + for (i = 0; i < num_segments; i++) { + segments.data[i].count = LPC_MIN(buffer.frame_count - i * segment_size, segment_size); + segments.data[i].buffer_offset = i * segment_size; + } + + return segments; +} + +LPC_API void lpc_pitch_estimate_internal(Lpc_Sample_Buffer buffer, Lpc_Segments segments, lpc_u32 window_size, lpc_f32 low_freq, lpc_f32 high_freq) { + lpc_u64 i, j, k, offset, best_period_i, min_dist_i, segment_size, work_buffer_size; + lpc_u32 min_period, max_period, best_period, period_count; + lpc_f32 *work_buffer, *window, *periods, best_period_value; + lpc_f32 min_dist, dist; + + assert(segments.count > 0); + + min_period = buffer.sample_rate / high_freq; + max_period = buffer.sample_rate / low_freq; + best_period = min_period; + + period_count = max_period - min_period; + periods = (lpc_f32 *)LPC_ALLOC(sizeof(lpc_f32) * period_count); + + assert(periods != NULL); // @todo, proper recovery from memory allocation errors + + // we assume that first segment is maximum size, @todo, test for that, + // as it should be always like that, except the garbage data + + segment_size = segments.data[0].count; + work_buffer_size = window_size * segment_size; + work_buffer = (lpc_f32 *)LPC_ALLOC(sizeof(lpc_f32) * work_buffer_size); + window = (lpc_f32 *)LPC_ALLOC(sizeof(lpc_f32) * work_buffer_size); + + assert(work_buffer != NULL); // @todo, proper recovery from memory allocation errors + assert(window != NULL); // @todo, proper recovery from memory allocation errors + + // @note apparently we need normalized coefficients in here, so we can get more accurate pitch correlation + // it is made in python-wizard via calculating correlations coefficients for every lag value + // but it works anyway? + + for (i = 0; i < work_buffer_size; i++) { + window[i] = 0.54f - 0.46f * cosf(LPC_TAU * ((lpc_f32)i / (lpc_f32)(work_buffer_size - 1))); + } + + for (i = 0; i < segments.count; i++) { + offset = 0; + memset(work_buffer, 0, sizeof(lpc_f32) * work_buffer_size); + memcpy(work_buffer, buffer.samples + segments.data[i].buffer_offset, sizeof(lpc_f32) * segments.data[i].count); + offset += segments.data[i].count; + + for (j = 1; j < window_size; j++) { + if ((i + j) >= segments.count) break; + memcpy(work_buffer + offset, buffer.samples + segments.data[i + j].buffer_offset, sizeof(lpc_f32) * segments.data[i + j].count); + offset += segments.data[i + j].count; + } + + for (j = 0; j < work_buffer_size; j++) { + work_buffer[j] *= window[j]; + } + + { // calculate best correlation factor + for (j = 0; j < period_count; j++) { + periods[j] = 0; + + for (k = 0; k < segment_size; k++) { + periods[j] += work_buffer[k + min_period + j] * work_buffer[k]; + } + } + + best_period_i = 0; + best_period_value = periods[0]; + + for (j = 1; j < period_count; j++) { + if (periods[j] > best_period_value) { + best_period_i = j; + best_period_value = fabsf(periods[j]); + } + } + } + + best_period = min_period + best_period_i; + + min_dist = max_period; + min_dist_i = 0; + + for (k = 0; k < LPC_PITCH_MASK; k++) { + dist = fabsf((lpc_f32)pitch_table[k] - best_period); + + if (min_dist > dist) { + min_dist = dist; + min_dist_i = k; + } + } + + segments.data[i].table_pitch = min_dist_i; + } + + LPC_FREE(work_buffer); + LPC_FREE(periods); +} + +LPC_API Lpc_Codes lpc_get_codes_from_segments_internal(Lpc_Segments segments) { + Lpc_Codes codes; + Lpc_Code code; + lpc_u64 i, j; + + codes.count = segments.count + 1; + codes.code = (Lpc_Code *)LPC_ALLOC(sizeof(Lpc_Code) * codes.count); + + if (codes.code == NULL) { + codes.count = 0; + return codes; + } + + for (i = 0; i < segments.count; i++) { + code.energy = (lpc_u4)segments.data[i].table_energy; + code.repeat = 0; // python wizard doesnt support it, but we can @todo + code.pitch = (lpc_u6)segments.data[i].table_pitch; + + for (j = 0; j < 10; j++) { + code.k[j] = segments.data[i].table_k[j]; + } + + codes.code[i] = lpc_code_clamp(code); + } + + code.energy = LPC_ENERGY_STOP; + codes.code[codes.count - 1] = lpc_code_clamp(code); + + return codes; +} + + +LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings settings) { + Lpc_Sample_Buffer pitch_buffer; + Lpc_Codes codes; + lpc_u64 size, i, j, k, l; + Lpc_Segments segments; + lpc_f32 sum, k_params[11], coeff[11]; + + assert(buffer.sample_rate >= LPC_SAMPLE_RATE); + buffer = lpc_buffer_prepare_internal(buffer); + pitch_buffer = lpc_buffer_copy_internal(buffer); + + lpc_u32 segment_size = buffer.sample_rate / 1000 * settings.frame_size_ms; + lpc_u32 num_segments = ceilf((lpc_f32)buffer.frame_count / (lpc_f32)segment_size); + + segments = lpc_get_segments_internal(buffer, segment_size, num_segments); + + if (settings.do_pre_emphasis) { + lpc_buffer_pre_emphasis(buffer, settings.pre_emphasis_alpha); + } + + lpc_buffer_filter_internal(buffer, settings.processing_low_cut, settings.processing_high_cut, settings.processing_q_factor, true); + lpc_buffer_filter_internal(pitch_buffer, settings.pitch_low_cut, settings.pitch_high_cut, settings.pitch_q_factor, false); + lpc_pitch_estimate_internal(pitch_buffer, segments, settings.window_size_in_segments, settings.pitch_low_cut, settings.pitch_high_cut); + + for (i = 0; i < num_segments; i++) { + memset(coeff, 0, sizeof(coeff)); + + // so we need to get the LPC coefficients, and this loop basically does it + for (j = 0; j < 11; j++) { + size = segment_size - j; + sum = 0; + + for (k = 0; k < size; k++) { + l = k + i * segment_size; + + if ((l + j) >= buffer.frame_count) continue; + + sum += buffer.samples[l] * buffer.samples[l + j]; + } + + coeff[j] = sum; + } + + // here we convert the lpc coefficients to K reflection coeffs + + { // Leroux Guegen algorithm for finding K + lpc_f32 y, b_params[11], d_params[12]; + + memset(k_params, 0, sizeof(k_params)); + memset(b_params, 0, sizeof(b_params)); + memset(d_params, 0, sizeof(d_params)); + + k_params[1] = -coeff[1] / coeff[0]; + d_params[1] = coeff[1]; + d_params[2] = coeff[0] + (k_params[1] * coeff[1]); + + for (j = 2; j < 11; j++) { + y = coeff[j]; + b_params[1] = y; + + for (k = 1; k < j; k++) { + b_params[k + 1] = d_params[k] + (k_params[k] * y); + y += k_params[k] * d_params[k]; + d_params[k] = b_params[k]; + } + + k_params[j] = -y / d_params[j]; + d_params[j + 1] = d_params[j] + (k_params[j] * y); + d_params[j] = b_params[j]; + } + + + if (k_params[1] > settings.unvoiced_thresh) { + segments.data[i].table_pitch = 0; + } + + { // setting RMS of signal + lpc_f32 rms, dist, min_dist; + lpc_u64 min_dist_i; + + rms = sqrtf(d_params[11] / segment_size) * (1 << 18); + + if (segments.data[i].table_pitch == 0) { + rms *= settings.unvoiced_rms_multiply; + } + + min_dist = fabsf(energy_table[0] - rms); + min_dist_i = 0; + + for (j = 1; j < LPC_ENERGY_MASK; j++) { + dist = fabsf(energy_table[j] - rms); + + if (dist < min_dist) { + min_dist = dist; + min_dist_i = j; + } + } + + segments.data[i].table_energy = min_dist_i; + } + } + + { + // and we set them so segment in here + lpc_f32 dist, min_dist; + lpc_u64 min_dist_i; + lpc_f32 *k_table = NULL; + + // K1 K2 + for (j = 0; j < 2; j++) { + switch (j) { + case 0: k_table = k1_table; break; + case 1: k_table = k2_table; break; + default: assert(false); break; + } + + min_dist = fabsf(k_table[0] - k_params[j + 1]); + min_dist_i = 0; + + for (k = 1; k <= LPC_K1_K2_MASK; k++) { + dist = fabsf(k_table[k] - k_params[j + 1]); + + if (dist < min_dist) { + min_dist = dist; + min_dist_i = k; + } + } + + segments.data[i].table_k[j] = min_dist_i; + } + + // K3-K7 + for (j = 2; j < 7; j++) { + switch (j) { + case 2: k_table = k3_table; break; + case 3: k_table = k4_table; break; + case 4: k_table = k5_table; break; + case 5: k_table = k6_table; break; + case 6: k_table = k7_table; break; + default: assert(false); break; + } + + + min_dist = fabsf(k_table[0] - k_params[j + 1]); + min_dist_i = 0; + + for (k = 1; k <= LPC_K3_K4_K5_K6_K7_MASK; k++) { + dist = fabsf(k_table[k] - k_params[j + 1]); + + if (dist < min_dist) { + min_dist = dist; + min_dist_i = k; + } + } + + segments.data[i].table_k[j] = min_dist_i; + } + + for (j = 7; j < 10; j++) { + switch (j) { + case 7: k_table = k8_table; break; + case 8: k_table = k9_table; break; + case 9: k_table = k10_table; break; + default: assert(false); break; + } + + min_dist = fabsf(k_table[0] - k_params[j + 1]); + min_dist_i = 0; + + for (k = 1; k <= LPC_K8_K9_K10_MASK; k++) { + dist = fabsf(k_table[k] - k_params[j + 1]); + + if (dist < min_dist) { + min_dist = dist; + min_dist_i = k; + } + } + + segments.data[i].table_k[j] = min_dist_i; + } + } + } + + codes = lpc_get_codes_from_segments_internal(segments); + + LPC_FREE(buffer.samples); + LPC_FREE(pitch_buffer.samples); + LPC_FREE(segments.data); + + return codes; +} + +// +// Decoding +// + +Lpc_Sample_Buffer lpc_decode(Lpc_Codes codes) { + Lpc_Synth previous, target, current; + Lpc_Code curr_code; + Lpc_Sample_Buffer buffer; + lpc_u64 i = 0, j = 0, sample_counter = 0, phase_counter = 0, code_index = 0; + lpc_f32 forward[10], backward[10]; + lpc_f32 in, t, max = FLT_MIN, min = FLT_MAX; + lpc_u32 noise = 1; + lpc_b32 repeat; + + memset(forward, 0, sizeof(forward)); + memset(backward, 0, sizeof(backward)); + memset(&previous, 0, sizeof(Lpc_Synth)); + memset(&target, 0, sizeof(Lpc_Synth)); + memset(¤t, 0, sizeof(Lpc_Synth)); + + buffer.sample_rate = LPC_SAMPLE_RATE; + buffer.channels = 1; + buffer.frame_count = codes.count * LPC_SAMPLES; + buffer.samples = (lpc_f32*)LPC_ALLOC(sizeof(lpc_f32) * buffer.frame_count); + + if (buffer.samples == NULL) { + memset(&buffer, 0, sizeof(Lpc_Sample_Buffer)); + return buffer; + } + + while (true) { + if (code_index >= codes.count) { + break; + } + + curr_code = lpc_code_clamp(codes.code[code_index++]); + + if (curr_code.energy == LPC_ENERGY_STOP) { + break; + } else if (curr_code.energy == LPC_ENERGY_ZERO) { + target.energy = 0; + } else { + target.energy = energy_table[curr_code.energy]; + repeat = curr_code.repeat; + target.pitch = pitch_table[curr_code.pitch]; + + if (!repeat) { + target.k[0] = k1_table[curr_code.k1]; + target.k[1] = k2_table[curr_code.k2]; + target.k[2] = k3_table[curr_code.k3]; + target.k[3] = k4_table[curr_code.k4]; + + if (target.pitch) { + target.k[4] = k5_table[curr_code.k5]; + target.k[5] = k6_table[curr_code.k6]; + target.k[6] = k7_table[curr_code.k7]; + target.k[7] = k8_table[curr_code.k8]; + target.k[8] = k9_table[curr_code.k9]; + target.k[9] = k10_table[curr_code.k10]; + } else { + target.k[4] = 0; + target.k[5] = 0; + target.k[6] = 0; + target.k[7] = 0; + target.k[8] = 0; + target.k[9] = 0; + } + } + } + + if (code_index == 0) { + previous = current = target; + } else { + previous = current; + } + + for (i = 0; i < LPC_SAMPLES; i++) { + t = ((lpc_f32)i / (lpc_f32)(LPC_SAMPLES - 1)); + + current.energy = lpc_lerpf(previous.energy, target.energy, t); + current.pitch = (lpc_u32)lpc_lerpf((lpc_f32)previous.pitch, (lpc_f32)target.pitch, t); + + for (j = 0; j < 10; j++) { + current.k[j] = lpc_lerpf(previous.k[j], target.k[j], t); + } + + if (current.energy == 0) { + in = 0; + } else if (current.pitch > 0) { + if (phase_counter < current.pitch) { + phase_counter++; + } else { + phase_counter = 0; + } + + if (phase_counter < LPC_CHIRP_TABLE_SIZE) { + in = chirp_table[phase_counter] * current.energy; + } else { + in = 0; + } + } else { + noise = (noise >> 1) ^ (noise & 1 ? 0xBD00 : 0); + in = noise & 1 ? (lpc_f32)(current.energy) : -((lpc_f32)current.energy); + } + + forward[9] = in - current.k[9] * backward[9]; + forward[8] = forward[9] - current.k[8] * backward[8]; + forward[7] = forward[8] - current.k[7] * backward[7]; + forward[6] = forward[7] - current.k[6] * backward[6]; + forward[5] = forward[6] - current.k[5] * backward[5]; + forward[4] = forward[5] - current.k[4] * backward[4]; + forward[3] = forward[4] - current.k[3] * backward[3]; + forward[2] = forward[3] - current.k[2] * backward[2]; + forward[1] = forward[2] - current.k[1] * backward[1]; + forward[0] = forward[1] - current.k[0] * backward[0]; + + backward[9] = backward[8] + current.k[8] * forward[8]; + backward[8] = backward[7] + current.k[7] * forward[7]; + backward[7] = backward[6] + current.k[6] * forward[6]; + backward[6] = backward[5] + current.k[5] * forward[5]; + backward[5] = backward[4] + current.k[4] * forward[4]; + backward[4] = backward[3] + current.k[3] * forward[3]; + backward[3] = backward[2] + current.k[2] * forward[2]; + backward[2] = backward[1] + current.k[1] * forward[1]; + backward[1] = backward[0] + current.k[0] * forward[0]; + backward[0] = forward[0]; + + assert(sample_counter < buffer.frame_count); + buffer.samples[sample_counter++] = forward[0]; + } + } + + buffer.frame_count = sample_counter; + + for (i = 0; i < buffer.frame_count; i++) { + if (buffer.samples[i] > max) max = buffer.samples[i]; + if (buffer.samples[i] < min) min = buffer.samples[i]; + } + + for (i = 0; i < buffer.frame_count; i++) { + buffer.samples[i] = buffer.samples[i] / (max - min); + } + + return buffer; +} + + +LPC_API void lpc_tms5220_encode_bits_internal(Lpc_List *bits, lpc_u64 code) { + lpc_s64 stop_at = 0, i = LPC_START_BIT; + lpc_u8 energy, pitch; + lpc_u1 curr = 0; + + energy = (code >> LPC_ENERGY_OFFSET) & LPC_ENERGY_MASK; + pitch = (code >> LPC_PITCH_OFFSET) & LPC_PITCH_MASK; + + if (stop_at == 0 && (energy == LPC_ENERGY_ZERO || energy == LPC_ENERGY_STOP)) { + stop_at = LPC_SIGNAL_BIT; + } + + if (stop_at == 0 && pitch == 0) { + stop_at = LPC_UNVOICED_STOP_BIT; + } + + if (stop_at == 0 && code & (1LL << LPC_REPEAT_BIT)) { + stop_at = LPC_REPEAT_STOP_BIT; + } + + while (i >= stop_at) { + curr = ((code & (1LL << i)) >> i); + lpc_list_append(bits, &curr); + i--; + } +} + +LPC_API Lpc_Bitcode_Info lpc_tms5220_decode_bits_internal(lpc_u1 *bits, lpc_u64 bits_count) { + Lpc_Bitcode_Info info; + lpc_s64 i = LPC_START_BIT; + lpc_u8 energy, pitch; + + memset(&info, 0, sizeof(Lpc_Bitcode_Info)); + + while (true) { + if (info.bits_count >= bits_count) { + info.not_enough_bits = true; + break; + } + + info.code |= (lpc_u64)bits[info.bits_count++] << i; + + if (i == 0) break; + + if (i == LPC_ENERGY_OFFSET) { + energy = (info.code >> LPC_ENERGY_OFFSET) & LPC_ENERGY_MASK; + if (energy == LPC_ENERGY_ZERO || energy == LPC_ENERGY_STOP) { + break; + } + } + + if (i <= LPC_PITCH_OFFSET) { + pitch = (info.code >> LPC_PITCH_OFFSET) & LPC_PITCH_MASK; + if (pitch == 0 && i == LPC_K4_OFFSET) { + break; + } + } + + i--; + } + + return info; +} + +LPC_API void lpc_tms5220_squash_bits_internal(lpc_u8 *bytes, lpc_u64 bytes_count, lpc_u1 *bits, lpc_u64 bits_count) { + lpc_u64 i, j = 0; + + UNUSED(bytes_count); + + assert((bytes_count * 8) == bits_count); + + for (i = 0; i < bits_count; i++) { + if ((i % 8) == 0) { + j++; + } + + bytes[j - 1] |= bits[i] << (i % 8); + } +} + +LPC_API void lpc_tms5220_unsquash_bits_internal(lpc_u1 *cont, lpc_u64 cont_count, lpc_u8 *from, lpc_u64 from_count) { + lpc_u64 i, j, k = 0; + lpc_u1 bit; + + UNUSED(cont_count); + + assert(cont_count == (from_count * 8)); + + for (i = 0; i < from_count; i++) { + for (j = 0; j < 8; j++) { + bit = (from[i] >> j) & 1; + + assert(k < cont_count); + cont[k++] = bit; + } + } +} + +LPC_API Lpc_TMS5220_Buffer lpc_tms5220_encode(Lpc_Codes codes) { + Lpc_TMS5220_Buffer buff; + Lpc_List bits; + lpc_u64 i; + + bits = lpc_list_create(codes.count * LPC_BIT_FRAME_SIZE, sizeof(lpc_u1)); + + for (i = 0; i < codes.count; i++) { + lpc_tms5220_encode_bits_internal(&bits, lpc_convert_to_bitcode_internal(lpc_code_clamp(codes.code[i]))); + } + + buff.count = bits.count / 8; + + if (bits.count != (buff.count * 8)) { + // we need to shift last bits on amount of bits + i = bits.count - buff.count * 8; + bits.count -= i; + } + + buff.bytes = (lpc_u8*)LPC_ALLOC(sizeof(lpc_u8) * buff.count); + assert(buff.bytes != NULL); // @todo, proper recovery from memory allocation errors + + lpc_tms5220_squash_bits_internal(buff.bytes, buff.count, (lpc_u1*) bits.data, bits.count); + lpc_list_destroy(&bits); + + return buff; +} + +LPC_API Lpc_Codes lpc_tms5220_decode(Lpc_TMS5220_Buffer buffer) { + Lpc_List codes; + Lpc_Code code; + Lpc_Bitcode_Info info; + lpc_u1 *bits = NULL; + lpc_u64 i = 0; + + codes = lpc_list_create(buffer.count * (LPC_BIT_FRAME_SIZE / 8), sizeof(Lpc_Code)); + bits = (lpc_u1*)LPC_ALLOC(buffer.count * 8); + + assert(bits != NULL); // @todo, proper recovery from memory allocation errors + + lpc_tms5220_unsquash_bits_internal(bits, buffer.count * 8, (lpc_u8*)buffer.bytes, buffer.count); + + while (i < (buffer.count * 8)) { + info = lpc_tms5220_decode_bits_internal(bits + i, (buffer.count * 8) - i); + code = lpc_convert_from_bitcode_internal(info.code); + lpc_list_append(&codes, &code); + i += info.bits_count; + } + + LPC_FREE(bits); + + return CLITERAL(Lpc_Codes) { (lpc_u32)codes.count, (Lpc_Code *)codes.data }; +} + +LPC_API Lpc_List lpc_list_create(lpc_u64 init_size, lpc_u64 element_size) { + Lpc_List list; + + memset(&list, 0, sizeof(Lpc_List)); + + list.data = LPC_ALLOC(init_size * element_size); + if (list.data == NULL) return list; + + list.capacity = init_size; + list.element_size = element_size; + + return list; +} + +LPC_API void lpc_list_destroy(Lpc_List *list) { + assert(list->data != NULL); + + LPC_FREE(list->data); + + memset(list, 0, sizeof(Lpc_List)); +} + +LPC_API void *lpc_list_get(Lpc_List *list, lpc_u64 index) { + if (index >= list->count) { + return NULL; + } + + return (lpc_u8*)list->data + list->element_size * index; +} + +LPC_API lpc_b32 lpc_list_append(Lpc_List *list, void *data) { + lpc_u64 size; + void *p; + assert(list->element_size > 0); + assert(list->capacity > 0); + + if ((list->count + 1) >= list->capacity) { + size = list->capacity * 2; + + p = LPC_ALLOC(list->element_size * size); + if (p == NULL) return false; + + memcpy(p, list->data, list->element_size * list->capacity); + LPC_FREE(list->data); + + list->capacity = size; + list->data = p; + } + + p = (lpc_u8*)list->data + list->element_size * list->count; + + memcpy(p, data, list->element_size); + + list->count++; + return true; +} + + +LPC_API void lpc_codes_free(Lpc_Codes *codes) { + assert(codes != NULL); + + if (codes->code) { + LPC_FREE(codes->code); + } + + memset(codes, 0, sizeof(Lpc_Codes)); +} + +LPC_API void lpc_buffer_free(Lpc_Sample_Buffer *buffer) { + assert(buffer != NULL); + + if (buffer->samples) { + LPC_FREE(buffer->samples); + } + + memset(buffer, 0, sizeof(Lpc_Sample_Buffer)); +} + +LPC_API void lpc_tms5220_buffer_free(Lpc_TMS5220_Buffer *buffer) { + assert(buffer != NULL); + + if (buffer->bytes) { + LPC_FREE(buffer->bytes); + } + + memset(buffer, 0, sizeof(Lpc_TMS5220_Buffer)); +} + + +#endif // LPC_ENC_DEC_IMPLEMENTATION +#endif // LPC_ENC_DEC_H |