audio_snake_checked.c File Reference

#include "ckernel_audio_snake_checked.h"
#include "checked_float_buffer.h"
#include <math.h>

Go to the source code of this file.

Functions
int	audio_snake_strided_f32_checked (const float *input, size_t input_elements, size_t input_stride, const float *alpha, size_t alpha_elements, float *output, size_t output_elements, size_t output_stride, size_t channels, size_t frames)
static int	snake_value (float x, float alpha, float *value)

Function Documentation

audio_snake_strided_f32_checked()

int audio_snake_strided_f32_checked	(	const float *	input,
		size_t	input_elements,
		size_t	input_stride,
		const float *	alpha,
		size_t	alpha_elements,
		float *	output,
		size_t	output_elements,
		size_t	output_stride,
		size_t	channels,
		size_t	frames
	)

Definition at line 21 of file audio_snake_checked.c.

                                    {
    size_t input_span, output_span;
    if (!channels || !frames || input_stride < frames || output_stride < frames)
        return -1;
    if (!ck_checked_span(channels, frames, input_stride, &input_span) ||
        !ck_checked_span(channels, frames, output_stride, &output_span))
        return -2;
    if (input_elements < input_span || output_elements < output_span ||
        alpha_elements < channels) return -2;
    if (!ck_checked_region(input, input_span) ||
        !ck_checked_region(alpha, channels) ||
        !ck_checked_region(output, output_span) ||
        ck_checked_overlap(input, input_span, output, output_span) ||
        ck_checked_overlap(alpha, channels, input, input_span) ||
        ck_checked_overlap(alpha, channels, output, output_span))
        return -1;
 
    /* A preflight pass preserves all output, including valid cells, when a
     * late element overflows. No heap or variable-length stack storage. */
    for (size_t channel = 0; channel < channels; ++channel) {
        const float a = alpha[channel];
        if (!isfinite(a) || a == 0.0f) return -3;
        for (size_t frame = 0; frame < frames; ++frame) {
            const float x = input[channel * input_stride + frame];
            float result;
            if (!isfinite(x) || !snake_value(x, a, &result)) return -3;
        }
    }
    for (size_t channel = 0; channel < channels; ++channel)
        for (size_t frame = 0; frame < frames; ++frame) {
            float result = 0.0f;
            /* Preflight established that this evaluation is finite. */
            (void)snake_value(input[channel * input_stride + frame],
                              alpha[channel], &result);
            output[channel * output_stride + frame] = result;
        }
    return 0;
}

References ck_checked_overlap(), ck_checked_region(), ck_checked_span(), and snake_value().

snake_value()

static int snake_value ( float  x, float  alpha, float *  value  )

static

Definition at line 6 of file audio_snake_checked.c.

                                                           {
    const float argument = alpha * x;
    if (!isfinite(argument)) return 0;
    const float sine = sinf(argument);
    const float inverse = 1.0f / alpha;
    const float square = sine * sine;
    /* Preserve the FP32 multiplication before addition even when the model
     * library is built with FMA enabled. */
    volatile float scaled = inverse * square;
    const float result = x + scaled;
    if (!isfinite(sine) || !isfinite(inverse) || !isfinite(result)) return 0;
    *value = result;
    return 1;
}

Referenced by audio_snake_strided_f32_checked().