Add function pointer typedef.
Switch to use /* */ comments to survive pickier compile flags. Change destroy function to take ** pointer so it can set the pointer back to NULL make code style consistent with the rest of the lib. git-svn-id: http://svn.openzap.org/svn/openzap/trunk@202 a93c3328-9c30-0410-af19-c9cd2b2d52af
This commit is contained in:
Michael Jerris
parent
2a79a09b8f
commit
e56c64a692
|
|
@ -46,7 +46,7 @@
|
|||
#define M_PI 3.14159265358979323846
|
||||
#endif
|
||||
|
||||
// local constants
|
||||
/* local constants */
|
||||
#define BELL202_MARK 1200
|
||||
#define BELL202_SPACE 2200
|
||||
#define BELL202_BAUD 1200
|
||||
|
|
@ -58,10 +58,9 @@
|
|||
* attributes structure is used.
|
||||
*/
|
||||
|
||||
void
|
||||
dsp_bell202_attr_init (dsp_bell202_attr_t *attr)
|
||||
void dsp_bell202_attr_init (dsp_bell202_attr_t *attr)
|
||||
{
|
||||
memset (attr, 0, sizeof (*attr));
|
||||
memset(attr, 0, sizeof(*attr));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -77,48 +76,42 @@ dsp_bell202_attr_init (dsp_bell202_attr_t *attr)
|
|||
* zero == ok, -1 == fail.
|
||||
*/
|
||||
|
||||
void (*
|
||||
dsp_bell202_attr_get_bithandler (dsp_bell202_attr_t *attr, void **bithandler_arg)) (void *, int)
|
||||
bithandler_func_t dsp_bell202_attr_get_bithandler(dsp_bell202_attr_t *attr, void **bithandler_arg)
|
||||
{
|
||||
*bithandler_arg = attr -> bithandler_arg;
|
||||
return (attr -> bithandler);
|
||||
*bithandler_arg = attr->bithandler_arg;
|
||||
return attr->bithandler;
|
||||
}
|
||||
|
||||
void
|
||||
dsp_bell202_attr_set_bithandler (dsp_bell202_attr_t *attr, void (*bithandler) (void *, int ), void *bithandler_arg)
|
||||
void dsp_bell202_attr_set_bithandler(dsp_bell202_attr_t *attr, bithandler_func_t bithandler, void *bithandler_arg)
|
||||
{
|
||||
attr -> bithandler = bithandler;
|
||||
attr -> bithandler_arg = bithandler_arg;
|
||||
attr->bithandler = bithandler;
|
||||
attr->bithandler_arg = bithandler_arg;
|
||||
}
|
||||
|
||||
void (*
|
||||
dsp_bell202_attr_get_bytehandler (dsp_bell202_attr_t *attr, void **bytehandler_arg)) (void *, int)
|
||||
bytehandler_func_t dsp_bell202_attr_get_bytehandler(dsp_bell202_attr_t *attr, void **bytehandler_arg)
|
||||
{
|
||||
*bytehandler_arg = attr -> bytehandler_arg;
|
||||
return (attr -> bytehandler);
|
||||
*bytehandler_arg = attr->bytehandler_arg;
|
||||
return attr->bytehandler;
|
||||
}
|
||||
|
||||
void
|
||||
dsp_bell202_attr_set_bytehandler (dsp_bell202_attr_t *attr, void (*bytehandler) (void *, int ), void *bytehandler_arg)
|
||||
void dsp_bell202_attr_set_bytehandler(dsp_bell202_attr_t *attr, bytehandler_func_t bytehandler, void *bytehandler_arg)
|
||||
{
|
||||
attr -> bytehandler = bytehandler;
|
||||
attr -> bytehandler_arg = bytehandler_arg;
|
||||
attr->bytehandler = bytehandler;
|
||||
attr->bytehandler_arg = bytehandler_arg;
|
||||
}
|
||||
|
||||
int
|
||||
dsp_bell202_attr_get_samplerate (dsp_bell202_attr_t *attr)
|
||||
int dsp_bell202_attr_get_samplerate (dsp_bell202_attr_t *attr)
|
||||
{
|
||||
return (attr -> sample_rate);
|
||||
return attr->sample_rate;
|
||||
}
|
||||
|
||||
int
|
||||
dsp_bell202_attr_set_samplerate (dsp_bell202_attr_t *attr, int samplerate)
|
||||
int dsp_bell202_attr_set_samplerate (dsp_bell202_attr_t *attr, int samplerate)
|
||||
{
|
||||
if (samplerate <= 0) {
|
||||
return (-1);
|
||||
return -1;
|
||||
}
|
||||
attr -> sample_rate = samplerate;
|
||||
return (0);
|
||||
attr->sample_rate = samplerate;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -132,123 +125,116 @@ dsp_bell202_attr_set_samplerate (dsp_bell202_attr_t *attr, int samplerate)
|
|||
* Once created, the handle can be used until it is destroyed.
|
||||
*/
|
||||
|
||||
dsp_bell202_handle_t *
|
||||
dsp_bell202_create (dsp_bell202_attr_t *attr)
|
||||
dsp_bell202_handle_t *dsp_bell202_create(dsp_bell202_attr_t *attr)
|
||||
{
|
||||
int i;
|
||||
double phi_mark, phi_space;
|
||||
dsp_bell202_handle_t *handle;
|
||||
|
||||
handle = malloc (sizeof (*handle));
|
||||
if (handle == NULL) {
|
||||
return (handle);
|
||||
handle = malloc(sizeof(*handle));
|
||||
if (!handle) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memset (handle, 0, sizeof (*handle));
|
||||
memset(handle, 0, sizeof(*handle));
|
||||
|
||||
// fill the attributes member
|
||||
memcpy (&handle -> attr, attr, sizeof (*attr));
|
||||
/* fill the attributes member */
|
||||
memcpy(&handle->attr, attr, sizeof(*attr));
|
||||
|
||||
// see if we can do downsampling. We only really need 6 samples to "match"
|
||||
if (attr -> sample_rate / BELL202_MARK > 6) {
|
||||
handle -> downsampling_count = attr -> sample_rate / BELL202_MARK / 6;
|
||||
/* see if we can do downsampling. We only really need 6 samples to "match" */
|
||||
if (attr->sample_rate / BELL202_MARK > 6) {
|
||||
handle->downsampling_count = attr->sample_rate / BELL202_MARK / 6;
|
||||
} else {
|
||||
handle -> downsampling_count = 1;
|
||||
handle->downsampling_count = 1;
|
||||
}
|
||||
handle -> current_downsample = 1;
|
||||
handle->current_downsample = 1;
|
||||
|
||||
// calculate the correlate size (number of samples required for slowest wave)
|
||||
handle -> corrsize = attr -> sample_rate / handle -> downsampling_count / BELL202_MARK;
|
||||
/* calculate the correlate size (number of samples required for slowest wave) */
|
||||
handle->corrsize = attr->sample_rate / handle->downsampling_count / BELL202_MARK;
|
||||
|
||||
// allocate the correlation sin/cos arrays and initialize
|
||||
/* allocate the correlation sin/cos arrays and initialize */
|
||||
for (i = 0; i < 4; i++) {
|
||||
handle -> correlates [i] = malloc (sizeof (double) * handle -> corrsize);
|
||||
if (handle -> correlates [i] == NULL) {
|
||||
break;
|
||||
handle->correlates[i] = malloc(sizeof(double) * handle->corrsize);
|
||||
if (handle->correlates[i] == NULL) {
|
||||
/* some failed, back out memory allocations */
|
||||
dsp_bell202_destroy(&handle);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (i != 4) { // some failed, back out memory allocations
|
||||
dsp_bell202_destroy (handle);
|
||||
return (NULL);
|
||||
|
||||
/* now initialize them */
|
||||
phi_mark = 2. * M_PI / ((double) attr->sample_rate / (double) handle->downsampling_count / (double) BELL202_MARK);
|
||||
phi_space = 2. * M_PI / ((double) attr->sample_rate / (double) handle->downsampling_count / (double) BELL202_SPACE);
|
||||
|
||||
for (i = 0; i < handle->corrsize; i++) {
|
||||
handle->correlates[0][i] = sin(phi_mark * (double) i);
|
||||
handle->correlates[1][i] = cos(phi_mark * (double) i);
|
||||
handle->correlates[2][i] = sin(phi_space * (double) i);
|
||||
handle->correlates[3][i] = cos(phi_space * (double) i);
|
||||
}
|
||||
|
||||
// now initialize them
|
||||
phi_mark = 2. * M_PI / ((double) attr -> sample_rate / (double) handle -> downsampling_count / (double) BELL202_MARK);
|
||||
phi_space = 2. * M_PI / ((double) attr -> sample_rate / (double) handle -> downsampling_count / (double) BELL202_SPACE);
|
||||
|
||||
// printf ("phi_mark is %g, phi_space is %g\n", phi_mark, phi_space);
|
||||
for (i = 0; i < handle -> corrsize; i++) {
|
||||
handle -> correlates [0][i] = sin (phi_mark * (double) i);
|
||||
handle -> correlates [1][i] = cos (phi_mark * (double) i);
|
||||
handle -> correlates [2][i] = sin (phi_space * (double) i);
|
||||
handle -> correlates [3][i] = cos (phi_space * (double) i);
|
||||
// printf ("[%2d] MS %10.4f MC %10.4f SS %10.4f SC %10.4f\n", i, handle -> correlates [0][i], handle -> correlates [1][i], handle -> correlates [2][i], handle -> correlates [3][i]);
|
||||
/* initialize the ring buffer */
|
||||
handle->buffer = malloc(sizeof(double) * handle->corrsize);
|
||||
if (!handle->buffer) { /* failed; back out memory allocations */
|
||||
dsp_bell202_destroy(&handle);
|
||||
return NULL;
|
||||
}
|
||||
memset(handle->buffer, 0, sizeof(double) * handle->corrsize);
|
||||
handle->ringstart = 0;
|
||||
|
||||
// initialize the ring buffer
|
||||
handle -> buffer = malloc (sizeof (double) * handle -> corrsize);
|
||||
if (handle -> buffer == NULL) { // failed; back out memory allocations
|
||||
dsp_bell202_destroy (handle);
|
||||
return (NULL);
|
||||
}
|
||||
memset (handle -> buffer, 0, sizeof (double) * handle -> corrsize);
|
||||
handle -> ringstart = 0;
|
||||
/* initalize intra-cell position */
|
||||
handle->cellpos = 0;
|
||||
handle->celladj = BELL202_BAUD / (double) attr->sample_rate * (double) handle->downsampling_count;
|
||||
|
||||
// initalize intra-cell position
|
||||
handle -> cellpos = 0;
|
||||
handle -> celladj = BELL202_BAUD / (double) attr -> sample_rate * (double) handle -> downsampling_count;
|
||||
|
||||
// printf ("corrsize %d celladj %g\n", handle -> corrsize, handle -> celladj);
|
||||
|
||||
// if they have provided a byte handler, add a UART to the processing chain
|
||||
if (handle -> attr.bytehandler) {
|
||||
/* if they have provided a byte handler, add a UART to the processing chain */
|
||||
if (handle->attr.bytehandler) {
|
||||
dsp_uart_attr_t uart_attr;
|
||||
dsp_uart_handle_t *uart_handle;
|
||||
|
||||
dsp_uart_attr_init (&uart_attr);
|
||||
dsp_uart_attr_set_bytehandler (&uart_attr, handle -> attr.bytehandler, handle -> attr.bytehandler_arg);
|
||||
uart_handle = dsp_uart_create (&uart_attr);
|
||||
dsp_uart_attr_init(&uart_attr);
|
||||
dsp_uart_attr_set_bytehandler(&uart_attr, handle->attr.bytehandler, handle->attr.bytehandler_arg);
|
||||
uart_handle = dsp_uart_create(&uart_attr);
|
||||
if (uart_handle == NULL) {
|
||||
dsp_bell202_destroy (handle);
|
||||
return (NULL);
|
||||
dsp_bell202_destroy(&handle);
|
||||
return NULL;
|
||||
}
|
||||
handle -> attr.bithandler = dsp_uart_bit_handler;
|
||||
handle -> attr.bithandler_arg = uart_handle;
|
||||
handle->attr.bithandler = dsp_uart_bit_handler;
|
||||
handle->attr.bithandler_arg = uart_handle;
|
||||
}
|
||||
|
||||
return (handle);
|
||||
return handle;
|
||||
}
|
||||
|
||||
/*
|
||||
* dsp_bell202_destroy
|
||||
*
|
||||
* Destroys a handle, releasing any associated memory. A destroyed handle
|
||||
* should not be used for anything.
|
||||
* Destroys a handle, releasing any associated memory. Sets handle pointer to NULL
|
||||
* so A destroyed handle can not be used for anything after the destroy.
|
||||
*/
|
||||
|
||||
void
|
||||
dsp_bell202_destroy (dsp_bell202_handle_t *handle)
|
||||
void dsp_bell202_destroy(dsp_bell202_handle_t **handle)
|
||||
{
|
||||
int i;
|
||||
|
||||
// if empty handle, just return
|
||||
if (handle == NULL) {
|
||||
/* if empty handle, just return */
|
||||
if (*handle == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (handle -> correlates [i] != NULL) {
|
||||
free (handle -> correlates [i]);
|
||||
handle -> correlates [i] = NULL;
|
||||
if ((*handle)->correlates[i] != NULL) {
|
||||
free((*handle)->correlates[i]);
|
||||
(*handle)->correlates[i] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (handle -> buffer != NULL) {
|
||||
free (handle -> buffer);
|
||||
handle -> buffer = NULL;
|
||||
if ((*handle)->buffer != NULL) {
|
||||
free((*handle)->buffer);
|
||||
(*handle)->buffer = NULL;
|
||||
}
|
||||
|
||||
free (handle);
|
||||
free(*handle);
|
||||
*handle = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -267,53 +253,52 @@ void
|
|||
dsp_bell202_sample (dsp_bell202_handle_t *handle, double normalized_sample)
|
||||
{
|
||||
double val;
|
||||
double factors [4];
|
||||
double factors[4];
|
||||
int i, j;
|
||||
|
||||
// if we can avoid processing samples, do so
|
||||
if (handle -> downsampling_count != 1) {
|
||||
if (handle -> current_downsample < handle -> downsampling_count) {
|
||||
handle -> current_downsample++;
|
||||
return; // throw this sample out
|
||||
/* if we can avoid processing samples, do so */
|
||||
if (handle->downsampling_count != 1) {
|
||||
if (handle->current_downsample < handle->downsampling_count) {
|
||||
handle->current_downsample++;
|
||||
return; /* throw this sample out */
|
||||
}
|
||||
handle -> current_downsample = 1;
|
||||
handle->current_downsample = 1;
|
||||
}
|
||||
|
||||
// store sample in buffer
|
||||
handle -> buffer [handle -> ringstart++] = normalized_sample;
|
||||
if (handle -> ringstart >= handle -> corrsize) {
|
||||
handle -> ringstart = 0;
|
||||
/* store sample in buffer */
|
||||
handle->buffer[handle->ringstart++] = normalized_sample;
|
||||
if (handle->ringstart >= handle->corrsize) {
|
||||
handle->ringstart = 0;
|
||||
}
|
||||
|
||||
// do the correlation calculation
|
||||
factors [0] = factors [1] = factors [2] = factors [3] = 0; // clear out intermediate sums
|
||||
j = handle -> ringstart;
|
||||
for (i = 0; i < handle -> corrsize; i++) {
|
||||
if (j >= handle -> corrsize) {
|
||||
/* do the correlation calculation */
|
||||
factors[0] = factors[1] = factors[2] = factors[3] = 0; /* clear out intermediate sums */
|
||||
j = handle->ringstart;
|
||||
for (i = 0; i < handle->corrsize; i++) {
|
||||
if (j >= handle->corrsize) {
|
||||
j = 0;
|
||||
}
|
||||
val = handle -> buffer [j];
|
||||
factors [0] += handle -> correlates [0][i] * val;
|
||||
factors [1] += handle -> correlates [1][i] * val;
|
||||
factors [2] += handle -> correlates [2][i] * val;
|
||||
factors [3] += handle -> correlates [3][i] * val;
|
||||
val = handle->buffer[j];
|
||||
factors[0] += handle->correlates[0][i] * val;
|
||||
factors[1] += handle->correlates[1][i] * val;
|
||||
factors[2] += handle->correlates[2][i] * val;
|
||||
factors[3] += handle->correlates[3][i] * val;
|
||||
j++;
|
||||
}
|
||||
|
||||
// store the bit (bit value is comparison of the two sets of correlate factors)
|
||||
handle -> previous_bit = handle -> current_bit;
|
||||
handle -> current_bit = (factors [0] * factors [0] + factors [1] * factors [1] > factors [2] * factors [2] + factors [3] * factors [3]);
|
||||
/* store the bit (bit value is comparison of the two sets of correlate factors) */
|
||||
handle->previous_bit = handle->current_bit;
|
||||
handle->current_bit = (factors[0] * factors[0] + factors[1] * factors[1] > factors[2] * factors[2] + factors[3] * factors[3]);
|
||||
|
||||
// printf ("Sample %10.4f factors %10.4f %10.4f %10.4f %10.4f (sum %10.4f) previous %d current %d cellpos %10.4f\n", normalized_sample, factors [0], factors [1], factors [2], factors [3], factors [0] * factors [0] + factors [1] * factors [1] - factors [2] * factors [2] - factors [3] * factors [3], handle -> previous_bit, handle -> current_bit, handle -> cellpos);
|
||||
// if there's a transition, we can synchronize the cell position
|
||||
if (handle -> previous_bit != handle -> current_bit) {
|
||||
handle -> cellpos = 0.5; // adjust cell position to be in the middle of the cell
|
||||
/* if there's a transition, we can synchronize the cell position */
|
||||
if (handle->previous_bit != handle->current_bit) {
|
||||
handle->cellpos = 0.5; /* adjust cell position to be in the middle of the cell */
|
||||
}
|
||||
handle -> cellpos += handle -> celladj; // walk the cell along
|
||||
handle->cellpos += handle->celladj; /* walk the cell along */
|
||||
|
||||
if (handle -> cellpos > 1.0) {
|
||||
handle -> cellpos -= 1.0;
|
||||
(*handle -> attr.bithandler) (handle -> attr.bithandler_arg, handle -> current_bit);
|
||||
if (handle->cellpos > 1.0) {
|
||||
handle->cellpos -= 1.0;
|
||||
(*handle->attr.bithandler) (handle->attr.bithandler_arg, handle->current_bit);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -35,19 +35,22 @@
|
|||
#ifndef __BELL202_H__
|
||||
#define __BELL202_H__
|
||||
|
||||
typedef void (*bytehandler_func_t) (void *, int);
|
||||
typedef void (*bithandler_func_t) (void *, int);
|
||||
|
||||
typedef struct dsp_bell202_attr_s
|
||||
{
|
||||
int sample_rate; // sample rate in HZ
|
||||
void (*bithandler) (void *, int); // bit handler
|
||||
bithandler_func_t bithandler; // bit handler
|
||||
void *bithandler_arg; // arbitrary ID passed to bithandler as first argument
|
||||
void (*bytehandler) (void *, int); // byte handler
|
||||
bytehandler_func_t bytehandler; // byte handler
|
||||
void *bytehandler_arg; // arbitrary ID passed to bytehandler as first argument
|
||||
} dsp_bell202_attr_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
dsp_bell202_attr_t attr; // attributes structure
|
||||
double *correlates [4]; // one for each of sin/cos for mark/space
|
||||
double *correlates[4]; // one for each of sin/cos for mark/space
|
||||
int corrsize; // correlate size (also number of samples in ring buffer)
|
||||
double *buffer; // sample ring buffer
|
||||
int ringstart; // ring buffer start offset
|
||||
|
|
@ -69,19 +72,19 @@ typedef struct
|
|||
* d) feed samples through the handler (dsp_bell202_sample)
|
||||
*/
|
||||
|
||||
extern void dsp_bell202_attr_init (dsp_bell202_attr_t *attributes);
|
||||
void dsp_bell202_attr_init(dsp_bell202_attr_t *attributes);
|
||||
|
||||
extern void (*dsp_bell202_attr_get_bithandler (dsp_bell202_attr_t *attributes, void **bithandler_arg)) (void *, int);
|
||||
extern void dsp_bell202_attr_set_bithandler (dsp_bell202_attr_t *attributes, void (*bithandler) (void *, int ), void *bithandler_arg);
|
||||
extern void (*dsp_bell202_attr_get_bytehandler (dsp_bell202_attr_t *attributes, void **bytehandler_arg)) (void *, int);
|
||||
extern void dsp_bell202_attr_set_bytehandler (dsp_bell202_attr_t *attributes, void (*bytehandler) (void *, int ), void *bytehandler_arg);
|
||||
extern int dsp_bell202_attr_get_samplerate (dsp_bell202_attr_t *attributes);
|
||||
extern int dsp_bell202_attr_set_samplerate (dsp_bell202_attr_t *attributes, int samplerate);
|
||||
bithandler_func_t dsp_bell202_attr_get_bithandler(dsp_bell202_attr_t *attributes, void **bithandler_arg);
|
||||
void dsp_bell202_attr_set_bithandler(dsp_bell202_attr_t *attributes, bithandler_func_t bithandler, void *bithandler_arg);
|
||||
bytehandler_func_t dsp_bell202_attr_get_bytehandler(dsp_bell202_attr_t *attributes, void **bytehandler_arg);
|
||||
void dsp_bell202_attr_set_bytehandler(dsp_bell202_attr_t *attributes, bytehandler_func_t bytehandler, void *bytehandler_arg);
|
||||
int dsp_bell202_attr_get_samplerate(dsp_bell202_attr_t *attributes);
|
||||
int dsp_bell202_attr_set_samplerate(dsp_bell202_attr_t *attributes, int samplerate);
|
||||
|
||||
extern dsp_bell202_handle_t * dsp_bell202_create (dsp_bell202_attr_t *attributes);
|
||||
extern void dsp_bell202_destroy (dsp_bell202_handle_t *handle);
|
||||
dsp_bell202_handle_t * dsp_bell202_create(dsp_bell202_attr_t *attributes);
|
||||
void dsp_bell202_destroy(dsp_bell202_handle_t **handle);
|
||||
|
||||
extern void dsp_bell202_sample (dsp_bell202_handle_t *handle, double normalized_sample);
|
||||
void dsp_bell202_sample(dsp_bell202_handle_t *handle, double normalized_sample);
|
||||
|
||||
#endif // __BELL202_H__
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue