delay_line.h

Go to the documentation of this file.

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license in the file COPYING
 * or http://www.opensource.org/licenses/CDDL-1.0.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file COPYING.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2023 Saso Kiselkov. All rights reserved.
 */
#ifndef _ACF_UTILS_DELAY_LINE_H_
#define _ACF_UTILS_DELAY_LINE_H_
 
#include <string.h>
#include <stdint.h>
 
#include "assert.h"
#include "core.h"
#include "crc64.h"
#include "time.h"
 
#ifdef  __cplusplus
extern "C" {
#endif
 
typedef uint64_t (*delay_line_time_func_t)(void *userinfo);
 
typedef struct {
    union {
        int64_t     i64;
        uint64_t    u64;
        double      f64;
    };
    union {
        int64_t     i64_new;
        uint64_t    u64_new;
        double      f64_new;
    };
    uint64_t        changed_t;
    uint64_t        delay_us;
    uint64_t        delay_base_us;
    double          delay_rand_fract;
#ifndef _MSC_VER
    int         __serialize_marker[0];
#else
    /* MSVC really hates a zero-length array */
    int         __serialize_marker[1];
#endif
    delay_line_time_func_t  time_func;
    void            *time_func_userinfo;
} delay_line_t;
 
static inline void
delay_line_init(delay_line_t *line, uint64_t delay_us)
{
    ASSERT(line != NULL);
    memset(line, 0, sizeof (*line));
    line->delay_us = delay_us;
    line->delay_base_us = delay_us;
    line->delay_rand_fract = 0;
}
 
static inline void
delay_line_init_time_func(delay_line_t *line, uint64_t delay_us,
    delay_line_time_func_t time_func, void *time_func_userinfo)
{
    ASSERT(line != NULL);
    memset(line, 0, sizeof (*line));
    line->delay_us = delay_us;
    line->delay_base_us = delay_us;
    line->delay_rand_fract = 0;
    line->time_func = time_func;
    line->time_func_userinfo = time_func_userinfo;
}
 
static inline void
delay_line_refresh_delay(delay_line_t *line)
{
    ASSERT(line != NULL);
    if (line->delay_rand_fract == 0) {
        line->delay_us = line->delay_base_us;
    } else {
        uint64_t rand_us = line->delay_rand_fract * line->delay_base_us;
        line->delay_us = line->delay_base_us +
            (uint64_t)((crc64_rand_fract() - 0.5) * rand_us);
    }
}
 
static inline void
delay_line_set_delay(delay_line_t *line, uint64_t delay_us)
{
    ASSERT(line != NULL);
    if (line->delay_base_us != delay_us) {
        line->delay_base_us = delay_us;
        delay_line_refresh_delay(line);
    }
}
 
static inline uint64_t
delay_line_get_delay(const delay_line_t *line)
{
    ASSERT(line != NULL);
    return (line->delay_base_us);
}
 
static inline uint64_t
delay_line_get_delay_act(const delay_line_t *line)
{
    ASSERT(line != NULL);
    return (line->delay_us);
}
 
static inline void
delay_line_set_rand(delay_line_t *line, double rand_fract)
{
    ASSERT(line != NULL);
    ASSERT3F(rand_fract, >=, 0);
    ASSERT3F(rand_fract, <=, 1);
    line->delay_rand_fract = rand_fract;
    delay_line_refresh_delay(line);
}
 
static inline double
delay_line_get_rand(const delay_line_t *line)
{
    return (line->delay_rand_fract);
}
 
#define DEF_DELAY_LINE_PULL(typename, abbrev_type) \
static inline typename \
delay_line_pull_ ## abbrev_type(delay_line_t *line) \
{ \
    uint64_t now; \
    ASSERT(line != NULL); \
    now = (line->time_func != NULL ? \
        line->time_func(line->time_func_userinfo) : microclock()); \
    if (line->abbrev_type ## _new != line->abbrev_type && \
        now - line->changed_t >= line->delay_us) { \
        line->abbrev_type = line->abbrev_type ## _new; \
        delay_line_refresh_delay(line); \
    } \
    return (line->abbrev_type); \
}
 
DEF_DELAY_LINE_PULL(int64_t, i64)
DEF_DELAY_LINE_PULL(uint64_t, u64)
DEF_DELAY_LINE_PULL(double, f64)
 
#define DEF_DELAY_LINE_PEEK(typename, abbrev_type) \
static inline typename \
delay_line_peek_ ## abbrev_type(const delay_line_t *line) \
{ \
    ASSERT(line != NULL); \
    return (line->abbrev_type); \
}
DEF_DELAY_LINE_PEEK(int64_t, i64)
DEF_DELAY_LINE_PEEK(uint64_t, u64)
DEF_DELAY_LINE_PEEK(double, f64)
 
DEF_DELAY_LINE_PEEK(int64_t, i64_new)
DEF_DELAY_LINE_PEEK(uint64_t, u64_new)
DEF_DELAY_LINE_PEEK(double, f64_new)
 
#define DEF_DELAY_LINE_PUSH(typename, abbrev_type) \
static inline typename \
delay_line_push_ ## abbrev_type(delay_line_t *line, typename value) \
{ \
    uint64_t now; \
    ASSERT(line != NULL); \
    now = (line->time_func != NULL ? \
        line->time_func(line->time_func_userinfo) : microclock()); \
    if (line->abbrev_type == line->abbrev_type ## _new && \
        value != line->abbrev_type ## _new) { \
        line->changed_t = now; \
        delay_line_refresh_delay(line); \
    } \
    line->abbrev_type ## _new = value; \
    return (delay_line_pull_ ## abbrev_type(line)); \
}
DEF_DELAY_LINE_PUSH(int64_t, i64)
DEF_DELAY_LINE_PUSH(uint64_t, u64)
DEF_DELAY_LINE_PUSH(double, f64)
 
#define DEF_DELAY_LINE_PUSH_IMM(typename, abbrev_type) \
static inline typename \
delay_line_push_imm_ ## abbrev_type(delay_line_t *line, typename value) \
{ \
    ASSERT(line != NULL); \
    line->abbrev_type = value; \
    line->abbrev_type ## _new = value; \
    return (line->abbrev_type); \
}
DEF_DELAY_LINE_PUSH_IMM(int64_t, i64)
DEF_DELAY_LINE_PUSH_IMM(uint64_t, u64)
DEF_DELAY_LINE_PUSH_IMM(double, f64)
 
/*
 * Generics require at least C11.
 */
#if __STDC_VERSION__ >= 201112L
#define DELAY_LINE_PUSH(line, value) \
    _Generic((value), \
        float:      delay_line_push_f64((line), (value)), \
        double:     delay_line_push_f64((line), (value)), \
        uint32_t:       delay_line_push_u64((line), (value)), \
        uint64_t:       delay_line_push_u64((line), (value)), \
        default:        delay_line_push_i64((line), (value)))
#define DELAY_LINE_PUSH_IMM(line, value) \
    _Generic((value), \
        float:      delay_line_push_imm_f64((line), (value)), \
        double:     delay_line_push_imm_f64((line), (value)), \
        uint32_t:       delay_line_push_imm_u64((line), (value)), \
        uint64_t:       delay_line_push_imm_u64((line), (value)), \
        default:        delay_line_push_imm_i64((line), (value)))
#else   /* __STDC_VERSION__ < 201112L */
#define DELAY_LINE_PUSH(line, value) \
    DELAY_LINE_PUSH_macro_requires_C11_or_greater
#define DELAY_LINE_PUSH_IMM(line, value) \
    DELAY_LINE_PUSH_IMM_macro_requires_C11_or_greater
#endif  /* __STDC_VERSION__ < 201112L */
 
static inline uint64_t
delay_line_get_time_since_change(const delay_line_t *line)
{
    uint64_t now;
    ASSERT(line != NULL);
    now = (line->time_func != NULL ?
        line->time_func(line->time_func_userinfo) : microclock());
    return (now - line->changed_t);
}
 
#ifdef  __cplusplus
}
#endif
 
#endif  /* _ACF_UTILS_DELAY_LINE_H_ */