test suite is now mostly OK with valgrind.
#define GEN_CONST
#include <math.h>
#endif
+#if defined(HAVE_STDBOOL_H)
+#include <stdbool.h>
+#else
+#include "spandsp/stdbool.h"
+#endif
#include "floating_fudge.h"
#include "spandsp.h"
#define PACKET_LOSS_TIME -1
-#define FALSE 0
-#define TRUE (!FALSE)
-
g1050_constants_t g1050_constants[1] =
{
{
s->max_jitter = parms->max_jitter;
/* The following is common state information to all links. */
- s->high_loss = FALSE;
+ s->high_loss = false;
s->congestion_delay = 0.0;
s->last_arrival_time = 0.0;
static void g1050_segment_model(g1050_segment_state_t *s, double delays[], int len)
{
int i;
- int lose;
+ bool lose;
int was_high_loss;
double impulse;
double slice_delay;
/* Compute delay and loss value for each time slice. */
for (i = 0; i < len; i++)
{
- lose = FALSE;
+ lose = false;
/* Initialize delay to the serial delay plus some jitter. */
slice_delay = s->serial_delay + s->max_jitter*q1050_rand();
/* If no QoS, do congestion delay and packet loss analysis. */
}
if (was_high_loss && q1050_rand() < s->prob_packet_loss)
- lose = TRUE;
+ lose = true;
/* Single pole LPF for the congestion delay impulses. */
s->congestion_delay = s->congestion_delay*s->impulse_coeff + impulse*(1.0 - s->impulse_coeff);
slice_delay += s->congestion_delay;
}
/* If duplex mismatch on LAN, packet loss based on loss probability. */
if (s->multiple_access && (q1050_rand() < s->prob_packet_collision_loss))
- lose = TRUE;
+ lose = true;
/* Put computed delay into time slice array. */
if (lose)
{
static void g1050_core_model(g1050_core_state_t *s, double delays[], int len)
{
int32_t i;
- int lose;
+ bool lose;
double jitter_delay;
for (i = 0; i < len; i++)
{
- lose = FALSE;
+ lose = false;
jitter_delay = s->base_delay + s->max_jitter*q1050_rand();
/* Route flapping */
if (--s->route_flap_counter <= 0)
s->route_flap_counter = s->route_flap_interval;
}
if (q1050_rand() < s->prob_packet_loss)
- lose = TRUE;
+ lose = true;
/* Link failures */
if (--s->link_failure_counter <= 0)
{
/* We are in a link failure */
- lose = TRUE;
+ lose = true;
if (--s->link_recovery_counter <= 0)
{
/* Leave failure state. */
s->link_failure_counter = s->link_failure_interval_ticks;
s->link_recovery_counter = s->link_failure_duration_ticks;
- lose = FALSE;
+ lose = false;
}
}
if (lose)
s->base_time += 1.0;
- memcpy(&s->segment[0].delays[0], &s->segment[0].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[0].delays[0]));
+ memmove(&s->segment[0].delays[0], &s->segment[0].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[0].delays[0]));
g1050_segment_model(&s->segment[0], &s->segment[0].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
- memcpy(&s->segment[1].delays[0], &s->segment[1].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[1].delays[0]));
+ memmove(&s->segment[1].delays[0], &s->segment[1].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[1].delays[0]));
g1050_segment_model(&s->segment[1], &s->segment[1].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
- memcpy(&s->core.delays[0], &s->core.delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->core.delays[0]));
+ memmove(&s->core.delays[0], &s->core.delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->core.delays[0]));
g1050_core_model(&s->core, &s->core.delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
- memcpy(&s->segment[2].delays[0], &s->segment[2].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[2].delays[0]));
+ memmove(&s->segment[2].delays[0], &s->segment[2].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[2].delays[0]));
g1050_segment_model(&s->segment[2], &s->segment[2].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
- memcpy(&s->segment[3].delays[0], &s->segment[3].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[3].delays[0]));
+ memmove(&s->segment[3].delays[0], &s->segment[3].delays[G1050_TICKS_PER_SEC], 2*G1050_TICKS_PER_SEC*sizeof(s->segment[3].delays[0]));
g1050_segment_model(&s->segment[3], &s->segment[3].delays[2*G1050_TICKS_PER_SEC], G1050_TICKS_PER_SEC);
- memcpy(&s->arrival_times_1[0], &s->arrival_times_1[s->packet_rate], 2*s->packet_rate*sizeof(s->arrival_times_1[0]));
- memcpy(&s->arrival_times_2[0], &s->arrival_times_2[s->packet_rate], 2*s->packet_rate*sizeof(s->arrival_times_2[0]));
+ memmove(&s->arrival_times_1[0], &s->arrival_times_1[s->packet_rate], 2*s->packet_rate*sizeof(s->arrival_times_1[0]));
+ memmove(&s->arrival_times_2[0], &s->arrival_times_2[s->packet_rate], 2*s->packet_rate*sizeof(s->arrival_times_2[0]));
for (i = 0; i < s->packet_rate; i++)
{
s->arrival_times_1[2*s->packet_rate + i] = s->base_time + 2.0 + (double) i/(double) s->packet_rate;
&mo->sidea_lan,
sp->sidea_lan_bit_rate,
sp->sidea_lan_multiple_access,
- FALSE,
+ false,
packet_size,
packet_rate);
g1050_segment_init(&s->segment[1],
&constants->segment[1],
&mo->sidea_access_link,
sp->sidea_access_link_bit_rate_ab,
- FALSE,
+ false,
sp->sidea_access_link_qos_enabled,
packet_size,
packet_rate);
&constants->segment[2],
&mo->sideb_access_link,
sp->sideb_access_link_bit_rate_ba,
- FALSE,
+ false,
sp->sideb_access_link_qos_enabled,
packet_size,
packet_rate);
&mo->sideb_lan,
sp->sideb_lan_bit_rate,
sp->sideb_lan_multiple_access,
- FALSE,
+ false,
packet_size,
packet_rate);
}
/*- End of function --------------------------------------------------------*/
+SPAN_DECLARE(int) g1050_free(g1050_state_t *s)
+{
+ free(s);
+ return 0;
+}
+/*- End of function --------------------------------------------------------*/
+
SPAN_DECLARE(void) g1050_dump_parms(int model, int speed_pattern)
{
g1050_channel_speeds_t *sp;
#define GEN_CONST
#include <math.h>
#endif
+#if defined(HAVE_STDBOOL_H)
+#include <stdbool.h>
+#else
+#include "spandsp/stdbool.h"
+#endif
#include "floating_fudge.h"
#define SPANDSP_EXPOSE_INTERNAL_STRUCTURES
if (f)
{
- tone_gen_descriptor_init(&mains_tone_desc, f, (int) (level - 10.0f), f*3, (int) level, 1, 0, 0, 0, TRUE);
+ tone_gen_descriptor_init(&mains_tone_desc, f, (int) (level - 10.0f), f*3, (int) level, 1, 0, 0, 0, true);
tone_gen_init(&s->mains_tone, &mains_tone_desc);
}
s->mains_interference = f;
if (f)
{
- tone_gen_descriptor_init(&mains_tone_desc, f, (int) (level1 - 10.0f), f*3, (int) level1, 1, 0, 0, 0, TRUE);
+ tone_gen_descriptor_init(&mains_tone_desc, f, (int) (level1 - 10.0f), f*3, (int) level1, 1, 0, 0, 0, true);
tone_gen_init(&s->line1.mains_tone, &mains_tone_desc);
- tone_gen_descriptor_init(&mains_tone_desc, f, (int) (level2 - 10.0f), f*3, (int) level2, 1, 0, 0, 0, TRUE);
+ tone_gen_descriptor_init(&mains_tone_desc, f, (int) (level2 - 10.0f), f*3, (int) level2, 1, 0, 0, 0, true);
tone_gen_init(&s->line2.mains_tone, &mains_tone_desc);
}
s->line1.mains_interference = f;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) one_way_line_model_release(one_way_line_model_state_t *s)
+SPAN_DECLARE(int) one_way_line_model_free(one_way_line_model_state_t *s)
{
+ codec_munge_free(s->munge);
free(s);
return 0;
}
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) both_ways_line_model_release(both_ways_line_model_state_t *s)
+SPAN_DECLARE(int) both_ways_line_model_free(both_ways_line_model_state_t *s)
{
+ codec_munge_free(s->line1.munge);
+ codec_munge_free(s->line2.munge);
free(s);
return 0;
}
#include <inttypes.h>
#include <string.h>
#include <stdio.h>
-#include "floating_fudge.h"
#if defined(HAVE_FFTW3_H)
#include <fftw3.h>
#else
#include <fftw.h>
#endif
-#if defined(HAVE_TGMATH_H)
-#include <tgmath.h>
-#endif
-#if defined(HAVE_MATH_H)
#include <math.h>
+#if defined(HAVE_STDBOOL_H)
+#include <stdbool.h>
+#else
+#include "spandsp/stdbool.h"
#endif
#include "spandsp.h"
#define GEN_CONST
#include <math.h>
#endif
+#if defined(HAVE_STDBOOL_H)
+#include <stdbool.h>
+#else
+#include "spandsp/stdbool.h"
+#endif
#include "floating_fudge.h"
#include "spandsp.h"
#define PACKET_LOSS_TIME -1
-#define FALSE 0
-#define TRUE (!FALSE)
-
SPAN_DECLARE(rfc2198_sim_state_t *) rfc2198_sim_init(int model,
int speed_pattern,
int packet_size,
}
/*- End of function --------------------------------------------------------*/
+SPAN_DECLARE(int) rfc2198_sim_free(rfc2198_sim_state_t *s)
+{
+ g1050_free(s->g1050);
+ free(s);
+ return 0;
+}
+/*- End of function --------------------------------------------------------*/
+
SPAN_DECLARE(int) rfc2198_sim_put(rfc2198_sim_state_t *s,
const uint8_t buf[],
int len,
int packet_size,
int packet_rate);
+SPAN_DECLARE(int) g1050_free(g1050_state_t *s);
+
SPAN_DECLARE(void) g1050_dump_parms(int model, int speed_pattern);
SPAN_DECLARE(int) g1050_put(g1050_state_t *s,
int codec,
int rbs_pattern);
-SPAN_DECLARE(int) both_ways_line_model_release(both_ways_line_model_state_t *s);
+SPAN_DECLARE(int) both_ways_line_model_free(both_ways_line_model_state_t *s);
SPAN_DECLARE(void) one_way_line_model(one_way_line_model_state_t *s,
int16_t output[],
SPAN_DECLARE(one_way_line_model_state_t *) one_way_line_model_init(int model, float noise, int codec, int rbs_pattern);
-SPAN_DECLARE(int) one_way_line_model_release(one_way_line_model_state_t *s);
+SPAN_DECLARE(int) one_way_line_model_free(one_way_line_model_state_t *s);
#ifdef __cplusplus
}
int packet_rate,
int redundancy_depth);
+SPAN_DECLARE(int) rfc2198_sim_free(rfc2198_sim_state_t *s);
+
SPAN_DECLARE(int) rfc2198_sim_put(rfc2198_sim_state_t *s,
const uint8_t buf[],
int len,
SPAN_DECLARE(complexify_state_t *) complexify_init(void);
-SPAN_DECLARE(void) complexify_release(complexify_state_t *s);
+SPAN_DECLARE(int) complexify_free(complexify_state_t *s);
SPAN_DECLARE(complexf_t) complexify(complexify_state_t *s, int16_t amp);
SPAN_DECLARE(codec_munge_state_t *) codec_munge_init(int codec, int info);
-SPAN_DECLARE(void) codec_munge_release(codec_munge_state_t *s);
+SPAN_DECLARE(void) codec_munge_free(codec_munge_state_t *s);
SPAN_DECLARE(void) codec_munge(codec_munge_state_t *s, int16_t amp[], int len);
#if defined(HAVE_MATH_H)
#include <math.h>
#endif
+#if defined(HAVE_STDBOOL_H)
+#include <stdbool.h>
+#else
+#include "spandsp/stdbool.h"
+#endif
#include "floating_fudge.h"
#include <time.h>
#include <fcntl.h>
};
static complex_t circle[MAX_FFT_LEN/2];
-static int circle_init = FALSE;
+static int circle_init = false;
static complex_t icircle[MAX_FFT_LEN/2];
-static int icircle_init = FALSE;
+static int icircle_init = false;
#define SF_MAX_HANDLE 32
-static int sf_close_at_exit_registered = FALSE;
+
+static int sf_close_at_exit_registered = false;
+
static SNDFILE *sf_close_at_exit_list[SF_MAX_HANDLE] =
{
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(void) complexify_release(complexify_state_t *s)
+SPAN_DECLARE(int) complexify_free(complexify_state_t *s)
{
free(s);
+ return 0;
}
/*- End of function --------------------------------------------------------*/
x = -(2.0*3.1415926535*i)/(double) MAX_FFT_LEN;
circle[i] = expj(x);
}
- circle_init = TRUE;
+ circle_init = true;
}
fftx(data, temp, len);
}
x = (2.0*3.1415926535*i)/(double) MAX_FFT_LEN;
icircle[i] = expj(x);
}
- icircle_init = TRUE;
+ icircle_init = true;
}
ifftx(data, temp, len);
}
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(void) codec_munge_release(codec_munge_state_t *s)
+SPAN_DECLARE(void) codec_munge_free(codec_munge_state_t *s)
{
free(s);
}
if (!sf_close_at_exit_registered)
{
atexit(sf_close_at_exit);
- sf_close_at_exit_registered = TRUE;
+ sf_close_at_exit_registered = true;
}
return 0;
}
{
if (sf_close_at_exit_list[i] == handle)
{
- sf_close(sf_close_at_exit_list[i]);
sf_close_at_exit_list[i] = NULL;
break;
}
SPAN_DECLARE(int) bell_mf_tx_release(bell_mf_tx_state_t *s)
{
+ queue_release(&s->queue.queue);
return 0;
}
/*- End of function --------------------------------------------------------*/
SPAN_DECLARE(int) bell_mf_tx_free(bell_mf_tx_state_t *s)
{
+ queue_release(&s->queue.queue);
span_free(s);
return 0;
}
SPAN_DECLARE(int) dtmf_tx_release(dtmf_tx_state_t *s)
{
+ queue_release(&s->queue.queue);
return 0;
}
/*- End of function --------------------------------------------------------*/
SPAN_DECLARE(int) dtmf_tx_free(dtmf_tx_state_t *s)
{
+ queue_release(&s->queue.queue);
span_free(s);
return 0;
}
SPAN_DECLARE(int) fax_release(fax_state_t *s)
{
t30_release(&s->t30);
+ v8_release(&s->v8);
return 0;
}
/*- End of function --------------------------------------------------------*/
SPAN_DECLARE(int) fax_free(fax_state_t *s)
{
- t30_release(&s->t30);
+ fax_release(s);
span_free(s);
return 0;
}
s->pixel_row[0][x - 1] = saturateu8(s->pixel_row[0][x - 1] + (7*quant_error)/16);
s->pixel_row[1][x + 0] = saturateu8(s->pixel_row[1][x + 0] + (5*quant_error)/16);
s->pixel_row[1][x - 1] = saturateu8(s->pixel_row[1][x - 1] + (1*quant_error)/16);
- for ( ; x > 0; x--)
+ while (--x > 0)
{
old_pixel = s->pixel_row[0][x];
new_pixel = find_closest_palette_color(old_pixel);
s->pixel_row[0][x + 1] = saturateu8(s->pixel_row[0][x + 1] + (7*quant_error)/16);
s->pixel_row[1][x + 0] = saturateu8(s->pixel_row[1][x + 0] + (5*quant_error)/16);
s->pixel_row[1][x + 1] = saturateu8(s->pixel_row[1][x + 1] + (1*quant_error)/16);
- for ( ; x < s->output_width - 1; x++)
+ while (++x < s->output_width - 1)
{
old_pixel = s->pixel_row[0][x];
new_pixel = find_closest_palette_color(old_pixel);
s->output_bytes_per_pixel = image_format_to_bytes_per_pixel(s->output_format);
s->resize = (output_width > 0);
- if (s->resize)
- s->output_width = output_width;
- else
- s->output_width = s->input_width;
+ s->output_width = (s->resize) ? output_width : s->input_width;
if (image_translate_restart(s, input_length))
return NULL;
/* Treat this as a bad quality page. */
if (s->phase_d_handler)
s->phase_d_handler(s->phase_d_user_data, fcf);
- s->next_rx_step = msg[2] & 0xFE;
+ s->next_rx_step = fcf;
queue_phase(s, T30_PHASE_D_TX);
set_state(s, T30_STATE_III_Q_RTN);
send_simple_frame(s, T30_RTN);
/* Treat this as a bad quality page. */
if (s->phase_d_handler)
s->phase_d_handler(s->phase_d_user_data, fcf);
- s->next_rx_step = msg[2] & 0xFE;
+ s->next_rx_step = fcf;
/* Return to phase B */
queue_phase(s, T30_PHASE_B_TX);
set_state(s, T30_STATE_III_Q_RTN);
/* Treat this as a bad quality page. */
if (s->phase_d_handler)
s->phase_d_handler(s->phase_d_user_data, fcf);
- s->next_rx_step = msg[2] & 0xFE;
+ s->next_rx_step = fcf;
queue_phase(s, T30_PHASE_D_TX);
set_state(s, T30_STATE_III_Q_RTN);
send_simple_frame(s, T30_RTN);
s->modem = FAX_MODEM_NONE;
s->at_state.transmit = true;
+ if (s->rx_queue)
+ queue_free(s->rx_queue);
if ((s->rx_queue = queue_init(NULL, 4096, QUEUE_WRITE_ATOMIC | QUEUE_READ_ATOMIC)) == NULL)
{
if (alloced)
SPAN_DECLARE(int) t31_release(t31_state_t *s)
{
at_reset_call_info(&s->at_state);
+ v8_release(&s->audio.v8);
+ fax_modems_release(&s->audio.modems);
+ queue_free(s->rx_queue);
return 0;
}
/*- End of function --------------------------------------------------------*/
}
/*- End of function --------------------------------------------------------*/
+static int release_encoder(t4_tx_state_t *s)
+{
+ switch (s->metadata.compression)
+ {
+ case T4_COMPRESSION_T4_1D:
+ case T4_COMPRESSION_T4_2D:
+ case T4_COMPRESSION_T6:
+ return t4_t6_encode_release(&s->encoder.t4_t6);
+ case T4_COMPRESSION_T85:
+ case T4_COMPRESSION_T85_L0:
+ return t85_encode_release(&s->encoder.t85);
+#if defined(SPANDSP_SUPPORT_T88)
+ case T4_COMPRESSION_T88:
+ return t88_encode_release(&s->encoder.t88);
+#endif
+ case T4_COMPRESSION_T42_T81:
+ case T4_COMPRESSION_SYCC_T81:
+ return t42_encode_release(&s->encoder.t42);
+ case T4_COMPRESSION_T43:
+ return t43_encode_release(&s->encoder.t43);
+#if defined(SPANDSP_SUPPORT_T45)
+ case T4_COMPRESSION_T45:
+ return t45_encode_release(&s->encoder.t45);
+#endif
+ }
+ return -1;
+}
+/*- End of function --------------------------------------------------------*/
+
SPAN_DECLARE(int) t4_tx_set_tx_image_format(t4_tx_state_t *s,
int supported_compressions,
int supported_image_sizes,
case T4_COMPRESSION_T6:
break;
default:
+ release_encoder(s);
t4_t6_encode_init(&s->encoder.t4_t6, compression, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
case T4_COMPRESSION_T85_L0:
break;
default:
+ release_encoder(s);
t85_encode_init(&s->encoder.t85, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
case T4_COMPRESSION_SYCC_T81:
break;
default:
+ release_encoder(s);
t42_encode_init(&s->encoder.t42, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
case T4_COMPRESSION_T43:
break;
default:
+ release_encoder(s);
t43_encode_init(&s->encoder.t43, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
case T4_COMPRESSION_T45:
break;
default:
+ release_encoder(s);
t45_encode_init(&s->encoder.t45, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
span_free(s->colour_map);
s->colour_map = NULL;
}
- switch (s->metadata.compression)
- {
- case T4_COMPRESSION_T4_1D:
- case T4_COMPRESSION_T4_2D:
- case T4_COMPRESSION_T6:
- return t4_t6_encode_release(&s->encoder.t4_t6);
- case T4_COMPRESSION_T85:
- case T4_COMPRESSION_T85_L0:
- return t85_encode_release(&s->encoder.t85);
-#if defined(SPANDSP_SUPPORT_T88)
- case T4_COMPRESSION_T88:
- return t88_encode_release(&s->encoder.t88);
-#endif
- case T4_COMPRESSION_T42_T81:
- case T4_COMPRESSION_SYCC_T81:
- return t42_encode_release(&s->encoder.t42);
- case T4_COMPRESSION_T43:
- return t43_encode_release(&s->encoder.t43);
-#if defined(SPANDSP_SUPPORT_T45)
- case T4_COMPRESSION_T45:
- return t45_encode_release(&s->encoder.t45);
-#endif
- }
- return -1;
+ return release_encoder(s);
}
/*- End of function --------------------------------------------------------*/
}
/*- End of function --------------------------------------------------------*/
+SPAN_DECLARE(logging_state_t *) t85_decode_get_logging_state(t85_decode_state_t *s)
+{
+ return &s->logging;
+}
+/*- End of function --------------------------------------------------------*/
+
SPAN_DECLARE(int) t85_decode_restart(t85_decode_state_t *s)
{
s->xd = 0;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(logging_state_t *) t85_decode_get_logging_state(t85_decode_state_t *s)
-{
- return &s->logging;
-}
-/*- End of function --------------------------------------------------------*/
-
SPAN_DECLARE(t85_decode_state_t *) t85_decode_init(t85_decode_state_t *s,
t4_row_write_handler_t handler,
void *user_data)
}
/*- End of function --------------------------------------------------------*/
+SPAN_DECLARE(logging_state_t *) t85_encode_get_logging_state(t85_encode_state_t *s)
+{
+ return &s->logging;
+}
+/*- End of function --------------------------------------------------------*/
+
SPAN_DECLARE(int) t85_encode_restart(t85_encode_state_t *s, uint32_t image_width, uint32_t image_length)
{
int bytes_per_row;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(logging_state_t *) t85_encode_get_logging_state(t85_encode_state_t *s)
-{
- return &s->logging;
-}
-/*- End of function --------------------------------------------------------*/
-
SPAN_DECLARE(t85_encode_state_t *) t85_encode_init(t85_encode_state_t *s,
uint32_t image_width,
uint32_t image_length,
{
memcpy(&out[out_len], s->buf, sizeof(int16_t)*s->lcp);
out_len += s->lcp;
- memcpy(s->buf, &s->buf[s->lcp], sizeof(int16_t)*(s->buf_len - s->lcp));
+ memmove(s->buf, &s->buf[s->lcp], sizeof(int16_t)*(s->buf_len - s->lcp));
if (len - in_len < s->lcp)
{
/* Cannot continue without more samples */
SPAN_DECLARE(int) v18_release(v18_state_t *s)
{
+ queue_release(&s->queue.queue);
return 0;
}
/*- End of function --------------------------------------------------------*/
SPAN_DECLARE(int) v18_free(v18_state_t *s)
{
+ queue_release(&s->queue.queue);
span_free(s);
return 0;
}
modem_connect_tones_tx_init(&s->ansam_tx, s->parms.modem_connect_tone);
s->modem_connect_tone_tx_on = ms_to_samples(75) + 1;
}
-
+ if (s->tx_queue)
+ queue_free(s->tx_queue);
if ((s->tx_queue = queue_init(NULL, 1024, 0)) == NULL)
return -1;
return 0;
/* The remainder of the Mitel tape is the talk-off test */
/* Here we use the Bellcore test tapes (much tougher), in six
- files - 1 from each side of the original 3 cassette tapes */
+ files - 1 from each side of the original 3 cassette tapes */
/* Bellcore say you should get no more than 470 false detections with
a good receiver. Dialogic claim 20. Of course, we can do better than
that, eh? */
return -1;
}
printf(" Passed\n");
+ ademco_contactid_sender_free(sender);
return 0;
}
/*- End of function --------------------------------------------------------*/
sf_writef_short(outhandle, sndfile_buf, SAMPLES_PER_CHUNK);
}
+ codec_munge_free(munge);
if (!rx_callback_reported)
{
fprintf(stderr, " Report not received\n");
return -1;
}
printf(" Passed\n");
+ ademco_contactid_sender_free(sender);
+ ademco_contactid_receiver_free(receiver);
return 0;
}
/*- End of function --------------------------------------------------------*/
printf("'%s'\n", buf);
printf("\n");
printf(" Passed\n");
+ ademco_contactid_sender_free(sender);
+ ademco_contactid_receiver_free(receiver);
return 0;
}
/*- End of function --------------------------------------------------------*/
exit(2);
}
printf("Tests passed.\n");
+ at_free(at_state);
return 0;
}
/*- End of function --------------------------------------------------------*/
clip_high = 0;
clip_low = 0;
total = 0.0;
- noise_source = awgn_init_dbm0(NULL, idum, (float) j);
+ if ((noise_source = awgn_init_dbm0(NULL, idum, (float) j)) == NULL)
+ {
+ printf("Failed to allocation AWGN source\n");
+ exit(2);
+ }
total_samples = 1000000;
for (i = 0; i < total_samples; i++)
{
printf("Test failed.\n");
exit(2);
}
+ awgn_free(noise_source);
}
/* Now look at the statistical spread of the results, by collecting data in
bins from a large number of samples. Use a fairly high noise level, but
memset(bins, 0, sizeof(bins));
clip_high = 0;
clip_low = 0;
- awgn_init_dbm0(noise_source, idum, -15);
+ if ((noise_source = awgn_init_dbm0(NULL, idum, -15.0)) == NULL)
+ {
+ printf("Failed to allocation AWGN source\n");
+ exit(2);
+ }
total_samples = 10000000;
for (i = 0; i < total_samples; i++)
{
/* Now send it out for graphing. */
printf("%6d %.7f %.7f\n", i - 32768, x, p);
}
-
+ awgn_free(noise_source);
printf("Tests passed.\n");
return 0;
}
printf(" Failed\n");
exit(2);
}
+ bell_mf_rx_free(mf_state);
printf(" Passed\n");
/* The remainder of the Mitel tape is the talk-off test. This is
printf(" Failed\n");
exit(2);
}
+ bell_mf_rx_free(mf_state);
printf(" Passed\n");
duration = time (NULL) - now;
fprintf(stderr, " Cannot close audio file '%s'\n", OUTPUT_FILE_NAME);
exit (2);
}
+ bell_mf_tx_free(gen);
return 0;
}
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
- bert_init(tx_bert, 0, BERT_PATTERN_ONES, 300, 20);
- bert_init(rx_bert, 0, BERT_PATTERN_ONES, 300, 20);
+ tx_bert = bert_init(NULL, 0, BERT_PATTERN_ONES, 300, 20);
+ rx_bert = bert_init(NULL, 0, BERT_PATTERN_ONES, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(tx_bert);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_1_TO_7, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_1_TO_7, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_1_TO_3, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_1_TO_3, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_1_TO_1, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_1_TO_1, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_3_TO_1, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_3_TO_1, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_7_TO_1, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_7_TO_1, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
tx_bert = bert_init(NULL, 0, BERT_PATTERN_QBF, 300, 20);
rx_bert = bert_init(NULL, 0, BERT_PATTERN_QBF, 300, 20);
printf("Test failed.\n");
exit(2);
}
+ bert_free(tx_bert);
+ bert_free(rx_bert);
/* Test the mechanism for categorising the error rate into <10^x bands */
/* TODO: The result of this test is not checked automatically */
// bert_put_bit(bert, bit);
bert_put_bit(bert, bit);
}
+ bert_free(bert);
printf("Tests passed.\n");
return 0;
printf("Test failed.\n");
exit(2);
}
+ awgn_free(noise_source);
printf("Test passed.\n");
return 0;
}
printf(" Failed\n");
exit(2);
}
+ dtmf_rx_free(dtmf_state);
printf(" Passed\n");
}
/*- End of function --------------------------------------------------------*/
exit(2);
}
printf(" Passed\n");
+ dtmf_rx_free(dtmf_state);
}
/*- End of function --------------------------------------------------------*/
exit(2);
}
printf(" Passed\n");
+ dtmf_rx_free(dtmf_state);
}
/*- End of function --------------------------------------------------------*/
printf(" Failed\n");
exit(2);
}
+ dtmf_rx_free(dtmf_state);
}
/*- End of function --------------------------------------------------------*/
printf("Tests passed in %ds\n", duration);
}
+ codec_munge_free(munge);
return 0;
}
/*- End of function --------------------------------------------------------*/
fprintf(stderr, " Cannot close audio file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
+ dtmf_tx_free(gen);
return 0;
}
}
return;
}
- fprintf(stderr, "V.21 Rx bit %d - %d\n", rx_bits++, bit);
+ //fprintf(stderr, "V.21 Rx bit %d - %d\n", rx_bits++, bit);
if (fast_trained == FAX_NONE)
hdlc_rx_put_bit(&hdlcrx, bit);
}
int mode[2] = {AUDIO_FAX, AUDIO_FAX};
-t30_state_t *t30_state[2];
-fax_state_t *fax_state[2];
-t38_gateway_state_t *t38_gateway_state[2];
-t38_terminal_state_t *t38_state[2];
-t38_core_state_t *t38_core_state[2];
-g1050_state_t *g1050_path[2];
-awgn_state_t *awgn_state[2];
+t30_state_t *t30_state[2] = {NULL, NULL};
+fax_state_t *fax_state[2] = {NULL, NULL};
+t38_gateway_state_t *t38_gateway_state[2] = {NULL, NULL};
+t38_terminal_state_t *t38_state[2] = {NULL, NULL};
+t38_core_state_t *t38_core_state[2] = {NULL, NULL};
+faxtester_state_t *faxtester[2] = {NULL, NULL};
+g1050_state_t *g1050_path[2] = {NULL, NULL};
+awgn_state_t *awgn_state[2] = {NULL, NULL};
int16_t audio_buffer[2*2][SAMPLES_PER_CHUNK];
int t38_subst_seq[2] = {0, 0};
break;
}
if (mode[i] == T38_TERMINAL_FAX)
- t38_terminal_release(t38_state[i]);
+ t38_terminal_free(t38_state[i]);
else
- fax_release(fax_state[i]);
+ fax_free(fax_state[i]);
if (mode[i] == T38_GATEWAY_FAX)
- t38_gateway_release(t38_gateway_state[i]);
+ t38_gateway_free(t38_gateway_state[i]);
+ if (g1050_path[i])
+ {
+ g1050_free(g1050_path[i]);
+ g1050_path[i] = NULL;
+ }
}
if (i < 2)
{
fprintf(stderr, " Cannot close audio file '%s'\n", decode_test_file);
exit(2);
}
+ fsk_rx_free(caller_rx);
}
else
{
printf("Tests failed.\n");
exit(2);
}
+ fsk_rx_free(caller_rx);
printf("Test with BERT\n");
test_bps = preset_fsk_specs[modem_under_test_1].baud_rate;
fsk_rx_set_modem_status_handler(caller_rx, rx_status, (void *) &caller_rx);
}
noise_level++;
+ both_ways_line_model_free(model);
if ((model = both_ways_line_model_init(line_model_no,
(float) noise_level,
line_model_no,
bert_set_report(&answerer_bert, 100000, reporter, (void *) (intptr_t) 2);
}
}
+ bert_release(&caller_bert);
+ bert_release(&answerer_bert);
+ if (modem_under_test_1 >= 0)
+ {
+ fsk_tx_free(caller_tx);
+ fsk_rx_free(answerer_rx);
+ }
+ if (modem_under_test_2 >= 0)
+ {
+ fsk_tx_free(answerer_tx);
+ fsk_rx_free(caller_rx);
+ }
+ both_ways_line_model_free(model);
printf("Tests passed.\n");
}
if (log_audio)
exit(2);
}
printf("%.3f%% of packets lost\n", 100.0*(packets_put - packets_really_put)/packets_put);
+ g1050_free(s);
+ free(packet_arrival_times);
return 0;
}
/*- End of function --------------------------------------------------------*/
printf("%d\n", css_c3[i]);
signal_free(&local_css);
signal_free(&far_css);
+ fir32_free(&line_model_d2);
+ fir32_free(&line_model_d3);
+ fir32_free(&line_model_d4);
+ fir32_free(&line_model_d5);
+ fir32_free(&line_model_d6);
+ fir32_free(&line_model_d7);
+ fir32_free(&line_model_d8);
+ fir32_free(&line_model_d9);
+ fir_float_free(&level_measurement_bp);
return 0;
}
/*- End of function --------------------------------------------------------*/
}
}
}
- g711_release(enc_state);
- g711_release(transcode);
- g711_release(dec_state);
+ g711_free(enc_state);
+ g711_free(transcode);
+ g711_free(dec_state);
if (log_audio)
{
exit(2);
}
printf("Test passed\n");
+ g722_encode_free(enc_state);
}
#endif
#if 1
exit(2);
}
printf("Test passed\n");
+ g722_decode_free(dec_state);
}
}
#endif
printf("%10d, %10d, %f\n", in_level, out_level, (float) out_level/in_level);
}
while (len > 0);
+ swept_tone_free(swept);
+ g722_encode_free(enc_state);
+ g722_decode_free(dec_state);
+ power_meter_free(in_meter);
+ power_meter_free(out_meter);
}
/*- End of function --------------------------------------------------------*/
fprintf(stderr, " Cannot close audio file '%s'\n", IN_FILE_NAME);
exit(2);
}
+ g722_encode_free(enc_state);
}
else
{
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME);
exit(2);
}
+ g722_decode_free(dec_state);
}
else
{
int main(int argc, char *argv[])
{
- g726_state_t enc_state;
- g726_state_t dec_state;
+ g726_state_t *enc_state;
+ g726_state_t *dec_state;
int opt;
bool itutests;
int bit_rate;
}
printf("ADPCM packing is %d\n", packing);
- g726_init(&enc_state, bit_rate, G726_ENCODING_LINEAR, packing);
- g726_init(&dec_state, bit_rate, G726_ENCODING_LINEAR, packing);
+ enc_state = g726_init(NULL, bit_rate, G726_ENCODING_LINEAR, packing);
+ dec_state = g726_init(NULL, bit_rate, G726_ENCODING_LINEAR, packing);
while ((frames = sf_readf_short(inhandle, amp, 159)))
{
- adpcm = g726_encode(&enc_state, adpcmdata, amp, frames);
- frames = g726_decode(&dec_state, amp, adpcmdata, adpcm);
+ adpcm = g726_encode(enc_state, adpcmdata, amp, frames);
+ frames = g726_decode(dec_state, amp, adpcmdata, adpcm);
sf_writef_short(outhandle, amp, frames);
}
if (sf_close_telephony(inhandle))
exit(2);
}
printf("'%s' transcoded to '%s' at %dbps.\n", IN_FILE_NAME, OUT_FILE_NAME, bit_rate);
+ g726_free(enc_state);
+ g726_free(dec_state);
}
return 0;
}
mismatches++;
}
}
- gsm0610_release(gsm0610_enc_state);
+ gsm0610_free(gsm0610_enc_state);
if (mismatches)
{
printf("Test failed: %d of %d samples mismatch\n", mismatches, xxx);
printf("Test failed: %d of %d samples mismatch\n", mismatches, vector_len);
exit(2);
}
- gsm0610_release(gsm0610_dec_state);
+ gsm0610_free(gsm0610_dec_state);
printf("Test passed\n");
return 0;
}
exit(2);
}
printf("Test passed\n");
- gsm0610_release(gsm0610_enc_state);
+ gsm0610_free(gsm0610_enc_state);
}
if ((gsm0610_dec_state = gsm0610_init(NULL, GSM0610_PACKING_NONE)) == NULL)
printf("Test failed: %d of %d samples mismatch\n", mismatches, vector_len);
exit(2);
}
- gsm0610_release(gsm0610_dec_state);
+ gsm0610_free(gsm0610_dec_state);
printf("Test passed\n");
return 0;
}
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME);
exit(2);
}
- gsm0610_release(gsm0610_enc_state);
- gsm0610_release(gsm0610_dec_state);
+ gsm0610_free(gsm0610_enc_state);
+ gsm0610_free(gsm0610_dec_state);
}
return 0;
}
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME);
exit(2);
}
- ima_adpcm_release(ima_enc_state);
- ima_adpcm_release(ima_dec_state);
+ ima_adpcm_free(ima_enc_state);
+ ima_adpcm_free(ima_dec_state);
printf("Pre samples: %d\n", total_pre_samples);
printf("Compressed bytes: %d\n", total_compressed_bytes);
TIFFWriteDirectory(out_file);
TIFFClose(out_file);
image_translate_free(s);
+ free(image);
+ free(image2);
}
/*- End of function --------------------------------------------------------*/
out[2*i] = cc.re;
out[2*i + 1] = cc.im;
}
+ awgn_release(&noise1);
+ complexify_free(s);
outframes = sf_writef_short(outhandle, out, 20000);
if (outframes != 20000)
{
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME1);
exit(2);
}
- one_way_line_model_release(model);
+ one_way_line_model_free(model);
}
/*- End of function --------------------------------------------------------*/
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME2);
exit(2);
}
- both_ways_line_model_release(model);
+ both_ways_line_model_free(model);
}
/*- End of function --------------------------------------------------------*/
span_log_set_message_handler(log, &message_handler, NULL);
+ span_log_free(log);
+
printf("Tests passed.\n");
return 0;
}
close(compress_file);
if (decompress)
close(decompress_file);
- lpc10_encode_release(lpc10_enc_state);
- lpc10_decode_release(lpc10_dec_state);
+ lpc10_encode_free(lpc10_enc_state);
+ lpc10_decode_free(lpc10_dec_state);
if (!decompress)
{
}
- oki_adpcm_release(oki_enc_state);
+ oki_adpcm_free(oki_enc_state);
if (sf_close_telephony(inhandle))
{
fprintf(stderr, " Cannot close audio file '%s'\n", in_file_name);
exit(2);
}
}
- oki_adpcm_release(oki_dec_state);
- oki_adpcm_release(oki_dec_state2);
+ oki_adpcm_free(oki_dec_state);
+ oki_adpcm_free(oki_dec_state2);
if (sf_close_telephony(outhandle))
{
fprintf(stderr, " Cannot close audio file '%s'\n", OUT_FILE_NAME);
exit(2);
}
printf("Min on %d, max on %d, min off %d, max off %d\n", extremes[0], extremes[1], extremes[2], extremes[3]);
+ power_surge_detector_free(sig);
+ awgn_free(awgnx);
return 0;
}
/*- End of function --------------------------------------------------------*/
{
tone = tone_gen_init(NULL, &my_mf_digit_tones[cp - r2_mf_tone_codes]);
len += tone_gen(tone, amp + len, 9999);
+ tone_gen_free(tone);
}
return len;
}
if (r2_mf_rx_get(mf_state) != digit)
break;
}
+ awgn_free(noise_source);
if (j < 500)
break;
}
printf("Test 8: Callback digit delivery mode.\n");
callback_ok = false;
callback_roll = 0;
- mf_state = r2_mf_rx_init(NULL, fwd, digit_delivery, (void *) 0x12345678);
+ mf_state = r2_mf_rx_init(mf_state, fwd, digit_delivery, (void *) 0x12345678);
my_mf_gen_init(0.0, -3, 0.0, -3, 68, fwd);
s = r2_mf_tone_codes;
noise_source = awgn_init_dbm0(NULL, 1234567, -40.0f);
codec_munge(amp, len);
r2_mf_rx(mf_state, amp, len);
}
+ awgn_free(noise_source);
if (!callback_ok)
{
printf(" Failed\n");
}
printf(" Passed\n");
+ r2_mf_rx_free(mf_state);
+
/* The remainder of the Mitel tape is the talk-off test. This is
meaningless for R2 MF. However the decoder's tolerance of
out of band noise is significant. */
fclose(out_file);
+ rfc2198_sim_free(s);
+
+ free(packet_arrival_times);
+
printf("Put %d packets. Really put %d packets. Got %d packets.\n", packets_put, packets_really_put, packets_got);
printf("%d OOS packets, %d missing packets\n", oos_packets_got, missing_packets_got - oos_packets_got);
printf("%d packets queued, %d received\n", packets_really_put, packets_got);
speech_immunity_tests(&rx_state);
level_and_ratio_tests(&rx_state, fc);
sequence_tests(&tx_state, &rx_state, munge);
+ if (munge)
+ codec_munge_free(munge);
}
/*endfor*/
exit(2);
}
+ swept_tone_free(s);
+
+ power_meter_release(&meter);
+
printf("Tests passed.\n");
return 0;
}
span_log_bump_samples(at_get_logging_state(t31_get_at_state(t31_state)), SAMPLES_PER_CHUNK);
}
+ g1050_free(path_a_to_b);
+ g1050_free(path_b_to_a);
if (t38_mode)
- t38_terminal_release(t38_state);
+ t38_terminal_free(t38_state);
+ else
+ fax_free(fax_state);
+ t31_free(t31_state);
if (decode_test_file)
{
printf(" Done\n");
t38_non_ecm_buffer_report_input_status(&buffer, &logging);
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
+ t38_non_ecm_buffer_release(&buffer);
printf("2 - Impose no minimum for the bits per row, different alignment\n");
t38_non_ecm_buffer_init(&buffer, true, 0);
}
t38_non_ecm_buffer_report_input_status(&buffer, &logging);
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
+ t38_non_ecm_buffer_release(&buffer);
printf("3 - Demand a fairly high minimum for the bits per row\n");
t38_non_ecm_buffer_init(&buffer, true, 400);
}
t38_non_ecm_buffer_report_input_status(&buffer, &logging);
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
+ t38_non_ecm_buffer_release(&buffer);
printf("4 - Take some time to get to the first row of the image, output ahead\n");
t38_non_ecm_buffer_init(&buffer, true, 400);
printf(" RTC output OK\n");
t38_non_ecm_buffer_report_input_status(&buffer, &logging);
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
+ t38_non_ecm_buffer_release(&buffer);
printf("5 - Take some time to get to the first row of the image, output behind\n");
t38_non_ecm_buffer_init(&buffer, true, 400);
printf(" RTC output OK\n");
t38_non_ecm_buffer_report_input_status(&buffer, &logging);
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
+ t38_non_ecm_buffer_release(&buffer);
printf("6 - TCF without leading ones\n");
t38_non_ecm_buffer_init(&buffer, false, 400);
printf(" End of data seen OK\n");
t38_non_ecm_buffer_report_input_status(&buffer, &logging);
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
+ t38_non_ecm_buffer_release(&buffer);
printf("7 - TCF with leading ones\n");
t38_non_ecm_buffer_init(&buffer, false, 400);
printf(" End of data seen OK\n");
t38_non_ecm_buffer_report_input_status(&buffer, &logging);
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
+ t38_non_ecm_buffer_release(&buffer);
printf("Tests passed\n");
return 0;
for (i = 0, total_image_len = 0; i < nstrips; i++)
total_image_len += TIFFRawStripSize(tif, i);
- data = malloc(total_image_len);
+ if ((data = malloc(total_image_len)) == NULL)
+ {
+ printf("Failed to allocate buffer\n");
+ exit(2);
+ }
for (i = 0, total_len = 0; i < nstrips; i++, total_len += len)
{
if ((len = TIFFReadRawStrip(tif, i, &data[total_len], total_image_len - total_len)) < 0)
printf("total %d\n", totdata);
/* Read the image into memory. */
- data = malloc(totdata);
+ if ((data = malloc(totdata)) == NULL)
+ {
+ printf("Failed to allocate buffer\n");
+ exit(2);
+ }
off = 0;
for (row = 0; row < h; row++)
{
}
free(data);
#else
- data2 = malloc(totdata);
+ if ((data2 = malloc(totdata)) == NULL)
+ {
+ printf("Failed to allocate buffer\n");
+ exit(2);
+ }
start = rdtscll();
//if (!t42_itulab_jpeg_to_srgb(logging, &lab_param, data2, &off, data, off, &w, &h, &samples_per_pixel))
{
if (TIFFGetField(tif, TIFFTAG_COLORMAP, &map_L, &map_a, &map_b, &map_z))
{
entries = 1 << meta->bits_per_sample;
- meta->colour_map = malloc(3*entries);
- if (meta->colour_map)
+ if ((meta->colour_map = malloc(3*entries)))
{
#if 0
/* Sweep the colormap in the proper order */
free(data);
data = data2;
#elif 1
- data2 = malloc(totdata);
+ if ((data2 = malloc(totdata)) == NULL)
+ {
+ printf("Failed to allocate buffer\n");
+ exit(2);
+ }
start = rdtscll();
//if (!t42_itulab_jpeg_to_srgb(&logging2, &lab_param, data2, &off, data, off, &meta.image_width, &meta.image_length, &meta.samples_per_pixel))
{
if (compression_step < 0)
break;
}
- t4_t6_encode_release(send_state);
- t4_t6_decode_release(receive_state);
+ t4_t6_encode_free(send_state);
+ t4_t6_decode_free(receive_state);
#endif
printf("Tests passed\n");
return 0;
dump_image_as_xxx(receive_state);
t4_rx_end_page(receive_state);
display_page_stats(receive_state);
- t4_rx_release(receive_state);
+ t4_rx_free(receive_state);
}
else
{
t4_rx_end_page(receive_state);
sends++;
}
- t4_tx_release(send_state);
- t4_rx_release(receive_state);
+ t4_tx_free(send_state);
+ t4_rx_free(receive_state);
/* And we should now have a matching received TIFF file. Note this will only match
at the image level. TIFF files allow a lot of ways to express the same thing,
so bit matching of the files is not the normal case. */
exit(2);
}
printf("Test passed\n");
-
+ t81_t82_arith_encode_free(se);
+ t81_t82_arith_encode_free(sd);
printf("Tests passed\n");
return 0;
}
if (comment && testbuf_len == 1000)
t85_encode_comment(t85_enc, comment, strlen((const char *) comment) + 1);
}
- t85_encode_release(t85_enc);
printf("Encoded BIE has %lu bytes\n", (unsigned long int) testbuf_len);
if (correct_length > 0)
{
printf("Test passed\n");
}
+ cnt_a = t85_encode_get_compressed_image_size(t85_enc);
+ t85_encode_free(t85_enc);
+
printf("%s.2: Decode in one big chunk\n", test_id);
if ((decoded_image = (uint8_t *) malloc(image_size)) == NULL)
{
result = t85_decode_put(t85_dec, testbuf, testbuf_len);
if (result == T4_DECODE_MORE_DATA)
result = t85_decode_put(t85_dec, NULL, 0);
- cnt_a = t85_encode_get_compressed_image_size(t85_enc);
cnt_b = t85_decode_get_compressed_image_size(t85_dec);
if (cnt_a != cnt_b || cnt_a != testbuf_len*8 || result != T4_DECODE_OK)
{
exit(2);
}
free(decoded_image);
- t85_decode_release(t85_dec);
+ t85_decode_free(t85_dec);
printf("Test passed\n");
printf("%s.3: Decode byte by byte\n", test_id);
exit(2);
}
free(decoded_image);
- t85_decode_release(t85_dec);
+ t85_decode_free(t85_dec);
printf("Test passed\n");
return 0;
break;
}
}
+ memset(&info, 0, sizeof(info));
if ((inhandle = sf_open(in_file_name, SFM_READ, &info)) == NULL)
{
printf(" Cannot open audio file '%s'\n", in_file_name);
count = 0;
}
}
+ time_scale_release(&state);
if (sf_close(inhandle))
{
printf(" Cannot close audio file '%s'\n", in_file_name);
return -1;
}
}
+ awgn_free(noise_source_re);
+ awgn_free(noise_source_im);
}
return 0;
}
400,
false);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
/* Try a different tone pair */
tone_gen_descriptor_init(&tone_desc,
100,
true);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
/* Try a different tone pair */
tone_gen_descriptor_init(&tone_desc,
400,
true);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
/* Try a single tone */
tone_gen_descriptor_init(&tone_desc,
400,
true);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
/* Try a single non-repeating tone */
tone_gen_descriptor_init(&tone_desc,
0,
false);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
/* Try a single non-repeating tone at 0dBm0 */
tone_gen_descriptor_init(&tone_desc,
0,
false);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
/* Try an AM modulated tone at a modest modulation level (25%) */
tone_gen_descriptor_init(&tone_desc,
400,
true);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
/* Try an AM modulated tone at maximum modulation level (100%) */
tone_gen_descriptor_init(&tone_desc,
400,
true);
tone_gen_init(&tone_state, &tone_desc);
-
for (i = 0; i < 1000; i++)
{
len = tone_gen(&tone_state, amp, 160);
break;
sf_writef_short(outhandle, amp, len);
}
+ tone_gen_release(&tone_state);
if (sf_close_telephony(outhandle))
{
static int next_step(faxtester_state_t *s);
+static bool test_for_call_drop = false;
+
static int phase_b_handler(void *user_data, int result)
{
int ch;
t4_tx_state_t t4_tx_state;
t30_state_t *t30;
+ test_for_call_drop = false;
if (s->cur == NULL)
{
if (!s->final_delayed)
{
faxtest_set_rx_silence(s);
}
+ else if (strcasecmp((const char *) type, "DROPCALL") == 0)
+ {
+ span_log(&s->logging, SPAN_LOG_FLOW, "Far end should drop the call\n");
+ test_for_call_drop = true;
+ }
else
{
span_log(&s->logging, SPAN_LOG_FLOW, "Unrecognised type '%s'\n", (const char *) type);
span_log(&s->logging, SPAN_LOG_FLOW, "ECM image is %d bytes (min row bits %d)\n", len, min_row_bits);
faxtester_set_ecm_image_buffer(s, image, len, ecm_block, ecm_frame_size, i);
}
+ else if (strcasecmp((const char *) type, "DROPCALL") == 0)
+ {
+ span_log(&s->logging, SPAN_LOG_FLOW, "Time to drop the call\n");
+ return 0;
+ }
else
{
span_log(&s->logging, SPAN_LOG_FLOW, "Unrecognised type '%s'\n", (const char *) type);
/*endif*/
}
/*endif*/
+ if (test_for_call_drop)
+ {
+ if (!t30_call_active(fax_get_t30_state(fax)))
+ {
+ printf("Call dropped\n");
+ //break;
+ }
+ /*endif*/
+ }
+ /*endif*/
}
/*endfor*/
if (log_audio)
span_log_set_level(&state.logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_SHOW_SAMPLE_TIME | SPAN_LOG_FLOW);
span_log_set_tag(&state.logging, "B");
get_test_set(&state, xml_file_name, test_name);
+ faxtester_release(&state);
printf("Done\n");
return 0;
}
//rx.eq_put_step = rand()%(192*10/3);
bert_init(&bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&bert, 10000, reporter, NULL);
- one_way_line_model_release(line_model);
+ one_way_line_model_free(line_model);
if ((line_model = one_way_line_model_init(line_model_no, (float) noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
fprintf(stderr, "At completion:\n");
fprintf(stderr, "Final result %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
fprintf(stderr, "Last report %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, latest_results.total_bits, latest_results.bad_bits, latest_results.resyncs);
- one_way_line_model_release(line_model);
+ one_way_line_model_free(line_model);
if (signal_level > -43)
{
printf("Tests passed.\n");
}
+ v17_rx_free(rx);
+ if (tx)
+ v17_tx_free(tx);
#if defined(ENABLE_GUI)
if (use_gui)
qam_wait_to_end(qam_monitor);
}
}
}
+ both_ways_line_model_free(model);
#if defined(ENABLE_GUI)
if (use_gui)
qam_wait_to_end(endpoint[0].qam_monitor);
v27ter_rx_restart(rx, test_bps, false);
bert_init(&bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&bert, 10000, reporter, NULL);
- one_way_line_model_release(line_model);
+ one_way_line_model_free(line_model);
if ((line_model = one_way_line_model_init(line_model_no, (float) noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
fprintf(stderr, "At completion:\n");
fprintf(stderr, "Final result %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
fprintf(stderr, "Last report %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, latest_results.total_bits, latest_results.bad_bits, latest_results.resyncs);
- one_way_line_model_release(line_model);
+ one_way_line_model_free(line_model);
+
if (signal_level > -43)
{
printf("Tests failed.\n");
printf("Tests passed.\n");
}
+ v27ter_rx_free(rx);
+ if (tx)
+ v27ter_tx_free(tx);
+ bert_release(&bert);
#if defined(ENABLE_GUI)
if (use_gui)
qam_wait_to_end(qam_monitor);
#endif
bert_init(&bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&bert, 10000, reporter, NULL);
- one_way_line_model_release(line_model);
+ one_way_line_model_free(line_model);
if ((line_model = one_way_line_model_init(line_model_no, (float) noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
fprintf(stderr, "At completion:\n");
fprintf(stderr, "Final result %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
fprintf(stderr, "Last report %ddBm0/%ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, noise_level, latest_results.total_bits, latest_results.bad_bits, latest_results.resyncs);
- one_way_line_model_release(line_model);
+ one_way_line_model_free(line_model);
if (signal_level > -43)
{
printf("Tests passed.\n");
}
+ v29_rx_free(rx);
+ if (tx)
+ v29_tx_free(tx);
+ bert_release(&bert);
#if defined(ENABLE_GUI)
if (use_gui)
qam_wait_to_end(qam_monitor);
projects / thirdparty / freeswitch.git / commitdiff
