#define M_PI 3.14159265358979323846
#endif
-// local constants
+/* local constants */
#define BELL202_MARK 1200
#define BELL202_SPACE 2200
#define BELL202_BAUD 1200
* 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));
}
/*
* 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;
}
/*
* 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);
-
- // 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]);
- }
+ /* 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);
- // 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);
+ 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);
}
- 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;
+ /* 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;
- // printf ("corrsize %d celladj %g\n", handle -> corrsize, handle -> celladj);
+ /* initalize intra-cell position */
+ handle->cellpos = 0;
+ handle->celladj = BELL202_BAUD / (double) attr->sample_rate * (double) handle->downsampling_count;
- // 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;
}
/*
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);
}
}
#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
* 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__
projects / thirdparty / freeswitch.git / commitdiff
