File psd_core.h¶

#ifndef DP_PSD_CORE_H
#define DP_PSD_CORE_H

#include "doppler/clib_common.h"
#include "doppler/dp_state.h"
#include "doppler/jm_perf.h"
#include "doppler/fft/fft_core.h"
#include "doppler/acc_trace/acc_trace_core.h"
#include "doppler/f32_buffer/f32_buffer_core.h"
#ifdef __cplusplus
extern "C" {
#endif

/* SSOT: enum=psd_window */
enum {
    DP_PSD_WINDOW_HANN = 0,            
    DP_PSD_WINDOW_KAISER = 1,          
    DP_PSD_WINDOW_BLACKMAN_HARRIS = 2, 
    DP_PSD_WINDOW_RECT = 3, 
};

typedef struct {
    dp_fft_state_t *fft;        
    float *w;                   
    float _Complex *frame;      
    float _Complex *spec;       
    float *pwr;                 
    double cg;                  
    double s2;                  
    double enbw;                
    size_t n;                   
    size_t nfft;                
    double full_scale;          
} dp_psd_kernel_t;

int dp_psd_kernel_init(dp_psd_kernel_t *k, size_t n, int window, float beta,
                       size_t pad, double full_scale);

void dp_psd_kernel_free(dp_psd_kernel_t *k);

typedef struct {
    dp_psd_kernel_t k;         
    dp_acc_trace_state_t *avg;    
    float *dbbuf;              
    double enbw;               
    double fs;                 
    size_t bits;               
    size_t hop;                
    dp_f32_t *ring;            
    dp_f32_framer_t fr;        
} dp_psd_state_t;

dp_psd_state_t *dp_psd_create(size_t n, double fs, int window, float beta,
                            size_t pad, double full_scale, size_t bits,
                            int mode, double alpha);

dp_psd_state_t *dp_psd_create_hop(size_t n, double fs, int window, float beta,
                                 size_t pad, double full_scale, size_t bits,
                                 int mode, double alpha, size_t hop);

void dp_psd_destroy(dp_psd_state_t *state);

void dp_psd_reset(dp_psd_state_t *state);

void dp_psd_accumulate(dp_psd_state_t *state, const float _Complex *x,
                      size_t x_len);

void dp_psd_frame_power(dp_psd_kernel_t *k, const float _Complex *x,
                        float *pwr);

void dp_psd_frame_linear(dp_psd_kernel_t *k, const float _Complex *x,
                         float *out);

void dp_psd_frame_db(dp_psd_kernel_t *k, const float _Complex *x,
                     float *out);

void dp_psd_accumulate_real(dp_psd_state_t *state, const float *x, size_t x_len);

size_t dp_psd_power_twosided_max_out(dp_psd_state_t *state);

size_t dp_psd_power_twosided(dp_psd_state_t *state, float *out,
                             size_t max_out);

size_t dp_psd_power_onesided_max_out(dp_psd_state_t *state);

size_t dp_psd_power_onesided(dp_psd_state_t *state, float *out,
                             size_t max_out);

size_t dp_psd_psd_db_max_out(dp_psd_state_t *state);

size_t dp_psd_psd_db(dp_psd_state_t *state, float *out, size_t max_out);

size_t dp_psd_psd_dbhz_max_out(dp_psd_state_t *state);

size_t dp_psd_psd_dbhz(dp_psd_state_t *state, float *out, size_t max_out);

size_t dp_psd_band_power_max_out(dp_psd_state_t *state);

size_t dp_psd_band_power(dp_psd_state_t *state, const double *bands,
                        size_t bands_len, float *out, size_t max_out);

double dp_psd_total_band_power(dp_psd_state_t *state, const double *bands,
                              size_t bands_len);

double dp_psd_occupied_bw(dp_psd_state_t *state, double fraction);

double dp_psd_noise_floor(dp_psd_state_t *state);

double dp_psd_snr(dp_psd_state_t *state, double lo_hz, double hi_hz);

double dp_psd_sfdr(dp_psd_state_t *state, float min_db);
/* ── Serializable state (standard bytes interface; see dp_state.h) ──────────
 * The blob is the acc_trace power averager, then the framer's snapshot of the
 * carried partial frame. Both children have fixed sizes, so the blob's size
 * depends on the config only. hop is a reject key: a blob of another hop is
 * refused, since the carried frame means something different at another hop.
 * Window, plan, scratch, n, nfft and hop are config, rebuilt by create. */
#define PSD_STATE_MAGIC DP_FOURCC ('P','S','D',' ')
#define PSD_STATE_VERSION 2u
size_t dp_psd_state_bytes (const dp_psd_state_t *state);
void dp_psd_get_state (const dp_psd_state_t *state, void *blob);
int dp_psd_set_state (dp_psd_state_t *state, const void *blob);

#ifdef __cplusplus
}
#endif

#endif /* PSD_CORE_H */