audio_spectral_head.c File Reference

#include "ckernel_tts.h"
#include <math.h>
#include <stdint.h>

Go to the source code of this file.

Functions
int	audio_spectral_head_mag_phase_f32 (const float *input, size_t input_elements, size_t input_stride, float *magnitude, size_t magnitude_elements, float *phase, size_t phase_elements, size_t bins, size_t frames)
static int	overlaps (const void *a, size_t a_bytes, const void *b, size_t b_bytes)
static int	product (size_t a, size_t b, size_t *out)

Function Documentation

audio_spectral_head_mag_phase_f32()

int audio_spectral_head_mag_phase_f32	(	const float *	input,
		size_t	input_elements,
		size_t	input_stride,
		float *	magnitude,
		size_t	magnitude_elements,
		float *	phase,
		size_t	phase_elements,
		size_t	bins,
		size_t	frames
	)

Definition at line 21 of file audio_spectral_head.c.

                                {
    if (!input || !magnitude || !phase || !bins || !frames ||
        input_stride < frames) return CK_AUDIO_EXTENT_INVALID;
 
    size_t channels, input_required, output_required;
    if (!product(bins, 2, &channels) ||
        !product(channels, input_stride, &input_required) ||
        !product(bins, frames, &output_required) ||
        input_required > SIZE_MAX / sizeof(float) ||
        output_required > SIZE_MAX / sizeof(float))
        return CK_AUDIO_EXTENT_OVERFLOW;
    if (input_elements < input_required ||
        magnitude_elements < output_required ||
        phase_elements < output_required) return CK_AUDIO_EXTENT_LIMIT;
 
    const size_t input_bytes = input_required * sizeof(float);
    const size_t output_bytes = output_required * sizeof(float);
    if (overlaps(input, input_bytes, magnitude, output_bytes) ||
        overlaps(input, input_bytes, phase, output_bytes) ||
        overlaps(magnitude, output_bytes, phase, output_bytes))
        return CK_AUDIO_EXTENT_INVALID;
 
    for (size_t bin = 0; bin < bins; ++bin) {
        for (size_t frame = 0; frame < frames; ++frame) {
            const float log_magnitude = input[bin * input_stride + frame];
            const float raw_phase = input[(bins + bin) * input_stride + frame];
            if (!isfinite(log_magnitude) || !isfinite(raw_phase) ||
                !isfinite(expf(log_magnitude)))
                return CK_AUDIO_EXTENT_INVALID;
        }
    }
    for (size_t frame = 0; frame < frames; ++frame) {
        for (size_t bin = 0; bin < bins; ++bin) {
            const size_t output_index = frame * bins + bin;
            magnitude[output_index] = expf(input[bin * input_stride + frame]);
            phase[output_index] = sinf(input[(bins + bin) * input_stride + frame]);
        }
    }
    return CK_AUDIO_EXTENT_OK;
}

References CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_LIMIT, CK_AUDIO_EXTENT_OK, CK_AUDIO_EXTENT_OVERFLOW, overlaps(), and product().

overlaps()

static int overlaps ( const void *  a, size_t  a_bytes, const void *  b, size_t  b_bytes  )

static

Definition at line 12 of file audio_spectral_head.c.

                                                   {
    const uintptr_t left = (uintptr_t)a;
    const uintptr_t right = (uintptr_t)b;
    if (a_bytes > UINTPTR_MAX - left || b_bytes > UINTPTR_MAX - right)
        return 1;
    return left < right + b_bytes && right < left + a_bytes;
}

References left, and right.

Referenced by audio_spectral_head_mag_phase_f32().

product()

static int product ( size_t  a, size_t  b, size_t *  out  )

static

Definition at line 6 of file audio_spectral_head.c.

                                                    {
    if (a && b > SIZE_MAX / a) return 0;
    *out = a * b;
    return 1;
}

Referenced by attention_full_token_major_f32_checked(), audio_spectral_head_mag_phase_f32(), ck_attention_dot_f16_llama(), ck_attention_mad_f16_llama(), ck_deltanet_pytorch_outer_sum(), ck_ssm_conv1d_llama_channel_range(), dot_bias(), qwen4_llama_mul_sum_rows(), qwen4_ple_gate_conv_inject_impl(), and score().