diff options
Diffstat (limited to 'src/lpc10_enc_dec.h')
| -rw-r--r-- | src/lpc10_enc_dec.h | 250 |
1 files changed, 148 insertions, 102 deletions
diff --git a/src/lpc10_enc_dec.h b/src/lpc10_enc_dec.h index 404ad38..1d8f782 100644 --- a/src/lpc10_enc_dec.h +++ b/src/lpc10_enc_dec.h @@ -1,12 +1,30 @@ /* LPC10 - simple audio encoder/decoder for tms5220. - Language version C89/C99. + Language version C89/C99. (compiles as -std=c89 with gcc) standard math library. - define LPC_ENC_DEC_IMPLEMENTATION before including file to include implementation code. + USAGE: - define LPC_STATIC_DECL to make all declarations static. + In exactly one translation unit define LPC_ENC_DEC_IMPLEMENTATION + before including this library: + + ```c + + #define LPC_ENC_DEC_IMPLEMENTATION + #include "lpc10_enc_dec.h" + + ``` + + DEFINES: + + LPC_ENC_DEC_IMPLEMENTATION (required once) - will include implementation + LPC_STATIC_DECL (optional) - makes all declarations static. + NDEBUG (optional) - will define internal asserts as (void)(expr). + + assert(expr) - redefine to bypass standard assertion mechanism, it also bypases including stdio.h. + LPC_ALLOC(size) - redefine to change allocation strategies (also need to redefine LPC_FREE). + LPC_FREE(ptr) - same as LPC_ALLOC. LICENSE: @@ -33,6 +51,7 @@ CHANGELOG: v1.0 Init version. + v1.1 Adding LPC_UNUSED and LPC_INLINE macro as I forget to add it, preprocessor typos and coments style. */ #if !defined(LPC_ENC_DEC_H) @@ -42,15 +61,17 @@ #define LPC_API static #else #define LPC_API -#endif // LPC_STATIC_DECL +#endif /* LPC_STATIC_DECL */ #if !defined(CLITERAL) #if defined(__cplusplus) #define CLITERAL(type) type #else #define CLITERAL(type) (type) -#endif // __cplusplus -#endif // CLITERAL +#endif /* __cplusplus */ +#endif /* CLITERAL */ + +#define LPC_UNUSED(x) (void)(x) #include <stddef.h> #include <stdint.h> @@ -81,30 +102,45 @@ extern "C" { #else #if !defined(LPC_FREE) #error "LPC_ALLOC was redefined but not LPC_FREE" -#endif // LPC_FREE -#endif // LPC_ALLOC +#endif /* LPC_FREE */ +#endif /* LPC_ALLOC */ #if !defined(LPC_FREE) #define LPC_FREE(ptr) free(ptr) #else -#if !defined(LPC_FREE) +#if !defined(LPC_ALLOC) #error "LPC_FREE was redefined but not LPC_ALLOC" -#endif // LPC_ALLOC -#endif // LPC_FREE +#endif /* LPC_ALLOC */ +#endif /* LPC_FREE */ + +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define LPC_INLINE inline +#elif defined(__GNUC__) || defined(__clang__) +#define LPC_INLINE __inline__ +#elif defined(_MSC_VER) +#define LPC_INLINE __inline +#else +#define LPC_INLINE +#endif + #if !defined(assert) +#if !defined(NDEBUG) #include <stdio.h> -#define assert(expr) if ((expr) == 0) {\ +#define assert(expr) if ((int)(expr) == 0) {\ fprintf(stderr, "Assert at %s:%d failed!", __FILE__, __LINE__); \ *((int *)0) = 0; \ } -#endif +#else +#define assert(expr) (void)(expr) +#endif /* NDEBUG */ +#endif /* assert */ -// +/* // Type declarations -// +*/ typedef uint64_t lpc_u64; typedef uint32_t lpc_u32; @@ -127,14 +163,17 @@ 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 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; @@ -153,9 +192,9 @@ typedef struct { 25, 2 \ } -// +/* // @todo, fixed version -// +*/ typedef struct { lpc_u32 sample_rate; lpc_u32 channels; @@ -177,14 +216,15 @@ typedef struct { 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; @@ -234,11 +274,11 @@ typedef struct { void *data; } Lpc_List; -// +/* // API -// +*/ -// Helper function to make sure, codes are correct +/* 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); @@ -254,7 +294,7 @@ 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 void* lpc_list_get(Lpc_List *list, lpc_u64 index); LPC_API lpc_b32 lpc_list_append(Lpc_List *list, void *data); @@ -297,8 +337,8 @@ LPC_API lpc_b32 lpc_list_append(Lpc_List *list, void *data); #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] = { +/* LATER_CHIRP, from python_wizard: https://github.com/ptwz/python_wizard */ +LPC_API 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, @@ -308,21 +348,21 @@ static lpc_f32 chirp_table[LPC_CHIRP_TABLE_SIZE] = { 0, 0, 0, 0, }; -static lpc_f32 energy_table[LPC_ENERGY_MASK + 1] = { +LPC_API 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] = { +LPC_API 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] = { +LPC_API 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, @@ -334,7 +374,7 @@ static lpc_f32 k1_table[LPC_K1_K2_MASK + 1] = { 0.66013, 0.75054, 0.80416, 0.85350, }; -static lpc_f32 k2_table[LPC_K1_K2_MASK + 1] = { +LPC_API 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, @@ -346,60 +386,59 @@ static lpc_f32 k2_table[LPC_K1_K2_MASK + 1] = { 0.90451, 0.91813, 0.92988, 0.98830 }; -static lpc_f32 k3_table[LPC_K3_K4_K5_K6_K7_MASK + 1] = { +LPC_API 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] = { +LPC_API 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] = { +LPC_API 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] = { +LPC_API 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] = { +LPC_API 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] = { +LPC_API 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] = { +LPC_API 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] = { +LPC_API 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; @@ -441,7 +480,7 @@ LPC_API Lpc_Biquad_Filter biquad_bandpass_design(lpc_u32 sample_rate, lpc_f32 lo return filter; } -LPC_API inline lpc_f32 biquad_process(Lpc_Biquad_Filter *filter, lpc_f32 input) { +LPC_API LPC_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 @@ -455,9 +494,9 @@ LPC_API inline lpc_f32 biquad_process(Lpc_Biquad_Filter *filter, lpc_f32 input) 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; @@ -502,20 +541,20 @@ LPC_API Lpc_Code lpc_code_clamp(Lpc_Code code) { 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.energy) & LPC_ENERGY_MASK) << LPC_ENERGY_OFFSET; + output |= (((lpc_u64)bitcode.repeat) & LPC_REP_MASK) << LPC_REP_OFFSET; + output |= (((lpc_u64)bitcode.pitch) & LPC_PITCH_MASK) << 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); + output |= (((lpc_u64)bitcode.k1) & LPC_K1_K2_MASK) << LPC_K1_OFFSET; + output |= (((lpc_u64)bitcode.k2) & LPC_K1_K2_MASK) << LPC_K2_OFFSET; + output |= (((lpc_u64)bitcode.k3) & LPC_K3_K4_K5_K6_K7_MASK) << LPC_K3_OFFSET; + output |= (((lpc_u64)bitcode.k4) & LPC_K3_K4_K5_K6_K7_MASK) << LPC_K4_OFFSET; + output |= (((lpc_u64)bitcode.k5) & LPC_K3_K4_K5_K6_K7_MASK) << LPC_K5_OFFSET; + output |= (((lpc_u64)bitcode.k6) & LPC_K3_K4_K5_K6_K7_MASK) << LPC_K6_OFFSET; + output |= (((lpc_u64)bitcode.k7) & LPC_K3_K4_K5_K6_K7_MASK) << LPC_K7_OFFSET; + output |= (((lpc_u64)bitcode.k8) & LPC_K8_K9_K10_MASK) << LPC_K8_OFFSET; + output |= (((lpc_u64)bitcode.k9) & LPC_K8_K9_K10_MASK) << LPC_K9_OFFSET; + output |= (((lpc_u64)bitcode.k10) & LPC_K8_K9_K10_MASK); return output; } @@ -524,41 +563,41 @@ 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; + output.energy = ((lpc_u64)bitcode & (LPC_ENERGY_MASK << 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; + output.repeat = ((lpc_u64)bitcode & (LPC_REP_MASK << LPC_REP_OFFSET)) >> LPC_REP_OFFSET; + output.pitch = ((lpc_u64)bitcode & (LPC_PITCH_MASK << 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; + output.k1 = ((lpc_u64)bitcode & (LPC_K1_K2_MASK << LPC_K1_OFFSET)) >> LPC_K1_OFFSET; + output.k2 = ((lpc_u64)bitcode & (LPC_K1_K2_MASK << LPC_K2_OFFSET)) >> LPC_K2_OFFSET; + output.k3 = ((lpc_u64)bitcode & (LPC_K3_K4_K5_K6_K7_MASK << LPC_K3_OFFSET)) >> LPC_K3_OFFSET; + output.k4 = ((lpc_u64)bitcode & (LPC_K3_K4_K5_K6_K7_MASK << 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); + output.k5 = ((lpc_u64)bitcode & (LPC_K3_K4_K5_K6_K7_MASK << LPC_K5_OFFSET)) >> LPC_K5_OFFSET; + output.k6 = ((lpc_u64)bitcode & (LPC_K3_K4_K5_K6_K7_MASK << LPC_K6_OFFSET)) >> LPC_K6_OFFSET; + output.k7 = ((lpc_u64)bitcode & (LPC_K3_K4_K5_K6_K7_MASK << LPC_K7_OFFSET)) >> LPC_K7_OFFSET; + output.k8 = ((lpc_u64)bitcode & (LPC_K8_K9_K10_MASK << LPC_K8_OFFSET)) >> LPC_K8_OFFSET; + output.k9 = ((lpc_u64)bitcode & (LPC_K8_K9_K10_MASK << LPC_K9_OFFSET)) >> LPC_K9_OFFSET; + output.k10 = ((lpc_u64)bitcode & LPC_K8_K9_K10_MASK); return output; } -// +/* // Encoding -// +*/ LPC_API Lpc_Sample_Buffer lpc_buffer_prepare_internal(Lpc_Sample_Buffer buffer) { Lpc_Sample_Buffer converted; @@ -574,7 +613,7 @@ LPC_API Lpc_Sample_Buffer lpc_buffer_prepare_internal(Lpc_Sample_Buffer buffer) 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 + 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)); @@ -618,7 +657,7 @@ LPC_API Lpc_Sample_Buffer lpc_buffer_copy_internal(Lpc_Sample_Buffer buffer) { new_buffer = buffer; new_buffer.samples = (lpc_f32*)LPC_ALLOC((sizeof(lpc_f32) * buffer.frame_count)); - assert(new_buffer.samples != NULL); // @todo, proper recovery + assert(new_buffer.samples != NULL); /* @todo, proper recovery */ memcpy(new_buffer.samples, buffer.samples, sizeof(lpc_f32) * new_buffer.frame_count); return new_buffer; @@ -659,9 +698,9 @@ LPC_API void lpc_buffer_filter_internal(Lpc_Sample_Buffer buffer, lpc_f32 low_cu } } -// +/* // Pre emphasis -// +*/ LPC_API lpc_f32 lpc_buffer_energy_sqr_sum_internal(Lpc_Sample_Buffer buffer) { lpc_u64 i; @@ -691,9 +730,9 @@ LPC_API void lpc_buffer_pre_emphasis(Lpc_Sample_Buffer buffer, lpc_f32 alpha) { } } -// +/* // Segments -// +*/ LPC_API Lpc_Segments lpc_get_segments_internal(Lpc_Sample_Buffer buffer, lpc_u32 segment_size, lpc_u32 num_segments) { lpc_u64 i; @@ -702,7 +741,7 @@ LPC_API Lpc_Segments lpc_get_segments_internal(Lpc_Sample_Buffer buffer, lpc_u32 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(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++) { @@ -728,22 +767,26 @@ LPC_API void lpc_pitch_estimate_internal(Lpc_Sample_Buffer buffer, Lpc_Segments 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 + 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 + 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))); @@ -765,7 +808,7 @@ LPC_API void lpc_pitch_estimate_internal(Lpc_Sample_Buffer buffer, Lpc_Segments work_buffer[j] *= window[j]; } - { // calculate best correlation factor + { /* calculate best correlation factor */ for (j = 0; j < period_count; j++) { periods[j] = 0; @@ -821,7 +864,7 @@ LPC_API Lpc_Codes lpc_get_codes_from_segments_internal(Lpc_Segments segments) { 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.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++) { @@ -865,7 +908,7 @@ LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings sett 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 + /* 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; @@ -881,9 +924,9 @@ LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings sett coeff[j] = sum; } - // here we convert the lpc coefficients to K reflection coeffs + /* here we convert the lpc coefficients to K reflection coeffs */ - { // Leroux Guegen algorithm for finding K + { /* Leroux Guegen algorithm for finding K */ lpc_f32 y, b_params[11], d_params[12]; memset(k_params, 0, sizeof(k_params)); @@ -914,7 +957,7 @@ LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings sett segments.data[i].table_pitch = 0; } - { // setting RMS of signal + { /* setting RMS of signal */ lpc_f32 rms, dist, min_dist; lpc_u64 min_dist_i; @@ -941,12 +984,14 @@ LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings sett } { - // and we set them so segment in here + /* and then we set the Ks to segments */ 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; @@ -969,7 +1014,9 @@ LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings sett 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; @@ -1030,17 +1077,17 @@ LPC_API Lpc_Codes lpc_encode(Lpc_Sample_Buffer buffer, Lpc_Encoder_Settings sett return codes; } -// +/* // Decoding -// +*/ Lpc_Sample_Buffer lpc_decode(Lpc_Codes codes) { + lpc_u64 i = 0, j = 0, sample_counter = 0, phase_counter = 0, code_index = 0; + lpc_f32 in, t, max = FLT_MIN, min = FLT_MAX; 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_Code curr_code; lpc_f32 forward[10], backward[10]; - lpc_f32 in, t, max = FLT_MIN, min = FLT_MAX; lpc_u32 noise = 1; lpc_b32 repeat; @@ -1244,7 +1291,7 @@ LPC_API Lpc_Bitcode_Info lpc_tms5220_decode_bits_internal(lpc_u1 *bits, lpc_u64 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); + LPC_UNUSED(bytes_count); assert((bytes_count * 8) == bits_count); @@ -1261,7 +1308,7 @@ LPC_API void lpc_tms5220_unsquash_bits_internal(lpc_u1 *cont, lpc_u64 cont_count lpc_u64 i, j, k = 0; lpc_u1 bit; - UNUSED(cont_count); + LPC_UNUSED(cont_count); assert(cont_count == (from_count * 8)); @@ -1289,13 +1336,13 @@ LPC_API Lpc_TMS5220_Buffer lpc_tms5220_encode(Lpc_Codes codes) { buff.count = bits.count / 8; if (bits.count != (buff.count * 8)) { - // we need to shift last bits on amount of bits + /* 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 + 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); @@ -1313,7 +1360,7 @@ LPC_API Lpc_Codes lpc_tms5220_decode(Lpc_TMS5220_Buffer buffer) { 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 + 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); @@ -1417,6 +1464,5 @@ LPC_API void lpc_tms5220_buffer_free(Lpc_TMS5220_Buffer *buffer) { memset(buffer, 0, sizeof(Lpc_TMS5220_Buffer)); } - -#endif // LPC_ENC_DEC_IMPLEMENTATION -#endif // LPC_ENC_DEC_H +#endif /* LPC_ENC_DEC_IMPLEMENTATION */ +#endif /* LPC_ENC_DEC_H */ |