From e56c64a6920e9588cce41e3c195702a9d55a5c6b Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Sun, 3 Jun 2007 04:06:36 +0000 Subject: [PATCH] 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 --- libs/openzap/src/dsp/bell202.c | 245 ++++++++++++++++----------------- libs/openzap/src/dsp/bell202.h | 29 ++-- 2 files changed, 131 insertions(+), 143 deletions(-) diff --git a/libs/openzap/src/dsp/bell202.c b/libs/openzap/src/dsp/bell202.c index 1213c2dcf5..0a8eaa038d 100644 --- a/libs/openzap/src/dsp/bell202.c +++ b/libs/openzap/src/dsp/bell202.c @@ -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); } } diff --git a/libs/openzap/src/dsp/bell202.h b/libs/openzap/src/dsp/bell202.h index caf144aec2..9ab47a91ca 100644 --- a/libs/openzap/src/dsp/bell202.h +++ b/libs/openzap/src/dsp/bell202.h @@ -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__