kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-07-14 11:06:36 +00:00
Code Issues Projects Releases Wiki Activity

fix windows build issues from snapshot spandsp-20090131

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@11602 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris 2009-02-02 21:36:29 +00:00
parent 0064924ba5
commit 356cfa02e8
124 changed files with 1675 additions and 1143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
libs/spandsp/src/adsi.c
View File

@ -392,7 +392,7 @@ static void start_tx(adsi_tx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int adsi_rx(adsi_rx_state_t *s, const int16_t *amp, int len) SPAN_DECLARE(int) adsi_rx(adsi_rx_state_t *s, const int16_t *amp, int len)
{ {
switch (s->standard) switch (s->standard)
{ {
@ -411,7 +411,7 @@ int adsi_rx(adsi_rx_state_t *s, const int16_t *amp, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
adsi_rx_state_t *adsi_rx_init(adsi_rx_state_t *s, SPAN_DECLARE(adsi_rx_state_t *) adsi_rx_init(adsi_rx_state_t *s,
int standard, int standard,
put_msg_func_t put_msg, put_msg_func_t put_msg,
void *user_data) void *user_data)
@ -448,14 +448,14 @@ adsi_rx_state_t *adsi_rx_init(adsi_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int adsi_rx_free(adsi_rx_state_t *s) SPAN_DECLARE(int) adsi_rx_free(adsi_rx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int adsi_tx(adsi_tx_state_t *s, int16_t *amp, int max_len) SPAN_DECLARE(int) adsi_tx(adsi_tx_state_t *s, int16_t *amp, int max_len)
{ {
int len; int len;
int lenx; int lenx;
@ -483,13 +483,13 @@ int adsi_tx(adsi_tx_state_t *s, int16_t *amp, int max_len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void adsi_tx_send_alert_tone(adsi_tx_state_t *s) SPAN_DECLARE(void) adsi_tx_send_alert_tone(adsi_tx_state_t *s)
{ {
tone_gen_init(&(s->alert_tone_gen), &(s->alert_tone_desc)); tone_gen_init(&(s->alert_tone_gen), &(s->alert_tone_desc));
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void adsi_tx_set_preamble(adsi_tx_state_t *s, SPAN_DECLARE(void) adsi_tx_set_preamble(adsi_tx_state_t *s,
int preamble_len, int preamble_len,
int preamble_ones_len, int preamble_ones_len,
int postamble_ones_len, int postamble_ones_len,
@ -542,7 +542,7 @@ void adsi_tx_set_preamble(adsi_tx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int adsi_tx_put_message(adsi_tx_state_t *s, const uint8_t *msg, int len) SPAN_DECLARE(int) adsi_tx_put_message(adsi_tx_state_t *s, const uint8_t *msg, int len)
{ {
int i; int i;
int j; int j;
@ -631,7 +631,7 @@ int adsi_tx_put_message(adsi_tx_state_t *s, const uint8_t *msg, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
adsi_tx_state_t *adsi_tx_init(adsi_tx_state_t *s, int standard) SPAN_DECLARE(adsi_tx_state_t *) adsi_tx_init(adsi_tx_state_t *s, int standard)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -657,7 +657,7 @@ adsi_tx_state_t *adsi_tx_init(adsi_tx_state_t *s, int standard)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int adsi_tx_free(adsi_tx_state_t *s) SPAN_DECLARE(int) adsi_tx_free(adsi_tx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
@ -846,7 +846,7 @@ static uint8_t adsi_decode_baudot(adsi_rx_state_t *s, uint8_t ch)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int adsi_next_field(adsi_rx_state_t *s, const uint8_t *msg, int msg_len, int pos, uint8_t *field_type, uint8_t const **field_body, int *field_len) SPAN_DECLARE(int) adsi_next_field(adsi_rx_state_t *s, const uint8_t *msg, int msg_len, int pos, uint8_t *field_type, uint8_t const **field_body, int *field_len)
{ {
int i; int i;
@ -966,7 +966,7 @@ int adsi_next_field(adsi_rx_state_t *s, const uint8_t *msg, int msg_len, int pos
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int adsi_add_field(adsi_tx_state_t *s, uint8_t *msg, int len, uint8_t field_type, uint8_t const *field_body, int field_len) SPAN_DECLARE(int) adsi_add_field(adsi_tx_state_t *s, uint8_t *msg, int len, uint8_t field_type, uint8_t const *field_body, int field_len)
{ {
int i; int i;
int x; int x;
@ -1068,7 +1068,7 @@ int adsi_add_field(adsi_tx_state_t *s, uint8_t *msg, int len, uint8_t field_type
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *adsi_standard_to_str(int standard) SPAN_DECLARE(const char *) adsi_standard_to_str(int standard)
{ {
switch (standard) switch (standard)
{ {

6
libs/spandsp/src/async.c
View File

@ -41,7 +41,7 @@
#include "spandsp/private/async.h" #include "spandsp/private/async.h"
const char *signal_status_to_str(int status) SPAN_DECLARE(const char *) signal_status_to_str(int status)
{ {
switch (status) switch (status)
{ {
@ -72,7 +72,7 @@ const char *signal_status_to_str(int status)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
async_rx_state_t *async_rx_init(async_rx_state_t *s, SPAN_DECLARE(async_rx_state_t *) async_rx_init(async_rx_state_t *s,
int data_bits, int data_bits,
int parity, int parity,
int stop_bits, int stop_bits,
@ -184,7 +184,7 @@ void async_rx_put_bit(void *user_data, int bit)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
async_tx_state_t *async_tx_init(async_tx_state_t *s, SPAN_DECLARE(async_tx_state_t *) async_tx_init(async_tx_state_t *s,
int data_bits, int data_bits,
int parity, int parity,
int stop_bits, int stop_bits,

26
libs/spandsp/src/at_interpreter.c
View File

@ -138,7 +138,7 @@ static const char *at_response_codes[] =
"+FRH:3" "+FRH:3"
}; };
void at_set_at_rx_mode(at_state_t *s, int new_mode) SPAN_DECLARE(void) at_set_at_rx_mode(at_state_t *s, int new_mode)
{ {
/* The use of a DTE timeout is mode dependent. Set the timeout appropriately in /* The use of a DTE timeout is mode dependent. Set the timeout appropriately in
the modem. */ the modem. */
@ -156,7 +156,7 @@ void at_set_at_rx_mode(at_state_t *s, int new_mode)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_put_response(at_state_t *s, const char *t) SPAN_DECLARE(void) at_put_response(at_state_t *s, const char *t)
{ {
uint8_t buf[3]; uint8_t buf[3];
@ -170,7 +170,7 @@ void at_put_response(at_state_t *s, const char *t)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_put_numeric_response(at_state_t *s, int val) SPAN_DECLARE(void) at_put_numeric_response(at_state_t *s, int val)
{ {
char buf[20]; char buf[20];
@ -179,7 +179,7 @@ void at_put_numeric_response(at_state_t *s, int val)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_put_response_code(at_state_t *s, int code) SPAN_DECLARE(void) at_put_response_code(at_state_t *s, int code)
{ {
uint8_t buf[20]; uint8_t buf[20];
@ -211,7 +211,7 @@ static int answer_call(at_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_call_event(at_state_t *s, int event) SPAN_DECLARE(void) at_call_event(at_state_t *s, int event)
{ {
span_log(&s->logging, SPAN_LOG_FLOW, "Call event %d received\n", event); span_log(&s->logging, SPAN_LOG_FLOW, "Call event %d received\n", event);
switch (event) switch (event)
@ -311,7 +311,7 @@ void at_call_event(at_state_t *s, int event)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_reset_call_info(at_state_t *s) SPAN_DECLARE(void) at_reset_call_info(at_state_t *s)
{ {
at_call_id_t *call_id; at_call_id_t *call_id;
at_call_id_t *next; at_call_id_t *next;
@ -327,7 +327,7 @@ void at_reset_call_info(at_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_set_call_info(at_state_t *s, char const *id, char const *value) SPAN_DECLARE(void) at_set_call_info(at_state_t *s, char const *id, char const *value)
{ {
at_call_id_t *new_call_id; at_call_id_t *new_call_id;
at_call_id_t *call_id; at_call_id_t *call_id;
@ -355,7 +355,7 @@ void at_set_call_info(at_state_t *s, char const *id, char const *value)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_display_call_info(at_state_t *s) SPAN_DECLARE(void) at_display_call_info(at_state_t *s)
{ {
char buf[132 + 1]; char buf[132 + 1];
at_call_id_t *call_id = s->call_id; at_call_id_t *call_id = s->call_id;
@ -5143,7 +5143,7 @@ static int command_search(const char *u, int len, int *matched)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int at_modem_control(at_state_t *s, int op, const char *num) SPAN_DECLARE(int) at_modem_control(at_state_t *s, int op, const char *num)
{ {
switch (op) switch (op)
{ {
@ -5177,7 +5177,7 @@ int at_modem_control(at_state_t *s, int op, const char *num)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_interpreter(at_state_t *s, const char *cmd, int len) SPAN_DECLARE(void) at_interpreter(at_state_t *s, const char *cmd, int len)
{ {
int i; int i;
int c; int c;
@ -5284,14 +5284,14 @@ void at_interpreter(at_state_t *s, const char *cmd, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void at_set_class1_handler(at_state_t *s, at_class1_handler_t handler, void *user_data) SPAN_DECLARE(void) at_set_class1_handler(at_state_t *s, at_class1_handler_t handler, void *user_data)
{ {
s->class1_handler = handler; s->class1_handler = handler;
s->class1_user_data = user_data; s->class1_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
at_state_t *at_init(at_state_t *s, SPAN_DECLARE(at_state_t *) at_init(at_state_t *s,
at_tx_handler_t *at_tx_handler, at_tx_handler_t *at_tx_handler,
void *at_tx_user_data, void *at_tx_user_data,
at_modem_control_handler_t *modem_control_handler, at_modem_control_handler_t *modem_control_handler,
@ -5318,7 +5318,7 @@ at_state_t *at_init(at_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int at_free(at_state_t *s) SPAN_DECLARE(int) at_free(at_state_t *s)
{ {
at_reset_call_info(s); at_reset_call_info(s);
if (s->local_id) if (s->local_id)

6
libs/spandsp/src/awgn.c
View File

@ -95,13 +95,13 @@ static double ran1(awgn_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
awgn_state_t *awgn_init_dbm0(awgn_state_t *s, int idum, float level) SPAN_DECLARE(awgn_state_t *) awgn_init_dbm0(awgn_state_t *s, int idum, float level)
{ {
return awgn_init_dbov(s, idum, level - DBM0_MAX_POWER); return awgn_init_dbov(s, idum, level - DBM0_MAX_POWER);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
awgn_state_t *awgn_init_dbov(awgn_state_t *s, int idum, float level) SPAN_DECLARE(awgn_state_t *) awgn_init_dbov(awgn_state_t *s, int idum, float level)
{ {
int j; int j;
@ -133,7 +133,7 @@ awgn_state_t *awgn_init_dbov(awgn_state_t *s, int idum, float level)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t awgn(awgn_state_t *s) SPAN_DECLARE(int16_t) awgn(awgn_state_t *s)
{ {
double fac; double fac;
double r; double r;

32
libs/spandsp/src/bell_r2_mf.c
View File

@ -276,7 +276,7 @@ static void bell_mf_gen_init(void)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int bell_mf_tx(bell_mf_tx_state_t *s, int16_t amp[], int max_samples) SPAN_DECLARE(int) bell_mf_tx(bell_mf_tx_state_t *s, int16_t amp[], int max_samples)
{ {
int len; int len;
const char *cp; const char *cp;
@ -300,7 +300,7 @@ int bell_mf_tx(bell_mf_tx_state_t *s, int16_t amp[], int max_samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int bell_mf_tx_put(bell_mf_tx_state_t *s, const char *digits, int len) SPAN_DECLARE(int) bell_mf_tx_put(bell_mf_tx_state_t *s, const char *digits, int len)
{ {
size_t space; size_t space;
@ -320,7 +320,7 @@ int bell_mf_tx_put(bell_mf_tx_state_t *s, const char *digits, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
bell_mf_tx_state_t *bell_mf_tx_init(bell_mf_tx_state_t *s) SPAN_DECLARE(bell_mf_tx_state_t *) bell_mf_tx_init(bell_mf_tx_state_t *s)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -339,14 +339,14 @@ bell_mf_tx_state_t *bell_mf_tx_init(bell_mf_tx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int bell_mf_tx_free(bell_mf_tx_state_t *s) SPAN_DECLARE(int) bell_mf_tx_free(bell_mf_tx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int r2_mf_tx(r2_mf_tx_state_t *s, int16_t amp[], int samples) SPAN_DECLARE(int) r2_mf_tx(r2_mf_tx_state_t *s, int16_t amp[], int samples)
{ {
int len; int len;
@ -363,7 +363,7 @@ int r2_mf_tx(r2_mf_tx_state_t *s, int16_t amp[], int samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int r2_mf_tx_put(r2_mf_tx_state_t *s, char digit) SPAN_DECLARE(int) r2_mf_tx_put(r2_mf_tx_state_t *s, char digit)
{ {
char *cp; char *cp;
@ -383,7 +383,7 @@ int r2_mf_tx_put(r2_mf_tx_state_t *s, char digit)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
r2_mf_tx_state_t *r2_mf_tx_init(r2_mf_tx_state_t *s, int fwd) SPAN_DECLARE(r2_mf_tx_state_t *) r2_mf_tx_init(r2_mf_tx_state_t *s, int fwd)
{ {
int i; int i;
const mf_digit_tones_t *tones; const mf_digit_tones_t *tones;
@ -436,14 +436,14 @@ r2_mf_tx_state_t *r2_mf_tx_init(r2_mf_tx_state_t *s, int fwd)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int r2_mf_tx_free(r2_mf_tx_state_t *s) SPAN_DECLARE(int) r2_mf_tx_free(r2_mf_tx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int bell_mf_rx(bell_mf_rx_state_t *s, const int16_t amp[], int samples) SPAN_DECLARE(int) bell_mf_rx(bell_mf_rx_state_t *s, const int16_t amp[], int samples)
{ {
#if defined(SPANDSP_USE_FIXED_POINT) #if defined(SPANDSP_USE_FIXED_POINT)
int32_t energy[6]; int32_t energy[6];
@ -596,7 +596,7 @@ int bell_mf_rx(bell_mf_rx_state_t *s, const int16_t amp[], int samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t bell_mf_rx_get(bell_mf_rx_state_t *s, char *buf, int max) SPAN_DECLARE(size_t) bell_mf_rx_get(bell_mf_rx_state_t *s, char *buf, int max)
{ {
if (max > s->current_digits) if (max > s->current_digits)
max = s->current_digits; max = s->current_digits;
@ -611,7 +611,7 @@ size_t bell_mf_rx_get(bell_mf_rx_state_t *s, char *buf, int max)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
bell_mf_rx_state_t *bell_mf_rx_init(bell_mf_rx_state_t *s, SPAN_DECLARE(bell_mf_rx_state_t *) bell_mf_rx_init(bell_mf_rx_state_t *s,
digits_rx_callback_t callback, digits_rx_callback_t callback,
void *user_data) void *user_data)
{ {
@ -650,14 +650,14 @@ bell_mf_rx_state_t *bell_mf_rx_init(bell_mf_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int bell_mf_rx_free(bell_mf_rx_state_t *s) SPAN_DECLARE(int) bell_mf_rx_free(bell_mf_rx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int r2_mf_rx(r2_mf_rx_state_t *s, const int16_t amp[], int samples) SPAN_DECLARE(int) r2_mf_rx(r2_mf_rx_state_t *s, const int16_t amp[], int samples)
{ {
#if defined(SPANDSP_USE_FIXED_POINT) #if defined(SPANDSP_USE_FIXED_POINT)
int32_t energy[6]; int32_t energy[6];
@ -778,13 +778,13 @@ int r2_mf_rx(r2_mf_rx_state_t *s, const int16_t amp[], int samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int r2_mf_rx_get(r2_mf_rx_state_t *s) SPAN_DECLARE(int) r2_mf_rx_get(r2_mf_rx_state_t *s)
{ {
return s->current_digit; return s->current_digit;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
r2_mf_rx_state_t *r2_mf_rx_init(r2_mf_rx_state_t *s, SPAN_DECLARE(r2_mf_rx_state_t *) r2_mf_rx_init(r2_mf_rx_state_t *s,
int fwd, int fwd,
tone_report_func_t callback, tone_report_func_t callback,
void *user_data) void *user_data)
@ -828,7 +828,7 @@ r2_mf_rx_state_t *r2_mf_rx_init(r2_mf_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int r2_mf_rx_free(r2_mf_rx_state_t *s) SPAN_DECLARE(int) r2_mf_rx_free(r2_mf_rx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;

12
libs/spandsp/src/bert.c
View File

@ -47,7 +47,7 @@
static const char *qbf = "VoyeZ Le BricK GeanT QuE J'ExaminE PreS Du WharF 123 456 7890 + - * : = $ % ( )" static const char *qbf = "VoyeZ Le BricK GeanT QuE J'ExaminE PreS Du WharF 123 456 7890 + - * : = $ % ( )"
"ThE QuicK BrowN FoX JumpS OveR ThE LazY DoG 123 456 7890 + - * : = $ % ( )"; "ThE QuicK BrowN FoX JumpS OveR ThE LazY DoG 123 456 7890 + - * : = $ % ( )";
const char *bert_event_to_str(int event) SPAN_DECLARE(const char *) bert_event_to_str(int event)
{ {
switch (event) switch (event)
{ {
@ -76,7 +76,7 @@ const char *bert_event_to_str(int event)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int bert_get_bit(bert_state_t *s) SPAN_DECLARE(int) bert_get_bit(bert_state_t *s)
{ {
int bit; int bit;
@ -183,7 +183,7 @@ static void assess_error_rate(bert_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void bert_put_bit(bert_state_t *s, int bit) SPAN_DECLARE(void) bert_put_bit(bert_state_t *s, int bit)
{ {
if (bit < 0) if (bit < 0)
{ {
@ -324,7 +324,7 @@ void bert_put_bit(bert_state_t *s, int bit)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int bert_result(bert_state_t *s, bert_results_t *results) SPAN_DECLARE(int) bert_result(bert_state_t *s, bert_results_t *results)
{ {
results->total_bits = s->results.total_bits; results->total_bits = s->results.total_bits;
results->bad_bits = s->results.bad_bits; results->bad_bits = s->results.bad_bits;
@ -333,7 +333,7 @@ int bert_result(bert_state_t *s, bert_results_t *results)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void bert_set_report(bert_state_t *s, int freq, bert_report_func_t reporter, void *user_data) SPAN_DECLARE(void) bert_set_report(bert_state_t *s, int freq, bert_report_func_t reporter, void *user_data)
{ {
s->report_frequency = freq; s->report_frequency = freq;
s->reporter = reporter; s->reporter = reporter;
@ -343,7 +343,7 @@ void bert_set_report(bert_state_t *s, int freq, bert_report_func_t reporter, voi
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
bert_state_t *bert_init(bert_state_t *s, int limit, int pattern, int resync_len, int resync_percent) SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern, int resync_len, int resync_percent)
{ {
int i; int i;
int j; int j;

14
libs/spandsp/src/bit_operations.c
View File

@ -41,7 +41,7 @@
#include "spandsp/telephony.h" #include "spandsp/telephony.h"
#include "spandsp/bit_operations.h" #include "spandsp/bit_operations.h"
uint16_t bit_reverse16(uint16_t x) SPAN_DECLARE(uint16_t) bit_reverse16(uint16_t x)
{ {
x = (x >> 8) | (x << 8); x = (x >> 8) | (x << 8);
x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4); x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
@ -50,7 +50,7 @@ uint16_t bit_reverse16(uint16_t x)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
uint32_t bit_reverse32(uint32_t x) SPAN_DECLARE(uint32_t) bit_reverse32(uint32_t x)
{ {
x = (x >> 16) | (x << 16); x = (x >> 16) | (x << 16);
x = ((x & 0xFF00FF00) >> 8) | ((x & 0x00FF00FF) << 8); x = ((x & 0xFF00FF00) >> 8) | ((x & 0x00FF00FF) << 8);
@ -60,7 +60,7 @@ uint32_t bit_reverse32(uint32_t x)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
uint32_t bit_reverse_4bytes(uint32_t x) SPAN_DECLARE(uint32_t) bit_reverse_4bytes(uint32_t x)
{ {
x = ((x & 0xF0F0F0F0) >> 4) | ((x & 0x0F0F0F0F) << 4); x = ((x & 0xF0F0F0F0) >> 4) | ((x & 0x0F0F0F0F) << 4);
x = ((x & 0xCCCCCCCC) >> 2) | ((x & 0x33333333) << 2); x = ((x & 0xCCCCCCCC) >> 2) | ((x & 0x33333333) << 2);
@ -78,7 +78,7 @@ uint64_t bit_reverse_8bytes(uint64_t x)
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
#endif #endif
void bit_reverse(uint8_t to[], const uint8_t from[], int len) SPAN_DECLARE(void) bit_reverse(uint8_t to[], const uint8_t from[], int len)
{ {
#if defined(SPANDSP_MISALIGNED_ACCESS_FAILS) #if defined(SPANDSP_MISALIGNED_ACCESS_FAILS)
int i; int i;
@ -138,7 +138,7 @@ void bit_reverse(uint8_t to[], const uint8_t from[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int one_bits32(uint32_t x) SPAN_DECLARE(int) one_bits32(uint32_t x)
{ {
x = x - ((x >> 1) & 0x55555555); x = x - ((x >> 1) & 0x55555555);
/* We now have 16 2-bit counts */ /* We now have 16 2-bit counts */
@ -158,7 +158,7 @@ int one_bits32(uint32_t x)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
uint32_t make_mask32(uint32_t x) SPAN_DECLARE(uint32_t) make_mask32(uint32_t x)
{ {
x |= (x >> 1); x |= (x >> 1);
x |= (x >> 2); x |= (x >> 2);
@ -169,7 +169,7 @@ uint32_t make_mask32(uint32_t x)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
uint16_t make_mask16(uint16_t x) SPAN_DECLARE(uint16_t) make_mask16(uint16_t x)
{ {
x |= (x >> 1); x |= (x >> 1);
x |= (x >> 2); x |= (x >> 2);

12
libs/spandsp/src/complex_filters.c
View File

@ -37,7 +37,7 @@
#include "spandsp/complex.h" #include "spandsp/complex.h"
#include "spandsp/complex_filters.h" #include "spandsp/complex_filters.h"
filter_t *filter_create(fspec_t *fs) SPAN_DECLARE(filter_t *) filter_create(fspec_t *fs)
{ {
int i; int i;
filter_t *fi; filter_t *fi;
@ -54,18 +54,18 @@ filter_t *filter_create(fspec_t *fs)
return fi; return fi;
} }
void filter_delete(filter_t *fi) SPAN_DECLARE(void) filter_delete(filter_t *fi)
{ {
if (fi) if (fi)
free(fi); free(fi);
} }
float filter_step(filter_t *fi, float x) SPAN_DECLARE(float) filter_step(filter_t *fi, float x)
{ {
return fi->fs->fsf(fi, x); return fi->fs->fsf(fi, x);
} }
cfilter_t *cfilter_create(fspec_t *fs) SPAN_DECLARE(cfilter_t *) cfilter_create(fspec_t *fs)
{ {
cfilter_t *cfi; cfilter_t *cfi;
@ -86,7 +86,7 @@ cfilter_t *cfilter_create(fspec_t *fs)
return cfi; return cfi;
} }
void cfilter_delete(cfilter_t *cfi) SPAN_DECLARE(void) cfilter_delete(cfilter_t *cfi)
{ {
if (cfi) if (cfi)
{ {
@ -95,7 +95,7 @@ void cfilter_delete(cfilter_t *cfi)
} }
} }
complexf_t cfilter_step(cfilter_t *cfi, const complexf_t *z) SPAN_DECLARE(complexf_t) cfilter_step(cfilter_t *cfi, const complexf_t *z)
{ {
complexf_t cc; complexf_t cc;

16
libs/spandsp/src/complex_vector_float.c
View File

@ -76,7 +76,7 @@
#include "spandsp/complex_vector_float.h" #include "spandsp/complex_vector_float.h"
#if defined(__GNUC__) && defined(SPANDSP_USE_SSE3) #if defined(__GNUC__) && defined(SPANDSP_USE_SSE3)
void cvec_mulf(complexf_t z[], const complexf_t x[], const complexf_t y[], int n) SPAN_DECLARE(void) cvec_mulf(complexf_t z[], const complexf_t x[], const complexf_t y[], int n)
{ {
int i; int i;
__m128 n0; __m128 n0;
@ -109,7 +109,7 @@ void cvec_mulf(complexf_t z[], const complexf_t x[], const complexf_t y[], int n
} }
} }
#else #else
void cvec_mulf(complexf_t z[], const complexf_t x[], const complexf_t y[], int n) SPAN_DECLARE(void) cvec_mulf(complexf_t z[], const complexf_t x[], const complexf_t y[], int n)
{ {
int i; int i;
@ -122,7 +122,7 @@ void cvec_mulf(complexf_t z[], const complexf_t x[], const complexf_t y[], int n
#endif #endif
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void cvec_mul(complex_t z[], const complex_t x[], const complex_t y[], int n) SPAN_DECLARE(void) cvec_mul(complex_t z[], const complex_t x[], const complex_t y[], int n)
{ {
int i; int i;
@ -148,7 +148,7 @@ void cvec_mull(complexl_t z[], const complexl_t x[], const complexl_t y[], int n
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
#endif #endif
complexf_t cvec_dot_prodf(const complexf_t x[], const complexf_t y[], int n) SPAN_DECLARE(complexf_t) cvec_dot_prodf(const complexf_t x[], const complexf_t y[], int n)
{ {
int i; int i;
complexf_t z; complexf_t z;
@ -163,7 +163,7 @@ complexf_t cvec_dot_prodf(const complexf_t x[], const complexf_t y[], int n)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complex_t cvec_dot_prod(const complex_t x[], const complex_t y[], int n) SPAN_DECLARE(complex_t) cvec_dot_prod(const complex_t x[], const complex_t y[], int n)
{ {
int i; int i;
complex_t z; complex_t z;
@ -195,7 +195,7 @@ complexl_t cvec_dot_prodl(const complexl_t x[], const complexl_t y[], int n)
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
#endif #endif
complexf_t cvec_circular_dot_prodf(const complexf_t x[], const complexf_t y[], int n, int pos) SPAN_DECLARE(complexf_t) cvec_circular_dot_prodf(const complexf_t x[], const complexf_t y[], int n, int pos)
{ {
complexf_t z; complexf_t z;
complexf_t z1; complexf_t z1;
@ -209,7 +209,7 @@ complexf_t cvec_circular_dot_prodf(const complexf_t x[], const complexf_t y[], i
#define LMS_LEAK_RATE 0.9999f #define LMS_LEAK_RATE 0.9999f
void cvec_lmsf(const complexf_t x[], complexf_t y[], int n, const complexf_t *error) SPAN_DECLARE(void) cvec_lmsf(const complexf_t x[], complexf_t y[], int n, const complexf_t *error)
{ {
int i; int i;
@ -222,7 +222,7 @@ void cvec_lmsf(const complexf_t x[], complexf_t y[], int n, const complexf_t *er
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void cvec_circular_lmsf(const complexf_t x[], complexf_t y[], int n, int pos, const complexf_t *error) SPAN_DECLARE(void) cvec_circular_lmsf(const complexf_t x[], complexf_t y[], int n, int pos, const complexf_t *error)
{ {
cvec_lmsf(&x[pos], &y[0], n - pos, error); cvec_lmsf(&x[pos], &y[0], n - pos, error);
cvec_lmsf(&x[0], &y[n - pos], pos, error); cvec_lmsf(&x[0], &y[n - pos], pos, error);

10
libs/spandsp/src/complex_vector_int.c
View File

@ -75,7 +75,7 @@
#include "spandsp/vector_int.h" #include "spandsp/vector_int.h"
#include "spandsp/complex_vector_int.h" #include "spandsp/complex_vector_int.h"
complexi32_t cvec_dot_prodi16(const complexi16_t x[], const complexi16_t y[], int n) SPAN_DECLARE(complexi32_t) cvec_dot_prodi16(const complexi16_t x[], const complexi16_t y[], int n)
{ {
int i; int i;
complexi32_t z; complexi32_t z;
@ -90,7 +90,7 @@ complexi32_t cvec_dot_prodi16(const complexi16_t x[], const complexi16_t y[], in
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi32_t cvec_dot_prodi32(const complexi32_t x[], const complexi32_t y[], int n) SPAN_DECLARE(complexi32_t) cvec_dot_prodi32(const complexi32_t x[], const complexi32_t y[], int n)
{ {
int i; int i;
complexi32_t z; complexi32_t z;
@ -105,7 +105,7 @@ complexi32_t cvec_dot_prodi32(const complexi32_t x[], const complexi32_t y[], in
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi32_t cvec_circular_dot_prodi16(const complexi16_t x[], const complexi16_t y[], int n, int pos) SPAN_DECLARE(complexi32_t) cvec_circular_dot_prodi16(const complexi16_t x[], const complexi16_t y[], int n, int pos)
{ {
complexi32_t z; complexi32_t z;
complexi32_t z1; complexi32_t z1;
@ -117,7 +117,7 @@ complexi32_t cvec_circular_dot_prodi16(const complexi16_t x[], const complexi16_
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void cvec_lmsi16(const complexi16_t x[], complexi16_t y[], int n, const complexi16_t *error) SPAN_DECLARE(void) cvec_lmsi16(const complexi16_t x[], complexi16_t y[], int n, const complexi16_t *error)
{ {
int i; int i;
@ -129,7 +129,7 @@ void cvec_lmsi16(const complexi16_t x[], complexi16_t y[], int n, const complexi
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void cvec_circular_lmsi16(const complexi16_t x[], complexi16_t y[], int n, int pos, const complexi16_t *error) SPAN_DECLARE(void) cvec_circular_lmsi16(const complexi16_t x[], complexi16_t y[], int n, int pos, const complexi16_t *error)
{ {
cvec_lmsi16(&x[pos], &y[0], n - pos, error); cvec_lmsi16(&x[pos], &y[0], n - pos, error);
cvec_lmsi16(&x[0], &y[n - pos], pos, error); cvec_lmsi16(&x[0], &y[n - pos], pos, error);

12
libs/spandsp/src/crc.c
View File

@ -107,7 +107,7 @@ static const uint32_t crc_itu32_table[] =
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
}; };
uint32_t crc_itu32_calc(const uint8_t *buf, int len, uint32_t crc) SPAN_DECLARE(uint32_t) crc_itu32_calc(const uint8_t *buf, int len, uint32_t crc)
{ {
int i; int i;
@ -117,7 +117,7 @@ uint32_t crc_itu32_calc(const uint8_t *buf, int len, uint32_t crc)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int crc_itu32_append(uint8_t *buf, int len) SPAN_DECLARE(int) crc_itu32_append(uint8_t *buf, int len)
{ {
uint32_t crc; uint32_t crc;
int new_len; int new_len;
@ -136,7 +136,7 @@ int crc_itu32_append(uint8_t *buf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int crc_itu32_check(const uint8_t *buf, int len) SPAN_DECLARE(int) crc_itu32_check(const uint8_t *buf, int len)
{ {
uint32_t crc; uint32_t crc;
int i; int i;
@ -184,7 +184,7 @@ static const uint16_t crc_itu16_table[] =
0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
}; };
uint16_t crc_itu16_calc(const uint8_t *buf, int len, uint16_t crc) SPAN_DECLARE(uint16_t) crc_itu16_calc(const uint8_t *buf, int len, uint16_t crc)
{ {
int i; int i;
@ -194,7 +194,7 @@ uint16_t crc_itu16_calc(const uint8_t *buf, int len, uint16_t crc)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int crc_itu16_append(uint8_t *buf, int len) SPAN_DECLARE(int) crc_itu16_append(uint8_t *buf, int len)
{ {
uint16_t crc; uint16_t crc;
int new_len; int new_len;
@ -211,7 +211,7 @@ int crc_itu16_append(uint8_t *buf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int crc_itu16_check(const uint8_t *buf, int len) SPAN_DECLARE(int) crc_itu16_check(const uint8_t *buf, int len)
{ {
uint16_t crc; uint16_t crc;
int i; int i;

22
libs/spandsp/src/dds_float.c
View File

@ -2102,37 +2102,37 @@ static const float sine_table[SINELEN] =
-0.00306796f -0.00306796f
}; };
int32_t dds_phase_ratef(float frequency) SPAN_DECLARE(int32_t) dds_phase_ratef(float frequency)
{ {
return (int32_t) (frequency*65536.0f*65536.0f/SAMPLE_RATE); return (int32_t) (frequency*65536.0f*65536.0f/SAMPLE_RATE);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float dds_frequencyf(int32_t phase_rate) SPAN_DECLARE(float) dds_frequencyf(int32_t phase_rate)
{ {
return (float) phase_rate*(float) SAMPLE_RATE/(65536.0f*65536.0f); return (float) phase_rate*(float) SAMPLE_RATE/(65536.0f*65536.0f);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float dds_scaling_dbm0f(float level) SPAN_DECLARE(float) dds_scaling_dbm0f(float level)
{ {
return powf(10.0f, (level - DBM0_MAX_SINE_POWER)/20.0f)*32767.0f; return powf(10.0f, (level - DBM0_MAX_SINE_POWER)/20.0f)*32767.0f;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float dds_scaling_dbovf(float level) SPAN_DECLARE(float) dds_scaling_dbovf(float level)
{ {
return powf(10.0f, (level - DBOV_MAX_SINE_POWER)/20.0f)*32767.0f; return powf(10.0f, (level - DBOV_MAX_SINE_POWER)/20.0f)*32767.0f;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void dds_advancef(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(void) dds_advancef(uint32_t *phase_acc, int32_t phase_rate)
{ {
*phase_acc += phase_rate; *phase_acc += phase_rate;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float ddsf(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(float) ddsf(uint32_t *phase_acc, int32_t phase_rate)
{ {
float amp; float amp;
@ -2142,13 +2142,13 @@ float ddsf(uint32_t *phase_acc, int32_t phase_rate)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float dds_lookupf(uint32_t phase) SPAN_DECLARE(float) dds_lookupf(uint32_t phase)
{ {
return sine_table[phase >> (32 - SLENK)]; return sine_table[phase >> (32 - SLENK)];
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float dds_modf(uint32_t *phase_acc, int32_t phase_rate, float scale, int32_t phase) SPAN_DECLARE(float) dds_modf(uint32_t *phase_acc, int32_t phase_rate, float scale, int32_t phase)
{ {
float amp; float amp;
@ -2158,7 +2158,7 @@ float dds_modf(uint32_t *phase_acc, int32_t phase_rate, float scale, int32_t pha
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexf_t dds_complexf(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(complexf_t) dds_complexf(uint32_t *phase_acc, int32_t phase_rate)
{ {
complexf_t amp; complexf_t amp;
@ -2169,14 +2169,14 @@ complexf_t dds_complexf(uint32_t *phase_acc, int32_t phase_rate)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexf_t dds_lookup_complexf(uint32_t phase) SPAN_DECLARE(complexf_t) dds_lookup_complexf(uint32_t phase)
{ {
return complex_setf(sine_table[(phase + (1 << 30)) >> (32 - SLENK)], return complex_setf(sine_table[(phase + (1 << 30)) >> (32 - SLENK)],
sine_table[phase >> (32 - SLENK)]); sine_table[phase >> (32 - SLENK)]);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexf_t dds_complex_modf(uint32_t *phase_acc, int32_t phase_rate, float scale, int32_t phase) SPAN_DECLARE(complexf_t) dds_complex_modf(uint32_t *phase_acc, int32_t phase_rate, float scale, int32_t phase)
{ {
complexf_t amp; complexf_t amp;

36
libs/spandsp/src/dds_int.c
View File

@ -190,31 +190,31 @@ static const int16_t sine_table[DDS_STEPS] =
32767, 32767,
}; };
int32_t dds_phase_rate(float frequency) SPAN_DECLARE(int32_t) dds_phase_rate(float frequency)
{ {
return (int32_t) (frequency*65536.0f*65536.0f/SAMPLE_RATE); return (int32_t) (frequency*65536.0f*65536.0f/SAMPLE_RATE);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float dds_frequency(int32_t phase_rate) SPAN_DECLARE(float) dds_frequency(int32_t phase_rate)
{ {
return (float) phase_rate*(float) SAMPLE_RATE/(65536.0f*65536.0f); return (float) phase_rate*(float) SAMPLE_RATE/(65536.0f*65536.0f);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t dds_scaling_dbm0(float level) SPAN_DECLARE(int16_t) dds_scaling_dbm0(float level)
{ {
return (int16_t) (powf(10.0f, (level - DBM0_MAX_SINE_POWER)/20.0f)*32767.0f); return (int16_t) (powf(10.0f, (level - DBM0_MAX_SINE_POWER)/20.0f)*32767.0f);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t dds_scaling_dbov(float level) SPAN_DECLARE(int16_t) dds_scaling_dbov(float level)
{ {
return (int16_t) (powf(10.0f, (level - DBOV_MAX_SINE_POWER)/20.0f)*32767.0f); return (int16_t) (powf(10.0f, (level - DBOV_MAX_SINE_POWER)/20.0f)*32767.0f);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t dds_lookup(uint32_t phase) SPAN_DECLARE(int16_t) dds_lookup(uint32_t phase)
{ {
uint32_t step; uint32_t step;
int16_t amp; int16_t amp;
@ -230,19 +230,19 @@ int16_t dds_lookup(uint32_t phase)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t dds_offset(uint32_t phase_acc, int32_t phase_offset) SPAN_DECLARE(int16_t) dds_offset(uint32_t phase_acc, int32_t phase_offset)
{ {
return dds_lookup(phase_acc + phase_offset); return dds_lookup(phase_acc + phase_offset);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void dds_advance(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(void) dds_advance(uint32_t *phase_acc, int32_t phase_rate)
{ {
*phase_acc += phase_rate; *phase_acc += phase_rate;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t dds(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(int16_t) dds(uint32_t *phase_acc, int32_t phase_rate)
{ {
int16_t amp; int16_t amp;
@ -252,7 +252,7 @@ int16_t dds(uint32_t *phase_acc, int32_t phase_rate)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t dds_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase) SPAN_DECLARE(int16_t) dds_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase)
{ {
int16_t amp; int16_t amp;
@ -262,13 +262,13 @@ int16_t dds_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi_t dds_lookup_complexi(uint32_t phase) SPAN_DECLARE(complexi_t) dds_lookup_complexi(uint32_t phase)
{ {
return complex_seti(dds_lookup(phase + (1 << 30)), dds_lookup(phase)); return complex_seti(dds_lookup(phase + (1 << 30)), dds_lookup(phase));
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi_t dds_complexi(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(complexi_t) dds_complexi(uint32_t *phase_acc, int32_t phase_rate)
{ {
complexi_t amp; complexi_t amp;
@ -278,7 +278,7 @@ complexi_t dds_complexi(uint32_t *phase_acc, int32_t phase_rate)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi_t dds_complexi_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase) SPAN_DECLARE(complexi_t) dds_complexi_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase)
{ {
complexi_t amp; complexi_t amp;
@ -289,13 +289,13 @@ complexi_t dds_complexi_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t sca
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi16_t dds_lookup_complexi16(uint32_t phase) SPAN_DECLARE(complexi16_t) dds_lookup_complexi16(uint32_t phase)
{ {
return complex_seti16(dds_lookup(phase + (1 << 30)), dds_lookup(phase)); return complex_seti16(dds_lookup(phase + (1 << 30)), dds_lookup(phase));
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi16_t dds_complexi16(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(complexi16_t) dds_complexi16(uint32_t *phase_acc, int32_t phase_rate)
{ {
complexi16_t amp; complexi16_t amp;
@ -305,7 +305,7 @@ complexi16_t dds_complexi16(uint32_t *phase_acc, int32_t phase_rate)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi16_t dds_complexi16_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase) SPAN_DECLARE(complexi16_t) dds_complexi16_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase)
{ {
complexi16_t amp; complexi16_t amp;
@ -316,13 +316,13 @@ complexi16_t dds_complexi16_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi32_t dds_lookup_complexi32(uint32_t phase) SPAN_DECLARE(complexi32_t) dds_lookup_complexi32(uint32_t phase)
{ {
return complex_seti32(dds_lookup(phase + (1 << 30)), dds_lookup(phase)); return complex_seti32(dds_lookup(phase + (1 << 30)), dds_lookup(phase));
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi32_t dds_complexi32(uint32_t *phase_acc, int32_t phase_rate) SPAN_DECLARE(complexi32_t) dds_complexi32(uint32_t *phase_acc, int32_t phase_rate)
{ {
complexi32_t amp; complexi32_t amp;
@ -332,7 +332,7 @@ complexi32_t dds_complexi32(uint32_t *phase_acc, int32_t phase_rate)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
complexi32_t dds_complexi32_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase) SPAN_DECLARE(complexi32_t) dds_complexi32_mod(uint32_t *phase_acc, int32_t phase_rate, int16_t scale, int32_t phase)
{ {
complexi32_t amp; complexi32_t amp;

26
libs/spandsp/src/dtmf.c
View File

@ -99,7 +99,7 @@ static goertzel_descriptor_t dtmf_detect_col[4];
static int dtmf_tx_inited = FALSE; static int dtmf_tx_inited = FALSE;
static tone_gen_descriptor_t dtmf_digit_tones[16]; static tone_gen_descriptor_t dtmf_digit_tones[16];
int dtmf_rx(dtmf_rx_state_t *s, const int16_t amp[], int samples) SPAN_DECLARE(int) dtmf_rx(dtmf_rx_state_t *s, const int16_t amp[], int samples)
{ {
#if defined(SPANDSP_USE_FIXED_POINT) #if defined(SPANDSP_USE_FIXED_POINT)
int32_t row_energy[4]; int32_t row_energy[4];
@ -296,7 +296,7 @@ int dtmf_rx(dtmf_rx_state_t *s, const int16_t amp[], int samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int dtmf_rx_status(dtmf_rx_state_t *s) SPAN_DECLARE(int) dtmf_rx_status(dtmf_rx_state_t *s)
{ {
if (s->in_digit) if (s->in_digit)
return s->in_digit; return s->in_digit;
@ -306,7 +306,7 @@ int dtmf_rx_status(dtmf_rx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t dtmf_rx_get(dtmf_rx_state_t *s, char *buf, int max) SPAN_DECLARE(size_t) dtmf_rx_get(dtmf_rx_state_t *s, char *buf, int max)
{ {
if (max > s->current_digits) if (max > s->current_digits)
max = s->current_digits; max = s->current_digits;
@ -321,7 +321,7 @@ size_t dtmf_rx_get(dtmf_rx_state_t *s, char *buf, int max)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void dtmf_rx_set_realtime_callback(dtmf_rx_state_t *s, SPAN_DECLARE(void) dtmf_rx_set_realtime_callback(dtmf_rx_state_t *s,
tone_report_func_t callback, tone_report_func_t callback,
void *user_data) void *user_data)
{ {
@ -330,7 +330,7 @@ void dtmf_rx_set_realtime_callback(dtmf_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void dtmf_rx_parms(dtmf_rx_state_t *s, SPAN_DECLARE(void) dtmf_rx_parms(dtmf_rx_state_t *s,
int filter_dialtone, int filter_dialtone,
int twist, int twist,
int reverse_twist, int reverse_twist,
@ -358,7 +358,7 @@ void dtmf_rx_parms(dtmf_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
dtmf_rx_state_t *dtmf_rx_init(dtmf_rx_state_t *s, SPAN_DECLARE(dtmf_rx_state_t *) dtmf_rx_init(dtmf_rx_state_t *s,
digits_rx_callback_t callback, digits_rx_callback_t callback,
void *user_data) void *user_data)
{ {
@ -409,7 +409,7 @@ dtmf_rx_state_t *dtmf_rx_init(dtmf_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int dtmf_rx_free(dtmf_rx_state_t *s) SPAN_DECLARE(int) dtmf_rx_free(dtmf_rx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
@ -443,7 +443,7 @@ static void dtmf_tx_initialise(void)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int dtmf_tx(dtmf_tx_state_t *s, int16_t amp[], int max_samples) SPAN_DECLARE(int) dtmf_tx(dtmf_tx_state_t *s, int16_t amp[], int max_samples)
{ {
int len; int len;
const char *cp; const char *cp;
@ -473,7 +473,7 @@ int dtmf_tx(dtmf_tx_state_t *s, int16_t amp[], int max_samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int dtmf_tx_put(dtmf_tx_state_t *s, const char *digits, int len) SPAN_DECLARE(int) dtmf_tx_put(dtmf_tx_state_t *s, const char *digits, int len)
{ {
size_t space; size_t space;
@ -493,21 +493,21 @@ int dtmf_tx_put(dtmf_tx_state_t *s, const char *digits, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void dtmf_tx_set_level(dtmf_tx_state_t *s, int level, int twist) SPAN_DECLARE(void) dtmf_tx_set_level(dtmf_tx_state_t *s, int level, int twist)
{ {
s->low_level = dds_scaling_dbm0f((float) level); s->low_level = dds_scaling_dbm0f((float) level);
s->high_level = dds_scaling_dbm0f((float) (level + twist)); s->high_level = dds_scaling_dbm0f((float) (level + twist));
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void dtmf_tx_set_timing(dtmf_tx_state_t *s, int on_time, int off_time) SPAN_DECLARE(void) dtmf_tx_set_timing(dtmf_tx_state_t *s, int on_time, int off_time)
{ {
s->on_time = ((on_time >= 0) ? on_time : DEFAULT_DTMF_TX_ON_TIME)*SAMPLE_RATE/1000; s->on_time = ((on_time >= 0) ? on_time : DEFAULT_DTMF_TX_ON_TIME)*SAMPLE_RATE/1000;
s->off_time = ((off_time >= 0) ? off_time : DEFAULT_DTMF_TX_OFF_TIME)*SAMPLE_RATE/1000; s->off_time = ((off_time >= 0) ? off_time : DEFAULT_DTMF_TX_OFF_TIME)*SAMPLE_RATE/1000;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
dtmf_tx_state_t *dtmf_tx_init(dtmf_tx_state_t *s) SPAN_DECLARE(dtmf_tx_state_t *) dtmf_tx_init(dtmf_tx_state_t *s)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -525,7 +525,7 @@ dtmf_tx_state_t *dtmf_tx_init(dtmf_tx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int dtmf_tx_free(dtmf_tx_state_t *s) SPAN_DECLARE(int) dtmf_tx_free(dtmf_tx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;

14
libs/spandsp/src/echo.c
View File

@ -237,7 +237,7 @@ static __inline__ void lms_adapt(echo_can_state_t *ec, int factor)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
echo_can_state_t *echo_can_create(int len, int adaption_mode) SPAN_DECLARE(echo_can_state_t *) echo_can_create(int len, int adaption_mode)
{ {
echo_can_state_t *ec; echo_can_state_t *ec;
int i; int i;
@ -282,7 +282,7 @@ echo_can_state_t *echo_can_create(int len, int adaption_mode)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void echo_can_free(echo_can_state_t *ec) SPAN_DECLARE(void) echo_can_free(echo_can_state_t *ec)
{ {
int i; int i;
@ -294,13 +294,13 @@ void echo_can_free(echo_can_state_t *ec)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void echo_can_adaption_mode(echo_can_state_t *ec, int adaption_mode) SPAN_DECLARE(void) echo_can_adaption_mode(echo_can_state_t *ec, int adaption_mode)
{ {
ec->adaption_mode = adaption_mode; ec->adaption_mode = adaption_mode;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void echo_can_flush(echo_can_state_t *ec) SPAN_DECLARE(void) echo_can_flush(echo_can_state_t *ec)
{ {
int i; int i;
@ -343,7 +343,7 @@ void echo_can_flush(echo_can_state_t *ec)
int sample_no = 0; int sample_no = 0;
void echo_can_snapshot(echo_can_state_t *ec) SPAN_DECLARE(void) echo_can_snapshot(echo_can_state_t *ec)
{ {
memcpy(ec->snapshot, ec->fir_taps16[0], ec->taps*sizeof(int16_t)); memcpy(ec->snapshot, ec->fir_taps16[0], ec->taps*sizeof(int16_t));
} }
@ -388,7 +388,7 @@ static __inline__ int16_t echo_can_hpf(int32_t coeff[2], int16_t amp)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx) SPAN_DECLARE(int16_t) echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
{ {
int32_t echo_value; int32_t echo_value;
int clean_rx; int clean_rx;
@ -603,7 +603,7 @@ printf("Narrowband score %4d %5d at %d\n", ec->narrowband_score, score, sample_n
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t echo_can_hpf_tx(echo_can_state_t *ec, int16_t tx) SPAN_DECLARE(int16_t) echo_can_hpf_tx(echo_can_state_t *ec, int16_t tx)
{ {
if (ec->adaption_mode & ECHO_CAN_USE_TX_HPF) if (ec->adaption_mode & ECHO_CAN_USE_TX_HPF)
tx = echo_can_hpf(ec->tx_hpf, tx); tx = echo_can_hpf(ec->tx_hpf, tx);

18
libs/spandsp/src/fax.c
View File

@ -255,7 +255,7 @@ static void fax_fax_modems_init(fax_modems_state_t *s, int use_tep, void *user_d
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int fax_rx(fax_state_t *s, int16_t *amp, int len) SPAN_DECLARE(int) fax_rx(fax_state_t *s, int16_t *amp, int len)
{ {
int i; int i;
@ -293,7 +293,7 @@ static int set_next_tx_type(fax_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int fax_tx(fax_state_t *s, int16_t *amp, int max_len) SPAN_DECLARE(int) fax_tx(fax_state_t *s, int16_t *amp, int max_len)
{ {
int len; int len;
#if defined(LOG_FAX_AUDIO) #if defined(LOG_FAX_AUDIO)
@ -514,31 +514,31 @@ static void fax_set_tx_type(void *user_data, int type, int bit_rate, int short_t
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fax_set_transmit_on_idle(fax_state_t *s, int transmit_on_idle) SPAN_DECLARE(void) fax_set_transmit_on_idle(fax_state_t *s, int transmit_on_idle)
{ {
s->modems.transmit_on_idle = transmit_on_idle; s->modems.transmit_on_idle = transmit_on_idle;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fax_set_tep_mode(fax_state_t *s, int use_tep) SPAN_DECLARE(void) fax_set_tep_mode(fax_state_t *s, int use_tep)
{ {
s->modems.use_tep = use_tep; s->modems.use_tep = use_tep;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
t30_state_t *fax_get_t30_state(fax_state_t *s) SPAN_DECLARE(t30_state_t *) fax_get_t30_state(fax_state_t *s)
{ {
return &s->t30; return &s->t30;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
logging_state_t *fax_get_logging_state(fax_state_t *s) SPAN_DECLARE(logging_state_t *) fax_get_logging_state(fax_state_t *s)
{ {
return &s->logging; return &s->logging;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
fax_state_t *fax_init(fax_state_t *s, int calling_party) SPAN_DECLARE(fax_state_t *) fax_init(fax_state_t *s, int calling_party)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -594,14 +594,14 @@ fax_state_t *fax_init(fax_state_t *s, int calling_party)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int fax_release(fax_state_t *s) SPAN_DECLARE(int) fax_release(fax_state_t *s)
{ {
t30_release(&s->t30); t30_release(&s->t30);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int fax_free(fax_state_t *s) SPAN_DECLARE(int) fax_free(fax_state_t *s)
{ {
t30_release(&s->t30); t30_release(&s->t30);
free(s); free(s);

22
libs/spandsp/src/fsk.c
View File

@ -120,7 +120,7 @@ const fsk_spec_t preset_fsk_specs[] =
} }
}; };
fsk_tx_state_t *fsk_tx_init(fsk_tx_state_t *s, SPAN_DECLARE(fsk_tx_state_t *) fsk_tx_init(fsk_tx_state_t *s,
const fsk_spec_t *spec, const fsk_spec_t *spec,
get_bit_func_t get_bit, get_bit_func_t get_bit,
void *user_data) void *user_data)
@ -149,7 +149,7 @@ fsk_tx_state_t *fsk_tx_init(fsk_tx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int fsk_tx(fsk_tx_state_t *s, int16_t amp[], int len) SPAN_DECLARE(int) fsk_tx(fsk_tx_state_t *s, int16_t amp[], int len)
{ {
int sample; int sample;
int bit; int bit;
@ -182,27 +182,27 @@ int fsk_tx(fsk_tx_state_t *s, int16_t amp[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fsk_tx_power(fsk_tx_state_t *s, float power) SPAN_DECLARE(void) fsk_tx_power(fsk_tx_state_t *s, float power)
{ {
s->scaling = dds_scaling_dbm0(power); s->scaling = dds_scaling_dbm0(power);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fsk_tx_set_get_bit(fsk_tx_state_t *s, get_bit_func_t get_bit, void *user_data) SPAN_DECLARE(void) fsk_tx_set_get_bit(fsk_tx_state_t *s, get_bit_func_t get_bit, void *user_data)
{ {
s->get_bit = get_bit; s->get_bit = get_bit;
s->get_bit_user_data = user_data; s->get_bit_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fsk_tx_set_modem_status_handler(fsk_tx_state_t *s, modem_tx_status_func_t handler, void *user_data) SPAN_DECLARE(void) fsk_tx_set_modem_status_handler(fsk_tx_state_t *s, modem_tx_status_func_t handler, void *user_data)
{ {
s->status_handler = handler; s->status_handler = handler;
s->status_user_data = user_data; s->status_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fsk_rx_signal_cutoff(fsk_rx_state_t *s, float cutoff) SPAN_DECLARE(void) fsk_rx_signal_cutoff(fsk_rx_state_t *s, float cutoff)
{ {
/* The 6.04 allows for the gain of the DC blocker */ /* The 6.04 allows for the gain of the DC blocker */
s->carrier_on_power = (int32_t) (power_meter_level_dbm0(cutoff + 2.5f - 6.04f)); s->carrier_on_power = (int32_t) (power_meter_level_dbm0(cutoff + 2.5f - 6.04f));
@ -210,27 +210,27 @@ void fsk_rx_signal_cutoff(fsk_rx_state_t *s, float cutoff)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float fsk_rx_signal_power(fsk_rx_state_t *s) SPAN_DECLARE(float) fsk_rx_signal_power(fsk_rx_state_t *s)
{ {
return power_meter_current_dbm0(&s->power); return power_meter_current_dbm0(&s->power);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fsk_rx_set_put_bit(fsk_rx_state_t *s, put_bit_func_t put_bit, void *user_data) SPAN_DECLARE(void) fsk_rx_set_put_bit(fsk_rx_state_t *s, put_bit_func_t put_bit, void *user_data)
{ {
s->put_bit = put_bit; s->put_bit = put_bit;
s->put_bit_user_data = user_data; s->put_bit_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void fsk_rx_set_modem_status_handler(fsk_rx_state_t *s, modem_tx_status_func_t handler, void *user_data) SPAN_DECLARE(void) fsk_rx_set_modem_status_handler(fsk_rx_state_t *s, modem_tx_status_func_t handler, void *user_data)
{ {
s->status_handler = handler; s->status_handler = handler;
s->status_user_data = user_data; s->status_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
fsk_rx_state_t *fsk_rx_init(fsk_rx_state_t *s, SPAN_DECLARE(fsk_rx_state_t *) fsk_rx_init(fsk_rx_state_t *s,
const fsk_spec_t *spec, const fsk_spec_t *spec,
int sync_mode, int sync_mode,
put_bit_func_t put_bit, put_bit_func_t put_bit,
@ -298,7 +298,7 @@ static void report_status_change(fsk_rx_state_t *s, int status)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int fsk_rx(fsk_rx_state_t *s, const int16_t *amp, int len) SPAN_DECLARE(int) fsk_rx(fsk_rx_state_t *s, const int16_t *amp, int len)
{ {
int buf_ptr; int buf_ptr;
int baudstate; int baudstate;

14
libs/spandsp/src/g711.c
View File

@ -85,19 +85,19 @@ static const uint8_t alaw_to_ulaw_table[256] =
214, 215, 212, 213, 218, 219, 216, 217, 207, 207, 206, 206, 210, 211, 208, 209 214, 215, 212, 213, 218, 219, 216, 217, 207, 207, 206, 206, 210, 211, 208, 209
}; };
uint8_t alaw_to_ulaw(uint8_t alaw) SPAN_DECLARE(uint8_t) alaw_to_ulaw(uint8_t alaw)
{ {
return alaw_to_ulaw_table[alaw]; return alaw_to_ulaw_table[alaw];
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
uint8_t ulaw_to_alaw(uint8_t ulaw) SPAN_DECLARE(uint8_t) ulaw_to_alaw(uint8_t ulaw)
{ {
return ulaw_to_alaw_table[ulaw]; return ulaw_to_alaw_table[ulaw];
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g711_decode(g711_state_t *s, SPAN_DECLARE(int) g711_decode(g711_state_t *s,
int16_t amp[], int16_t amp[],
const uint8_t g711_data[], const uint8_t g711_data[],
int g711_bytes) int g711_bytes)
@ -121,7 +121,7 @@ int g711_decode(g711_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g711_encode(g711_state_t *s, SPAN_DECLARE(int) g711_encode(g711_state_t *s,
uint8_t g711_data[], uint8_t g711_data[],
const int16_t amp[], const int16_t amp[],
int len) int len)
@ -145,7 +145,7 @@ int g711_encode(g711_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g711_transcode(g711_state_t *s, SPAN_DECLARE(int) g711_transcode(g711_state_t *s,
uint8_t g711_out[], uint8_t g711_out[],
const uint8_t g711_in[], const uint8_t g711_in[],
int g711_bytes) int g711_bytes)
@ -169,7 +169,7 @@ int g711_transcode(g711_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
g711_state_t *g711_init(g711_state_t *s, int mode) SPAN_DECLARE(g711_state_t *) g711_init(g711_state_t *s, int mode)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -181,7 +181,7 @@ g711_state_t *g711_init(g711_state_t *s, int mode)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g711_release(g711_state_t *s) SPAN_DECLARE(int) g711_release(g711_state_t *s)
{ {
free(s); free(s);
return 0; return 0;

12
libs/spandsp/src/g722.c
View File

@ -254,7 +254,7 @@ static void block4(g722_band_t *s, int16_t dx)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
g722_decode_state_t *g722_decode_init(g722_decode_state_t *s, int rate, int options) SPAN_DECLARE(g722_decode_state_t *) g722_decode_init(g722_decode_state_t *s, int rate, int options)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -280,14 +280,14 @@ g722_decode_state_t *g722_decode_init(g722_decode_state_t *s, int rate, int opti
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g722_decode_release(g722_decode_state_t *s) SPAN_DECLARE(int) g722_decode_release(g722_decode_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g722_decode(g722_decode_state_t *s, int16_t amp[], const uint8_t g722_data[], int len) SPAN_DECLARE(int) g722_decode(g722_decode_state_t *s, int16_t amp[], const uint8_t g722_data[], int len)
{ {
int rlow; int rlow;
int ihigh; int ihigh;
@ -426,7 +426,7 @@ int g722_decode(g722_decode_state_t *s, int16_t amp[], const uint8_t g722_data[]
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
g722_encode_state_t *g722_encode_init(g722_encode_state_t *s, int rate, int options) SPAN_DECLARE(g722_encode_state_t *) g722_encode_init(g722_encode_state_t *s, int rate, int options)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -452,14 +452,14 @@ g722_encode_state_t *g722_encode_init(g722_encode_state_t *s, int rate, int opti
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g722_encode_release(g722_encode_state_t *s) SPAN_DECLARE(int) g722_encode_release(g722_encode_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g722_encode(g722_encode_state_t *s, uint8_t g722_data[], const int16_t amp[], int len) SPAN_DECLARE(int) g722_encode(g722_encode_state_t *s, uint8_t g722_data[], const int16_t amp[], int len)
{ {
int16_t dlow; int16_t dlow;
int16_t dhigh; int16_t dhigh;

8
libs/spandsp/src/g726.c
View File

@ -997,7 +997,7 @@ static int16_t g726_40_decoder(g726_state_t *s, uint8_t code)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
g726_state_t *g726_init(g726_state_t *s, int bit_rate, int ext_coding, int packing) SPAN_DECLARE(g726_state_t *) g726_init(g726_state_t *s, int bit_rate, int ext_coding, int packing)
{ {
int i; int i;
@ -1057,14 +1057,14 @@ g726_state_t *g726_init(g726_state_t *s, int bit_rate, int ext_coding, int packi
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g726_release(g726_state_t *s) SPAN_DECLARE(int) g726_release(g726_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g726_decode(g726_state_t *s, SPAN_DECLARE(int) g726_decode(g726_state_t *s,
int16_t amp[], int16_t amp[],
const uint8_t g726_data[], const uint8_t g726_data[],
int g726_bytes) int g726_bytes)
@ -1120,7 +1120,7 @@ int g726_decode(g726_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int g726_encode(g726_state_t *s, SPAN_DECLARE(int) g726_encode(g726_state_t *s,
uint8_t g726_data[], uint8_t g726_data[],
const int16_t amp[], const int16_t amp[],
int len) int len)

8
libs/spandsp/src/gsm0610_decode.c
View File

@ -101,7 +101,7 @@ static void decode_a_frame(gsm0610_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_unpack_none(gsm0610_frame_t *s, const uint8_t c[]) SPAN_DECLARE(int) gsm0610_unpack_none(gsm0610_frame_t *s, const uint8_t c[])
{ {
int i; int i;
int j; int j;
@ -123,7 +123,7 @@ int gsm0610_unpack_none(gsm0610_frame_t *s, const uint8_t c[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_unpack_wav49(gsm0610_frame_t *s, const uint8_t c[]) SPAN_DECLARE(int) gsm0610_unpack_wav49(gsm0610_frame_t *s, const uint8_t c[])
{ {
uint16_t sr; uint16_t sr;
int i; int i;
@ -265,7 +265,7 @@ int gsm0610_unpack_wav49(gsm0610_frame_t *s, const uint8_t c[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_unpack_voip(gsm0610_frame_t *s, const uint8_t c[33]) SPAN_DECLARE(int) gsm0610_unpack_voip(gsm0610_frame_t *s, const uint8_t c[33])
{ {
int i; int i;
@ -310,7 +310,7 @@ int gsm0610_unpack_voip(gsm0610_frame_t *s, const uint8_t c[33])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_decode(gsm0610_state_t *s, int16_t amp[], const uint8_t code[], int len) SPAN_DECLARE(int) gsm0610_decode(gsm0610_state_t *s, int16_t amp[], const uint8_t code[], int len)
{ {
gsm0610_frame_t frame[2]; gsm0610_frame_t frame[2];
int bytes; int bytes;

14
libs/spandsp/src/gsm0610_encode.c
View File

@ -105,7 +105,7 @@ static void encode_a_frame(gsm0610_state_t *s, gsm0610_frame_t *f, const int16_t
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
gsm0610_state_t *gsm0610_init(gsm0610_state_t *s, int packing) SPAN_DECLARE(gsm0610_state_t *) gsm0610_init(gsm0610_state_t *s, int packing)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -121,14 +121,14 @@ gsm0610_state_t *gsm0610_init(gsm0610_state_t *s, int packing)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_set_packing(gsm0610_state_t *s, int packing) SPAN_DECLARE(int) gsm0610_set_packing(gsm0610_state_t *s, int packing)
{ {
s->packing = packing; s->packing = packing;
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_release(gsm0610_state_t *s) SPAN_DECLARE(int) gsm0610_release(gsm0610_state_t *s)
{ {
if (s) if (s)
free(s); free(s);
@ -137,7 +137,7 @@ int gsm0610_release(gsm0610_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_pack_none(uint8_t c[], const gsm0610_frame_t *s) SPAN_DECLARE(int) gsm0610_pack_none(uint8_t c[], const gsm0610_frame_t *s)
{ {
int i; int i;
int j; int j;
@ -160,7 +160,7 @@ int gsm0610_pack_none(uint8_t c[], const gsm0610_frame_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_pack_wav49(uint8_t c[], const gsm0610_frame_t *s) SPAN_DECLARE(int) gsm0610_pack_wav49(uint8_t c[], const gsm0610_frame_t *s)
{ {
uint16_t sr; uint16_t sr;
int i; int i;
@ -255,7 +255,7 @@ int gsm0610_pack_wav49(uint8_t c[], const gsm0610_frame_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_pack_voip(uint8_t c[33], const gsm0610_frame_t *s) SPAN_DECLARE(int) gsm0610_pack_voip(uint8_t c[33], const gsm0610_frame_t *s)
{ {
int i; int i;
@ -302,7 +302,7 @@ int gsm0610_pack_voip(uint8_t c[33], const gsm0610_frame_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int gsm0610_encode(gsm0610_state_t *s, uint8_t code[], const int16_t amp[], int len) SPAN_DECLARE(int) gsm0610_encode(gsm0610_state_t *s, uint8_t code[], const int16_t amp[], int len)
{ {
gsm0610_frame_t frame[2]; gsm0610_frame_t frame[2];
int bytes; int bytes;

32
libs/spandsp/src/hdlc.c
View File

@ -243,7 +243,7 @@ static __inline__ void hdlc_rx_put_bit_core(hdlc_rx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void hdlc_rx_put_bit(hdlc_rx_state_t *s, int new_bit) SPAN_DECLARE(void) hdlc_rx_put_bit(hdlc_rx_state_t *s, int new_bit)
{ {
if (new_bit < 0) if (new_bit < 0)
{ {
@ -255,7 +255,7 @@ void hdlc_rx_put_bit(hdlc_rx_state_t *s, int new_bit)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void hdlc_rx_put_byte(hdlc_rx_state_t *s, int new_byte) SPAN_DECLARE(void) hdlc_rx_put_byte(hdlc_rx_state_t *s, int new_byte)
{ {
int i; int i;
@ -273,7 +273,7 @@ void hdlc_rx_put_byte(hdlc_rx_state_t *s, int new_byte)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void hdlc_rx_put(hdlc_rx_state_t *s, const uint8_t buf[], int len) SPAN_DECLARE(void) hdlc_rx_put(hdlc_rx_state_t *s, const uint8_t buf[], int len)
{ {
int i; int i;
@ -282,20 +282,20 @@ void hdlc_rx_put(hdlc_rx_state_t *s, const uint8_t buf[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void hdlc_rx_set_max_frame_len(hdlc_rx_state_t *s, size_t max_len) SPAN_DECLARE(void) hdlc_rx_set_max_frame_len(hdlc_rx_state_t *s, size_t max_len)
{ {
max_len += s->crc_bytes; max_len += s->crc_bytes;
s->max_frame_len = (max_len <= sizeof(s->buffer)) ? max_len : sizeof(s->buffer); s->max_frame_len = (max_len <= sizeof(s->buffer)) ? max_len : sizeof(s->buffer);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void hdlc_rx_set_octet_counting_report_interval(hdlc_rx_state_t *s, int interval) SPAN_DECLARE(void) hdlc_rx_set_octet_counting_report_interval(hdlc_rx_state_t *s, int interval)
{ {
s->octet_count_report_interval = interval; s->octet_count_report_interval = interval;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
hdlc_rx_state_t *hdlc_rx_init(hdlc_rx_state_t *s, SPAN_DECLARE(hdlc_rx_state_t *) hdlc_rx_init(hdlc_rx_state_t *s,
int crc32, int crc32,
int report_bad_frames, int report_bad_frames,
int framing_ok_threshold, int framing_ok_threshold,
@ -318,7 +318,7 @@ hdlc_rx_state_t *hdlc_rx_init(hdlc_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_rx_get_stats(hdlc_rx_state_t *s, SPAN_DECLARE(int) hdlc_rx_get_stats(hdlc_rx_state_t *s,
hdlc_rx_stats_t *t) hdlc_rx_stats_t *t)
{ {
t->bytes = s->rx_bytes; t->bytes = s->rx_bytes;
@ -330,7 +330,7 @@ int hdlc_rx_get_stats(hdlc_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_tx_frame(hdlc_tx_state_t *s, const uint8_t *frame, size_t len) SPAN_DECLARE(int) hdlc_tx_frame(hdlc_tx_state_t *s, const uint8_t *frame, size_t len)
{ {
if (len <= 0) if (len <= 0)
{ {
@ -365,7 +365,7 @@ int hdlc_tx_frame(hdlc_tx_state_t *s, const uint8_t *frame, size_t len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_tx_flags(hdlc_tx_state_t *s, int len) SPAN_DECLARE(int) hdlc_tx_flags(hdlc_tx_state_t *s, int len)
{ {
/* Some HDLC applications require the ability to force a period of HDLC /* Some HDLC applications require the ability to force a period of HDLC
flag words. */ flag words. */
@ -381,7 +381,7 @@ int hdlc_tx_flags(hdlc_tx_state_t *s, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_tx_abort(hdlc_tx_state_t *s) SPAN_DECLARE(int) hdlc_tx_abort(hdlc_tx_state_t *s)
{ {
/* TODO: This is a really crude way of just fudging an abort out for simple /* TODO: This is a really crude way of just fudging an abort out for simple
test purposes. */ test purposes. */
@ -391,7 +391,7 @@ int hdlc_tx_abort(hdlc_tx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_tx_corrupt_frame(hdlc_tx_state_t *s) SPAN_DECLARE(int) hdlc_tx_corrupt_frame(hdlc_tx_state_t *s)
{ {
if (s->len <= 0) if (s->len <= 0)
return -1; return -1;
@ -404,7 +404,7 @@ int hdlc_tx_corrupt_frame(hdlc_tx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_tx_get_byte(hdlc_tx_state_t *s) SPAN_DECLARE(int) hdlc_tx_get_byte(hdlc_tx_state_t *s)
{ {
int i; int i;
int byte_in_progress; int byte_in_progress;
@ -509,7 +509,7 @@ int hdlc_tx_get_byte(hdlc_tx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_tx_get_bit(hdlc_tx_state_t *s) SPAN_DECLARE(int) hdlc_tx_get_bit(hdlc_tx_state_t *s)
{ {
int txbit; int txbit;
@ -525,7 +525,7 @@ int hdlc_tx_get_bit(hdlc_tx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int hdlc_tx_get(hdlc_tx_state_t *s, uint8_t buf[], size_t max_len) SPAN_DECLARE(int) hdlc_tx_get(hdlc_tx_state_t *s, uint8_t buf[], size_t max_len)
{ {
size_t i; size_t i;
int x; int x;
@ -540,13 +540,13 @@ int hdlc_tx_get(hdlc_tx_state_t *s, uint8_t buf[], size_t max_len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void hdlc_tx_set_max_frame_len(hdlc_tx_state_t *s, size_t max_len) SPAN_DECLARE(void) hdlc_tx_set_max_frame_len(hdlc_tx_state_t *s, size_t max_len)
{ {
s->max_frame_len = (max_len <= HDLC_MAXFRAME_LEN) ? max_len : HDLC_MAXFRAME_LEN; s->max_frame_len = (max_len <= HDLC_MAXFRAME_LEN) ? max_len : HDLC_MAXFRAME_LEN;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
hdlc_tx_state_t *hdlc_tx_init(hdlc_tx_state_t *s, SPAN_DECLARE(hdlc_tx_state_t *) hdlc_tx_init(hdlc_tx_state_t *s,
int crc32, int crc32,
int inter_frame_flags, int inter_frame_flags,
int progressive, int progressive,

8
libs/spandsp/src/ima_adpcm.c
View File

@ -276,7 +276,7 @@ static uint8_t encode(ima_adpcm_state_t *s, int16_t linear)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
ima_adpcm_state_t *ima_adpcm_init(ima_adpcm_state_t *s, int variant, int chunk_size) SPAN_DECLARE(ima_adpcm_state_t *) ima_adpcm_init(ima_adpcm_state_t *s, int variant, int chunk_size)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -291,14 +291,14 @@ ima_adpcm_state_t *ima_adpcm_init(ima_adpcm_state_t *s, int variant, int chunk_s
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int ima_adpcm_release(ima_adpcm_state_t *s) SPAN_DECLARE(int) ima_adpcm_release(ima_adpcm_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int ima_adpcm_decode(ima_adpcm_state_t *s, SPAN_DECLARE(int) ima_adpcm_decode(ima_adpcm_state_t *s,
int16_t amp[], int16_t amp[],
const uint8_t ima_data[], const uint8_t ima_data[],
int ima_bytes) int ima_bytes)
@ -414,7 +414,7 @@ int ima_adpcm_decode(ima_adpcm_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int ima_adpcm_encode(ima_adpcm_state_t *s, SPAN_DECLARE(int) ima_adpcm_encode(ima_adpcm_state_t *s,
uint8_t ima_data[], uint8_t ima_data[],
const int16_t amp[], const int16_t amp[],
int len) int len)

1030
libs/spandsp/src/libspandsp.vcproj
View File

File diff suppressed because it is too large Load Diff

24
libs/spandsp/src/logging.c
View File

@ -75,7 +75,7 @@ static void default_message_handler(int level, const char *text)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_test(logging_state_t *s, int level) SPAN_DECLARE(int) span_log_test(logging_state_t *s, int level)
{ {
if (s && (s->level & SPAN_LOG_SEVERITY_MASK) >= (level & SPAN_LOG_SEVERITY_MASK)) if (s && (s->level & SPAN_LOG_SEVERITY_MASK) >= (level & SPAN_LOG_SEVERITY_MASK))
return TRUE; return TRUE;
@ -157,7 +157,7 @@ int span_log(logging_state_t *s, int level, const char *format, ...)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_buf(logging_state_t *s, int level, const char *tag, const uint8_t *buf, int len) SPAN_DECLARE(int) span_log_buf(logging_state_t *s, int level, const char *tag, const uint8_t *buf, int len)
{ {
char msg[1024]; char msg[1024];
int i; int i;
@ -177,7 +177,7 @@ int span_log_buf(logging_state_t *s, int level, const char *tag, const uint8_t *
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_init(logging_state_t *s, int level, const char *tag) SPAN_DECLARE(int) span_log_init(logging_state_t *s, int level, const char *tag)
{ {
s->span_error = __span_error; s->span_error = __span_error;
s->span_message = __span_message; s->span_message = __span_message;
@ -191,7 +191,7 @@ int span_log_init(logging_state_t *s, int level, const char *tag)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_set_level(logging_state_t *s, int level) SPAN_DECLARE(int) span_log_set_level(logging_state_t *s, int level)
{ {
s->level = level; s->level = level;
@ -199,7 +199,7 @@ int span_log_set_level(logging_state_t *s, int level)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_set_tag(logging_state_t *s, const char *tag) SPAN_DECLARE(int) span_log_set_tag(logging_state_t *s, const char *tag)
{ {
s->tag = tag; s->tag = tag;
@ -207,7 +207,7 @@ int span_log_set_tag(logging_state_t *s, const char *tag)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_set_protocol(logging_state_t *s, const char *protocol) SPAN_DECLARE(int) span_log_set_protocol(logging_state_t *s, const char *protocol)
{ {
s->protocol = protocol; s->protocol = protocol;
@ -215,7 +215,7 @@ int span_log_set_protocol(logging_state_t *s, const char *protocol)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_set_sample_rate(logging_state_t *s, int samples_per_second) SPAN_DECLARE(int) span_log_set_sample_rate(logging_state_t *s, int samples_per_second)
{ {
s->samples_per_second = samples_per_second; s->samples_per_second = samples_per_second;
@ -223,7 +223,7 @@ int span_log_set_sample_rate(logging_state_t *s, int samples_per_second)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_log_bump_samples(logging_state_t *s, int samples) SPAN_DECLARE(int) span_log_bump_samples(logging_state_t *s, int samples)
{ {
s->elapsed_samples += samples; s->elapsed_samples += samples;
@ -231,25 +231,25 @@ int span_log_bump_samples(logging_state_t *s, int samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void span_log_set_message_handler(logging_state_t *s, message_handler_func_t func) SPAN_DECLARE(void) span_log_set_message_handler(logging_state_t *s, message_handler_func_t func)
{ {
s->span_message = func; s->span_message = func;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void span_log_set_error_handler(logging_state_t *s, error_handler_func_t func) SPAN_DECLARE(void) span_log_set_error_handler(logging_state_t *s, error_handler_func_t func)
{ {
s->span_error = func; s->span_error = func;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void span_set_message_handler(message_handler_func_t func) SPAN_DECLARE(void) span_set_message_handler(message_handler_func_t func)
{ {
__span_message = func; __span_message = func;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void span_set_error_handler(error_handler_func_t func) SPAN_DECLARE(void) span_set_error_handler(error_handler_func_t func)
{ {
__span_error = func; __span_error = func;
} }

6
libs/spandsp/src/lpc10_decode.c
View File

@ -999,7 +999,7 @@ static void decode(lpc10_decode_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
lpc10_decode_state_t *lpc10_decode_init(lpc10_decode_state_t *s, int error_correction) SPAN_DECLARE(lpc10_decode_state_t *) lpc10_decode_init(lpc10_decode_state_t *s, int error_correction)
{ {
static const int16_t rand_init[] = static const int16_t rand_init[] =
{ {
@ -1074,14 +1074,14 @@ lpc10_decode_state_t *lpc10_decode_init(lpc10_decode_state_t *s, int error_corre
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int lpc10_decode_release(lpc10_decode_state_t *s) SPAN_DECLARE(int) lpc10_decode_release(lpc10_decode_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int lpc10_decode(lpc10_decode_state_t *s, int16_t amp[], const uint8_t code[], int len) SPAN_DECLARE(int) lpc10_decode(lpc10_decode_state_t *s, int16_t amp[], const uint8_t code[], int len)
{ {
int voice[2]; int voice[2];
int32_t pitch; int32_t pitch;

6
libs/spandsp/src/lpc10_encode.c
View File

@ -266,7 +266,7 @@ static void high_pass_100hz(lpc10_encode_state_t *s, float speech[], int start,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
lpc10_encode_state_t *lpc10_encode_init(lpc10_encode_state_t *s, int error_correction) SPAN_DECLARE(lpc10_encode_state_t *) lpc10_encode_init(lpc10_encode_state_t *s, int error_correction)
{ {
int i; int i;
int j; int j;
@ -363,14 +363,14 @@ lpc10_encode_state_t *lpc10_encode_init(lpc10_encode_state_t *s, int error_corre
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int lpc10_encode_release(lpc10_encode_state_t *s) SPAN_DECLARE(int) lpc10_encode_release(lpc10_encode_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int lpc10_encode(lpc10_encode_state_t *s, uint8_t code[], const int16_t amp[], int len) SPAN_DECLARE(int) lpc10_encode(lpc10_encode_state_t *s, uint8_t code[], const int16_t amp[], int len)
{ {
int32_t voice[2]; int32_t voice[2];
int32_t pitch; int32_t pitch;

16
libs/spandsp/src/modem_connect_tones.c
View File

@ -61,7 +61,7 @@
#define HDLC_FRAMING_OK_THRESHOLD 5 #define HDLC_FRAMING_OK_THRESHOLD 5
const char *modem_connect_tone_to_str(int tone) SPAN_DECLARE(const char *) modem_connect_tone_to_str(int tone)
{ {
switch (tone) switch (tone)
{ {
@ -86,7 +86,7 @@ const char *modem_connect_tone_to_str(int tone)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int modem_connect_tones_tx(modem_connect_tones_tx_state_t *s, SPAN_DECLARE(int) modem_connect_tones_tx(modem_connect_tones_tx_state_t *s,
int16_t amp[], int16_t amp[],
int len) int len)
{ {
@ -196,7 +196,7 @@ int modem_connect_tones_tx(modem_connect_tones_tx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
modem_connect_tones_tx_state_t *modem_connect_tones_tx_init(modem_connect_tones_tx_state_t *s, SPAN_DECLARE(modem_connect_tones_tx_state_t *) modem_connect_tones_tx_init(modem_connect_tones_tx_state_t *s,
int tone_type) int tone_type)
{ {
int alloced; int alloced;
@ -252,7 +252,7 @@ modem_connect_tones_tx_state_t *modem_connect_tones_tx_init(modem_connect_tones_
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int modem_connect_tones_tx_free(modem_connect_tones_tx_state_t *s) SPAN_DECLARE(int) modem_connect_tones_tx_free(modem_connect_tones_tx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
@ -347,7 +347,7 @@ static void v21_put_bit(void *user_data, int bit)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int modem_connect_tones_rx(modem_connect_tones_rx_state_t *s, const int16_t amp[], int len) SPAN_DECLARE(int) modem_connect_tones_rx(modem_connect_tones_rx_state_t *s, const int16_t amp[], int len)
{ {
int i; int i;
int16_t notched; int16_t notched;
@ -489,7 +489,7 @@ int modem_connect_tones_rx(modem_connect_tones_rx_state_t *s, const int16_t amp[
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int modem_connect_tones_rx_get(modem_connect_tones_rx_state_t *s) SPAN_DECLARE(int) modem_connect_tones_rx_get(modem_connect_tones_rx_state_t *s)
{ {
int x; int x;
@ -499,7 +499,7 @@ int modem_connect_tones_rx_get(modem_connect_tones_rx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
modem_connect_tones_rx_state_t *modem_connect_tones_rx_init(modem_connect_tones_rx_state_t *s, SPAN_DECLARE(modem_connect_tones_rx_state_t *) modem_connect_tones_rx_init(modem_connect_tones_rx_state_t *s,
int tone_type, int tone_type,
tone_report_func_t tone_callback, tone_report_func_t tone_callback,
void *user_data) void *user_data)
@ -543,7 +543,7 @@ modem_connect_tones_rx_state_t *modem_connect_tones_rx_init(modem_connect_tones_
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int modem_connect_tones_rx_free(modem_connect_tones_rx_state_t *s) SPAN_DECLARE(int) modem_connect_tones_rx_free(modem_connect_tones_rx_state_t *s)
{ {
free(s); free(s);
return 0; return 0;

10
libs/spandsp/src/modem_echo.c
View File

@ -53,7 +53,7 @@
#include "spandsp/dc_restore.h" #include "spandsp/dc_restore.h"
#include "spandsp/modem_echo.h" #include "spandsp/modem_echo.h"
modem_echo_can_state_t *modem_echo_can_create(int len) SPAN_DECLARE(modem_echo_can_state_t *) modem_echo_can_create(int len)
{ {
modem_echo_can_state_t *ec; modem_echo_can_state_t *ec;
@ -86,7 +86,7 @@ modem_echo_can_state_t *modem_echo_can_create(int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void modem_echo_can_free(modem_echo_can_state_t *ec) SPAN_DECLARE(void) modem_echo_can_free(modem_echo_can_state_t *ec)
{ {
fir16_free(&ec->fir_state); fir16_free(&ec->fir_state);
free(ec->fir_taps32); free(ec->fir_taps32);
@ -95,7 +95,7 @@ void modem_echo_can_free(modem_echo_can_state_t *ec)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void modem_echo_can_flush(modem_echo_can_state_t *ec) SPAN_DECLARE(void) modem_echo_can_flush(modem_echo_can_state_t *ec)
{ {
ec->tx_power = 0; ec->tx_power = 0;
@ -107,13 +107,13 @@ void modem_echo_can_flush(modem_echo_can_state_t *ec)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void modem_echo_can_adaption_mode(modem_echo_can_state_t *ec, int adapt) SPAN_DECLARE(void) modem_echo_can_adaption_mode(modem_echo_can_state_t *ec, int adapt)
{ {
ec->adapt = adapt; ec->adapt = adapt;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int16_t modem_echo_can_update(modem_echo_can_state_t *ec, int16_t tx, int16_t rx) SPAN_DECLARE(int16_t) modem_echo_can_update(modem_echo_can_state_t *ec, int16_t tx, int16_t rx)
{ {
int32_t echo_value; int32_t echo_value;
int clean_rx; int clean_rx;

2
libs/spandsp/src/msvc/config.h
View File

@ -32,6 +32,8 @@
#define HAVE_MATH_H #define HAVE_MATH_H
#define HAVE_TGMATH_H #define HAVE_TGMATH_H
#define SPANDSP_USE_EXPORT_CAPABILITY 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif

1
libs/spandsp/src/msvc/spandsp.h
View File

@ -33,7 +33,6 @@
#undef SPANDSP_USE_FIXED_POINT #undef SPANDSP_USE_FIXED_POINT
#undef SPANDSP_MISALIGNED_ACCESS_FAILS #undef SPANDSP_MISALIGNED_ACCESS_FAILS
#define SPANDSP_USE_EXPORT_CAPABILITY 1
#include <stdlib.h> #include <stdlib.h>
#include <inttypes.h> #include <inttypes.h>

102
libs/spandsp/src/msvc/vc8proj.head
View File

@ -3,7 +3,7 @@
ProjectType="Visual C++" ProjectType="Visual C++"
Version="9.00" Version="9.00"
Name="libspandsp" Name="libspandsp"
ProjectGUID="{CF70F278-3364-4395-A2E1-23501C9B8AD2}" ProjectGUID="{1CBB0077-18C5-455F-801C-0A0CE7B0BBF5}"
RootNamespace="libspandsp" RootNamespace="libspandsp"
Keyword="Win32Proj" Keyword="Win32Proj"
TargetFrameworkVersion="131072" TargetFrameworkVersion="131072"
@ -18,30 +18,15 @@
<Configurations> <Configurations>
<Configuration <Configuration
Name="Debug|Win32" Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)" OutputDirectory="$(SolutionDir)Debug"
IntermediateDirectory="$(ConfigurationName)" IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2" ConfigurationType="2"
CharacterSet="1" CharacterSet="1"
> >
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories=".;.\spandsp;.\msvc;.\generated;..\..\tiff\libtiff" AdditionalIncludeDirectories=".;.\spandsp;.\msvc;..\..\tiff-3.8.2\libtiff;.\generated"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBSPANDSP_EXPORTS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;HAVE_CONFIG_H" PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBSPANDSP_EXPORTS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;HAVE_CONFIG_H"
MinimalRebuild="true" MinimalRebuild="true"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
@ -52,15 +37,6 @@
CompileAs="1" CompileAs="1"
DisableSpecificWarnings="4127" DisableSpecificWarnings="4127"
/> />
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
LinkIncremental="2" LinkIncremental="2"
@ -68,56 +44,21 @@
SubSystem="2" SubSystem="2"
RandomizedBaseAddress="1" RandomizedBaseAddress="1"
DataExecutionPrevention="0" DataExecutionPrevention="0"
ImportLibrary="./Debug\spandsp.lib"
TargetMachine="1" TargetMachine="1"
/> />
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration> </Configuration>
<Configuration <Configuration
Name="Release|Win32" Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)" OutputDirectory="$(SolutionDir)Release"
IntermediateDirectory="$(ConfigurationName)" IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2" ConfigurationType="2"
CharacterSet="1" CharacterSet="1"
WholeProgramOptimization="1" WholeProgramOptimization="1"
> >
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool <Tool
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
AdditionalIncludeDirectories=".;.\spandsp;.\msvc;.\generated;..\..\tiff\libtiff" AdditionalIncludeDirectories=".;.\spandsp;.\msvc;..\..\tiff-3.8.2\libtiff;.\generated"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBSPANDSP_EXPORTS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;HAVE_CONFIG_H" PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBSPANDSP_EXPORTS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;HAVE_CONFIG_H"
RuntimeLibrary="2" RuntimeLibrary="2"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
@ -125,15 +66,6 @@
DebugInformationFormat="3" DebugInformationFormat="3"
DisableSpecificWarnings="4127" DisableSpecificWarnings="4127"
/> />
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
LinkIncremental="1" LinkIncremental="1"
@ -143,29 +75,9 @@
EnableCOMDATFolding="2" EnableCOMDATFolding="2"
RandomizedBaseAddress="1" RandomizedBaseAddress="1"
DataExecutionPrevention="0" DataExecutionPrevention="0"
ImportLibrary="./Release\spandsp.lib"
TargetMachine="1" TargetMachine="1"
/> />
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration> </Configuration>
</Configurations> </Configurations>
<References> <References>

8
libs/spandsp/src/noise.c
View File

@ -50,7 +50,7 @@
#include "spandsp/private/noise.h" #include "spandsp/private/noise.h"
int16_t noise(noise_state_t *s) SPAN_DECLARE(int16_t) noise(noise_state_t *s)
{ {
int32_t val; int32_t val;
int i; int i;
@ -79,13 +79,13 @@ int16_t noise(noise_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
noise_state_t *noise_init_dbm0(noise_state_t *s, int seed, float level, int class_of_noise, int quality) SPAN_DECLARE(noise_state_t *) noise_init_dbm0(noise_state_t *s, int seed, float level, int class_of_noise, int quality)
{ {
return noise_init_dbov(s, seed, (level - DBM0_MAX_POWER), class_of_noise, quality); return noise_init_dbov(s, seed, (level - DBM0_MAX_POWER), class_of_noise, quality);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
noise_state_t *noise_init_dbov(noise_state_t *s, int seed, float level, int class_of_noise, int quality) SPAN_DECLARE(noise_state_t *) noise_init_dbov(noise_state_t *s, int seed, float level, int class_of_noise, int quality)
{ {
float rms; float rms;
@ -114,7 +114,7 @@ noise_state_t *noise_init_dbov(noise_state_t *s, int seed, float level, int clas
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int noise_free(noise_state_t *s) SPAN_DECLARE(int) noise_free(noise_state_t *s)
{ {
free(s); free(s);
return 0; return 0;

8
libs/spandsp/src/oki_adpcm.c
View File

@ -242,7 +242,7 @@ static uint8_t encode(oki_adpcm_state_t *s, int16_t linear)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
oki_adpcm_state_t *oki_adpcm_init(oki_adpcm_state_t *s, int bit_rate) SPAN_DECLARE(oki_adpcm_state_t *) oki_adpcm_init(oki_adpcm_state_t *s, int bit_rate)
{ {
if (bit_rate != 32000 && bit_rate != 24000) if (bit_rate != 32000 && bit_rate != 24000)
return NULL; return NULL;
@ -258,14 +258,14 @@ oki_adpcm_state_t *oki_adpcm_init(oki_adpcm_state_t *s, int bit_rate)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int oki_adpcm_release(oki_adpcm_state_t *s) SPAN_DECLARE(int) oki_adpcm_release(oki_adpcm_state_t *s)
{ {
free(s); free(s);
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int oki_adpcm_decode(oki_adpcm_state_t *s, SPAN_DECLARE(int) oki_adpcm_decode(oki_adpcm_state_t *s,
int16_t amp[], int16_t amp[],
const uint8_t oki_data[], const uint8_t oki_data[],
int oki_bytes) int oki_bytes)
@ -318,7 +318,7 @@ int oki_adpcm_decode(oki_adpcm_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int oki_adpcm_encode(oki_adpcm_state_t *s, SPAN_DECLARE(int) oki_adpcm_encode(oki_adpcm_state_t *s,
uint8_t oki_data[], uint8_t oki_data[],
const int16_t amp[], const int16_t amp[],
int len) int len)

16
libs/spandsp/src/playout.c
View File

@ -73,19 +73,19 @@ static playout_frame_t *queue_get(playout_state_t *s, timestamp_t sender_stamp)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
timestamp_t playout_next_due(playout_state_t *s) SPAN_DECLARE(timestamp_t) playout_next_due(playout_state_t *s)
{ {
return s->last_speech_sender_stamp + s->last_speech_sender_len; return s->last_speech_sender_stamp + s->last_speech_sender_len;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
timestamp_t playout_current_length(playout_state_t *s) SPAN_DECLARE(timestamp_t) playout_current_length(playout_state_t *s)
{ {
return s->target_buffer_length; return s->target_buffer_length;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
playout_frame_t *playout_get_unconditional(playout_state_t *s) SPAN_DECLARE(playout_frame_t *) playout_get_unconditional(playout_state_t *s)
{ {
playout_frame_t *frame; playout_frame_t *frame;
@ -103,7 +103,7 @@ playout_frame_t *playout_get_unconditional(playout_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int playout_get(playout_state_t *s, playout_frame_t *frameout, timestamp_t now) SPAN_DECLARE(int) playout_get(playout_state_t *s, playout_frame_t *frameout, timestamp_t now)
{ {
playout_frame_t *frame; playout_frame_t *frame;
@ -222,7 +222,7 @@ int playout_get(playout_state_t *s, playout_frame_t *frameout, timestamp_t now)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int playout_put(playout_state_t *s, void *data, int type, timestamp_t sender_len, timestamp_t sender_stamp, timestamp_t receiver_stamp) SPAN_DECLARE(int) playout_put(playout_state_t *s, void *data, int type, timestamp_t sender_len, timestamp_t sender_stamp, timestamp_t receiver_stamp)
{ {
playout_frame_t *frame; playout_frame_t *frame;
playout_frame_t *p; playout_frame_t *p;
@ -305,7 +305,7 @@ int playout_put(playout_state_t *s, void *data, int type, timestamp_t sender_len
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void playout_restart(playout_state_t *s, int min_length, int max_length) SPAN_DECLARE(void) playout_restart(playout_state_t *s, int min_length, int max_length)
{ {
playout_frame_t *frame; playout_frame_t *frame;
playout_frame_t *next; playout_frame_t *next;
@ -330,7 +330,7 @@ void playout_restart(playout_state_t *s, int min_length, int max_length)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
playout_state_t *playout_new(int min_length, int max_length) SPAN_DECLARE(playout_state_t *) playout_new(int min_length, int max_length)
{ {
playout_state_t *s; playout_state_t *s;
@ -342,7 +342,7 @@ playout_state_t *playout_new(int min_length, int max_length)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void playout_free(playout_state_t *s) SPAN_DECLARE(void) playout_free(playout_state_t *s)
{ {
playout_frame_t *frame; playout_frame_t *frame;
playout_frame_t *next; playout_frame_t *next;

8
libs/spandsp/src/plc.c
View File

@ -115,7 +115,7 @@ static __inline__ int amdf_pitch(int min_pitch, int max_pitch, int16_t amp[], in
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int plc_rx(plc_state_t *s, int16_t amp[], int len) SPAN_DECLARE(int) plc_rx(plc_state_t *s, int16_t amp[], int len)
{ {
int i; int i;
int pitch_overlap; int pitch_overlap;
@ -159,7 +159,7 @@ int plc_rx(plc_state_t *s, int16_t amp[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int plc_fillin(plc_state_t *s, int16_t amp[], int len) SPAN_DECLARE(int) plc_fillin(plc_state_t *s, int16_t amp[], int len)
{ {
int i; int i;
int pitch_overlap; int pitch_overlap;
@ -235,7 +235,7 @@ int plc_fillin(plc_state_t *s, int16_t amp[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
plc_state_t *plc_init(plc_state_t *s) SPAN_DECLARE(plc_state_t *) plc_init(plc_state_t *s)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -247,7 +247,7 @@ plc_state_t *plc_init(plc_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int plc_free(plc_state_t *s) SPAN_DECLARE(int) plc_free(plc_state_t *s)
{ {
if (s) if (s)
free(s); free(s);

16
libs/spandsp/src/power_meter.c
View File

@ -49,7 +49,7 @@
#include "spandsp/telephony.h" #include "spandsp/telephony.h"
#include "spandsp/power_meter.h" #include "spandsp/power_meter.h"
power_meter_t *power_meter_init(power_meter_t *s, int shift) SPAN_DECLARE(power_meter_t *) power_meter_init(power_meter_t *s, int shift)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -62,21 +62,21 @@ power_meter_t *power_meter_init(power_meter_t *s, int shift)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
power_meter_t *power_meter_damping(power_meter_t *s, int shift) SPAN_DECLARE(power_meter_t *) power_meter_damping(power_meter_t *s, int shift)
{ {
s->shift = shift; s->shift = shift;
return s; return s;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int32_t power_meter_update(power_meter_t *s, int16_t amp) SPAN_DECLARE(int32_t) power_meter_update(power_meter_t *s, int16_t amp)
{ {
s->reading += ((amp*amp - s->reading) >> s->shift); s->reading += ((amp*amp - s->reading) >> s->shift);
return s->reading; return s->reading;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int32_t power_meter_level_dbm0(float level) SPAN_DECLARE(int32_t) power_meter_level_dbm0(float level)
{ {
float l; float l;
@ -88,7 +88,7 @@ int32_t power_meter_level_dbm0(float level)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int32_t power_meter_level_dbov(float level) SPAN_DECLARE(int32_t) power_meter_level_dbov(float level)
{ {
float l; float l;
@ -99,13 +99,13 @@ int32_t power_meter_level_dbov(float level)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int32_t power_meter_current(power_meter_t *s) SPAN_DECLARE(int32_t) power_meter_current(power_meter_t *s)
{ {
return s->reading; return s->reading;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float power_meter_current_dbm0(power_meter_t *s) SPAN_DECLARE(float) power_meter_current_dbm0(power_meter_t *s)
{ {
if (s->reading <= 0) if (s->reading <= 0)
return FLT_MIN; return FLT_MIN;
@ -114,7 +114,7 @@ float power_meter_current_dbm0(power_meter_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
float power_meter_current_dbov(power_meter_t *s) SPAN_DECLARE(float) power_meter_current_dbov(power_meter_t *s)
{ {
if (s->reading <= 0) if (s->reading <= 0)
return FLT_MIN; return FLT_MIN;

28
libs/spandsp/src/queue.c
View File

@ -45,13 +45,13 @@
#include "spandsp/private/queue.h" #include "spandsp/private/queue.h"
int queue_empty(queue_state_t *s) SPAN_DECLARE(int) queue_empty(queue_state_t *s)
{ {
return (s->iptr == s->optr); return (s->iptr == s->optr);
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_free_space(queue_state_t *s) SPAN_DECLARE(int) queue_free_space(queue_state_t *s)
{ {
int len; int len;
@ -62,7 +62,7 @@ int queue_free_space(queue_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_contents(queue_state_t *s) SPAN_DECLARE(int) queue_contents(queue_state_t *s)
{ {
int len; int len;
@ -73,13 +73,13 @@ int queue_contents(queue_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void queue_flush(queue_state_t *s) SPAN_DECLARE(void) queue_flush(queue_state_t *s)
{ {
s->optr = s->iptr; s->optr = s->iptr;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_view(queue_state_t *s, uint8_t *buf, int len) SPAN_DECLARE(int) queue_view(queue_state_t *s, uint8_t *buf, int len)
{ {
int real_len; int real_len;
int to_end; int to_end;
@ -129,7 +129,7 @@ int queue_view(queue_state_t *s, uint8_t *buf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_read(queue_state_t *s, uint8_t *buf, int len) SPAN_DECLARE(int) queue_read(queue_state_t *s, uint8_t *buf, int len)
{ {
int real_len; int real_len;
int to_end; int to_end;
@ -187,7 +187,7 @@ int queue_read(queue_state_t *s, uint8_t *buf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_read_byte(queue_state_t *s) SPAN_DECLARE(int) queue_read_byte(queue_state_t *s)
{ {
int real_len; int real_len;
int to_end; int to_end;
@ -215,7 +215,7 @@ int queue_read_byte(queue_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_write(queue_state_t *s, const uint8_t *buf, int len) SPAN_DECLARE(int) queue_write(queue_state_t *s, const uint8_t *buf, int len)
{ {
int real_len; int real_len;
int to_end; int to_end;
@ -268,7 +268,7 @@ int queue_write(queue_state_t *s, const uint8_t *buf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_write_byte(queue_state_t *s, uint8_t byte) SPAN_DECLARE(int) queue_write_byte(queue_state_t *s, uint8_t byte)
{ {
int real_len; int real_len;
int iptr; int iptr;
@ -299,7 +299,7 @@ int queue_write_byte(queue_state_t *s, uint8_t byte)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_state_test_msg(queue_state_t *s) SPAN_DECLARE(int) queue_state_test_msg(queue_state_t *s)
{ {
uint16_t lenx; uint16_t lenx;
@ -310,7 +310,7 @@ int queue_state_test_msg(queue_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_read_msg(queue_state_t *s, uint8_t *buf, int len) SPAN_DECLARE(int) queue_read_msg(queue_state_t *s, uint8_t *buf, int len)
{ {
uint16_t lenx; uint16_t lenx;
@ -336,7 +336,7 @@ int queue_read_msg(queue_state_t *s, uint8_t *buf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_write_msg(queue_state_t *s, const uint8_t *buf, int len) SPAN_DECLARE(int) queue_write_msg(queue_state_t *s, const uint8_t *buf, int len)
{ {
int real_len; int real_len;
int to_end; int to_end;
@ -395,7 +395,7 @@ int queue_write_msg(queue_state_t *s, const uint8_t *buf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
queue_state_t *queue_init(queue_state_t *s, int len, int flags) SPAN_DECLARE(queue_state_t *) queue_init(queue_state_t *s, int len, int flags)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -410,7 +410,7 @@ queue_state_t *queue_init(queue_state_t *s, int len, int flags)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int queue_free(queue_state_t *s) SPAN_DECLARE(int) queue_free(queue_state_t *s)
{ {
free(s); free(s);
return 0; return 0;

14
libs/spandsp/src/schedule.c
View File

@ -41,7 +41,7 @@
#include "spandsp/private/logging.h" #include "spandsp/private/logging.h"
#include "spandsp/private/schedule.h" #include "spandsp/private/schedule.h"
int span_schedule_event(span_sched_state_t *s, int us, span_sched_callback_func_t function, void *user_data) SPAN_DECLARE(int) span_schedule_event(span_sched_state_t *s, int us, span_sched_callback_func_t function, void *user_data)
{ {
int i; int i;
@ -68,7 +68,7 @@ int span_schedule_event(span_sched_state_t *s, int us, span_sched_callback_func_
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
uint64_t span_schedule_next(span_sched_state_t *s) SPAN_DECLARE(uint64_t) span_schedule_next(span_sched_state_t *s)
{ {
int i; int i;
uint64_t earliest; uint64_t earliest;
@ -85,13 +85,13 @@ uint64_t span_schedule_next(span_sched_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
uint64_t span_schedule_time(span_sched_state_t *s) SPAN_DECLARE(uint64_t) span_schedule_time(span_sched_state_t *s)
{ {
return s->ticker; return s->ticker;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void span_schedule_update(span_sched_state_t *s, int us) SPAN_DECLARE(void) span_schedule_update(span_sched_state_t *s, int us)
{ {
int i; int i;
span_sched_callback_func_t callback; span_sched_callback_func_t callback;
@ -114,7 +114,7 @@ void span_schedule_update(span_sched_state_t *s, int us)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void span_schedule_del(span_sched_state_t *s, int i) SPAN_DECLARE(void) span_schedule_del(span_sched_state_t *s, int i)
{ {
if (i >= s->max_to_date if (i >= s->max_to_date
|| ||
@ -130,7 +130,7 @@ void span_schedule_del(span_sched_state_t *s, int i)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
span_sched_state_t *span_schedule_init(span_sched_state_t *s) SPAN_DECLARE(span_sched_state_t *) span_schedule_init(span_sched_state_t *s)
{ {
memset(s, 0, sizeof(*s)); memset(s, 0, sizeof(*s));
span_log_init(&s->logging, SPAN_LOG_NONE, NULL); span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
@ -139,7 +139,7 @@ span_sched_state_t *span_schedule_init(span_sched_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_schedule_release(span_sched_state_t *s) SPAN_DECLARE(int) span_schedule_release(span_sched_state_t *s)
{ {
if (s->sched) if (s->sched)
{ {

10
libs/spandsp/src/sig_tone.c
View File

@ -268,7 +268,7 @@ sig_tone_descriptor_t sig_tones[4] =
} }
}; };
int sig_tone_tx(sig_tone_tx_state_t *s, int16_t amp[], int len) SPAN_DECLARE(int) sig_tone_tx(sig_tone_tx_state_t *s, int16_t amp[], int len)
{ {
int i; int i;
int j; int j;
@ -347,7 +347,7 @@ int sig_tone_tx(sig_tone_tx_state_t *s, int16_t amp[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void sig_tone_tx_set_mode(sig_tone_tx_state_t *s, int mode) SPAN_DECLARE(void) sig_tone_tx_set_mode(sig_tone_tx_state_t *s, int mode)
{ {
if ((mode & 0x03) == 0x03 && !(s->current_tx_tone & SIG_TONE_1_PRESENT)) if ((mode & 0x03) == 0x03 && !(s->current_tx_tone & SIG_TONE_1_PRESENT))
s->high_low_timer = s->desc->high_low_timeout; s->high_low_timer = s->desc->high_low_timeout;
@ -357,7 +357,7 @@ void sig_tone_tx_set_mode(sig_tone_tx_state_t *s, int mode)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
sig_tone_tx_state_t *sig_tone_tx_init(sig_tone_tx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data) SPAN_DECLARE(sig_tone_tx_state_t *) sig_tone_tx_init(sig_tone_tx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data)
{ {
int i; int i;
@ -389,7 +389,7 @@ sig_tone_tx_state_t *sig_tone_tx_init(sig_tone_tx_state_t *s, int tone_type, sig
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int sig_tone_rx(sig_tone_rx_state_t *s, int16_t amp[], int len) SPAN_DECLARE(int) sig_tone_rx(sig_tone_rx_state_t *s, int16_t amp[], int len)
{ {
#if defined(SPANDSP_USE_FIXED_POINT) #if defined(SPANDSP_USE_FIXED_POINT)
int32_t x; int32_t x;
@ -648,7 +648,7 @@ int sig_tone_rx(sig_tone_rx_state_t *s, int16_t amp[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
sig_tone_rx_state_t *sig_tone_rx_init(sig_tone_rx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data) SPAN_DECLARE(sig_tone_rx_state_t *) sig_tone_rx_init(sig_tone_rx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data)
{ {
if (sig_update == NULL || tone_type < 1 || tone_type > 3) if (sig_update == NULL || tone_type < 1 || tone_type > 3)
return NULL; return NULL;

18
libs/spandsp/src/silence_gen.c
View File

@ -51,7 +51,7 @@
#include "spandsp/async.h" #include "spandsp/async.h"
#include "spandsp/silence_gen.h" #include "spandsp/silence_gen.h"
int silence_gen(silence_gen_state_t *s, int16_t *amp, int max_len) SPAN_DECLARE(int) silence_gen(silence_gen_state_t *s, int16_t *amp, int max_len)
{ {
if (s->remaining_samples != INT_MAX) if (s->remaining_samples != INT_MAX)
{ {
@ -70,20 +70,20 @@ int silence_gen(silence_gen_state_t *s, int16_t *amp, int max_len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void silence_gen_always(silence_gen_state_t *s) SPAN_DECLARE(void) silence_gen_always(silence_gen_state_t *s)
{ {
s->remaining_samples = INT_MAX; s->remaining_samples = INT_MAX;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void silence_gen_set(silence_gen_state_t *s, int silent_samples) SPAN_DECLARE(void) silence_gen_set(silence_gen_state_t *s, int silent_samples)
{ {
s->remaining_samples = silent_samples; s->remaining_samples = silent_samples;
s->total_samples = 0; s->total_samples = 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void silence_gen_alter(silence_gen_state_t *s, int silent_samples) SPAN_DECLARE(void) silence_gen_alter(silence_gen_state_t *s, int silent_samples)
{ {
/* Block negative silences */ /* Block negative silences */
if (silent_samples < 0) if (silent_samples < 0)
@ -96,26 +96,26 @@ void silence_gen_alter(silence_gen_state_t *s, int silent_samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int silence_gen_remainder(silence_gen_state_t *s) SPAN_DECLARE(int) silence_gen_remainder(silence_gen_state_t *s)
{ {
return s->remaining_samples; return s->remaining_samples;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int silence_gen_generated(silence_gen_state_t *s) SPAN_DECLARE(int) silence_gen_generated(silence_gen_state_t *s)
{ {
return s->total_samples; return s->total_samples;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void silence_gen_status_handler(silence_gen_state_t *s, modem_tx_status_func_t handler, void *user_data) SPAN_DECLARE(void) silence_gen_status_handler(silence_gen_state_t *s, modem_tx_status_func_t handler, void *user_data)
{ {
s->status_handler = handler; s->status_handler = handler;
s->status_user_data = user_data; s->status_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
silence_gen_state_t *silence_gen_init(silence_gen_state_t *s, int silent_samples) SPAN_DECLARE(silence_gen_state_t *) silence_gen_init(silence_gen_state_t *s, int silent_samples)
{ {
if (s == NULL) if (s == NULL)
{ {
@ -137,7 +137,7 @@ int span_dummy_rx(void *user_data, const int16_t amp[], int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int span_dummy_mod(void *user_data, int16_t amp[], int len) SPAN_DECLARE(int) span_dummy_mod(void *user_data, int16_t amp[], int len)
{ {
return len; return len;
} }

6
libs/spandsp/src/spandsp/adsi.h
View File

@ -392,7 +392,7 @@ extern "C"
\param user_data An opaque pointer for the callback routine. \param user_data An opaque pointer for the callback routine.
\return A pointer to the initialised context, or NULL if there was a problem. \return A pointer to the initialised context, or NULL if there was a problem.
*/ */
SPAN_DECLARE(adsi_rx_state_t) *adsi_rx_init(adsi_rx_state_t *s, int standard, put_msg_func_t put_msg, void *user_data); SPAN_DECLARE(adsi_rx_state_t *) adsi_rx_init(adsi_rx_state_t *s, int standard, put_msg_func_t put_msg, void *user_data);
SPAN_DECLARE(int) adsi_rx_free(adsi_rx_state_t *s); SPAN_DECLARE(int) adsi_rx_free(adsi_rx_state_t *s);
@ -409,7 +409,7 @@ SPAN_DECLARE(int) adsi_rx(adsi_rx_state_t *s, const int16_t *amp, int len);
\param standard The code for the ADSI standard to be used. \param standard The code for the ADSI standard to be used.
\return A pointer to the initialised context, or NULL if there was a problem. \return A pointer to the initialised context, or NULL if there was a problem.
*/ */
SPAN_DECLARE(adsi_tx_state_t) *adsi_tx_init(adsi_tx_state_t *s, int standard); SPAN_DECLARE(adsi_tx_state_t *) adsi_tx_init(adsi_tx_state_t *s, int standard);
SPAN_DECLARE(int) adsi_tx_free(adsi_tx_state_t *s); SPAN_DECLARE(int) adsi_tx_free(adsi_tx_state_t *s);
@ -474,7 +474,7 @@ SPAN_DECLARE(int) adsi_add_field(adsi_tx_state_t *s, uint8_t *msg, int len, uint
\param standard The code for the standard. \param standard The code for the standard.
\return A pointer to the name. \return A pointer to the name.
*/ */
SPAN_DECLARE(const char) *adsi_standard_to_str(int standard); SPAN_DECLARE(const char *) adsi_standard_to_str(int standard);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

10
libs/spandsp/src/spandsp/async.h
View File

@ -138,7 +138,7 @@ extern "C"
\brief Convert a signal status to a short text description. \brief Convert a signal status to a short text description.
\param status The modem signal status. \param status The modem signal status.
\return A pointer to the description. */ \return A pointer to the description. */
SPAN_DECLARE(const char) *signal_status_to_str(int status); SPAN_DECLARE(const char *) signal_status_to_str(int status);
/*! Initialise an asynchronous data transmit context. /*! Initialise an asynchronous data transmit context.
\brief Initialise an asynchronous data transmit context. \brief Initialise an asynchronous data transmit context.
@ -150,7 +150,7 @@ SPAN_DECLARE(const char) *signal_status_to_str(int status);
\param get_byte The callback routine used to get the data to be transmitted. \param get_byte The callback routine used to get the data to be transmitted.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the initialised context, or NULL if there was a problem. */ \return A pointer to the initialised context, or NULL if there was a problem. */
SPAN_DECLARE(async_tx_state_t) *async_tx_init(async_tx_state_t *s, SPAN_DECLARE(async_tx_state_t *) async_tx_init(async_tx_state_t *s,
int data_bits, int data_bits,
int parity_bits, int parity_bits,
int stop_bits, int stop_bits,
@ -162,7 +162,7 @@ SPAN_DECLARE(async_tx_state_t) *async_tx_init(async_tx_state_t *s,
\brief Get the next bit of a transmitted serial bit stream. \brief Get the next bit of a transmitted serial bit stream.
\param user_data An opaque point which must point to a transmitter context. \param user_data An opaque point which must point to a transmitter context.
\return the next bit, or PUTBIT_END_OF_DATA to indicate the data stream has ended. */ \return the next bit, or PUTBIT_END_OF_DATA to indicate the data stream has ended. */
SPAN_DECLARE(int) async_tx_get_bit(void *user_data); int async_tx_get_bit(void *user_data);
/*! Initialise an asynchronous data receiver context. /*! Initialise an asynchronous data receiver context.
\brief Initialise an asynchronous data receiver context. \brief Initialise an asynchronous data receiver context.
@ -174,7 +174,7 @@ SPAN_DECLARE(int) async_tx_get_bit(void *user_data);
\param put_byte The callback routine used to put the received data. \param put_byte The callback routine used to put the received data.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the initialised context, or NULL if there was a problem. */ \return A pointer to the initialised context, or NULL if there was a problem. */
SPAN_DECLARE(async_rx_state_t) *async_rx_init(async_rx_state_t *s, SPAN_DECLARE(async_rx_state_t *) async_rx_init(async_rx_state_t *s,
int data_bits, int data_bits,
int parity_bits, int parity_bits,
int stop_bits, int stop_bits,
@ -191,7 +191,7 @@ SPAN_DECLARE(async_rx_state_t) *async_rx_init(async_rx_state_t *s,
- SIG_STATUS_TRAINING_SUCCEEDED - SIG_STATUS_TRAINING_SUCCEEDED
- SIG_STATUS_TRAINING_FAILED - SIG_STATUS_TRAINING_FAILED
- SIG_STATUS_END_OF_DATA */ - SIG_STATUS_END_OF_DATA */
SPAN_DECLARE(void) async_rx_put_bit(void *user_data, int bit); void async_rx_put_bit(void *user_data, int bit);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

2
libs/spandsp/src/spandsp/at_interpreter.h
View File

@ -173,7 +173,7 @@ SPAN_DECLARE(void) at_set_class1_handler(at_state_t *s, at_class1_handler_t hand
\param modem_control_handler x. \param modem_control_handler x.
\param modem_control_user_data x. \param modem_control_user_data x.
\return A pointer to the AT context, or NULL if there was a problem. */ \return A pointer to the AT context, or NULL if there was a problem. */
SPAN_DECLARE(at_state_t) *at_init(at_state_t *s, SPAN_DECLARE(at_state_t *) at_init(at_state_t *s,
at_tx_handler_t *at_tx_handler, at_tx_handler_t *at_tx_handler,
void *at_tx_user_data, void *at_tx_user_data,
at_modem_control_handler_t *modem_control_handler, at_modem_control_handler_t *modem_control_handler,

4
libs/spandsp/src/spandsp/awgn.h
View File

@ -78,9 +78,9 @@ extern "C"
{ {
#endif #endif
SPAN_DECLARE(awgn_state_t) *awgn_init_dbm0(awgn_state_t *s, int idum, float level); SPAN_DECLARE(awgn_state_t *) awgn_init_dbm0(awgn_state_t *s, int idum, float level);
SPAN_DECLARE(awgn_state_t) *awgn_init_dbov(awgn_state_t *s, int idum, float level); SPAN_DECLARE(awgn_state_t *) awgn_init_dbov(awgn_state_t *s, int idum, float level);
SPAN_DECLARE(int16_t) awgn(awgn_state_t *s); SPAN_DECLARE(int16_t) awgn(awgn_state_t *s);

8
libs/spandsp/src/spandsp/bell_r2_mf.h
View File

@ -150,7 +150,7 @@ SPAN_DECLARE(int) bell_mf_tx_put(bell_mf_tx_state_t *s, const char *digits, int
/*! \brief Initialise a Bell MF generator context. /*! \brief Initialise a Bell MF generator context.
\param s The Bell MF generator context. \param s The Bell MF generator context.
\return A pointer to the Bell MF generator context.*/ \return A pointer to the Bell MF generator context.*/
SPAN_DECLARE(bell_mf_tx_state_t) *bell_mf_tx_init(bell_mf_tx_state_t *s); SPAN_DECLARE(bell_mf_tx_state_t *) bell_mf_tx_init(bell_mf_tx_state_t *s);
/*! \brief Free a Bell MF generator context. /*! \brief Free a Bell MF generator context.
\param s The Bell MF generator context. \param s The Bell MF generator context.
@ -175,7 +175,7 @@ SPAN_DECLARE(int) r2_mf_tx_put(r2_mf_tx_state_t *s, char digit);
\param fwd TRUE if the context is for forward signals. FALSE if the \param fwd TRUE if the context is for forward signals. FALSE if the
context is for backward signals. context is for backward signals.
\return A pointer to the MFC/R2 generator context.*/ \return A pointer to the MFC/R2 generator context.*/
SPAN_DECLARE(r2_mf_tx_state_t) *r2_mf_tx_init(r2_mf_tx_state_t *s, int fwd); SPAN_DECLARE(r2_mf_tx_state_t *) r2_mf_tx_init(r2_mf_tx_state_t *s, int fwd);
/*! \brief Free an R2 MF tone generator context. /*! \brief Free an R2 MF tone generator context.
\param s The R2 MF tone generator context. \param s The R2 MF tone generator context.
@ -205,7 +205,7 @@ SPAN_DECLARE(size_t) bell_mf_rx_get(bell_mf_rx_state_t *s, char *buf, int max);
\param user_data An opaque pointer which is associated with the context, \param user_data An opaque pointer which is associated with the context,
and supplied in callbacks. and supplied in callbacks.
\return A pointer to the Bell MF receiver context.*/ \return A pointer to the Bell MF receiver context.*/
SPAN_DECLARE(bell_mf_rx_state_t) *bell_mf_rx_init(bell_mf_rx_state_t *s, SPAN_DECLARE(bell_mf_rx_state_t *) bell_mf_rx_init(bell_mf_rx_state_t *s,
digits_rx_callback_t callback, digits_rx_callback_t callback,
void *user_data); void *user_data);
@ -237,7 +237,7 @@ SPAN_DECLARE(int) r2_mf_rx_get(r2_mf_rx_state_t *s);
\param user_data An opaque pointer which is associated with the context, \param user_data An opaque pointer which is associated with the context,
and supplied in callbacks. and supplied in callbacks.
\return A pointer to the R2 MF receiver context. */ \return A pointer to the R2 MF receiver context. */
SPAN_DECLARE(r2_mf_rx_state_t) *r2_mf_rx_init(r2_mf_rx_state_t *s, SPAN_DECLARE(r2_mf_rx_state_t *) r2_mf_rx_init(r2_mf_rx_state_t *s,
int fwd, int fwd,
tone_report_func_t callback, tone_report_func_t callback,
void *user_data); void *user_data);

4
libs/spandsp/src/spandsp/bert.h
View File

@ -116,7 +116,7 @@ extern "C"
/*! Return a short description of a BERT event. /*! Return a short description of a BERT event.
\param event The event type. \param event The event type.
\return A pointer to a short text string describing the event. */ \return A pointer to a short text string describing the event. */
SPAN_DECLARE(const char) *bert_event_to_str(int event); SPAN_DECLARE(const char *) bert_event_to_str(int event);
/*! Initialise a BERT context. /*! Initialise a BERT context.
\param s The BERT context. \param s The BERT context.
@ -125,7 +125,7 @@ SPAN_DECLARE(const char) *bert_event_to_str(int event);
\param resync_len ??? \param resync_len ???
\param resync_percent The percentage of bad bits which will cause a resync. \param resync_percent The percentage of bad bits which will cause a resync.
\return The BERT context. */ \return The BERT context. */
SPAN_DECLARE(bert_state_t) *bert_init(bert_state_t *s, int limit, int pattern, int resync_len, int resync_percent); SPAN_DECLARE(bert_state_t *) bert_init(bert_state_t *s, int limit, int pattern, int resync_len, int resync_percent);
/*! Get the next bit of the BERT sequence from the generator. /*! Get the next bit of the BERT sequence from the generator.
\param s The BERT context. \param s The BERT context.

4
libs/spandsp/src/spandsp/complex_filters.h
View File

@ -59,11 +59,11 @@ extern "C"
{ {
#endif #endif
SPAN_DECLARE(filter_t) *filter_create(fspec_t *fs); SPAN_DECLARE(filter_t *) filter_create(fspec_t *fs);
SPAN_DECLARE(void) filter_delete(filter_t *fi); SPAN_DECLARE(void) filter_delete(filter_t *fi);
SPAN_DECLARE(float) filter_step(filter_t *fi, float x); SPAN_DECLARE(float) filter_step(filter_t *fi, float x);
SPAN_DECLARE(cfilter_t) *cfilter_create(fspec_t *fs); SPAN_DECLARE(cfilter_t *) cfilter_create(fspec_t *fs);
SPAN_DECLARE(void) cfilter_delete(cfilter_t *cfi); SPAN_DECLARE(void) cfilter_delete(cfilter_t *cfi);
SPAN_DECLARE(complexf_t) cfilter_step(cfilter_t *cfi, const complexf_t *z); SPAN_DECLARE(complexf_t) cfilter_step(cfilter_t *cfi, const complexf_t *z);

4
libs/spandsp/src/spandsp/dtmf.h
View File

@ -125,7 +125,7 @@ SPAN_DECLARE(void) dtmf_tx_set_timing(dtmf_tx_state_t *s, int on_time, int off_t
/*! \brief Initialise a DTMF tone generator context. /*! \brief Initialise a DTMF tone generator context.
\param s The DTMF generator context. \param s The DTMF generator context.
\return A pointer to the DTMF generator context. */ \return A pointer to the DTMF generator context. */
SPAN_DECLARE(dtmf_tx_state_t) *dtmf_tx_init(dtmf_tx_state_t *s); SPAN_DECLARE(dtmf_tx_state_t *) dtmf_tx_init(dtmf_tx_state_t *s);
/*! \brief Free a DTMF tone generator context. /*! \brief Free a DTMF tone generator context.
\param s The DTMF tone generator context. \param s The DTMF tone generator context.
@ -191,7 +191,7 @@ SPAN_DECLARE(size_t) dtmf_rx_get(dtmf_rx_state_t *s, char *digits, int max);
\param user_data An opaque pointer which is associated with the context, \param user_data An opaque pointer which is associated with the context,
and supplied in callbacks. and supplied in callbacks.
\return A pointer to the DTMF receiver context. */ \return A pointer to the DTMF receiver context. */
SPAN_DECLARE(dtmf_rx_state_t) *dtmf_rx_init(dtmf_rx_state_t *s, SPAN_DECLARE(dtmf_rx_state_t *) dtmf_rx_init(dtmf_rx_state_t *s,
digits_rx_callback_t callback, digits_rx_callback_t callback,
void *user_data); void *user_data);

2
libs/spandsp/src/spandsp/echo.h
View File

@ -196,7 +196,7 @@ extern "C"
\param len The length of the canceller, in samples. \param len The length of the canceller, in samples.
\return The new canceller context, or NULL if the canceller could not be created. \return The new canceller context, or NULL if the canceller could not be created.
*/ */
SPAN_DECLARE(echo_can_state_t) *echo_can_create(int len, int adaption_mode); SPAN_DECLARE(echo_can_state_t *) echo_can_create(int len, int adaption_mode);
/*! Free a voice echo canceller context. /*! Free a voice echo canceller context.
\param ec The echo canceller context. \param ec The echo canceller context.

6
libs/spandsp/src/spandsp/fax.h
View File

@ -85,14 +85,14 @@ SPAN_DECLARE(void) fax_set_tep_mode(fax_state_t *s, int use_tep);
\param s The FAX context. \param s The FAX context.
\return A pointer to the T.30 context, or NULL. \return A pointer to the T.30 context, or NULL.
*/ */
SPAN_DECLARE(t30_state_t) *fax_get_t30_state(fax_state_t *s); SPAN_DECLARE(t30_state_t *) fax_get_t30_state(fax_state_t *s);
/*! Get a pointer to the logging context associated with a FAX context. /*! Get a pointer to the logging context associated with a FAX context.
\brief Get a pointer to the logging context associated with a FAX context. \brief Get a pointer to the logging context associated with a FAX context.
\param s The FAX context. \param s The FAX context.
\return A pointer to the logging context, or NULL. \return A pointer to the logging context, or NULL.
*/ */
SPAN_DECLARE(logging_state_t) *fax_get_logging_state(fax_state_t *s); SPAN_DECLARE(logging_state_t *) fax_get_logging_state(fax_state_t *s);
/*! Initialise a FAX context. /*! Initialise a FAX context.
\brief Initialise a FAX context. \brief Initialise a FAX context.
@ -101,7 +101,7 @@ SPAN_DECLARE(logging_state_t) *fax_get_logging_state(fax_state_t *s);
context is for an answering party. context is for an answering party.
\return A pointer to the FAX context, or NULL if there was a problem. \return A pointer to the FAX context, or NULL if there was a problem.
*/ */
SPAN_DECLARE(fax_state_t) *fax_init(fax_state_t *s, int calling_party); SPAN_DECLARE(fax_state_t *) fax_init(fax_state_t *s, int calling_party);
/*! Release a FAX context. /*! Release a FAX context.
\brief Release a FAX context. \brief Release a FAX context.

2
libs/spandsp/src/spandsp/fax_modems.h
View File

@ -44,7 +44,7 @@ extern "C"
SPAN_DECLARE(int) fax_modems_v17_v21_rx(void *user_data, const int16_t amp[], int len); SPAN_DECLARE(int) fax_modems_v17_v21_rx(void *user_data, const int16_t amp[], int len);
SPAN_DECLARE(int) fax_modems_v27ter_v21_rx(void *user_data, const int16_t amp[], int len); SPAN_DECLARE(int) fax_modems_v27ter_v21_rx(void *user_data, const int16_t amp[], int len);
SPAN_DECLARE(int) fax_modems_v29_v21_rx(void *user_data, const int16_t amp[], int len); SPAN_DECLARE(int) fax_modems_v29_v21_rx(void *user_data, const int16_t amp[], int len);
SPAN_DECLARE(fax_modems_state_t) *fax_modems_init(fax_modems_state_t *s, void *user_data); SPAN_DECLARE(fax_modems_state_t *) fax_modems_init(fax_modems_state_t *s, void *user_data);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

4
libs/spandsp/src/spandsp/fsk.h
View File

@ -143,7 +143,7 @@ extern "C"
\param get_bit The callback routine used to get the data to be transmitted. \param get_bit The callback routine used to get the data to be transmitted.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(fsk_tx_state_t) *fsk_tx_init(fsk_tx_state_t *s, SPAN_DECLARE(fsk_tx_state_t *) fsk_tx_init(fsk_tx_state_t *s,
const fsk_spec_t *spec, const fsk_spec_t *spec,
get_bit_func_t get_bit, get_bit_func_t get_bit,
void *user_data); void *user_data);
@ -191,7 +191,7 @@ SPAN_DECLARE(void) fsk_rx_signal_cutoff(fsk_rx_state_t *s, float cutoff);
\param put_bit The callback routine used to put the received data. \param put_bit The callback routine used to put the received data.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(fsk_rx_state_t) *fsk_rx_init(fsk_rx_state_t *s, SPAN_DECLARE(fsk_rx_state_t *) fsk_rx_init(fsk_rx_state_t *s,
const fsk_spec_t *spec, const fsk_spec_t *spec,
int sync_mode, int sync_mode,
put_bit_func_t put_bit, put_bit_func_t put_bit,

2
libs/spandsp/src/spandsp/g711.h
View File

@ -278,7 +278,7 @@ SPAN_DECLARE(int) g711_transcode(g711_state_t *s,
\param s The G.711 context. \param s The G.711 context.
\param mode The G.711 mode. \param mode The G.711 mode.
\return A pointer to the G.711 context, or NULL for error. */ \return A pointer to the G.711 context, or NULL for error. */
SPAN_DECLARE(g711_state_t) *g711_init(g711_state_t *s, int mode); SPAN_DECLARE(g711_state_t *) g711_init(g711_state_t *s, int mode);
/*! Free a G.711 encode or decode context. /*! Free a G.711 encode or decode context.
\param s The G.711 context. \param s The G.711 context.

4
libs/spandsp/src/spandsp/g722.h
View File

@ -71,7 +71,7 @@ extern "C"
The valid rates are 64000, 56000 and 48000. The valid rates are 64000, 56000 and 48000.
\param options \param options
\return A pointer to the G.722 encode context, or NULL for error. */ \return A pointer to the G.722 encode context, or NULL for error. */
SPAN_DECLARE(g722_encode_state_t) *g722_encode_init(g722_encode_state_t *s, int rate, int options); SPAN_DECLARE(g722_encode_state_t *) g722_encode_init(g722_encode_state_t *s, int rate, int options);
SPAN_DECLARE(int) g722_encode_release(g722_encode_state_t *s); SPAN_DECLARE(int) g722_encode_release(g722_encode_state_t *s);
@ -89,7 +89,7 @@ SPAN_DECLARE(int) g722_encode(g722_encode_state_t *s, uint8_t g722_data[], const
The valid rates are 64000, 56000 and 48000. The valid rates are 64000, 56000 and 48000.
\param options \param options
\return A pointer to the G.722 decode context, or NULL for error. */ \return A pointer to the G.722 decode context, or NULL for error. */
SPAN_DECLARE(g722_decode_state_t) *g722_decode_init(g722_decode_state_t *s, int rate, int options); SPAN_DECLARE(g722_decode_state_t *) g722_decode_init(g722_decode_state_t *s, int rate, int options);
SPAN_DECLARE(int) g722_decode_release(g722_decode_state_t *s); SPAN_DECLARE(int) g722_decode_release(g722_decode_state_t *s);

2
libs/spandsp/src/spandsp/g726.h
View File

@ -77,7 +77,7 @@ extern "C"
\param ext_coding The coding used outside G.726. \param ext_coding The coding used outside G.726.
\param packing One of the G.726_PACKING_xxx options. \param packing One of the G.726_PACKING_xxx options.
\return A pointer to the G.726 context, or NULL for error. */ \return A pointer to the G.726 context, or NULL for error. */
SPAN_DECLARE(g726_state_t) *g726_init(g726_state_t *s, int bit_rate, int ext_coding, int packing); SPAN_DECLARE(g726_state_t *) g726_init(g726_state_t *s, int bit_rate, int ext_coding, int packing);
/*! Free a G.726 encode or decode context. /*! Free a G.726 encode or decode context.
\param s The G.726 context. \param s The G.726 context.

2
libs/spandsp/src/spandsp/gsm0610.h
View File

@ -83,7 +83,7 @@ extern "C"
\param s The GSM 06.10 context \param s The GSM 06.10 context
\param packing One of the GSM0610_PACKING_xxx options. \param packing One of the GSM0610_PACKING_xxx options.
\return A pointer to the GSM 06.10 context, or NULL for error. */ \return A pointer to the GSM 06.10 context, or NULL for error. */
SPAN_DECLARE(gsm0610_state_t) *gsm0610_init(gsm0610_state_t *s, int packing); SPAN_DECLARE(gsm0610_state_t *) gsm0610_init(gsm0610_state_t *s, int packing);
/*! Release a GSM 06.10 encode or decode context. /*! Release a GSM 06.10 encode or decode context.
\param s The GSM 06.10 context \param s The GSM 06.10 context

4
libs/spandsp/src/spandsp/hdlc.h
View File

@ -94,7 +94,7 @@ extern "C"
\param user_data An opaque parameter for the callback routine. \param user_data An opaque parameter for the callback routine.
\return A pointer to the HDLC receiver context. \return A pointer to the HDLC receiver context.
*/ */
SPAN_DECLARE(hdlc_rx_state_t) *hdlc_rx_init(hdlc_rx_state_t *s, SPAN_DECLARE(hdlc_rx_state_t *) hdlc_rx_init(hdlc_rx_state_t *s,
int crc32, int crc32,
int report_bad_frames, int report_bad_frames,
int framing_ok_threshold, int framing_ok_threshold,
@ -150,7 +150,7 @@ SPAN_DECLARE(void) hdlc_rx_put(hdlc_rx_state_t *s, const uint8_t buf[], int len)
\param user_data An opaque parameter for the callback routine. \param user_data An opaque parameter for the callback routine.
\return A pointer to the HDLC transmitter context. \return A pointer to the HDLC transmitter context.
*/ */
SPAN_DECLARE(hdlc_tx_state_t) *hdlc_tx_init(hdlc_tx_state_t *s, SPAN_DECLARE(hdlc_tx_state_t *) hdlc_tx_init(hdlc_tx_state_t *s,
int crc32, int crc32,
int inter_frame_flags, int inter_frame_flags,
int progressive, int progressive,

2
libs/spandsp/src/spandsp/ima_adpcm.h
View File

@ -73,7 +73,7 @@ extern "C"
zero sample samples means treat each encode or decode operation zero sample samples means treat each encode or decode operation
as a chunk. as a chunk.
\return A pointer to the IMA ADPCM context, or NULL for error. */ \return A pointer to the IMA ADPCM context, or NULL for error. */
SPAN_DECLARE(ima_adpcm_state_t) *ima_adpcm_init(ima_adpcm_state_t *s, SPAN_DECLARE(ima_adpcm_state_t *) ima_adpcm_init(ima_adpcm_state_t *s,
int variant, int variant,
int chunk_size); int chunk_size);

4
libs/spandsp/src/spandsp/lpc10.h
View File

@ -74,7 +74,7 @@ extern "C"
\param s The LPC10e context \param s The LPC10e context
\param error_correction ??? \param error_correction ???
\return A pointer to the LPC10e context, or NULL for error. */ \return A pointer to the LPC10e context, or NULL for error. */
SPAN_DECLARE(lpc10_encode_state_t) *lpc10_encode_init(lpc10_encode_state_t *s, int error_correction); SPAN_DECLARE(lpc10_encode_state_t *) lpc10_encode_init(lpc10_encode_state_t *s, int error_correction);
SPAN_DECLARE(int) lpc10_encode_release(lpc10_encode_state_t *s); SPAN_DECLARE(int) lpc10_encode_release(lpc10_encode_state_t *s);
@ -91,7 +91,7 @@ SPAN_DECLARE(int) lpc10_encode(lpc10_encode_state_t *s, uint8_t code[], const in
\param s The LPC10e context \param s The LPC10e context
\param error_correction ??? \param error_correction ???
\return A pointer to the LPC10e context, or NULL for error. */ \return A pointer to the LPC10e context, or NULL for error. */
SPAN_DECLARE(lpc10_decode_state_t) *lpc10_decode_init(lpc10_decode_state_t *st, int error_correction); SPAN_DECLARE(lpc10_decode_state_t *) lpc10_decode_init(lpc10_decode_state_t *st, int error_correction);
SPAN_DECLARE(int) lpc10_decode_release(lpc10_decode_state_t *s); SPAN_DECLARE(int) lpc10_decode_release(lpc10_decode_state_t *s);

6
libs/spandsp/src/spandsp/modem_connect_tones.h
View File

@ -104,7 +104,7 @@ extern "C"
/*! \brief Initialise an instance of the modem connect tones generator. /*! \brief Initialise an instance of the modem connect tones generator.
\param s The context. \param s The context.
*/ */
SPAN_DECLARE(modem_connect_tones_tx_state_t) *modem_connect_tones_tx_init(modem_connect_tones_tx_state_t *s, SPAN_DECLARE(modem_connect_tones_tx_state_t *) modem_connect_tones_tx_init(modem_connect_tones_tx_state_t *s,
int tone_type); int tone_type);
/*! \brief Free an instance of the modem connect tones generator. /*! \brief Free an instance of the modem connect tones generator.
@ -147,7 +147,7 @@ SPAN_DECLARE(int) modem_connect_tones_rx_get(modem_connect_tones_rx_state_t *s);
\param user_data An opaque pointer passed to the callback routine, \param user_data An opaque pointer passed to the callback routine,
\return A pointer to the context. \return A pointer to the context.
*/ */
SPAN_DECLARE(modem_connect_tones_rx_state_t) *modem_connect_tones_rx_init(modem_connect_tones_rx_state_t *s, SPAN_DECLARE(modem_connect_tones_rx_state_t *) modem_connect_tones_rx_init(modem_connect_tones_rx_state_t *s,
int tone_type, int tone_type,
tone_report_func_t tone_callback, tone_report_func_t tone_callback,
void *user_data); void *user_data);
@ -157,7 +157,7 @@ SPAN_DECLARE(modem_connect_tones_rx_state_t) *modem_connect_tones_rx_init(modem_
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(int) modem_connect_tones_rx_free(modem_connect_tones_rx_state_t *s); SPAN_DECLARE(int) modem_connect_tones_rx_free(modem_connect_tones_rx_state_t *s);
SPAN_DECLARE(const char) *modem_connect_tone_to_str(int tone); SPAN_DECLARE(const char *) modem_connect_tone_to_str(int tone);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

2
libs/spandsp/src/spandsp/modem_echo.h
View File

@ -110,7 +110,7 @@ extern "C"
\param len The length of the canceller, in samples. \param len The length of the canceller, in samples.
eturn The new canceller context, or NULL if the canceller could not be created. eturn The new canceller context, or NULL if the canceller could not be created.
*/ */
SPAN_DECLARE(modem_echo_can_state_t) *modem_echo_can_create(int len); SPAN_DECLARE(modem_echo_can_state_t *) modem_echo_can_create(int len);
/*! Free a modem echo canceller context. /*! Free a modem echo canceller context.
\param ec The echo canceller context. \param ec The echo canceller context.

4
libs/spandsp/src/spandsp/noise.h
View File

@ -108,9 +108,9 @@ extern "C"
generation to be adjusted. generation to be adjusted.
\return A pointer to the noise generator context. \return A pointer to the noise generator context.
*/ */
SPAN_DECLARE(noise_state_t) *noise_init_dbm0(noise_state_t *s, int seed, float level, int class_of_noise, int quality); SPAN_DECLARE(noise_state_t *) noise_init_dbm0(noise_state_t *s, int seed, float level, int class_of_noise, int quality);
SPAN_DECLARE(noise_state_t) *noise_init_dbov(noise_state_t *s, int seed, float level, int class_of_noise, int quality); SPAN_DECLARE(noise_state_t *) noise_init_dbov(noise_state_t *s, int seed, float level, int class_of_noise, int quality);
SPAN_DECLARE(int) noise_free(noise_state_t *s); SPAN_DECLARE(int) noise_free(noise_state_t *s);

2
libs/spandsp/src/spandsp/oki_adpcm.h
View File

@ -61,7 +61,7 @@ extern "C"
\param bit_rate The required bit rate for the ADPCM data. \param bit_rate The required bit rate for the ADPCM data.
The valid rates are 24000 and 32000. The valid rates are 24000 and 32000.
\return A pointer to the Oki ADPCM context, or NULL for error. */ \return A pointer to the Oki ADPCM context, or NULL for error. */
SPAN_DECLARE(oki_adpcm_state_t) *oki_adpcm_init(oki_adpcm_state_t *s, SPAN_DECLARE(oki_adpcm_state_t *) oki_adpcm_init(oki_adpcm_state_t *s,
int bit_rate); int bit_rate);
/*! Free an Oki ADPCM encode or decode context. /*! Free an Oki ADPCM encode or decode context.

4
libs/spandsp/src/spandsp/playout.h
View File

@ -168,7 +168,7 @@ SPAN_DECLARE(int) playout_get(playout_state_t *s, playout_frame_t *frame, timest
all its contents, before the context is freed. all its contents, before the context is freed.
\param s The play-out context. \param s The play-out context.
\return The frame, or NULL is the queue is empty. */ \return The frame, or NULL is the queue is empty. */
SPAN_DECLARE(playout_frame_t) *playout_get_unconditional(playout_state_t *s); SPAN_DECLARE(playout_frame_t *) playout_get_unconditional(playout_state_t *s);
/*! Find the current length of the buffer. /*! Find the current length of the buffer.
\param s The play-out context. \param s The play-out context.
@ -187,7 +187,7 @@ SPAN_DECLARE(timestamp_t) playout_next_due(playout_state_t *s);
\param max_length Maximum length of the buffer, in samples. If this equals min_length, static \param max_length Maximum length of the buffer, in samples. If this equals min_length, static
length buffering is used. length buffering is used.
\return The new context */ \return The new context */
SPAN_DECLARE(playout_state_t) *playout_new(int min_length, int max_length); SPAN_DECLARE(playout_state_t *) playout_new(int min_length, int max_length);
/*! Destroy an instance of play-out buffering. /*! Destroy an instance of play-out buffering.
\param s The play-out context to be destroyed */ \param s The play-out context to be destroyed */

2
libs/spandsp/src/spandsp/plc.h
View File

@ -153,7 +153,7 @@ SPAN_DECLARE(int) plc_fillin(plc_state_t *s, int16_t amp[], int len);
\brief Initialise a PLC context. \brief Initialise a PLC context.
\param s The packet loss concealer context. \param s The packet loss concealer context.
\return A pointer to the the packet loss concealer context. */ \return A pointer to the the packet loss concealer context. */
SPAN_DECLARE(plc_state_t) *plc_init(plc_state_t *s); SPAN_DECLARE(plc_state_t *) plc_init(plc_state_t *s);
/*! Free a packet loss concealer context. /*! Free a packet loss concealer context.
\param s The packet loss concealer context. \param s The packet loss concealer context.

4
libs/spandsp/src/spandsp/power_meter.h
View File

@ -66,14 +66,14 @@ extern "C"
\param s The power meter context. \param s The power meter context.
\param shift The shift to be used by the IIR filter. \param shift The shift to be used by the IIR filter.
\return The power meter context. */ \return The power meter context. */
SPAN_DECLARE(power_meter_t) *power_meter_init(power_meter_t *s, int shift); SPAN_DECLARE(power_meter_t *) power_meter_init(power_meter_t *s, int shift);
/*! Change the damping factor of a power meter context. /*! Change the damping factor of a power meter context.
\brief Change the damping factor of a power meter context. \brief Change the damping factor of a power meter context.
\param s The power meter context. \param s The power meter context.
\param shift The new shift to be used by the IIR filter. \param shift The new shift to be used by the IIR filter.
\return The power meter context. */ \return The power meter context. */
SPAN_DECLARE(power_meter_t) *power_meter_damping(power_meter_t *s, int shift); SPAN_DECLARE(power_meter_t *) power_meter_damping(power_meter_t *s, int shift);
/*! Update a power meter. /*! Update a power meter.
\brief Update a power meter. \brief Update a power meter.

2
libs/spandsp/src/spandsp/queue.h
View File

@ -158,7 +158,7 @@ SPAN_DECLARE(int) queue_write_msg(queue_state_t *s, const uint8_t *buf, int len)
\param flags Flags controlling the operation of the queue. \param flags Flags controlling the operation of the queue.
Valid flags are QUEUE_READ_ATOMIC and QUEUE_WRITE_ATOMIC. Valid flags are QUEUE_READ_ATOMIC and QUEUE_WRITE_ATOMIC.
\return A pointer to the context if OK, else NULL. */ \return A pointer to the context if OK, else NULL. */
SPAN_DECLARE(queue_state_t) *queue_init(queue_state_t *s, int len, int flags); SPAN_DECLARE(queue_state_t *) queue_init(queue_state_t *s, int len, int flags);
/*! Delete a queue. /*! Delete a queue.
\brief Delete a queue. \brief Delete a queue.

2
libs/spandsp/src/spandsp/schedule.h
View File

@ -58,7 +58,7 @@ SPAN_DECLARE(int) span_schedule_event(span_sched_state_t *s, int us, span_sched_
SPAN_DECLARE(void) span_schedule_update(span_sched_state_t *s, int us); SPAN_DECLARE(void) span_schedule_update(span_sched_state_t *s, int us);
SPAN_DECLARE(void) span_schedule_del(span_sched_state_t *s, int id); SPAN_DECLARE(void) span_schedule_del(span_sched_state_t *s, int id);
SPAN_DECLARE(span_sched_state_t) *span_schedule_init(span_sched_state_t *s); SPAN_DECLARE(span_sched_state_t *) span_schedule_init(span_sched_state_t *s);
SPAN_DECLARE(int) span_schedule_release(span_sched_state_t *s); SPAN_DECLARE(int) span_schedule_release(span_sched_state_t *s);
#if defined(__cplusplus) #if defined(__cplusplus)

4
libs/spandsp/src/spandsp/sig_tone.h
View File

@ -113,7 +113,7 @@ SPAN_DECLARE(int) sig_tone_rx(sig_tone_rx_state_t *s, int16_t amp[], int len);
\param sig_update Callback function to handle signaling updates. \param sig_update Callback function to handle signaling updates.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the signalling tone context, or NULL if there was a problem. */ \return A pointer to the signalling tone context, or NULL if there was a problem. */
SPAN_DECLARE(sig_tone_rx_state_t) *sig_tone_rx_init(sig_tone_rx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data); SPAN_DECLARE(sig_tone_rx_state_t *) sig_tone_rx_init(sig_tone_rx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data);
/*! Generate a block of signaling tone audio samples. /*! Generate a block of signaling tone audio samples.
\brief Generate a block of signaling tone audio samples. \brief Generate a block of signaling tone audio samples.
@ -136,7 +136,7 @@ SPAN_DECLARE(void) sig_tone_tx_set_mode(sig_tone_tx_state_t *s, int mode);
\param sig_update Callback function to handle signaling updates. \param sig_update Callback function to handle signaling updates.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the signalling tone context, or NULL if there was a problem. */ \return A pointer to the signalling tone context, or NULL if there was a problem. */
SPAN_DECLARE(sig_tone_tx_state_t) *sig_tone_tx_init(sig_tone_tx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data); SPAN_DECLARE(sig_tone_tx_state_t *) sig_tone_tx_init(sig_tone_tx_state_t *s, int tone_type, sig_tone_func_t sig_update, void *user_data);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

4
libs/spandsp/src/spandsp/silence_gen.h
View File

@ -103,7 +103,7 @@ SPAN_DECLARE(void) silence_gen_status_handler(silence_gen_state_t *s, modem_tx_s
\param silent_samples The initial number of samples to set the silence to. \param silent_samples The initial number of samples to set the silence to.
\return A pointer to the silence generator context. \return A pointer to the silence generator context.
*/ */
SPAN_DECLARE(silence_gen_state_t) *silence_gen_init(silence_gen_state_t *s, int silent_samples); SPAN_DECLARE(silence_gen_state_t *) silence_gen_init(silence_gen_state_t *s, int silent_samples);
/* The following dummy routines, to absorb data, don't really have a proper home, /* The following dummy routines, to absorb data, don't really have a proper home,
so they have been put here. */ so they have been put here. */
@ -117,7 +117,7 @@ SPAN_DECLARE(silence_gen_state_t) *silence_gen_init(silence_gen_state_t *s, int
\param len The length of the signal buffer \param len The length of the signal buffer
\return 0. \return 0.
*/ */
SPAN_DECLARE(int) span_dummy_rx(void *user_data, const int16_t amp[], int len); int span_dummy_rx(void *user_data, const int16_t amp[], int len);
/*! A dummy routine to use as a signal modifier callback, when we aren't /*! A dummy routine to use as a signal modifier callback, when we aren't
really trying to process the signal. It just returns without affecting really trying to process the signal. It just returns without affecting

4
libs/spandsp/src/spandsp/super_tone_rx.h
View File

@ -73,7 +73,7 @@ extern "C"
descriptor. descriptor.
\return The supervisory tone set descriptor. \return The supervisory tone set descriptor.
*/ */
SPAN_DECLARE(super_tone_rx_descriptor_t) *super_tone_rx_make_descriptor(super_tone_rx_descriptor_t *desc); SPAN_DECLARE(super_tone_rx_descriptor_t *) super_tone_rx_make_descriptor(super_tone_rx_descriptor_t *desc);
/*! Free a supervisory tone detector descriptor. /*! Free a supervisory tone detector descriptor.
\param desc The supervisory tone set desciptor. \param desc The supervisory tone set desciptor.
@ -110,7 +110,7 @@ SPAN_DECLARE(int) super_tone_rx_add_element(super_tone_rx_descriptor_t *desc,
\param user_data An opaque pointer passed when calling the callback routine. \param user_data An opaque pointer passed when calling the callback routine.
\return The supervisory tone detector context. \return The supervisory tone detector context.
*/ */
SPAN_DECLARE(super_tone_rx_state_t) *super_tone_rx_init(super_tone_rx_state_t *s, SPAN_DECLARE(super_tone_rx_state_t *) super_tone_rx_init(super_tone_rx_state_t *s,
super_tone_rx_descriptor_t *desc, super_tone_rx_descriptor_t *desc,
tone_report_func_t callback, tone_report_func_t callback,
void *user_data); void *user_data);

4
libs/spandsp/src/spandsp/super_tone_tx.h
View File

@ -50,7 +50,7 @@ extern "C"
{ {
#endif #endif
SPAN_DECLARE(super_tone_tx_step_t) *super_tone_tx_make_step(super_tone_tx_step_t *s, SPAN_DECLARE(super_tone_tx_step_t *) super_tone_tx_make_step(super_tone_tx_step_t *s,
float f1, float f1,
float l1, float l1,
float f2, float f2,
@ -65,7 +65,7 @@ SPAN_DECLARE(void) super_tone_tx_free(super_tone_tx_step_t *s);
\param s The supervisory tone generator context. \param s The supervisory tone generator context.
\param tree The supervisory tone tree to be generated. \param tree The supervisory tone tree to be generated.
\return The supervisory tone generator context. */ \return The supervisory tone generator context. */
SPAN_DECLARE(super_tone_tx_state_t) *super_tone_tx_init(super_tone_tx_state_t *s, super_tone_tx_step_t *tree); SPAN_DECLARE(super_tone_tx_state_t *) super_tone_tx_init(super_tone_tx_state_t *s, super_tone_tx_step_t *tree);
/*! Generate a block of audio samples for a supervisory tone pattern. /*! Generate a block of audio samples for a supervisory tone pattern.
\brief Generate a block of audio samples for a supervisory tone pattern. \brief Generate a block of audio samples for a supervisory tone pattern.

8
libs/spandsp/src/spandsp/t30.h
View File

@ -558,7 +558,7 @@ extern "C"
\param send_hdlc_handler \param send_hdlc_handler
\param send_hdlc_user_data \param send_hdlc_user_data
\return A pointer to the context, or NULL if there was a problem. */ \return A pointer to the context, or NULL if there was a problem. */
SPAN_DECLARE(t30_state_t) *t30_init(t30_state_t *s, SPAN_DECLARE(t30_state_t *) t30_init(t30_state_t *s,
int calling_party, int calling_party,
t30_set_handler_t *set_rx_type_handler, t30_set_handler_t *set_rx_type_handler,
void *set_rx_type_user_data, void *set_rx_type_user_data,
@ -607,7 +607,7 @@ SPAN_DECLARE(void) t30_front_end_status(void *user_data, int status);
\brief Get a bit of received non-ECM image data. \brief Get a bit of received non-ECM image data.
\param user_data An opaque pointer, which must point to the T.30 context. \param user_data An opaque pointer, which must point to the T.30 context.
\return The next bit to transmit. */ \return The next bit to transmit. */
SPAN_DECLARE(int) t30_non_ecm_get_bit(void *user_data); int t30_non_ecm_get_bit(void *user_data);
/*! Get a byte of received non-ECM image data. /*! Get a byte of received non-ECM image data.
\brief Get a byte of received non-ECM image data. \brief Get a byte of received non-ECM image data.
@ -627,7 +627,7 @@ SPAN_DECLARE(int) t30_non_ecm_get_chunk(void *user_data, uint8_t buf[], int max_
\brief Process a bit of received non-ECM image data \brief Process a bit of received non-ECM image data
\param user_data An opaque pointer, which must point to the T.30 context. \param user_data An opaque pointer, which must point to the T.30 context.
\param bit The received bit. */ \param bit The received bit. */
SPAN_DECLARE(void) t30_non_ecm_put_bit(void *user_data, int bit); void t30_non_ecm_put_bit(void *user_data, int bit);
/*! Process a byte of received non-ECM image data. /*! Process a byte of received non-ECM image data.
\brief Process a byte of received non-ECM image data \brief Process a byte of received non-ECM image data
@ -648,7 +648,7 @@ SPAN_DECLARE(void) t30_non_ecm_put_chunk(void *user_data, const uint8_t buf[], i
\param msg The HDLC message. \param msg The HDLC message.
\param len The length of the message, in octets. \param len The length of the message, in octets.
\param ok TRUE if the frame was received without error. */ \param ok TRUE if the frame was received without error. */
SPAN_DECLARE(void) t30_hdlc_accept(void *user_data, const uint8_t *msg, int len, int ok); void t30_hdlc_accept(void *user_data, const uint8_t *msg, int len, int ok);
/*! Report the passage of time to the T.30 engine. /*! Report the passage of time to the T.30 engine.
\brief Report the passage of time to the T.30 engine. \brief Report the passage of time to the T.30 engine.

32
libs/spandsp/src/spandsp/t30_api.h
View File

@ -113,14 +113,14 @@ SPAN_DECLARE(int) t30_set_tx_ident(t30_state_t *s, const char *id);
\param s The T.30 context. \param s The T.30 context.
\param id A pointer to the identifier. \param id A pointer to the identifier.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_tx_ident(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_tx_ident(t30_state_t *s);
/*! Get the transmitted identifier associated with a T.30 context. /*! Get the transmitted identifier associated with a T.30 context.
\brief Set the transmitted identifier associated with a T.30 context. \brief Set the transmitted identifier associated with a T.30 context.
\param s The T.30 context. \param s The T.30 context.
\param id A pointer to the identifier. \param id A pointer to the identifier.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_rx_ident(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_ident(t30_state_t *s);
/*! Set the transmitted sub-address associated with a T.30 context. /*! Set the transmitted sub-address associated with a T.30 context.
\brief Set the transmitted sub-address associated with a T.30 context. \brief Set the transmitted sub-address associated with a T.30 context.
@ -134,14 +134,14 @@ SPAN_DECLARE(int) t30_set_tx_sub_address(t30_state_t *s, const char *sub_address
\param s The T.30 context. \param s The T.30 context.
\param sub_address A pointer to the sub-address. \param sub_address A pointer to the sub-address.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_tx_sub_address(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_tx_sub_address(t30_state_t *s);
/*! Get the received sub-address associated with a T.30 context. /*! Get the received sub-address associated with a T.30 context.
\brief Get the received sub-address associated with a T.30 context. \brief Get the received sub-address associated with a T.30 context.
\param s The T.30 context. \param s The T.30 context.
\param sub_address A pointer to the sub-address. \param sub_address A pointer to the sub-address.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_rx_sub_address(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_sub_address(t30_state_t *s);
/*! Set the transmitted selective polling address (i.e. the one we will send to the far /*! Set the transmitted selective polling address (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -157,7 +157,7 @@ SPAN_DECLARE(int) t30_set_tx_selective_polling_address(t30_state_t *s, const cha
\param s The T.30 context. \param s The T.30 context.
\param selective_polling_address A pointer to the selective polling address. \param selective_polling_address A pointer to the selective polling address.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_tx_selective_polling_address(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_tx_selective_polling_address(t30_state_t *s);
/*! Get the received selective polling address (i.e. the one we will send to the far /*! Get the received selective polling address (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -165,7 +165,7 @@ SPAN_DECLARE(const char) *t30_get_tx_selective_polling_address(t30_state_t *s);
\param s The T.30 context. \param s The T.30 context.
\param selective_polling_address A pointer to the selective polling address. \param selective_polling_address A pointer to the selective polling address.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_rx_selective_polling_address(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_selective_polling_address(t30_state_t *s);
/*! Set the transmitted polled sub-address (i.e. the one we will send to the far /*! Set the transmitted polled sub-address (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -181,7 +181,7 @@ SPAN_DECLARE(int) t30_set_tx_polled_sub_address(t30_state_t *s, const char *poll
\param s The T.30 context. \param s The T.30 context.
\param polled_sub_address A pointer to the polled sub-address. \param polled_sub_address A pointer to the polled sub-address.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_tx_polled_sub_address(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_tx_polled_sub_address(t30_state_t *s);
/*! Get the received polled sub-address (i.e. the one we will send to the far /*! Get the received polled sub-address (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -189,7 +189,7 @@ SPAN_DECLARE(const char) *t30_get_tx_polled_sub_address(t30_state_t *s);
\param s The T.30 context. \param s The T.30 context.
\param polled_sub_address A pointer to the polled sub-address. \param polled_sub_address A pointer to the polled sub-address.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_rx_polled_sub_address(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_polled_sub_address(t30_state_t *s);
/*! Set the transmitted sender ident (i.e. the one we will send to the far /*! Set the transmitted sender ident (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -205,7 +205,7 @@ SPAN_DECLARE(int) t30_set_tx_sender_ident(t30_state_t *s, const char *sender_ide
\param s The T.30 context. \param s The T.30 context.
\param sender_ident A pointer to the sender ident. \param sender_ident A pointer to the sender ident.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_tx_sender_ident(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_tx_sender_ident(t30_state_t *s);
/*! Get the received sender ident (i.e. the one we will send to the far /*! Get the received sender ident (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -213,7 +213,7 @@ SPAN_DECLARE(const char) *t30_get_tx_sender_ident(t30_state_t *s);
\param s The T.30 context. \param s The T.30 context.
\param sender_ident A pointer to the sender ident. \param sender_ident A pointer to the sender ident.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_rx_sender_ident(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_sender_ident(t30_state_t *s);
/*! Set the transmitted password (i.e. the one we will send to the far /*! Set the transmitted password (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -229,7 +229,7 @@ SPAN_DECLARE(int) t30_set_tx_password(t30_state_t *s, const char *password);
\param s The T.30 context. \param s The T.30 context.
\param password A pointer to the password. \param password A pointer to the password.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_tx_password(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_tx_password(t30_state_t *s);
/*! Get the received password (i.e. the one we will send to the far /*! Get the received password (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -237,7 +237,7 @@ SPAN_DECLARE(const char) *t30_get_tx_password(t30_state_t *s);
\param s The T.30 context. \param s The T.30 context.
\param password A pointer to the password. \param password A pointer to the password.
\return 0 for OK, else -1. */ \return 0 for OK, else -1. */
SPAN_DECLARE(const char) *t30_get_rx_password(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_password(t30_state_t *s);
/*! Set the transmitted ??? (i.e. the one we will send to the far /*! Set the transmitted ??? (i.e. the one we will send to the far
end) associated with a T.30 context. end) associated with a T.30 context.
@ -406,19 +406,19 @@ SPAN_DECLARE(size_t) t30_get_tx_page_header_info(t30_state_t *s, char *info);
\brief Get the country of origin of the remote FAX machine associated with a T.30 context. \brief Get the country of origin of the remote FAX machine associated with a T.30 context.
\param s The T.30 context. \param s The T.30 context.
\return a pointer to the country name, or NULL if the country is not known. */ \return a pointer to the country name, or NULL if the country is not known. */
SPAN_DECLARE(const char) *t30_get_rx_country(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_country(t30_state_t *s);
/*! Get the name of the vendor of the remote FAX machine associated with a T.30 context. /*! Get the name of the vendor of the remote FAX machine associated with a T.30 context.
\brief Get the name of the vendor of the remote FAX machine associated with a T.30 context. \brief Get the name of the vendor of the remote FAX machine associated with a T.30 context.
\param s The T.30 context. \param s The T.30 context.
\return a pointer to the vendor name, or NULL if the vendor is not known. */ \return a pointer to the vendor name, or NULL if the vendor is not known. */
SPAN_DECLARE(const char) *t30_get_rx_vendor(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_vendor(t30_state_t *s);
/*! Get the name of the model of the remote FAX machine associated with a T.30 context. /*! Get the name of the model of the remote FAX machine associated with a T.30 context.
\brief Get the name of the model of the remote FAX machine associated with a T.30 context. \brief Get the name of the model of the remote FAX machine associated with a T.30 context.
\param s The T.30 context. \param s The T.30 context.
\return a pointer to the model name, or NULL if the model is not known. */ \return a pointer to the model name, or NULL if the model is not known. */
SPAN_DECLARE(const char) *t30_get_rx_model(t30_state_t *s); SPAN_DECLARE(const char *) t30_get_rx_model(t30_state_t *s);
/*! Specify the file name of the next TIFF file to be received by a T.30 /*! Specify the file name of the next TIFF file to be received by a T.30
context. context.
@ -557,7 +557,7 @@ SPAN_DECLARE(void) t30_set_real_time_frame_handler(t30_state_t *s, t30_real_time
\param s The T.30 context. \param s The T.30 context.
\return A pointer to the logging context, or NULL. \return A pointer to the logging context, or NULL.
*/ */
SPAN_DECLARE(logging_state_t) *t30_get_logging_state(t30_state_t *s); SPAN_DECLARE(logging_state_t *) t30_get_logging_state(t30_state_t *s);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

4
libs/spandsp/src/spandsp/t30_logging.h
View File

@ -40,7 +40,7 @@ extern "C"
\param x The frametype octet. \param x The frametype octet.
\return A pointer to the text name for the frame type. If the frame type is \return A pointer to the text name for the frame type. If the frame type is
not value, the string "???" is returned. */ not value, the string "???" is returned. */
SPAN_DECLARE(const char) *t30_frametype(uint8_t x); SPAN_DECLARE(const char *) t30_frametype(uint8_t x);
/*! Decode a DIS, DTC or DCS frame, and log the contents. /*! Decode a DIS, DTC or DCS frame, and log the contents.
\brief Decode a DIS, DTC or DCS frame, and log the contents. \brief Decode a DIS, DTC or DCS frame, and log the contents.
@ -53,7 +53,7 @@ SPAN_DECLARE(void) t30_decode_dis_dtc_dcs(t30_state_t *s, const uint8_t *dis, in
\brief Convert a phase E completion code to a short text description. \brief Convert a phase E completion code to a short text description.
\param result The result code. \param result The result code.
\return A pointer to the description. */ \return A pointer to the description. */
SPAN_DECLARE(const char) *t30_completion_code_to_str(int result); SPAN_DECLARE(const char *) t30_completion_code_to_str(int result);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

6
libs/spandsp/src/spandsp/t31.h
View File

@ -111,9 +111,9 @@ SPAN_DECLARE(void) t31_set_mode(t31_state_t *s, int t38_mode);
\param s The T.31 context. \param s The T.31 context.
\return A pointer to the logging context, or NULL. \return A pointer to the logging context, or NULL.
*/ */
SPAN_DECLARE(logging_state_t) *t31_get_logging_state(t31_state_t *s); SPAN_DECLARE(logging_state_t *) t31_get_logging_state(t31_state_t *s);
SPAN_DECLARE(t38_core_state_t) *t31_get_t38_core_state(t31_state_t *s); SPAN_DECLARE(t38_core_state_t *) t31_get_t38_core_state(t31_state_t *s);
/*! Initialise a T.31 context. This must be called before the first /*! Initialise a T.31 context. This must be called before the first
use of the context, to initialise its contents. use of the context, to initialise its contents.
@ -126,7 +126,7 @@ SPAN_DECLARE(t38_core_state_t) *t31_get_t38_core_state(t31_state_t *s);
\param tx_t38_packet_handler ??? \param tx_t38_packet_handler ???
\param tx_t38_packet_user_data ??? \param tx_t38_packet_user_data ???
\return A pointer to the T.31 context. */ \return A pointer to the T.31 context. */
SPAN_DECLARE(t31_state_t) *t31_init(t31_state_t *s, SPAN_DECLARE(t31_state_t *) t31_init(t31_state_t *s,
at_tx_handler_t *at_tx_handler, at_tx_handler_t *at_tx_handler,
void *at_tx_user_data, void *at_tx_user_data,
t31_modem_control_handler_t *modem_control_handler, t31_modem_control_handler_t *modem_control_handler,

14
libs/spandsp/src/spandsp/t38_core.h
View File

@ -197,28 +197,28 @@ extern "C"
/*! \brief Convert the code for an indicator to a short text name. /*! \brief Convert the code for an indicator to a short text name.
\param indicator The type of indicator. \param indicator The type of indicator.
\return A pointer to a short text name for the indicator. */ \return A pointer to a short text name for the indicator. */
SPAN_DECLARE(const char) *t38_indicator_to_str(int indicator); SPAN_DECLARE(const char *) t38_indicator_to_str(int indicator);
/*! \brief Convert the code for a type of data to a short text name. /*! \brief Convert the code for a type of data to a short text name.
\param data_type The data type. \param data_type The data type.
\return A pointer to a short text name for the data type. */ \return A pointer to a short text name for the data type. */
SPAN_DECLARE(const char) *t38_data_type_to_str(int data_type); SPAN_DECLARE(const char *) t38_data_type_to_str(int data_type);
/*! \brief Convert the code for a type of data field to a short text name. /*! \brief Convert the code for a type of data field to a short text name.
\param field_type The field type. \param field_type The field type.
\return A pointer to a short text name for the field type. */ \return A pointer to a short text name for the field type. */
SPAN_DECLARE(const char) *t38_field_type_to_str(int field_type); SPAN_DECLARE(const char *) t38_field_type_to_str(int field_type);
/*! \brief Convert the code for a CM profile code to text description. /*! \brief Convert the code for a CM profile code to text description.
\param profile The profile code from a CM message. \param profile The profile code from a CM message.
\return A pointer to a short text description of the profile. */ \return A pointer to a short text description of the profile. */
SPAN_DECLARE(const char) *t38_cm_profile_to_str(int profile); SPAN_DECLARE(const char *) t38_cm_profile_to_str(int profile);
/*! \brief Convert a JM message code to text description. /*! \brief Convert a JM message code to text description.
\param data The data field of the message. \param data The data field of the message.
\param len The length of the data field. \param len The length of the data field.
\return A pointer to a short text description of the profile. */ \return A pointer to a short text description of the profile. */
SPAN_DECLARE(const char) *t38_jm_to_str(const uint8_t *data, int len); SPAN_DECLARE(const char *) t38_jm_to_str(const uint8_t *data, int len);
/*! \brief Convert a V34rate message to an actual bit rate. /*! \brief Convert a V34rate message to an actual bit rate.
\param data The data field of the message. \param data The data field of the message.
@ -326,9 +326,9 @@ SPAN_DECLARE(void) t38_set_tep_handling(t38_core_state_t *s, int allow_for_tep);
\param s The T.38 context. \param s The T.38 context.
\return A pointer to the logging context, or NULL. \return A pointer to the logging context, or NULL.
*/ */
SPAN_DECLARE(logging_state_t) *t38_core_get_logging_state(t38_core_state_t *s); SPAN_DECLARE(logging_state_t *) t38_core_get_logging_state(t38_core_state_t *s);
SPAN_DECLARE(t38_core_state_t) *t38_core_init(t38_core_state_t *s, SPAN_DECLARE(t38_core_state_t *) t38_core_init(t38_core_state_t *s,
t38_rx_indicator_handler_t *rx_indicator_handler, t38_rx_indicator_handler_t *rx_indicator_handler,
t38_rx_data_handler_t *rx_data_handler, t38_rx_data_handler_t *rx_data_handler,
t38_rx_missing_handler_t *rx_missing_handler, t38_rx_missing_handler_t *rx_missing_handler,

6
libs/spandsp/src/spandsp/t38_gateway.h
View File

@ -82,7 +82,7 @@ extern "C"
\param tx_packet_handler A callback routine to encapsulate and transmit T.38 packets. \param tx_packet_handler A callback routine to encapsulate and transmit T.38 packets.
\param tx_packet_user_data An opaque pointer passed to the tx_packet_handler routine. \param tx_packet_user_data An opaque pointer passed to the tx_packet_handler routine.
\return A pointer to the termination mode T.38 context, or NULL if there was a problem. */ \return A pointer to the termination mode T.38 context, or NULL if there was a problem. */
SPAN_DECLARE(t38_gateway_state_t) *t38_gateway_init(t38_gateway_state_t *s, SPAN_DECLARE(t38_gateway_state_t *) t38_gateway_init(t38_gateway_state_t *s,
t38_tx_packet_handler_t *tx_packet_handler, t38_tx_packet_handler_t *tx_packet_handler,
void *tx_packet_user_data); void *tx_packet_user_data);
@ -177,14 +177,14 @@ SPAN_DECLARE(void) t38_gateway_get_transfer_statistics(t38_gateway_state_t *s, t
\param s The T.38 context. \param s The T.38 context.
\return A pointer to the T.38 core context, or NULL. \return A pointer to the T.38 core context, or NULL.
*/ */
SPAN_DECLARE(t38_core_state_t) *t38_gateway_get_t38_core_state(t38_gateway_state_t *s); SPAN_DECLARE(t38_core_state_t *) t38_gateway_get_t38_core_state(t38_gateway_state_t *s);
/*! Get a pointer to the logging context associated with a T.38 context. /*! Get a pointer to the logging context associated with a T.38 context.
\brief Get a pointer to the logging context associated with a T.38 context. \brief Get a pointer to the logging context associated with a T.38 context.
\param s The T.38 context. \param s The T.38 context.
\return A pointer to the logging context, or NULL. \return A pointer to the logging context, or NULL.
*/ */
SPAN_DECLARE(logging_state_t) *t38_gateway_get_logging_state(t38_gateway_state_t *s); SPAN_DECLARE(logging_state_t *) t38_gateway_get_logging_state(t38_gateway_state_t *s);
/*! Set a callback function for T.30 frame exchange monitoring. This is called from the heart /*! Set a callback function for T.30 frame exchange monitoring. This is called from the heart
of the signal processing, so don't take too long in the handler routine. of the signal processing, so don't take too long in the handler routine.

4
libs/spandsp/src/spandsp/t38_non_ecm_buffer.h
View File

@ -59,7 +59,7 @@ extern "C"
\param mode TRUE for image data mode, or FALSE for TCF mode. \param mode TRUE for image data mode, or FALSE for TCF mode.
\param bits The minimum number of bits per FAX image row. \param bits The minimum number of bits per FAX image row.
\return A pointer to the buffer context, or NULL if there was a problem. */ \return A pointer to the buffer context, or NULL if there was a problem. */
SPAN_DECLARE(t38_non_ecm_buffer_state_t) *t38_non_ecm_buffer_init(t38_non_ecm_buffer_state_t *s, int mode, int min_row_bits); SPAN_DECLARE(t38_non_ecm_buffer_state_t *) t38_non_ecm_buffer_init(t38_non_ecm_buffer_state_t *s, int mode, int min_row_bits);
/*! \brief Set the mode of a T.38 rate adapting non-ECM buffer context. /*! \brief Set the mode of a T.38 rate adapting non-ECM buffer context.
\param s The buffer context. \param s The buffer context.
@ -93,7 +93,7 @@ SPAN_DECLARE(void) t38_non_ecm_buffer_report_output_status(t38_non_ecm_buffer_st
/*! \brief Get the next bit of data from a T.38 rate adapting non-ECM buffer context. /*! \brief Get the next bit of data from a T.38 rate adapting non-ECM buffer context.
\param user_data The buffer context, cast to a void pointer. \param user_data The buffer context, cast to a void pointer.
\return The next bit, or one of the values indicating a change of modem status. */ \return The next bit, or one of the values indicating a change of modem status. */
SPAN_DECLARE(int) t38_non_ecm_buffer_get_bit(void *user_data); int t38_non_ecm_buffer_get_bit(void *user_data);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

8
libs/spandsp/src/spandsp/t38_terminal.h
View File

@ -69,7 +69,7 @@ SPAN_DECLARE(void) t38_terminal_set_fill_bit_removal(t38_terminal_state_t *s, in
\param s The T.38 context. \param s The T.38 context.
\return A pointer to the T.30 context, or NULL. \return A pointer to the T.30 context, or NULL.
*/ */
SPAN_DECLARE(t30_state_t) *t38_terminal_get_t30_state(t38_terminal_state_t *s); SPAN_DECLARE(t30_state_t *) t38_terminal_get_t30_state(t38_terminal_state_t *s);
/*! Get a pointer to the T.38 core IFP packet engine associated with a /*! Get a pointer to the T.38 core IFP packet engine associated with a
termination mode T.38 context. termination mode T.38 context.
@ -78,14 +78,14 @@ SPAN_DECLARE(t30_state_t) *t38_terminal_get_t30_state(t38_terminal_state_t *s);
\param s The T.38 context. \param s The T.38 context.
\return A pointer to the T.38 core context, or NULL. \return A pointer to the T.38 core context, or NULL.
*/ */
SPAN_DECLARE(t38_core_state_t) *t38_terminal_get_t38_core_state(t38_terminal_state_t *s); SPAN_DECLARE(t38_core_state_t *) t38_terminal_get_t38_core_state(t38_terminal_state_t *s);
/*! Get a pointer to the logging context associated with a T.38 context. /*! Get a pointer to the logging context associated with a T.38 context.
\brief Get a pointer to the logging context associated with a T.38 context. \brief Get a pointer to the logging context associated with a T.38 context.
\param s The T.38 context. \param s The T.38 context.
\return A pointer to the logging context, or NULL. \return A pointer to the logging context, or NULL.
*/ */
SPAN_DECLARE(logging_state_t) *t38_terminal_get_logging_state(t38_terminal_state_t *s); SPAN_DECLARE(logging_state_t *) t38_terminal_get_logging_state(t38_terminal_state_t *s);
/*! \brief Initialise a termination mode T.38 context. /*! \brief Initialise a termination mode T.38 context.
\param s The T.38 context. \param s The T.38 context.
@ -94,7 +94,7 @@ SPAN_DECLARE(logging_state_t) *t38_terminal_get_logging_state(t38_terminal_state
\param tx_packet_handler A callback routine to encapsulate and transmit T.38 packets. \param tx_packet_handler A callback routine to encapsulate and transmit T.38 packets.
\param tx_packet_user_data An opaque pointer passed to the tx_packet_handler routine. \param tx_packet_user_data An opaque pointer passed to the tx_packet_handler routine.
\return A pointer to the termination mode T.38 context, or NULL if there was a problem. */ \return A pointer to the termination mode T.38 context, or NULL if there was a problem. */
SPAN_DECLARE(t38_terminal_state_t) *t38_terminal_init(t38_terminal_state_t *s, SPAN_DECLARE(t38_terminal_state_t *) t38_terminal_init(t38_terminal_state_t *s,
int calling_party, int calling_party,
t38_tx_packet_handler_t *tx_packet_handler, t38_tx_packet_handler_t *tx_packet_handler,
void *tx_packet_user_data); void *tx_packet_user_data);

6
libs/spandsp/src/spandsp/t4.h
View File

@ -213,7 +213,7 @@ extern "C" {
\param file The name of the file to be received. \param file The name of the file to be received.
\param output_encoding The output encoding. \param output_encoding The output encoding.
\return A pointer to the context, or NULL if there was a problem. */ \return A pointer to the context, or NULL if there was a problem. */
SPAN_DECLARE(t4_state_t) *t4_rx_init(t4_state_t *s, const char *file, int output_encoding); SPAN_DECLARE(t4_state_t *) t4_rx_init(t4_state_t *s, const char *file, int output_encoding);
/*! \brief Prepare to receive the next page of the current document. /*! \brief Prepare to receive the next page of the current document.
\param s The T.4 context. \param s The T.4 context.
@ -311,7 +311,7 @@ SPAN_DECLARE(void) t4_rx_set_model(t4_state_t *s, const char *model);
\param start_page The first page to send. -1 for no restriction. \param start_page The first page to send. -1 for no restriction.
\param stop_page The last page to send. -1 for no restriction. \param stop_page The last page to send. -1 for no restriction.
\return A pointer to the context, or NULL if there was a problem. */ \return A pointer to the context, or NULL if there was a problem. */
SPAN_DECLARE(t4_state_t) *t4_tx_init(t4_state_t *s, const char *file, int start_page, int stop_page); SPAN_DECLARE(t4_state_t *) t4_tx_init(t4_state_t *s, const char *file, int start_page, int stop_page);
/*! \brief Prepare to send the next page of the current document. /*! \brief Prepare to send the next page of the current document.
\param s The T.4 context. \param s The T.4 context.
@ -445,7 +445,7 @@ SPAN_DECLARE(void) t4_get_transfer_statistics(t4_state_t *s, t4_stats_t *t);
\brief Get the short text name of an encoding format. \brief Get the short text name of an encoding format.
\param encoding The encoding type. \param encoding The encoding type.
\return A pointer to the string. */ \return A pointer to the string. */
SPAN_DECLARE(const char) *t4_encoding_to_str(int encoding); SPAN_DECLARE(const char *) t4_encoding_to_str(int encoding);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

15
libs/spandsp/src/spandsp/telephony.h
View File

@ -28,17 +28,20 @@
#if !defined(_SPANDSP_TELEPHONY_H_) #if !defined(_SPANDSP_TELEPHONY_H_)
#define _SPANDSP_TELEPHONY_H_ #define _SPANDSP_TELEPHONY_H_
#if defined(SPANDSP_USE_EXPORT_CAPABILITY)
#if defined(__GNUC__) || defined(__SUNCC__)
#define SPAN_DECLARE(type) __attribute__((visibility("default"))) type
#define SPAN_DECLARE_NONSTD(type) __attribute__((visibility("default"))) type
#define SPAN_DECLARE_DATA __attribute__((visibility("default")))
#endif
#if defined(WIN32) #if defined(WIN32)
# if defined(LIBSPANDSP_EXPORTS)
# define SPAN_DECLARE(type) __declspec(dllexport) type __stdcall # define SPAN_DECLARE(type) __declspec(dllexport) type __stdcall
# define SPAN_DECLARE_NONSTD(type) __declspec(dllexport) type __cdecl # define SPAN_DECLARE_NONSTD(type) __declspec(dllexport) type __cdecl
# define SPAN_DECLARE_DATA __declspec(dllexport) # define SPAN_DECLARE_DATA __declspec(dllexport)
# else
# define SPAN_DECLARE(type) __declspec(dllimport) type __stdcall
# define SPAN_DECLARE_NONSTD(type) __declspec(dllimport) type __cdecl
# define SPAN_DECLARE_DATA __declspec(dllimport)
# endif # endif
#elif defined(SPANDSP_USE_EXPORT_CAPABILITY) && (defined(__GNUC__) || defined(__SUNCC__))
# define SPAN_DECLARE(type) __attribute__((visibility("default"))) type
# define SPAN_DECLARE_NONSTD(type) __attribute__((visibility("default"))) type
# define SPAN_DECLARE_DATA __attribute__((visibility("default")))
#else #else
# define SPAN_DECLARE(type) /**/ type # define SPAN_DECLARE(type) /**/ type
# define SPAN_DECLARE_NONSTD(type) /**/ type # define SPAN_DECLARE_NONSTD(type) /**/ type

2
libs/spandsp/src/spandsp/time_scale.h
View File

@ -71,7 +71,7 @@ extern "C"
\param sample_rate The sample rate of the signal. \param sample_rate The sample rate of the signal.
\param playout_rate The ratio between the output speed and the input speed. \param playout_rate The ratio between the output speed and the input speed.
\return A pointer to the context, or NULL if there was a problem. */ \return A pointer to the context, or NULL if there was a problem. */
SPAN_DECLARE(time_scale_state_t) *time_scale_init(time_scale_state_t *s, int sample_rate, float playout_rate); SPAN_DECLARE(time_scale_state_t *) time_scale_init(time_scale_state_t *s, int sample_rate, float playout_rate);
/*! \brief Free a time scale context. /*! \brief Free a time scale context.
\param s The time scale context. \param s The time scale context.

2
libs/spandsp/src/spandsp/tone_generate.h
View File

@ -88,7 +88,7 @@ SPAN_DECLARE(void) make_tone_gen_descriptor(tone_gen_descriptor_t *s,
int d4, int d4,
int repeat); int repeat);
SPAN_DECLARE(tone_gen_state_t) *tone_gen_init(tone_gen_state_t *s, tone_gen_descriptor_t *t); SPAN_DECLARE(tone_gen_state_t *) tone_gen_init(tone_gen_state_t *s, tone_gen_descriptor_t *t);
SPAN_DECLARE(int) tone_gen(tone_gen_state_t *s, int16_t amp[], int max_samples); SPAN_DECLARE(int) tone_gen(tone_gen_state_t *s, int16_t amp[], int max_samples);

4
libs/spandsp/src/spandsp/v17rx.h
View File

@ -243,7 +243,7 @@ extern "C"
\param put_bit The callback routine used to put the received data. \param put_bit The callback routine used to put the received data.
\param user_data An opaque pointer passed to the put_bit routine. \param user_data An opaque pointer passed to the put_bit routine.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(v17_rx_state_t) *v17_rx_init(v17_rx_state_t *s, int bit_rate, put_bit_func_t put_bit, void *user_data); SPAN_DECLARE(v17_rx_state_t *) v17_rx_init(v17_rx_state_t *s, int bit_rate, put_bit_func_t put_bit, void *user_data);
/*! Reinitialise an existing V.17 modem receive context. /*! Reinitialise an existing V.17 modem receive context.
\brief Reinitialise an existing V.17 modem receive context. \brief Reinitialise an existing V.17 modem receive context.
@ -259,7 +259,7 @@ SPAN_DECLARE(int) v17_rx_restart(v17_rx_state_t *s, int bit_rate, int short_trai
\return 0 for OK */ \return 0 for OK */
SPAN_DECLARE(int) v17_rx_free(v17_rx_state_t *s); SPAN_DECLARE(int) v17_rx_free(v17_rx_state_t *s);
SPAN_DECLARE(logging_state_t) *v17_rx_get_logging_state(v17_rx_state_t *s); SPAN_DECLARE(logging_state_t *) v17_rx_get_logging_state(v17_rx_state_t *s);
/*! Change the put_bit function associated with a V.17 modem receive context. /*! Change the put_bit function associated with a V.17 modem receive context.
\brief Change the put_bit function associated with a V.17 modem receive context. \brief Change the put_bit function associated with a V.17 modem receive context.

4
libs/spandsp/src/spandsp/v17tx.h
View File

@ -109,7 +109,7 @@ SPAN_DECLARE(void) v17_tx_power(v17_tx_state_t *s, float power);
\param get_bit The callback routine used to get the data to be transmitted. \param get_bit The callback routine used to get the data to be transmitted.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(v17_tx_state_t) *v17_tx_init(v17_tx_state_t *s, int rate, int tep, get_bit_func_t get_bit, void *user_data); SPAN_DECLARE(v17_tx_state_t *) v17_tx_init(v17_tx_state_t *s, int rate, int tep, get_bit_func_t get_bit, void *user_data);
/*! Reinitialise an existing V.17 modem transmit context, so it may be reused. /*! Reinitialise an existing V.17 modem transmit context, so it may be reused.
\brief Reinitialise an existing V.17 modem transmit context. \brief Reinitialise an existing V.17 modem transmit context.
@ -126,7 +126,7 @@ SPAN_DECLARE(int) v17_tx_restart(v17_tx_state_t *s, int bit_rate, int tep, int s
\return 0 for OK */ \return 0 for OK */
SPAN_DECLARE(int) v17_tx_free(v17_tx_state_t *s); SPAN_DECLARE(int) v17_tx_free(v17_tx_state_t *s);
SPAN_DECLARE(logging_state_t) *v17_tx_get_logging_state(v17_tx_state_t *s); SPAN_DECLARE(logging_state_t *) v17_tx_get_logging_state(v17_tx_state_t *s);
/*! Change the get_bit function associated with a V.17 modem transmit context. /*! Change the get_bit function associated with a V.17 modem transmit context.
\brief Change the get_bit function associated with a V.17 modem transmit context. \brief Change the get_bit function associated with a V.17 modem transmit context.

4
libs/spandsp/src/spandsp/v22bis.h
View File

@ -144,7 +144,7 @@ SPAN_DECLARE(int) v22bis_restart(v22bis_state_t *s, int bit_rate);
\param put_bit The callback routine used to get the data to be transmitted. \param put_bit The callback routine used to get the data to be transmitted.
\param user_data An opaque pointer, passed in calls to the get and put routines. \param user_data An opaque pointer, passed in calls to the get and put routines.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(v22bis_state_t) *v22bis_init(v22bis_state_t *s, SPAN_DECLARE(v22bis_state_t *) v22bis_init(v22bis_state_t *s,
int bit_rate, int bit_rate,
int guard, int guard,
int caller, int caller,
@ -158,7 +158,7 @@ SPAN_DECLARE(v22bis_state_t) *v22bis_init(v22bis_state_t *s,
\return 0 for OK */ \return 0 for OK */
SPAN_DECLARE(int) v22bis_free(v22bis_state_t *s); SPAN_DECLARE(int) v22bis_free(v22bis_state_t *s);
SPAN_DECLARE(logging_state_t) *v22bis_get_logging_state(v22bis_state_t *s); SPAN_DECLARE(logging_state_t *) v22bis_get_logging_state(v22bis_state_t *s);
/*! Change the get_bit function associated with a V.22bis modem context. /*! Change the get_bit function associated with a V.22bis modem context.
\brief Change the get_bit function associated with a V.22bis modem context. \brief Change the get_bit function associated with a V.22bis modem context.

4
libs/spandsp/src/spandsp/v27ter_rx.h
View File

@ -78,7 +78,7 @@ extern "C"
\param put_bit The callback routine used to put the received data. \param put_bit The callback routine used to put the received data.
\param user_data An opaque pointer passed to the put_bit routine. \param user_data An opaque pointer passed to the put_bit routine.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(v27ter_rx_state_t) *v27ter_rx_init(v27ter_rx_state_t *s, int bit_rate, put_bit_func_t put_bit, void *user_data); SPAN_DECLARE(v27ter_rx_state_t *) v27ter_rx_init(v27ter_rx_state_t *s, int bit_rate, put_bit_func_t put_bit, void *user_data);
/*! Reinitialise an existing V.27ter modem receive context. /*! Reinitialise an existing V.27ter modem receive context.
\brief Reinitialise an existing V.27ter modem receive context. \brief Reinitialise an existing V.27ter modem receive context.
@ -94,7 +94,7 @@ SPAN_DECLARE(int) v27ter_rx_restart(v27ter_rx_state_t *s, int bit_rate, int old_
\return 0 for OK */ \return 0 for OK */
SPAN_DECLARE(int) v27ter_rx_free(v27ter_rx_state_t *s); SPAN_DECLARE(int) v27ter_rx_free(v27ter_rx_state_t *s);
SPAN_DECLARE(logging_state_t) *v27ter_rx_get_logging_state(v27ter_rx_state_t *s); SPAN_DECLARE(logging_state_t *) v27ter_rx_get_logging_state(v27ter_rx_state_t *s);
/*! Change the put_bit function associated with a V.27ter modem receive context. /*! Change the put_bit function associated with a V.27ter modem receive context.
\brief Change the put_bit function associated with a V.27ter modem receive context. \brief Change the put_bit function associated with a V.27ter modem receive context.

4
libs/spandsp/src/spandsp/v27ter_tx.h
View File

@ -91,7 +91,7 @@ SPAN_DECLARE(void) v27ter_tx_power(v27ter_tx_state_t *s, float power);
\param get_bit The callback routine used to get the data to be transmitted. \param get_bit The callback routine used to get the data to be transmitted.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(v27ter_tx_state_t) *v27ter_tx_init(v27ter_tx_state_t *s, int bit_rate, int tep, get_bit_func_t get_bit, void *user_data); SPAN_DECLARE(v27ter_tx_state_t *) v27ter_tx_init(v27ter_tx_state_t *s, int bit_rate, int tep, get_bit_func_t get_bit, void *user_data);
/*! Reinitialise an existing V.27ter modem transmit context, so it may be reused. /*! Reinitialise an existing V.27ter modem transmit context, so it may be reused.
\brief Reinitialise an existing V.27ter modem transmit context. \brief Reinitialise an existing V.27ter modem transmit context.
@ -107,7 +107,7 @@ SPAN_DECLARE(int) v27ter_tx_restart(v27ter_tx_state_t *s, int bit_rate, int tep)
\return 0 for OK */ \return 0 for OK */
SPAN_DECLARE(int) v27ter_tx_free(v27ter_tx_state_t *s); SPAN_DECLARE(int) v27ter_tx_free(v27ter_tx_state_t *s);
SPAN_DECLARE(logging_state_t) *v27ter_tx_get_logging_state(v27ter_tx_state_t *s); SPAN_DECLARE(logging_state_t *) v27ter_tx_get_logging_state(v27ter_tx_state_t *s);
/*! Change the get_bit function associated with a V.27ter modem transmit context. /*! Change the get_bit function associated with a V.27ter modem transmit context.
\brief Change the get_bit function associated with a V.27ter modem transmit context. \brief Change the get_bit function associated with a V.27ter modem transmit context.

4
libs/spandsp/src/spandsp/v29rx.h
View File

@ -147,7 +147,7 @@ extern "C"
\param put_bit The callback routine used to put the received data. \param put_bit The callback routine used to put the received data.
\param user_data An opaque pointer passed to the put_bit routine. \param user_data An opaque pointer passed to the put_bit routine.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(v29_rx_state_t) *v29_rx_init(v29_rx_state_t *s, int bit_rate, put_bit_func_t put_bit, void *user_data); SPAN_DECLARE(v29_rx_state_t *) v29_rx_init(v29_rx_state_t *s, int bit_rate, put_bit_func_t put_bit, void *user_data);
/*! Reinitialise an existing V.29 modem receive context. /*! Reinitialise an existing V.29 modem receive context.
\brief Reinitialise an existing V.29 modem receive context. \brief Reinitialise an existing V.29 modem receive context.
@ -163,7 +163,7 @@ SPAN_DECLARE(int) v29_rx_restart(v29_rx_state_t *s, int bit_rate, int old_train)
\return 0 for OK */ \return 0 for OK */
SPAN_DECLARE(int) v29_rx_free(v29_rx_state_t *s); SPAN_DECLARE(int) v29_rx_free(v29_rx_state_t *s);
SPAN_DECLARE(logging_state_t) *v29_rx_get_logging_state(v29_rx_state_t *s); SPAN_DECLARE(logging_state_t *) v29_rx_get_logging_state(v29_rx_state_t *s);
/*! Change the put_bit function associated with a V.29 modem receive context. /*! Change the put_bit function associated with a V.29 modem receive context.
\brief Change the put_bit function associated with a V.29 modem receive context. \brief Change the put_bit function associated with a V.29 modem receive context.

4
libs/spandsp/src/spandsp/v29tx.h
View File

@ -122,7 +122,7 @@ SPAN_DECLARE(void) v29_tx_power(v29_tx_state_t *s, float power);
\param get_bit The callback routine used to get the data to be transmitted. \param get_bit The callback routine used to get the data to be transmitted.
\param user_data An opaque pointer. \param user_data An opaque pointer.
\return A pointer to the modem context, or NULL if there was a problem. */ \return A pointer to the modem context, or NULL if there was a problem. */
SPAN_DECLARE(v29_tx_state_t) *v29_tx_init(v29_tx_state_t *s, int bit_rate, int tep, get_bit_func_t get_bit, void *user_data); SPAN_DECLARE(v29_tx_state_t *) v29_tx_init(v29_tx_state_t *s, int bit_rate, int tep, get_bit_func_t get_bit, void *user_data);
/*! Reinitialise an existing V.29 modem transmit context, so it may be reused. /*! Reinitialise an existing V.29 modem transmit context, so it may be reused.
\brief Reinitialise an existing V.29 modem transmit context. \brief Reinitialise an existing V.29 modem transmit context.
@ -138,7 +138,7 @@ SPAN_DECLARE(int) v29_tx_restart(v29_tx_state_t *s, int bit_rate, int tep);
\return 0 for OK */ \return 0 for OK */
SPAN_DECLARE(int) v29_tx_free(v29_tx_state_t *s); SPAN_DECLARE(int) v29_tx_free(v29_tx_state_t *s);
SPAN_DECLARE(logging_state_t) *v29_tx_get_logging_state(v29_tx_state_t *s); SPAN_DECLARE(logging_state_t *) v29_tx_get_logging_state(v29_tx_state_t *s);
/*! Change the get_bit function associated with a V.29 modem transmit context. /*! Change the get_bit function associated with a V.29 modem transmit context.
\brief Change the get_bit function associated with a V.29 modem transmit context. \brief Change the get_bit function associated with a V.29 modem transmit context.

6
libs/spandsp/src/spandsp/v42.h
View File

@ -82,7 +82,7 @@ extern "C"
{ {
#endif #endif
SPAN_DECLARE(const char) *lapm_status_to_str(int status); SPAN_DECLARE(const char *) lapm_status_to_str(int status);
/*! Dump LAP.M frames in a raw and/or decoded forms /*! Dump LAP.M frames in a raw and/or decoded forms
\param frame The frame itself \param frame The frame itself
@ -94,7 +94,7 @@ SPAN_DECLARE(void) lapm_dump(lapm_state_t *s, const uint8_t *frame, int len, int
/*! Accept an HDLC packet /*! Accept an HDLC packet
*/ */
SPAN_DECLARE(void) lapm_receive(void *user_data, const uint8_t *buf, int len, int ok); void lapm_receive(void *user_data, const uint8_t *buf, int len, int ok);
/*! Transmit a LAP.M frame /*! Transmit a LAP.M frame
*/ */
@ -135,7 +135,7 @@ SPAN_DECLARE(int) v42_tx_bit(void *user_data);
\param user_data An opaque pointer passed to the frame handler routine. \param user_data An opaque pointer passed to the frame handler routine.
\return ??? \return ???
*/ */
SPAN_DECLARE(v42_state_t) *v42_init(v42_state_t *s, int caller, int detect, v42_frame_handler_t frame_handler, void *user_data); SPAN_DECLARE(v42_state_t *) v42_init(v42_state_t *s, int caller, int detect, v42_frame_handler_t frame_handler, void *user_data);
/*! Restart a V.42 context. /*! Restart a V.42 context.
\param s The V.42 context. \param s The V.42 context.

2
libs/spandsp/src/spandsp/v42bis.h
View File

@ -106,7 +106,7 @@ SPAN_DECLARE(int) v42bis_decompress_flush(v42bis_state_t *s);
\param data_user_data . \param data_user_data .
\param max_data_len The maximum length that should be passed to the data handler. \param max_data_len The maximum length that should be passed to the data handler.
\return The V.42bis context. */ \return The V.42bis context. */
SPAN_DECLARE(v42bis_state_t) *v42bis_init(v42bis_state_t *s, SPAN_DECLARE(v42bis_state_t *) v42bis_init(v42bis_state_t *s,
int negotiated_p0, int negotiated_p0,
int negotiated_p1, int negotiated_p1,
int negotiated_p2, int negotiated_p2,

14
libs/spandsp/src/spandsp/v8.h
View File

@ -128,7 +128,7 @@ extern "C"
\param result_handler The callback routine used to handle the results of negotiation. \param result_handler The callback routine used to handle the results of negotiation.
\param user_data An opaque pointer passed to the result_handler routine. \param user_data An opaque pointer passed to the result_handler routine.
\return A pointer to the V.8 context, or NULL if there was a problem. */ \return A pointer to the V.8 context, or NULL if there was a problem. */
SPAN_DECLARE(v8_state_t) *v8_init(v8_state_t *s, SPAN_DECLARE(v8_state_t *) v8_init(v8_state_t *s,
int caller, int caller,
int available_modulations, int available_modulations,
v8_result_handler_t *result_handler, v8_result_handler_t *result_handler,
@ -146,7 +146,7 @@ SPAN_DECLARE(int) v8_release(v8_state_t *s);
\return 0 for OK. */ \return 0 for OK. */
SPAN_DECLARE(int) v8_free(v8_state_t *s); SPAN_DECLARE(int) v8_free(v8_state_t *s);
SPAN_DECLARE(logging_state_t) *v8_get_logging_state(v8_state_t *s); SPAN_DECLARE(logging_state_t *) v8_get_logging_state(v8_state_t *s);
/*! Generate a block of V.8 audio samples. /*! Generate a block of V.8 audio samples.
\brief Generate a block of V.8 audio samples. \brief Generate a block of V.8 audio samples.
@ -171,11 +171,11 @@ SPAN_DECLARE(int) v8_rx(v8_state_t *s, const int16_t *amp, int len);
\param modulation_schemes The list of supported modulations. */ \param modulation_schemes The list of supported modulations. */
SPAN_DECLARE(void) v8_log_supported_modulations(v8_state_t *s, int modulation_schemes); SPAN_DECLARE(void) v8_log_supported_modulations(v8_state_t *s, int modulation_schemes);
SPAN_DECLARE(const char) *v8_call_function_to_str(int call_function); SPAN_DECLARE(const char *) v8_call_function_to_str(int call_function);
SPAN_DECLARE(const char) *v8_modulation_to_str(int modulation_scheme); SPAN_DECLARE(const char *) v8_modulation_to_str(int modulation_scheme);
SPAN_DECLARE(const char) *v8_protocol_to_str(int protocol); SPAN_DECLARE(const char *) v8_protocol_to_str(int protocol);
SPAN_DECLARE(const char) *v8_pstn_access_to_str(int pstn_access); SPAN_DECLARE(const char *) v8_pstn_access_to_str(int pstn_access);
SPAN_DECLARE(const char) *v8_pcm_modem_availability_to_str(int pcm_modem_availability); SPAN_DECLARE(const char *) v8_pcm_modem_availability_to_str(int pcm_modem_availability);
#if defined(__cplusplus) #if defined(__cplusplus)
} }

16
libs/spandsp/src/super_tone_rx.c
View File

@ -105,7 +105,7 @@ static int add_super_tone_freq(super_tone_rx_descriptor_t *desc, int freq)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int super_tone_rx_add_tone(super_tone_rx_descriptor_t *desc) SPAN_DECLARE(int) super_tone_rx_add_tone(super_tone_rx_descriptor_t *desc)
{ {
if (desc->tones%5 == 0) if (desc->tones%5 == 0)
{ {
@ -119,7 +119,7 @@ int super_tone_rx_add_tone(super_tone_rx_descriptor_t *desc)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int super_tone_rx_add_element(super_tone_rx_descriptor_t *desc, SPAN_DECLARE(int) super_tone_rx_add_element(super_tone_rx_descriptor_t *desc,
int tone, int tone,
int f1, int f1,
int f2, int f2,
@ -197,7 +197,7 @@ static int test_cadence(super_tone_rx_segment_t *pattern,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
super_tone_rx_descriptor_t *super_tone_rx_make_descriptor(super_tone_rx_descriptor_t *desc) SPAN_DECLARE(super_tone_rx_descriptor_t *) super_tone_rx_make_descriptor(super_tone_rx_descriptor_t *desc)
{ {
if (desc == NULL) if (desc == NULL)
{ {
@ -215,7 +215,7 @@ super_tone_rx_descriptor_t *super_tone_rx_make_descriptor(super_tone_rx_descript
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int super_tone_rx_free_descriptor(super_tone_rx_descriptor_t *desc) SPAN_DECLARE(int) super_tone_rx_free_descriptor(super_tone_rx_descriptor_t *desc)
{ {
if (desc) if (desc)
free(desc); free(desc);
@ -223,14 +223,14 @@ int super_tone_rx_free_descriptor(super_tone_rx_descriptor_t *desc)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void super_tone_rx_segment_callback(super_tone_rx_state_t *s, SPAN_DECLARE(void) super_tone_rx_segment_callback(super_tone_rx_state_t *s,
void (*callback)(void *data, int f1, int f2, int duration)) void (*callback)(void *data, int f1, int f2, int duration))
{ {
s->segment_callback = callback; s->segment_callback = callback;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
super_tone_rx_state_t *super_tone_rx_init(super_tone_rx_state_t *s, SPAN_DECLARE(super_tone_rx_state_t *) super_tone_rx_init(super_tone_rx_state_t *s,
super_tone_rx_descriptor_t *desc, super_tone_rx_descriptor_t *desc,
tone_report_func_t callback, tone_report_func_t callback,
void *user_data) void *user_data)
@ -266,7 +266,7 @@ super_tone_rx_state_t *super_tone_rx_init(super_tone_rx_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int super_tone_rx_free(super_tone_rx_state_t *s) SPAN_DECLARE(int) super_tone_rx_free(super_tone_rx_state_t *s)
{ {
if (s) if (s)
free(s); free(s);
@ -410,7 +410,7 @@ static void super_tone_chunk(super_tone_rx_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int super_tone_rx(super_tone_rx_state_t *s, const int16_t amp[], int samples) SPAN_DECLARE(int) super_tone_rx(super_tone_rx_state_t *s, const int16_t amp[], int samples)
{ {
int i; int i;
int x; int x;

8
libs/spandsp/src/super_tone_tx.c
View File

@ -69,7 +69,7 @@
two iterations of 50 seconds each. two iterations of 50 seconds each.
*/ */
super_tone_tx_step_t *super_tone_tx_make_step(super_tone_tx_step_t *s, SPAN_DECLARE(super_tone_tx_step_t *) super_tone_tx_make_step(super_tone_tx_step_t *s,
float f1, float f1,
float l1, float l1,
float f2, float f2,
@ -111,7 +111,7 @@ super_tone_tx_step_t *super_tone_tx_make_step(super_tone_tx_step_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void super_tone_tx_free(super_tone_tx_step_t *s) SPAN_DECLARE(void) super_tone_tx_free(super_tone_tx_step_t *s)
{ {
super_tone_tx_step_t *t; super_tone_tx_step_t *t;
@ -127,7 +127,7 @@ void super_tone_tx_free(super_tone_tx_step_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
super_tone_tx_state_t *super_tone_tx_init(super_tone_tx_state_t *s, super_tone_tx_step_t *tree) SPAN_DECLARE(super_tone_tx_state_t *) super_tone_tx_init(super_tone_tx_state_t *s, super_tone_tx_step_t *tree)
{ {
if (tree == NULL) if (tree == NULL)
return NULL; return NULL;
@ -146,7 +146,7 @@ super_tone_tx_state_t *super_tone_tx_init(super_tone_tx_state_t *s, super_tone_t
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int super_tone_tx(super_tone_tx_state_t *s, int16_t amp[], int max_samples) SPAN_DECLARE(int) super_tone_tx(super_tone_tx_state_t *s, int16_t amp[], int max_samples)
{ {
int samples; int samples;
int limit; int limit;

28
libs/spandsp/src/t30.c
View File

@ -5026,7 +5026,7 @@ void t30_non_ecm_put_bit(void *user_data, int bit)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_non_ecm_put_byte(void *user_data, int byte) SPAN_DECLARE(void) t30_non_ecm_put_byte(void *user_data, int byte)
{ {
t30_state_t *s; t30_state_t *s;
@ -5062,7 +5062,7 @@ void t30_non_ecm_put_byte(void *user_data, int byte)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_non_ecm_put_chunk(void *user_data, const uint8_t buf[], int len) SPAN_DECLARE(void) t30_non_ecm_put_chunk(void *user_data, const uint8_t buf[], int len)
{ {
t30_state_t *s; t30_state_t *s;
int i; int i;
@ -5137,7 +5137,7 @@ int t30_non_ecm_get_bit(void *user_data)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_non_ecm_get_byte(void *user_data) SPAN_DECLARE(int) t30_non_ecm_get_byte(void *user_data)
{ {
int byte; int byte;
t30_state_t *s; t30_state_t *s;
@ -5172,7 +5172,7 @@ int t30_non_ecm_get_byte(void *user_data)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_non_ecm_get_chunk(void *user_data, uint8_t buf[], int max_len) SPAN_DECLARE(int) t30_non_ecm_get_chunk(void *user_data, uint8_t buf[], int max_len)
{ {
int len; int len;
t30_state_t *s; t30_state_t *s;
@ -5356,7 +5356,7 @@ void t30_hdlc_accept(void *user_data, const uint8_t *msg, int len, int ok)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_front_end_status(void *user_data, int status) SPAN_DECLARE(void) t30_front_end_status(void *user_data, int status)
{ {
t30_state_t *s; t30_state_t *s;
@ -5671,7 +5671,7 @@ void t30_front_end_status(void *user_data, int status)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_timer_update(t30_state_t *s, int samples) SPAN_DECLARE(void) t30_timer_update(t30_state_t *s, int samples)
{ {
if (s->timer_t0_t1 > 0) if (s->timer_t0_t1 > 0)
{ {
@ -5723,7 +5723,7 @@ void t30_timer_update(t30_state_t *s, int samples)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_terminate(t30_state_t *s) SPAN_DECLARE(void) t30_terminate(t30_state_t *s)
{ {
if (s->phase != T30_PHASE_CALL_FINISHED) if (s->phase != T30_PHASE_CALL_FINISHED)
{ {
@ -5753,7 +5753,7 @@ void t30_terminate(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_get_transfer_statistics(t30_state_t *s, t30_stats_t *t) SPAN_DECLARE(void) t30_get_transfer_statistics(t30_state_t *s, t30_stats_t *t)
{ {
t4_stats_t stats; t4_stats_t stats;
@ -5775,7 +5775,7 @@ void t30_get_transfer_statistics(t30_state_t *s, t30_stats_t *t)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_local_interrupt_request(t30_state_t *s, int state) SPAN_DECLARE(void) t30_local_interrupt_request(t30_state_t *s, int state)
{ {
if (s->timer_t3 > 0) if (s->timer_t3 > 0)
{ {
@ -5787,7 +5787,7 @@ void t30_local_interrupt_request(t30_state_t *s, int state)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_restart(t30_state_t *s) SPAN_DECLARE(int) t30_restart(t30_state_t *s)
{ {
s->phase = T30_PHASE_IDLE; s->phase = T30_PHASE_IDLE;
s->next_phase = T30_PHASE_IDLE; s->next_phase = T30_PHASE_IDLE;
@ -5822,7 +5822,7 @@ int t30_restart(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
t30_state_t *t30_init(t30_state_t *s, SPAN_DECLARE(t30_state_t *) t30_init(t30_state_t *s,
int calling_party, int calling_party,
t30_set_handler_t *set_rx_type_handler, t30_set_handler_t *set_rx_type_handler,
void *set_rx_type_user_data, void *set_rx_type_user_data,
@ -5863,7 +5863,7 @@ t30_state_t *t30_init(t30_state_t *s,
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_release(t30_state_t *s) SPAN_DECLARE(int) t30_release(t30_state_t *s)
{ {
/* Make sure any FAX in progress is tidied up. If the tidying up has /* Make sure any FAX in progress is tidied up. If the tidying up has
already happened, repeating it here is harmless. */ already happened, repeating it here is harmless. */
@ -5881,7 +5881,7 @@ int t30_release(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_free(t30_state_t *s) SPAN_DECLARE(int) t30_free(t30_state_t *s)
{ {
t30_release(s); t30_release(s);
free(s); free(s);
@ -5889,7 +5889,7 @@ int t30_free(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_call_active(t30_state_t *s) SPAN_DECLARE(int) t30_call_active(t30_state_t *s)
{ {
return (s->phase != T30_PHASE_CALL_FINISHED); return (s->phase != T30_PHASE_CALL_FINISHED);
} }

132
libs/spandsp/src/t30_api.c
View File

@ -73,7 +73,7 @@
#include "t30_local.h" #include "t30_local.h"
int t30_set_tx_ident(t30_state_t *s, const char *id) SPAN_DECLARE(int) t30_set_tx_ident(t30_state_t *s, const char *id)
{ {
if (id == NULL) if (id == NULL)
{ {
@ -88,7 +88,7 @@ int t30_set_tx_ident(t30_state_t *s, const char *id)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_tx_ident(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_tx_ident(t30_state_t *s)
{ {
if (s->tx_info.ident[0] == '\0') if (s->tx_info.ident[0] == '\0')
return NULL; return NULL;
@ -96,7 +96,7 @@ const char *t30_get_tx_ident(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_ident(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_ident(t30_state_t *s)
{ {
if (s->rx_info.ident[0] == '\0') if (s->rx_info.ident[0] == '\0')
return NULL; return NULL;
@ -104,7 +104,7 @@ const char *t30_get_rx_ident(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_sub_address(t30_state_t *s, const char *sub_address) SPAN_DECLARE(int) t30_set_tx_sub_address(t30_state_t *s, const char *sub_address)
{ {
if (sub_address == NULL) if (sub_address == NULL)
{ {
@ -118,7 +118,7 @@ int t30_set_tx_sub_address(t30_state_t *s, const char *sub_address)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_tx_sub_address(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_tx_sub_address(t30_state_t *s)
{ {
if (s->tx_info.sub_address[0] == '\0') if (s->tx_info.sub_address[0] == '\0')
return NULL; return NULL;
@ -126,7 +126,7 @@ const char *t30_get_tx_sub_address(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_sub_address(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_sub_address(t30_state_t *s)
{ {
if (s->rx_info.sub_address[0] == '\0') if (s->rx_info.sub_address[0] == '\0')
return NULL; return NULL;
@ -134,7 +134,7 @@ const char *t30_get_rx_sub_address(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_selective_polling_address(t30_state_t *s, const char *selective_polling_address) SPAN_DECLARE(int) t30_set_tx_selective_polling_address(t30_state_t *s, const char *selective_polling_address)
{ {
if (selective_polling_address == NULL) if (selective_polling_address == NULL)
{ {
@ -148,7 +148,7 @@ int t30_set_tx_selective_polling_address(t30_state_t *s, const char *selective_p
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_tx_selective_polling_address(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_tx_selective_polling_address(t30_state_t *s)
{ {
if (s->tx_info.selective_polling_address[0] == '\0') if (s->tx_info.selective_polling_address[0] == '\0')
return NULL; return NULL;
@ -156,7 +156,7 @@ const char *t30_get_tx_selective_polling_address(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_selective_polling_address(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_selective_polling_address(t30_state_t *s)
{ {
if (s->rx_info.selective_polling_address[0] == '\0') if (s->rx_info.selective_polling_address[0] == '\0')
return NULL; return NULL;
@ -164,7 +164,7 @@ const char *t30_get_rx_selective_polling_address(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_polled_sub_address(t30_state_t *s, const char *polled_sub_address) SPAN_DECLARE(int) t30_set_tx_polled_sub_address(t30_state_t *s, const char *polled_sub_address)
{ {
if (polled_sub_address == NULL) if (polled_sub_address == NULL)
{ {
@ -178,7 +178,7 @@ int t30_set_tx_polled_sub_address(t30_state_t *s, const char *polled_sub_address
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_tx_polled_sub_address(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_tx_polled_sub_address(t30_state_t *s)
{ {
if (s->tx_info.polled_sub_address[0] == '\0') if (s->tx_info.polled_sub_address[0] == '\0')
return NULL; return NULL;
@ -186,7 +186,7 @@ const char *t30_get_tx_polled_sub_address(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_polled_sub_address(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_polled_sub_address(t30_state_t *s)
{ {
if (s->rx_info.polled_sub_address[0] == '\0') if (s->rx_info.polled_sub_address[0] == '\0')
return NULL; return NULL;
@ -194,7 +194,7 @@ const char *t30_get_rx_polled_sub_address(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_sender_ident(t30_state_t *s, const char *sender_ident) SPAN_DECLARE(int) t30_set_tx_sender_ident(t30_state_t *s, const char *sender_ident)
{ {
if (sender_ident == NULL) if (sender_ident == NULL)
{ {
@ -208,7 +208,7 @@ int t30_set_tx_sender_ident(t30_state_t *s, const char *sender_ident)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_tx_sender_ident(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_tx_sender_ident(t30_state_t *s)
{ {
if (s->tx_info.sender_ident[0] == '\0') if (s->tx_info.sender_ident[0] == '\0')
return NULL; return NULL;
@ -216,7 +216,7 @@ const char *t30_get_tx_sender_ident(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_sender_ident(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_sender_ident(t30_state_t *s)
{ {
if (s->rx_info.sender_ident[0] == '\0') if (s->rx_info.sender_ident[0] == '\0')
return NULL; return NULL;
@ -224,7 +224,7 @@ const char *t30_get_rx_sender_ident(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_password(t30_state_t *s, const char *password) SPAN_DECLARE(int) t30_set_tx_password(t30_state_t *s, const char *password)
{ {
if (password == NULL) if (password == NULL)
{ {
@ -238,7 +238,7 @@ int t30_set_tx_password(t30_state_t *s, const char *password)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_tx_password(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_tx_password(t30_state_t *s)
{ {
if (s->tx_info.password[0] == '\0') if (s->tx_info.password[0] == '\0')
return NULL; return NULL;
@ -246,7 +246,7 @@ const char *t30_get_tx_password(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_password(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_password(t30_state_t *s)
{ {
if (s->rx_info.password[0] == '\0') if (s->rx_info.password[0] == '\0')
return NULL; return NULL;
@ -254,7 +254,7 @@ const char *t30_get_rx_password(t30_state_t *s)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_nsf(t30_state_t *s, const uint8_t *nsf, int len) SPAN_DECLARE(int) t30_set_tx_nsf(t30_state_t *s, const uint8_t *nsf, int len)
{ {
if (s->tx_info.nsf) if (s->tx_info.nsf)
free(s->tx_info.nsf); free(s->tx_info.nsf);
@ -272,7 +272,7 @@ int t30_set_tx_nsf(t30_state_t *s, const uint8_t *nsf, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_nsf(t30_state_t *s, const uint8_t *nsf[]) SPAN_DECLARE(size_t) t30_get_tx_nsf(t30_state_t *s, const uint8_t *nsf[])
{ {
if (nsf) if (nsf)
*nsf = s->tx_info.nsf; *nsf = s->tx_info.nsf;
@ -280,7 +280,7 @@ size_t t30_get_tx_nsf(t30_state_t *s, const uint8_t *nsf[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_nsf(t30_state_t *s, const uint8_t *nsf[]) SPAN_DECLARE(size_t) t30_get_rx_nsf(t30_state_t *s, const uint8_t *nsf[])
{ {
if (nsf) if (nsf)
*nsf = s->rx_info.nsf; *nsf = s->rx_info.nsf;
@ -288,7 +288,7 @@ size_t t30_get_rx_nsf(t30_state_t *s, const uint8_t *nsf[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_nsc(t30_state_t *s, const uint8_t *nsc, int len) SPAN_DECLARE(int) t30_set_tx_nsc(t30_state_t *s, const uint8_t *nsc, int len)
{ {
if (s->tx_info.nsc) if (s->tx_info.nsc)
free(s->tx_info.nsc); free(s->tx_info.nsc);
@ -306,7 +306,7 @@ int t30_set_tx_nsc(t30_state_t *s, const uint8_t *nsc, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_nsc(t30_state_t *s, const uint8_t *nsc[]) SPAN_DECLARE(size_t) t30_get_tx_nsc(t30_state_t *s, const uint8_t *nsc[])
{ {
if (nsc) if (nsc)
*nsc = s->tx_info.nsc; *nsc = s->tx_info.nsc;
@ -314,7 +314,7 @@ size_t t30_get_tx_nsc(t30_state_t *s, const uint8_t *nsc[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_nsc(t30_state_t *s, const uint8_t *nsc[]) SPAN_DECLARE(size_t) t30_get_rx_nsc(t30_state_t *s, const uint8_t *nsc[])
{ {
if (nsc) if (nsc)
*nsc = s->rx_info.nsc; *nsc = s->rx_info.nsc;
@ -322,7 +322,7 @@ size_t t30_get_rx_nsc(t30_state_t *s, const uint8_t *nsc[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_nss(t30_state_t *s, const uint8_t *nss, int len) SPAN_DECLARE(int) t30_set_tx_nss(t30_state_t *s, const uint8_t *nss, int len)
{ {
if (s->tx_info.nss) if (s->tx_info.nss)
free(s->tx_info.nss); free(s->tx_info.nss);
@ -340,7 +340,7 @@ int t30_set_tx_nss(t30_state_t *s, const uint8_t *nss, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_nss(t30_state_t *s, const uint8_t *nss[]) SPAN_DECLARE(size_t) t30_get_tx_nss(t30_state_t *s, const uint8_t *nss[])
{ {
if (nss) if (nss)
*nss = s->tx_info.nss; *nss = s->tx_info.nss;
@ -348,7 +348,7 @@ size_t t30_get_tx_nss(t30_state_t *s, const uint8_t *nss[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_nss(t30_state_t *s, const uint8_t *nss[]) SPAN_DECLARE(size_t) t30_get_rx_nss(t30_state_t *s, const uint8_t *nss[])
{ {
if (nss) if (nss)
*nss = s->rx_info.nss; *nss = s->rx_info.nss;
@ -356,7 +356,7 @@ size_t t30_get_rx_nss(t30_state_t *s, const uint8_t *nss[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_tsa(t30_state_t *s, int type, const char *address, int len) SPAN_DECLARE(int) t30_set_tx_tsa(t30_state_t *s, int type, const char *address, int len)
{ {
if (s->tx_info.tsa) if (s->tx_info.tsa)
free(s->tx_info.tsa); free(s->tx_info.tsa);
@ -378,7 +378,7 @@ int t30_set_tx_tsa(t30_state_t *s, int type, const char *address, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_tsa(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_tx_tsa(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->tx_info.tsa_type; *type = s->tx_info.tsa_type;
@ -388,7 +388,7 @@ size_t t30_get_tx_tsa(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_tsa(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_rx_tsa(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->rx_info.tsa_type; *type = s->rx_info.tsa_type;
@ -398,7 +398,7 @@ size_t t30_get_rx_tsa(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_ira(t30_state_t *s, int type, const char *address, int len) SPAN_DECLARE(int) t30_set_tx_ira(t30_state_t *s, int type, const char *address, int len)
{ {
if (s->tx_info.ira) if (s->tx_info.ira)
free(s->tx_info.ira); free(s->tx_info.ira);
@ -412,7 +412,7 @@ int t30_set_tx_ira(t30_state_t *s, int type, const char *address, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_ira(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_tx_ira(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->tx_info.ira_type; *type = s->tx_info.ira_type;
@ -422,7 +422,7 @@ size_t t30_get_tx_ira(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_ira(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_rx_ira(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->rx_info.ira_type; *type = s->rx_info.ira_type;
@ -432,7 +432,7 @@ size_t t30_get_rx_ira(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_cia(t30_state_t *s, int type, const char *address, int len) SPAN_DECLARE(int) t30_set_tx_cia(t30_state_t *s, int type, const char *address, int len)
{ {
if (s->tx_info.cia) if (s->tx_info.cia)
free(s->tx_info.cia); free(s->tx_info.cia);
@ -446,7 +446,7 @@ int t30_set_tx_cia(t30_state_t *s, int type, const char *address, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_cia(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_tx_cia(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->tx_info.cia_type; *type = s->tx_info.cia_type;
@ -456,7 +456,7 @@ size_t t30_get_tx_cia(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_cia(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_rx_cia(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->rx_info.cia_type; *type = s->rx_info.cia_type;
@ -466,7 +466,7 @@ size_t t30_get_rx_cia(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_isp(t30_state_t *s, int type, const char *address, int len) SPAN_DECLARE(int) t30_set_tx_isp(t30_state_t *s, int type, const char *address, int len)
{ {
if (s->tx_info.isp) if (s->tx_info.isp)
free(s->tx_info.isp); free(s->tx_info.isp);
@ -480,7 +480,7 @@ int t30_set_tx_isp(t30_state_t *s, int type, const char *address, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_isp(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_tx_isp(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->tx_info.isp_type; *type = s->tx_info.isp_type;
@ -490,7 +490,7 @@ size_t t30_get_tx_isp(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_isp(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_rx_isp(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->rx_info.isp_type; *type = s->rx_info.isp_type;
@ -500,7 +500,7 @@ size_t t30_get_rx_isp(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_csa(t30_state_t *s, int type, const char *address, int len) SPAN_DECLARE(int) t30_set_tx_csa(t30_state_t *s, int type, const char *address, int len)
{ {
if (s->tx_info.csa) if (s->tx_info.csa)
free(s->tx_info.csa); free(s->tx_info.csa);
@ -514,7 +514,7 @@ int t30_set_tx_csa(t30_state_t *s, int type, const char *address, int len)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_csa(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_tx_csa(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->tx_info.csa_type; *type = s->tx_info.csa_type;
@ -524,7 +524,7 @@ size_t t30_get_tx_csa(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_rx_csa(t30_state_t *s, int *type, const char *address[]) SPAN_DECLARE(size_t) t30_get_rx_csa(t30_state_t *s, int *type, const char *address[])
{ {
if (type) if (type)
*type = s->rx_info.csa_type; *type = s->rx_info.csa_type;
@ -534,7 +534,7 @@ size_t t30_get_rx_csa(t30_state_t *s, int *type, const char *address[])
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_tx_page_header_info(t30_state_t *s, const char *info) SPAN_DECLARE(int) t30_set_tx_page_header_info(t30_state_t *s, const char *info)
{ {
if (info == NULL) if (info == NULL)
{ {
@ -549,7 +549,7 @@ int t30_set_tx_page_header_info(t30_state_t *s, const char *info)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
size_t t30_get_tx_page_header_info(t30_state_t *s, char *info) SPAN_DECLARE(size_t) t30_get_tx_page_header_info(t30_state_t *s, char *info)
{ {
if (info) if (info)
strcpy(info, s->header_info); strcpy(info, s->header_info);
@ -557,25 +557,25 @@ size_t t30_get_tx_page_header_info(t30_state_t *s, char *info)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_country(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_country(t30_state_t *s)
{ {
return s->country; return s->country;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_vendor(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_vendor(t30_state_t *s)
{ {
return s->vendor; return s->vendor;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
const char *t30_get_rx_model(t30_state_t *s) SPAN_DECLARE(const char *) t30_get_rx_model(t30_state_t *s)
{ {
return s->model; return s->model;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_rx_file(t30_state_t *s, const char *file, int stop_page) SPAN_DECLARE(void) t30_set_rx_file(t30_state_t *s, const char *file, int stop_page)
{ {
strncpy(s->rx_file, file, sizeof(s->rx_file)); strncpy(s->rx_file, file, sizeof(s->rx_file));
s->rx_file[sizeof(s->rx_file) - 1] = '\0'; s->rx_file[sizeof(s->rx_file) - 1] = '\0';
@ -583,7 +583,7 @@ void t30_set_rx_file(t30_state_t *s, const char *file, int stop_page)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_tx_file(t30_state_t *s, const char *file, int start_page, int stop_page) SPAN_DECLARE(void) t30_set_tx_file(t30_state_t *s, const char *file, int start_page, int stop_page)
{ {
strncpy(s->tx_file, file, sizeof(s->tx_file)); strncpy(s->tx_file, file, sizeof(s->tx_file));
s->tx_file[sizeof(s->tx_file) - 1] = '\0'; s->tx_file[sizeof(s->tx_file) - 1] = '\0';
@ -592,13 +592,13 @@ void t30_set_tx_file(t30_state_t *s, const char *file, int start_page, int stop_
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_iaf_mode(t30_state_t *s, int iaf) SPAN_DECLARE(void) t30_set_iaf_mode(t30_state_t *s, int iaf)
{ {
s->iaf = iaf; s->iaf = iaf;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_ecm_capability(t30_state_t *s, int enabled) SPAN_DECLARE(int) t30_set_ecm_capability(t30_state_t *s, int enabled)
{ {
s->ecm_allowed = enabled; s->ecm_allowed = enabled;
t30_build_dis_or_dtc(s); t30_build_dis_or_dtc(s);
@ -606,7 +606,7 @@ int t30_set_ecm_capability(t30_state_t *s, int enabled)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_rx_encoding(t30_state_t *s, int encoding) SPAN_DECLARE(int) t30_set_rx_encoding(t30_state_t *s, int encoding)
{ {
switch (encoding) switch (encoding)
{ {
@ -620,7 +620,7 @@ int t30_set_rx_encoding(t30_state_t *s, int encoding)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_minimum_scan_line_time(t30_state_t *s, int min_time) SPAN_DECLARE(int) t30_set_minimum_scan_line_time(t30_state_t *s, int min_time)
{ {
/* There are only certain possible times supported, so we need to select /* There are only certain possible times supported, so we need to select
the code which best matches the request. */ the code which best matches the request. */
@ -641,7 +641,7 @@ int t30_set_minimum_scan_line_time(t30_state_t *s, int min_time)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_supported_modems(t30_state_t *s, int supported_modems) SPAN_DECLARE(int) t30_set_supported_modems(t30_state_t *s, int supported_modems)
{ {
s->supported_modems = supported_modems; s->supported_modems = supported_modems;
t30_build_dis_or_dtc(s); t30_build_dis_or_dtc(s);
@ -649,7 +649,7 @@ int t30_set_supported_modems(t30_state_t *s, int supported_modems)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_supported_compressions(t30_state_t *s, int supported_compressions) SPAN_DECLARE(int) t30_set_supported_compressions(t30_state_t *s, int supported_compressions)
{ {
s->supported_compressions = supported_compressions; s->supported_compressions = supported_compressions;
t30_build_dis_or_dtc(s); t30_build_dis_or_dtc(s);
@ -657,7 +657,7 @@ int t30_set_supported_compressions(t30_state_t *s, int supported_compressions)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_supported_resolutions(t30_state_t *s, int supported_resolutions) SPAN_DECLARE(int) t30_set_supported_resolutions(t30_state_t *s, int supported_resolutions)
{ {
s->supported_resolutions = supported_resolutions; s->supported_resolutions = supported_resolutions;
t30_build_dis_or_dtc(s); t30_build_dis_or_dtc(s);
@ -665,7 +665,7 @@ int t30_set_supported_resolutions(t30_state_t *s, int supported_resolutions)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_supported_image_sizes(t30_state_t *s, int supported_image_sizes) SPAN_DECLARE(int) t30_set_supported_image_sizes(t30_state_t *s, int supported_image_sizes)
{ {
s->supported_image_sizes = supported_image_sizes; s->supported_image_sizes = supported_image_sizes;
t30_build_dis_or_dtc(s); t30_build_dis_or_dtc(s);
@ -673,7 +673,7 @@ int t30_set_supported_image_sizes(t30_state_t *s, int supported_image_sizes)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_supported_t30_features(t30_state_t *s, int supported_t30_features) SPAN_DECLARE(int) t30_set_supported_t30_features(t30_state_t *s, int supported_t30_features)
{ {
s->supported_t30_features = supported_t30_features; s->supported_t30_features = supported_t30_features;
t30_build_dis_or_dtc(s); t30_build_dis_or_dtc(s);
@ -681,55 +681,55 @@ int t30_set_supported_t30_features(t30_state_t *s, int supported_t30_features)
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_status(t30_state_t *s, int status) SPAN_DECLARE(void) t30_set_status(t30_state_t *s, int status)
{ {
s->current_status = status; s->current_status = status;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
int t30_set_receiver_not_ready(t30_state_t *s, int count) SPAN_DECLARE(int) t30_set_receiver_not_ready(t30_state_t *s, int count)
{ {
s->receiver_not_ready_count = count; s->receiver_not_ready_count = count;
return 0; return 0;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_phase_b_handler(t30_state_t *s, t30_phase_b_handler_t *handler, void *user_data) SPAN_DECLARE(void) t30_set_phase_b_handler(t30_state_t *s, t30_phase_b_handler_t *handler, void *user_data)
{ {
s->phase_b_handler = handler; s->phase_b_handler = handler;
s->phase_b_user_data = user_data; s->phase_b_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_phase_d_handler(t30_state_t *s, t30_phase_d_handler_t *handler, void *user_data) SPAN_DECLARE(void) t30_set_phase_d_handler(t30_state_t *s, t30_phase_d_handler_t *handler, void *user_data)
{ {
s->phase_d_handler = handler; s->phase_d_handler = handler;
s->phase_d_user_data = user_data; s->phase_d_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_phase_e_handler(t30_state_t *s, t30_phase_e_handler_t *handler, void *user_data) SPAN_DECLARE(void) t30_set_phase_e_handler(t30_state_t *s, t30_phase_e_handler_t *handler, void *user_data)
{ {
s->phase_e_handler = handler; s->phase_e_handler = handler;
s->phase_e_user_data = user_data; s->phase_e_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_document_handler(t30_state_t *s, t30_document_handler_t *handler, void *user_data) SPAN_DECLARE(void) t30_set_document_handler(t30_state_t *s, t30_document_handler_t *handler, void *user_data)
{ {
s->document_handler = handler; s->document_handler = handler;
s->document_user_data = user_data; s->document_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
void t30_set_real_time_frame_handler(t30_state_t *s, t30_real_time_frame_handler_t *handler, void *user_data) SPAN_DECLARE(void) t30_set_real_time_frame_handler(t30_state_t *s, t30_real_time_frame_handler_t *handler, void *user_data)
{ {
s->real_time_frame_handler = handler; s->real_time_frame_handler = handler;
s->real_time_frame_user_data = user_data; s->real_time_frame_user_data = user_data;
} }
/*- End of function --------------------------------------------------------*/ /*- End of function --------------------------------------------------------*/
logging_state_t *t30_get_logging_state(t30_state_t *s) SPAN_DECLARE(logging_state_t *) t30_get_logging_state(t30_state_t *s)
{ {
return &s->logging; return &s->logging;
} }

Some files were not shown because too many files have changed in this diff Show More