ckernel_tts.h File Reference

#include <stddef.h>
#include <stdint.h>

Go to the source code of this file.

Data Structures
struct	CKKokoroShapeLimitsV8
struct	CKKokoroShapeV8

Enumerations
enum	CKAudioExtentStatus { CK_AUDIO_EXTENT_OK = 0 , CK_AUDIO_EXTENT_INVALID = -1 , CK_AUDIO_EXTENT_LIMIT = -2 , CK_AUDIO_EXTENT_OVERFLOW = -3 }

Functions
int	audio_duration_expand_channel_major_f32 (const float *features, size_t input_elements, size_t channels, size_t phoneme_count, size_t input_stride, const int32_t *durations, size_t expanded_frames, float *output, size_t output_elements, size_t output_stride)
int	audio_duration_logits_to_frames_f32 (const float *logits, size_t input_elements, size_t tokens, size_t bins, size_t input_stride, float speed, int32_t *durations, size_t duration_capacity, size_t max_duration_per_token, size_t max_expanded_frames, int32_t *expanded_frames)
int	audio_harmonic_source_checked_f32 (const float *f0, size_t f0_capacity, const float *gaussian, size_t gaussian_capacity, float *output, size_t output_capacity, float *phase_scratch, size_t scratch_capacity, size_t frames, size_t upsample, size_t harmonics, float sample_rate, float voiced_threshold, float sine_amp, float noise_std)
int	audio_harmonic_source_weighted_fma_checked_f32 (const float *f0, size_t f0_capacity, const float *gaussian, size_t gaussian_capacity, float *output, size_t output_capacity, float *phase_scratch, size_t scratch_capacity, size_t frames, size_t upsample, size_t harmonics, float sample_rate, float voiced_threshold, float sine_amp, float noise_std)
int	audio_istft_mag_phase_f32 (const float *magnitude, const float *phase, size_t spectral_elements, size_t frames, size_t n_fft, size_t hop, float *output, size_t output_capacity, float *scratch, size_t scratch_elements)
int	audio_istft_mag_phase_plan_f32 (size_t frames, size_t n_fft, size_t hop, size_t *spectral_elements, size_t *output_samples, size_t *scratch_elements)
int	audio_noise_counter_gaussian_f32 (float *output, size_t output_capacity, size_t count, uint64_t seed, uint64_t stream)
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)
int	audio_stft_mag_phase_checked_f32 (const float *samples, size_t samples_capacity, const float *window, size_t window_capacity, const float *cos_table, const float *sin_table, size_t table_capacity, float *output, size_t output_capacity, size_t output_stride, float *scratch, size_t scratch_capacity, size_t samples_count, size_t n_fft, size_t hop, size_t frames)
int	audio_stft_mag_phase_plan_f32 (size_t samples, size_t n_fft, size_t hop, size_t *frames, size_t *spectral_elements)
int	audio_stft_mag_phase_trace_checked_f32 (const float *samples, size_t samples_capacity, const float *window, size_t window_capacity, const float *cos_table, const float *sin_table, size_t table_capacity, float *output, size_t output_capacity, size_t output_stride, float *scratch, size_t scratch_capacity, size_t samples_count, size_t n_fft, size_t hop, size_t frames, double *complex_trace, size_t complex_trace_capacity)
int	ck_kokoro_plan_shape_v8 (const int32_t *durations, size_t phoneme_count, const CKKokoroShapeLimitsV8 *limits, CKKokoroShapeV8 *shape)

Enumeration Type Documentation

CKAudioExtentStatus

enum CKAudioExtentStatus

Enumerator
CK_AUDIO_EXTENT_OK
CK_AUDIO_EXTENT_INVALID
CK_AUDIO_EXTENT_LIMIT
CK_AUDIO_EXTENT_OVERFLOW

Definition at line 40 of file ckernel_tts.h.

                         {
    CK_AUDIO_EXTENT_OK = 0,
    CK_AUDIO_EXTENT_INVALID = -1,
    CK_AUDIO_EXTENT_LIMIT = -2,
    CK_AUDIO_EXTENT_OVERFLOW = -3
};

Function Documentation

audio_duration_expand_channel_major_f32()

int audio_duration_expand_channel_major_f32	(	const float *	features,
		size_t	input_elements,
		size_t	channels,
		size_t	phoneme_count,
		size_t	input_stride,
		const int32_t *	durations,
		size_t	expanded_frames,
		float *	output,
		size_t	output_elements,
		size_t	output_stride
	)

Definition at line 5 of file audio_duration_expand.c.

                          {
    if (!features || !durations || !output || !channels || !phoneme_count ||
        !expanded_frames || input_stride < phoneme_count ||
        output_stride < expanded_frames) return CK_AUDIO_EXTENT_INVALID;
    if (channels - 1 > (SIZE_MAX - phoneme_count) / input_stride ||
        channels - 1 > (SIZE_MAX - expanded_frames) / output_stride)
        return CK_AUDIO_EXTENT_OVERFLOW;
    const size_t required_input = (channels - 1) * input_stride + phoneme_count;
    const size_t required_output = (channels - 1) * output_stride + expanded_frames;
    if (required_input > SIZE_MAX / sizeof(float) ||
        required_output > SIZE_MAX / sizeof(float)) return CK_AUDIO_EXTENT_OVERFLOW;
    if (input_elements < required_input || output_elements < required_output)
        return CK_AUDIO_EXTENT_LIMIT;
 
    size_t sum = 0;
    for (size_t token = 0; token < phoneme_count; ++token) {
        if (durations[token] <= 0) return CK_AUDIO_EXTENT_INVALID;
        if ((size_t)durations[token] > expanded_frames - sum)
            return CK_AUDIO_EXTENT_LIMIT;
        sum += (size_t)durations[token];
    }
    if (sum != expanded_frames) return CK_AUDIO_EXTENT_INVALID;
 
    for (size_t channel = 0; channel < channels; ++channel) {
        size_t frame = 0;
        for (size_t token = 0; token < phoneme_count; ++token) {
            const float value = features[channel * input_stride + token];
            for (int32_t j = 0; j < durations[token]; ++j) {
                output[channel * output_stride + frame++] = value;
            }
        }
    }
    return CK_AUDIO_EXTENT_OK;
}

References CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_LIMIT, CK_AUDIO_EXTENT_OK, CK_AUDIO_EXTENT_OVERFLOW, and token.

audio_duration_logits_to_frames_f32()

int audio_duration_logits_to_frames_f32	(	const float *	logits,
		size_t	input_elements,
		size_t	tokens,
		size_t	bins,
		size_t	input_stride,
		float	speed,
		int32_t *	durations,
		size_t	duration_capacity,
		size_t	max_duration_per_token,
		size_t	max_expanded_frames,
		int32_t *	expanded_frames
	)

Definition at line 43 of file audio_duration_logits.c.

                                                          {
    if (!logits || !durations || !expanded_frames || !tokens || !bins ||
        input_stride < bins || !isfinite(speed) || speed <= 0.0f ||
        !max_duration_per_token || max_duration_per_token > INT32_MAX ||
        !max_expanded_frames || max_expanded_frames > INT32_MAX)
        return CK_AUDIO_EXTENT_INVALID;
    if (tokens - 1 > (SIZE_MAX - bins) / input_stride ||
        tokens > SIZE_MAX / sizeof(int32_t))
        return CK_AUDIO_EXTENT_OVERFLOW;
    const size_t required_input = (tokens - 1) * input_stride + bins;
    if (required_input > SIZE_MAX / sizeof(float))
        return CK_AUDIO_EXTENT_OVERFLOW;
    if (input_elements < required_input || duration_capacity < tokens)
        return CK_AUDIO_EXTENT_LIMIT;
 
    size_t total = 0;
    for (size_t token = 0; token < tokens; ++token) {
        int32_t frames = 0;
        const int rc = token_frames(logits + token * input_stride, bins, speed,
                                    max_duration_per_token, &frames);
        if (rc != CK_AUDIO_EXTENT_OK) return rc;
        if ((size_t)frames > max_expanded_frames - total)
            return CK_AUDIO_EXTENT_LIMIT;
        total += (size_t)frames;
    }
 
    for (size_t token = 0; token < tokens; ++token) {
        int32_t frames = 0;
        /* The first pass validated all inputs and capacities. */
        (void)token_frames(logits + token * input_stride, bins, speed,
                           max_duration_per_token, &frames);
        durations[token] = frames;
    }
    *expanded_frames = (int32_t)total;
    return CK_AUDIO_EXTENT_OK;
}

References CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_LIMIT, CK_AUDIO_EXTENT_OK, CK_AUDIO_EXTENT_OVERFLOW, token, and token_frames().

audio_harmonic_source_checked_f32()

int audio_harmonic_source_checked_f32	(	const float *	f0,
		size_t	f0_capacity,
		const float *	gaussian,
		size_t	gaussian_capacity,
		float *	output,
		size_t	output_capacity,
		float *	phase_scratch,
		size_t	scratch_capacity,
		size_t	frames,
		size_t	upsample,
		size_t	harmonics,
		float	sample_rate,
		float	voiced_threshold,
		float	sine_amp,
		float	noise_std
	)

Definition at line 106 of file audio_harmonic_source_checked.c.

                                     {
    return audio_harmonic_source_impl_f32(f0, f0_capacity, gaussian,
        gaussian_capacity, output, output_capacity, phase_scratch,
        scratch_capacity, frames, upsample, harmonics, sample_rate,
        voiced_threshold, sine_amp, noise_std, 0);
}

References audio_harmonic_source_impl_f32().

audio_harmonic_source_weighted_fma_checked_f32()

int audio_harmonic_source_weighted_fma_checked_f32	(	const float *	f0,
		size_t	f0_capacity,
		const float *	gaussian,
		size_t	gaussian_capacity,
		float *	output,
		size_t	output_capacity,
		float *	phase_scratch,
		size_t	scratch_capacity,
		size_t	frames,
		size_t	upsample,
		size_t	harmonics,
		float	sample_rate,
		float	voiced_threshold,
		float	sine_amp,
		float	noise_std
	)

Definition at line 120 of file audio_harmonic_source_checked.c.

                                     {
    return audio_harmonic_source_impl_f32(f0, f0_capacity, gaussian,
        gaussian_capacity, output, output_capacity, phase_scratch,
        scratch_capacity, frames, upsample, harmonics, sample_rate,
        voiced_threshold, sine_amp, noise_std, 1);
}

References audio_harmonic_source_impl_f32().

audio_istft_mag_phase_f32()

int audio_istft_mag_phase_f32	(	const float *	magnitude,
		const float *	phase,
		size_t	spectral_elements,
		size_t	frames,
		size_t	n_fft,
		size_t	hop,
		float *	output,
		size_t	output_capacity,
		float *	scratch,
		size_t	scratch_elements
	)

Definition at line 50 of file audio_istft_mag_phase.c.

                             {
    if (!magnitude || !phase || !output || !scratch)
        return CK_AUDIO_EXTENT_INVALID;
    size_t required_spectrum, output_samples, required_scratch;
    int status = audio_istft_mag_phase_plan_f32(
        frames, n_fft, hop, &required_spectrum, &output_samples,
        &required_scratch);
    if (status != CK_AUDIO_EXTENT_OK) return status;
    if (spectral_elements < required_spectrum ||
        output_capacity < output_samples ||
        scratch_elements < required_scratch) return CK_AUDIO_EXTENT_LIMIT;
    for (size_t i = 0; i < required_spectrum; ++i) {
        if (!isfinite(magnitude[i]) || !isfinite(phase[i]) || magnitude[i] < 0.0f)
            return CK_AUDIO_EXTENT_INVALID;
    }
 
    const size_t padded_samples = output_samples + n_fft;
    float *overlap = scratch;
    float *window_sum = overlap + padded_samples;
    float *window = window_sum + padded_samples;
    memset(overlap, 0, padded_samples * sizeof(float));
    memset(window_sum, 0, padded_samples * sizeof(float));
    const float tau = 6.2831853071795864769f;
    for (size_t n = 0; n < n_fft; ++n)
        window[n] = 0.5f - 0.5f * cosf(tau * (float)n / (float)n_fft);
 
    const size_t bins = n_fft / 2 + 1;
    const float inverse_n = 1.0f / (float)n_fft;
    for (size_t frame = 0; frame < frames; ++frame) {
        const size_t base = frame * bins;
        const size_t offset = frame * hop;
        for (size_t n = 0; n < n_fft; ++n) {
            float acc = magnitude[base] * cosf(phase[base]);
            const size_t nyquist = bins - 1;
            float end = magnitude[base + nyquist] * cosf(phase[base + nyquist]);
            acc += (n & 1) ? -end : end;
            for (size_t k = 1; k < nyquist; ++k) {
                const float real = magnitude[base + k] * cosf(phase[base + k]);
                const float imag = magnitude[base + k] * sinf(phase[base + k]);
                const float angle = tau * (float)k * (float)n / (float)n_fft;
                acc += 2.0f * (real * cosf(angle) - imag * sinf(angle));
            }
            const float w = window[n];
            overlap[offset + n] += acc * inverse_n * w;
            window_sum[offset + n] += w * w;
        }
    }
 
    const size_t left_trim = n_fft / 2;
    for (size_t i = 0; i < output_samples; ++i) {
        const size_t pos = left_trim + i;
        const float norm = window_sum[pos];
        if (!(norm > 1e-11f)) return CK_AUDIO_EXTENT_INVALID;
        if (!isfinite(overlap[pos] / norm)) return CK_AUDIO_EXTENT_INVALID;
    }
    for (size_t i = 0; i < output_samples; ++i) {
        const size_t pos = left_trim + i;
        output[i] = overlap[pos] / window_sum[pos];
    }
    return CK_AUDIO_EXTENT_OK;
}

References audio_istft_mag_phase_plan_f32(), CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_LIMIT, CK_AUDIO_EXTENT_OK, and end.

audio_istft_mag_phase_plan_f32()

int audio_istft_mag_phase_plan_f32	(	size_t	frames,
		size_t	n_fft,
		size_t	hop,
		size_t *	spectral_elements,
		size_t *	output_samples,
		size_t *	scratch_elements
	)

Definition at line 19 of file audio_istft_mag_phase.c.

                              {
    if (!spectral_elements || !output_samples || !scratch_elements ||
        frames < 2 || n_fft < 2 || (n_fft & 1) || !hop || hop > n_fft / 2) {
        return CK_AUDIO_EXTENT_INVALID;
    }
    size_t bins = n_fft / 2 + 1;
    size_t spectrum, output, padded, scratch;
    if (!mul_size(frames, bins, &spectrum) ||
        !mul_size(frames - 1, hop, &output) ||
        !add_size(output, n_fft, &padded) ||
        !mul_size(padded, 2, &scratch) ||
        !add_size(scratch, n_fft, &scratch)) {
        return CK_AUDIO_EXTENT_OVERFLOW;
    }
    if (spectrum > SIZE_MAX / sizeof(float) ||
        output > SIZE_MAX / sizeof(float) ||
        scratch > SIZE_MAX / sizeof(float)) {
        return CK_AUDIO_EXTENT_OVERFLOW;
    }
    *spectral_elements = spectrum;
    *output_samples = output;
    *scratch_elements = scratch;
    return CK_AUDIO_EXTENT_OK;
}

References add_size(), CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_OK, CK_AUDIO_EXTENT_OVERFLOW, and mul_size().

Referenced by audio_istft_mag_phase_f32().

audio_noise_counter_gaussian_f32()

int audio_noise_counter_gaussian_f32	(	float *	output,
		size_t	output_capacity,
		size_t	count,
		uint64_t	seed,
		uint64_t	stream
	)

Definition at line 18 of file audio_noise_counter.c.

                                                  {
    if (!count) return CK_AUDIO_EXTENT_INVALID;
    if (count > (1u << 24) || output_capacity < count)
        return CK_AUDIO_EXTENT_LIMIT;
    if (!ck_checked_region(output, count)) return CK_AUDIO_EXTENT_INVALID;
    const uint64_t domain = mix64(seed ^ mix64(stream));
    for (size_t index = 0; index < count; ++index) {
        const uint64_t counter = (uint64_t)index * UINT64_C(2);
        const uint64_t first = mix64(domain + counter);
        const uint64_t second = mix64(domain + counter + UINT64_C(1));
        const double uniform_positive =
            ((double)(first >> 11) + 0.5) * 0x1.0p-53;
        const double uniform_angle = (double)(second >> 11) * 0x1.0p-53;
        const double radius = sqrt(-2.0 * log(uniform_positive));
        output[index] = (float)(radius * cos(
            6.283185307179586476925286766559 * uniform_angle));
    }
    return CK_AUDIO_EXTENT_OK;
}

References CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_LIMIT, CK_AUDIO_EXTENT_OK, ck_checked_region(), count, and mix64().

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().

audio_stft_mag_phase_checked_f32()

int audio_stft_mag_phase_checked_f32	(	const float *	samples,
		size_t	samples_capacity,
		const float *	window,
		size_t	window_capacity,
		const float *	cos_table,
		const float *	sin_table,
		size_t	table_capacity,
		float *	output,
		size_t	output_capacity,
		size_t	output_stride,
		float *	scratch,
		size_t	scratch_capacity,
		size_t	samples_count,
		size_t	n_fft,
		size_t	hop,
		size_t	frames
	)

Definition at line 133 of file audio_stft_mag_phase_checked.c.

                                                                   {
    return stft_mag_phase_impl(samples, samples_capacity, window,
        window_capacity, cos_table, sin_table, table_capacity, output,
        output_capacity, output_stride, scratch, scratch_capacity,
        samples_count, n_fft, hop, frames, NULL, 0);
}

References stft_mag_phase_impl().

audio_stft_mag_phase_plan_f32()

int audio_stft_mag_phase_plan_f32	(	size_t	samples,
		size_t	n_fft,
		size_t	hop,
		size_t *	frames,
		size_t *	spectral_elements
	)

Definition at line 8 of file audio_stft_mag_phase_checked.c.

                                               {
    if (!frames || !spectral_elements || n_fft < 2 || (n_fft & 1) ||
        !hop || samples <= n_fft / 2 || samples > INT64_MAX / 2 ||
        n_fft > INT64_MAX / 2 || samples > SIZE_MAX / sizeof(float) ||
        n_fft > SIZE_MAX / sizeof(float)) return CK_AUDIO_EXTENT_INVALID;
    const size_t count = samples / hop + 1;
    const size_t bins = n_fft / 2 + 1;
    if (count > SIZE_MAX / (2 * bins) ||
        count * (2 * bins) > SIZE_MAX / sizeof(float))
        return CK_AUDIO_EXTENT_OVERFLOW;
    *frames = count;
    *spectral_elements = count * 2 * bins;
    return CK_AUDIO_EXTENT_OK;
}

References CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_OK, CK_AUDIO_EXTENT_OVERFLOW, and count.

Referenced by stft_mag_phase_impl().

audio_stft_mag_phase_trace_checked_f32()

int audio_stft_mag_phase_trace_checked_f32	(	const float *	samples,
		size_t	samples_capacity,
		const float *	window,
		size_t	window_capacity,
		const float *	cos_table,
		const float *	sin_table,
		size_t	table_capacity,
		float *	output,
		size_t	output_capacity,
		size_t	output_stride,
		float *	scratch,
		size_t	scratch_capacity,
		size_t	samples_count,
		size_t	n_fft,
		size_t	hop,
		size_t	frames,
		double *	complex_trace,
		size_t	complex_trace_capacity
	)

Definition at line 147 of file audio_stft_mag_phase_checked.c.

                                                          {
    if (!complex_trace) return CK_AUDIO_EXTENT_INVALID;
    return stft_mag_phase_impl(samples, samples_capacity, window,
        window_capacity, cos_table, sin_table, table_capacity, output,
        output_capacity, output_stride, scratch, scratch_capacity,
        samples_count, n_fft, hop, frames, complex_trace,
        complex_trace_capacity);
}

References CK_AUDIO_EXTENT_INVALID, and stft_mag_phase_impl().

ck_kokoro_plan_shape_v8()

int ck_kokoro_plan_shape_v8	(	const int32_t *	durations,
		size_t	phoneme_count,
		const CKKokoroShapeLimitsV8 *	limits,
		CKKokoroShapeV8 *	shape
	)

Definition at line 18 of file kokoro_shape_bounds.c.

                            {
    if (!durations || !limits || !shape || !phoneme_count ||
        !limits->max_phonemes || !limits->max_duration_per_phoneme ||
        !limits->max_expanded_frames || !limits->max_generator_samples ||
        !limits->max_output_samples || !limits->max_alignment_elements ||
        !limits->alignment_channels || !limits->decoder_upsample_factor ||
        !limits->generator_upsample_rate_0 || !limits->generator_upsample_rate_1 ||
        !limits->istft_hop_size || !limits->istft_fft_size) {
        return CK_AUDIO_EXTENT_INVALID;
    }
    memset(shape, 0, sizeof(*shape));
    if (phoneme_count > limits->max_phonemes) return CK_AUDIO_EXTENT_LIMIT;
 
    size_t frames = 0;
    for (size_t i = 0; i < phoneme_count; ++i) {
        if (durations[i] <= 0) return CK_AUDIO_EXTENT_INVALID;
        if ((size_t)durations[i] > limits->max_duration_per_phoneme)
            return CK_AUDIO_EXTENT_LIMIT;
        if (!checked_add(frames, (size_t)durations[i], &frames))
            return CK_AUDIO_EXTENT_OVERFLOW;
        if (frames > limits->max_expanded_frames)
            return CK_AUDIO_EXTENT_LIMIT;
    }
 
    size_t align, decoder, generator, istft_frames, padded, output;
    if (!checked_mul(frames, limits->alignment_channels, &align) ||
        !checked_mul(frames, limits->decoder_upsample_factor, &decoder) ||
        !checked_mul(decoder, limits->generator_upsample_rate_0, &generator) ||
        !checked_mul(generator, limits->generator_upsample_rate_1, &generator) ||
        !checked_add(generator / limits->istft_hop_size, 1, &istft_frames) ||
        !checked_add(generator, limits->istft_fft_size, &padded) ||
        !checked_add(generator, limits->istft_fft_size, &output)) {
        return CK_AUDIO_EXTENT_OVERFLOW;
    }
    if (align > SIZE_MAX / sizeof(float) ||
        decoder > SIZE_MAX / sizeof(float) ||
        generator > SIZE_MAX / sizeof(float) ||
        padded > SIZE_MAX / sizeof(float) ||
        output > SIZE_MAX / sizeof(float)) {
        return CK_AUDIO_EXTENT_OVERFLOW;
    }
    if (align > limits->max_alignment_elements ||
        generator > limits->max_generator_samples ||
        output > limits->max_output_samples) {
        return CK_AUDIO_EXTENT_LIMIT;
    }
 
    shape->phonemes = phoneme_count;
    shape->expanded_frames = frames;
    shape->alignment_elements = align;
    shape->decoder_frames = decoder;
    shape->generator_samples = generator;
    shape->istft_frames = istft_frames;
    shape->istft_padded_samples = padded;
    shape->output_samples_upper_bound = output;
    return CK_AUDIO_EXTENT_OK;
}

References CKKokoroShapeLimitsV8::alignment_channels, CKKokoroShapeV8::alignment_elements, checked_add(), checked_mul(), CK_AUDIO_EXTENT_INVALID, CK_AUDIO_EXTENT_LIMIT, CK_AUDIO_EXTENT_OK, CK_AUDIO_EXTENT_OVERFLOW, CKKokoroShapeV8::decoder_frames, CKKokoroShapeLimitsV8::decoder_upsample_factor, CKKokoroShapeV8::expanded_frames, CKKokoroShapeV8::generator_samples, CKKokoroShapeLimitsV8::generator_upsample_rate_0, CKKokoroShapeLimitsV8::generator_upsample_rate_1, CKKokoroShapeLimitsV8::istft_fft_size, CKKokoroShapeV8::istft_frames, CKKokoroShapeLimitsV8::istft_hop_size, CKKokoroShapeV8::istft_padded_samples, CKKokoroShapeLimitsV8::max_alignment_elements, CKKokoroShapeLimitsV8::max_duration_per_phoneme, CKKokoroShapeLimitsV8::max_expanded_frames, CKKokoroShapeLimitsV8::max_generator_samples, CKKokoroShapeLimitsV8::max_output_samples, CKKokoroShapeLimitsV8::max_phonemes, CKKokoroShapeV8::output_samples_upper_bound, and CKKokoroShapeV8::phonemes.