if (s == NULL)
{
if ((s = (ademco_contactid_receiver_state_t *) malloc(sizeof (*s))) == NULL)
- return NULL;
+ return NULL;
}
memset(s, 0, sizeof(*s));
span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
if (s == NULL)
{
if ((s = (ademco_contactid_sender_state_t *) malloc(sizeof (*s))) == NULL)
- return NULL;
+ return NULL;
}
memset(s, 0, sizeof(*s));
span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
if (len == (int) strlen(*variant) && memcmp(*variant, s, len) == 0)
{
*variant += len;
- return i;
+ return i;
}
s += len;
if (*s == ',')
s++;
}
- return -1;
+ return -1;
}
/*- End of function --------------------------------------------------------*/
if (val < 0)
{
/* It was just a query */
- return TRUE;
+ return TRUE;
}
/* All class 1 FAX commands are supposed to give an ERROR response, if the phone
is on-hook. */
if (s == NULL)
{
if ((s = (awgn_state_t *) malloc(sizeof(*s))) == NULL)
- return NULL;
+ return NULL;
}
if (idum < 0)
idum = -idum;
s->current_digits -= max;
}
buf[max] = '\0';
- return max;
+ return max;
}
/*- End of function --------------------------------------------------------*/
span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
span_log_set_protocol(&s->logging, "BERT");
- return s;
+ return s;
}
/*- End of function --------------------------------------------------------*/
int j;
if ((ec = (echo_can_state_t *) malloc(sizeof(*ec))) == NULL)
- return NULL;
+ return NULL;
memset(ec, 0, sizeof(*ec));
ec->taps = len;
ec->curr_pos = ec->taps - 1;
if ((ec->fir_taps32 = (int32_t *) malloc(ec->taps*sizeof(int32_t))) == NULL)
{
free(ec);
- return NULL;
+ return NULL;
}
memset(ec->fir_taps32, 0, ec->taps*sizeof(int32_t));
for (i = 0; i < 4; i++)
free(ec->fir_taps16[j]);
free(ec->fir_taps32);
free(ec);
- return NULL;
+ return NULL;
}
memset(ec->fir_taps16[i], 0, ec->taps*sizeof(int16_t));
}
if (s == NULL)
{
if ((s = (g711_state_t *) malloc(sizeof(*s))) == NULL)
- return NULL;
+ return NULL;
}
s->mode = mode;
return s;
if (s == NULL)
{
if ((s = (g726_state_t *) malloc(sizeof(*s))) == NULL)
- return NULL;
+ return NULL;
}
s->yl = 34816;
s->yu = 544;
if (s == NULL)
{
if ((s = (gsm0610_state_t *) malloc(sizeof (*s))) == NULL)
- return NULL;
+ return NULL;
/*endif*/
}
/*endif*/
/* Normalization of L_max and L_power */
if (L_max <= 0)
- return 0;
+ return 0;
/*endif*/
if (L_max >= L_power)
- return 3;
+ return 3;
/*endif*/
temp = gsm0610_norm(L_power);
if (x < 0)
{
if (x <= -1073741824)
- return 0;
+ return 0;
/*endif*/
x = ~x;
}
assert(num >= 0 && denom >= num);
if (num == 0)
- return 0;
+ return 0;
/*endif*/
num32 = num;
denom32 = denom;
}
/*endwhile*/
- return div;
+ return div;
}
/*- End of function --------------------------------------------------------*/
}
s->bits--;
txbit = (s->byte >> s->bits) & 0x01;
- return txbit;
+ return txbit;
}
/*- End of function --------------------------------------------------------*/
if (s == NULL)
{
if ((s = (ima_adpcm_state_t *) malloc(sizeof(*s))) == NULL)
- return NULL;
+ return NULL;
}
/*endif*/
memset(s, 0, sizeof(*s));
s->variant = variant;
s->chunk_size = chunk_size;
- return s;
+ return s;
}
/*- End of function --------------------------------------------------------*/
break;
}
/*endswitch*/
- return bytes;
+ return bytes;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
__span_message(s->user_data, level, msg);
/*endif*/
va_end(arg_ptr);
- return 1;
+ return 1;
}
/*endif*/
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
{
s->level = level;
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
{
s->tag = tag;
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
{
s->protocol = protocol;
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
{
s->samples_per_second = samples_per_second;
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
{
s->elapsed_samples += samples;
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
modem_echo_can_state_t *ec;
if ((ec = (modem_echo_can_state_t *) malloc(sizeof(*ec))) == NULL)
- return NULL;
+ return NULL;
memset(ec, 0, sizeof(*ec));
ec->taps = len;
ec->curr_pos = ec->taps - 1;
if ((ec->fir_taps32 = (int32_t *) malloc(ec->taps*sizeof(int32_t))) == NULL)
{
free(ec);
- return NULL;
+ return NULL;
}
memset(ec->fir_taps32, 0, ec->taps*sizeof(int32_t));
if ((ec->fir_taps16 = (int16_t *) malloc(ec->taps*sizeof(int16_t))) == NULL)
{
free(ec->fir_taps32);
free(ec);
- return NULL;
+ return NULL;
}
memset(ec->fir_taps16, 0, ec->taps*sizeof(int16_t));
if (fir16_create(&ec->fir_state, ec->fir_taps16, ec->taps) == NULL)
free(ec->fir_taps16);
free(ec->fir_taps32);
free(ec);
- return NULL;
+ return NULL;
}
- return ec;
+ return ec;
}
/*- End of function --------------------------------------------------------*/
if (ec->curr_pos <= 0)
ec->curr_pos = ec->taps;
ec->curr_pos--;
- return (int16_t) clean_rx;
+ return (int16_t) clean_rx;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
if (s == NULL)
{
if ((s = (oki_adpcm_state_t *) malloc(sizeof(*s))) == NULL)
- return NULL;
+ return NULL;
}
memset(s, 0, sizeof(*s));
s->bit_rate = bit_rate;
- return s;
+ return s;
}
/*- End of function --------------------------------------------------------*/
/*endfor*/
}
/*endif*/
- return samples;
+ return samples;
}
/*- End of function --------------------------------------------------------*/
/*endfor*/
}
/*endif*/
- return bytes;
+ return bytes;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
\return The next bit to transmit. */
SPAN_DECLARE_NONSTD(int) t30_non_ecm_get_bit(void *user_data);
-/*! Get a byte of received non-ECM image data.
- \brief Get a byte of received non-ECM image data.
- \param user_data An opaque pointer, which must point to the T.30 context.
- \return The next byte to transmit. */
-SPAN_DECLARE(int) t30_non_ecm_get_byte(void *user_data);
-
/*! Get a chunk 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 buf The buffer to contain the data.
\param max_len The maximum length of the chunk.
\return The actual length of the chunk. */
-SPAN_DECLARE(int) t30_non_ecm_get_chunk(void *user_data, uint8_t buf[], int max_len);
+SPAN_DECLARE(int) t30_non_ecm_get(void *user_data, uint8_t buf[], int max_len);
/*! Process a bit of received non-ECM image data.
\brief Process a bit of received non-ECM image data
\param bit The received bit. */
SPAN_DECLARE_NONSTD(void) t30_non_ecm_put_bit(void *user_data, int bit);
-/*! Process a byte of received non-ECM image data.
- \brief Process a byte of received non-ECM image data
- \param user_data An opaque pointer, which must point to the T.30 context.
- \param byte The received byte. */
-SPAN_DECLARE(void) t30_non_ecm_put_byte(void *user_data, int byte);
-
/*! Process a chunk of received non-ECM image data.
\brief Process a chunk of received non-ECM image data
\param user_data An opaque pointer, which must point to the T.30 context.
\param buf The buffer containing the received data.
\param len The length of the data in buf. */
-SPAN_DECLARE(void) t30_non_ecm_put_chunk(void *user_data, const uint8_t buf[], int len);
+SPAN_DECLARE(void) t30_non_ecm_put(void *user_data, const uint8_t buf[], int len);
/*! Process a received HDLC frame.
\brief Process a received HDLC frame.
/*! \brief Check if we are at the end of the current document page.
\param s The T.42 context.
\return 0 for more data to come. SIG_STATUS_END_OF_DATA for no more data. */
-SPAN_DECLARE(int) t42_encode_check_if_complete(t42_encode_state_t *s);
+SPAN_DECLARE(int) t42_encode_image_complete(t42_encode_state_t *s);
-SPAN_DECLARE(int) t42_encode_get_byte(t42_encode_state_t *s);
-
-SPAN_DECLARE(int) t42_encode_get_chunk(t42_encode_state_t *s, uint8_t buf[], int max_len);
+SPAN_DECLARE(int) t42_encode_get(t42_encode_state_t *s, uint8_t buf[], size_t max_len);
SPAN_DECLARE(uint32_t) t42_encode_get_image_width(t42_encode_state_t *s);
SPAN_DECLARE(void) t42_decode_rx_status(t42_decode_state_t *s, int status);
-SPAN_DECLARE(int) t42_decode_put_byte(t42_decode_state_t *s, int byte);
-
-SPAN_DECLARE(int) t42_decode_put_chunk(t42_decode_state_t *s,
- const uint8_t data[],
- size_t len);
+SPAN_DECLARE(int) t42_decode_put(t42_decode_state_t *s, const uint8_t data[], size_t len);
SPAN_DECLARE(int) t42_decode_set_row_write_handler(t42_decode_state_t *s,
t4_row_write_handler_t handler,
\return TRUE when the bit ends the document page, otherwise FALSE. */
SPAN_DECLARE(int) t4_rx_put_bit(t4_rx_state_t *s, int bit);
-/*! \brief Put a byte of the current document page.
- \param s The T.4 context.
- \param byte The data byte.
- \return TRUE when the byte ends the document page, otherwise FALSE. */
-SPAN_DECLARE(int) t4_rx_put_byte(t4_rx_state_t *s, uint8_t byte);
-
/*! \brief Put a byte of the current document page.
\param s The T.4 context.
\param buf The buffer containing the chunk.
\param len The length of the chunk.
\return TRUE when the byte ends the document page, otherwise FALSE. */
-SPAN_DECLARE(int) t4_rx_put_chunk(t4_rx_state_t *s, const uint8_t buf[], int len);
+SPAN_DECLARE(int) t4_rx_put(t4_rx_state_t *s, const uint8_t buf[], size_t len);
/*! \brief Complete the reception of a page.
\param s The T.4 receive context.
\return TRUE when the bit ends the document page, otherwise FALSE. */
SPAN_DECLARE(int) t4_t6_decode_put_bit(t4_t6_decode_state_t *s, int bit);
-/*! \brief Put a byte of the current document page.
- \param s The T.4/T.6 context.
- \param byte The data byte.
- \return TRUE when the byte ends the document page, otherwise FALSE. */
-SPAN_DECLARE(int) t4_t6_decode_put_byte(t4_t6_decode_state_t *s, int byte);
-
/*! \brief Put a byte of the current document page.
\param s The T.4/T.6 context.
\param buf The buffer containing the chunk.
\param len The length of the chunk.
- \return TRUE when the byte ends the document page, otherwise FALSE. */
-SPAN_DECLARE(int) t4_t6_decode_put_chunk(t4_t6_decode_state_t *s, const uint8_t buf[], int len);
+ \return T4_DECODE_MORE_DATA when the image is still in progress. T4_DECODE_OK when the image is complete. */
+SPAN_DECLARE(int) t4_t6_decode_put(t4_t6_decode_state_t *s, const uint8_t buf[], size_t len);
/*! \brief Set the row write handler for a T.4/T.6 decode context.
\param s The T.4/T.6 context.
moving forward in the buffer. The document will be padded for the
current minimum scan line time.
\param s The T.4/T.6 context.
- \return The next bit (i.e. 0 or 1). SIG_STATUS_END_OF_DATA for no more data. */
-SPAN_DECLARE(int) t4_t6_encode_check_bit(t4_t6_encode_state_t *s);
+ \return 0 for more data to come. SIG_STATUS_END_OF_DATA for no more data. */
+SPAN_DECLARE(int) t4_t6_encode_image_complete(t4_t6_encode_state_t *s);
/*! \brief Get the next bit of the current image. The image will
be padded for the current minimum scan line time.
\return The next bit (i.e. 0 or 1). SIG_STATUS_END_OF_DATA for no more data. */
SPAN_DECLARE(int) t4_t6_encode_get_bit(t4_t6_encode_state_t *s);
-/*! \brief Get the next byte of the current document page. The document will
- be padded for the current minimum scan line time.
- \param s The T.4/T.6 context.
- \return The next byte. For the last byte of data, bit 8 is
- set. In this case, one or more bits of the byte may be padded with
- zeros, to complete the byte. */
-SPAN_DECLARE(int) t4_t6_encode_get_byte(t4_t6_encode_state_t *s);
-
/*! \brief Get the next chunk of the current document page. The document will
be padded for the current minimum scan line time.
\param s The T.4/T.6 context.
\param max_len The maximum length of the chunk.
\return The actual length of the chunk. If this is less than max_len it
indicates that the end of the document has been reached. */
-SPAN_DECLARE(int) t4_t6_encode_get_chunk(t4_t6_encode_state_t *s, uint8_t buf[], int max_len);
+SPAN_DECLARE(int) t4_t6_encode_get(t4_t6_encode_state_t *s, uint8_t buf[], int max_len);
/*! \brief Set the row read handler for a T.4/T.6 encode context.
\param s The T.4/T.6 context.
moving forward in the buffer. The document will be padded for the
current minimum scan line time.
\param s The T.4 context.
- \return The next bit (i.e. 0 or 1). SIG_STATUS_END_OF_DATA for no more data. */
-SPAN_DECLARE(int) t4_tx_check_if_complete(t4_tx_state_t *s);
+ \return 0 for more data to come. SIG_STATUS_END_OF_DATA for no more data. */
+SPAN_DECLARE(int) t4_tx_image_complete(t4_tx_state_t *s);
/*! \brief Get the next bit of the current document page. The document will
be padded for the current minimum scan line time.
\return The next bit (i.e. 0 or 1). SIG_STATUS_END_OF_DATA for no more data. */
SPAN_DECLARE(int) t4_tx_get_bit(t4_tx_state_t *s);
-/*! \brief Get the next byte of the current document page. The document will
- be padded for the current minimum scan line time.
- \param s The T.4 context.
- \return The next byte. For the last byte of data, bit 8 is
- set. In this case, one or more bits of the byte may be padded with
- zeros, to complete the byte. */
-SPAN_DECLARE(int) t4_tx_get_byte(t4_tx_state_t *s);
-
/*! \brief Get the next chunk of the current document page. The document will
be padded for the current minimum scan line time.
\param s The T.4 context.
\param max_len The maximum length of the chunk.
\return The actual length of the chunk. If this is less than max_len it
indicates that the end of the document has been reached. */
-SPAN_DECLARE(int) t4_tx_get_chunk(t4_tx_state_t *s, uint8_t buf[], int max_len);
+SPAN_DECLARE(int) t4_tx_get(t4_tx_state_t *s, uint8_t buf[], size_t max_len);
/*! \brief End the transmission of a document. Tidy up and close the file.
This should be used to end T.4 transmission started with t4_tx_init.
/*! \brief Check if we are at the end of the current document page.
\param s The T.85 context.
\return 0 for more data to come. SIG_STATUS_END_OF_DATA for no more data. */
-SPAN_DECLARE(int) t85_encode_check_if_complete(t85_encode_state_t *s);
-
-/*! \brief Get the next byte of the current document page.
- \param s The T.85 context.
- \return The next byte. For the last byte of data, bit 8 is
- set. In this case, one or more bits of the byte may be padded with
- zeros, to complete the byte. */
-SPAN_DECLARE(int) t85_encode_get_byte(t85_encode_state_t *s);
+SPAN_DECLARE(int) t85_encode_image_complete(t85_encode_state_t *s);
/*! \brief Get the next chunk of the current document page. The document will
be padded for the current minimum scan line time.
\param max_len The maximum length of the chunk.
\return The actual length of the chunk. If this is less than max_len it
indicates that the end of the document has been reached. */
-SPAN_DECLARE(int) t85_encode_get_chunk(t85_encode_state_t *s, uint8_t buf[], int max_len);
+SPAN_DECLARE(int) t85_encode_get(t85_encode_state_t *s, uint8_t buf[], size_t max_len);
/*! \brief Set the row read handler for a T.85 encode context.
\param s The T.85 context.
\param status The type of status change which occured. */
SPAN_DECLARE(void) t85_decode_rx_status(t85_decode_state_t *s, int status);
-/*! \brief Decode a byte of T.85 data.
- \param s The T.85 context.
- \param byte The data to be decoded.
- \return 0 for OK. */
-SPAN_DECLARE(int) t85_decode_put_byte(t85_decode_state_t *s, int byte);
-
/*! \brief Decode a chunk of T.85 data.
\param s The T.85 context.
\param data The data to be decoded.
\param len The length of the data to be decoded.
\return 0 for OK. */
-SPAN_DECLARE(int) t85_decode_put_chunk(t85_decode_state_t *s,
- const uint8_t data[],
- size_t len);
+SPAN_DECLARE(int) t85_decode_put(t85_decode_state_t *s, const uint8_t data[], size_t len);
#if defined(__cplusplus)
}
steps = -steps;
j = (rotation + steps - 2)%steps;
if (pattern[j].f1 != test[8].f1 || pattern[j].f2 != test[8].f2)
- return 0;
+ return 0;
if (pattern[j].min_duration > test[8].min_duration*SUPER_TONE_BINS
||
pattern[j].max_duration < test[8].min_duration*SUPER_TONE_BINS)
{
- return 0;
+ return 0;
}
}
j = (rotation + steps - 1)%steps;
if (pattern[j].f1 != test[9].f1 || pattern[j].f2 != test[9].f2)
- return 0;
+ return 0;
if (pattern[j].max_duration < test[9].min_duration*SUPER_TONE_BINS)
- return 0;
+ return 0;
}
else
{
{
j = i + 10 - steps;
if (pattern[i].f1 != test[j].f1 || pattern[i].f2 != test[j].f2)
- return 0;
+ return 0;
if (pattern[i].min_duration > test[j].min_duration*SUPER_TONE_BINS
||
pattern[i].max_duration < test[j].min_duration*SUPER_TONE_BINS)
{
- return 0;
+ return 0;
}
}
}
- return 1;
+ return 1;
}
/*- End of function --------------------------------------------------------*/
#endif
for (i = 0; i < desc->monitored_frequencies; i++)
goertzel_init(&s->state[i], &s->desc->desc[i]);
- return s;
+ return s;
}
/*- End of function --------------------------------------------------------*/
super_tone_tx_step_t *tree;
if (s->level < 0 || s->level > 3)
- return 0;
+ return 0;
samples = 0;
tree = s->levels[s->level];
while (tree && samples < max_samples)
}
}
- return samples;
+ return samples;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
/* These frames contain a frame sequence number within the partial page (one octet) followed
by some image data. */
s->ecm_data[i][3] = (uint8_t) i;
- if ((len = t4_tx_get_chunk(&s->t4.tx, &s->ecm_data[i][4], s->octets_per_ecm_frame)) < s->octets_per_ecm_frame)
+ if ((len = t4_tx_get(&s->t4.tx, &s->ecm_data[i][4], s->octets_per_ecm_frame)) < s->octets_per_ecm_frame)
{
/* The image is not big enough to fill the entire buffer */
/* We need to pad to a full frame, as most receivers expect that. */
/* We filled the entire buffer */
s->ecm_frames = 256;
span_log(&s->logging, SPAN_LOG_FLOW, "Partial page buffer full (%d per frame)\n", s->octets_per_ecm_frame);
- s->ecm_at_page_end = (t4_tx_check_if_complete(&s->t4.tx) == SIG_STATUS_END_OF_DATA);
+ s->ecm_at_page_end = (t4_tx_image_complete(&s->t4.tx) == SIG_STATUS_END_OF_DATA);
return 256;
}
/*- End of function --------------------------------------------------------*/
span_log(&s->logging, SPAN_LOG_FLOW, "Partial page OK - committing block %d, %d frames\n", s->ecm_block, s->ecm_frames);
for (i = 0; i < s->ecm_frames; i++)
{
- if (t4_rx_put_chunk(&s->t4.rx, s->ecm_data[i], s->ecm_len[i]))
+ if (t4_rx_put(&s->t4.rx, s->ecm_data[i], s->ecm_len[i]))
{
/* This is the end of the document */
break;
break;
case T30_STATE_F_DOC_NON_ECM:
/* Document transfer */
- if (t4_rx_put_bit(&s->t4.rx, bit))
+ if (t4_rx_put_bit(&s->t4.rx, bit) == T4_DECODE_OK)
{
/* That is the end of the document */
set_state(s, T30_STATE_F_POST_DOC_NON_ECM);
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(void) t30_non_ecm_put_byte(void *user_data, int byte)
-{
- t30_state_t *s;
-
- if (byte < 0)
- {
- t30_non_ecm_rx_status(user_data, byte);
- return;
- }
- s = (t30_state_t *) user_data;
- switch (s->state)
- {
- case T30_STATE_F_TCF:
- /* Trainability test */
- /* This makes counting zeros fast, but approximate. That really doesn't matter */
- s->tcf_test_bits += 8;
- if (byte)
- {
- if (s->tcf_current_zeros > s->tcf_most_zeros)
- s->tcf_most_zeros = s->tcf_current_zeros;
- s->tcf_current_zeros = 0;
- }
- else
- {
- s->tcf_current_zeros += 8;
- }
- break;
- case T30_STATE_F_DOC_NON_ECM:
- /* Document transfer */
- if (t4_rx_put_byte(&s->t4.rx, (uint8_t) byte))
- {
- /* That is the end of the document */
- set_state(s, T30_STATE_F_POST_DOC_NON_ECM);
- queue_phase(s, T30_PHASE_D_RX);
- timer_t2_start(s);
- }
- break;
- }
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(void) t30_non_ecm_put_chunk(void *user_data, const uint8_t buf[], int len)
+SPAN_DECLARE(void) t30_non_ecm_put(void *user_data, const uint8_t buf[], int len)
{
t30_state_t *s;
int i;
break;
case T30_STATE_F_DOC_NON_ECM:
/* Document transfer */
- if (t4_rx_put_chunk(&s->t4.rx, buf, len))
+ if (t4_rx_put(&s->t4.rx, buf, len))
{
/* That is the end of the document */
set_state(s, T30_STATE_F_POST_DOC_NON_ECM);
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t30_non_ecm_get_byte(void *user_data)
-{
- int byte;
- t30_state_t *s;
-
- s = (t30_state_t *) user_data;
- switch (s->state)
- {
- case T30_STATE_D_TCF:
- /* Trainability test. */
- byte = 0;
- if ((s->tcf_test_bits -= 8) < 0)
- {
- /* Finished sending training test. */
- byte = 0x100;
- }
- break;
- case T30_STATE_I:
- /* Transferring real data. */
- byte = t4_tx_get_byte(&s->t4.tx);
- break;
- case T30_STATE_D_POST_TCF:
- case T30_STATE_II_Q:
- /* We should be padding out a block of samples if we are here */
- byte = 0;
- break;
- default:
- span_log(&s->logging, SPAN_LOG_WARNING, "t30_non_ecm_get_byte in bad state %d\n", s->state);
- byte = 0x100;
- break;
- }
- return byte;
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t30_non_ecm_get_chunk(void *user_data, uint8_t buf[], int max_len)
+SPAN_DECLARE(int) t30_non_ecm_get(void *user_data, uint8_t buf[], int max_len)
{
int len;
t30_state_t *s;
break;
case T30_STATE_I:
/* Transferring real data. */
- len = t4_tx_get_chunk(&s->t4.tx, buf, max_len);
+ len = t4_tx_get(&s->t4.tx, buf, max_len);
break;
case T30_STATE_D_POST_TCF:
case T30_STATE_II_Q:
len = 0;
break;
default:
- span_log(&s->logging, SPAN_LOG_WARNING, "t30_non_ecm_get_chunk in bad state %d\n", s->state);
+ span_log(&s->logging, SPAN_LOG_WARNING, "t30_non_ecm_get in bad state %d\n", s->state);
len = -1;
break;
}
static int silence_rx(void *user_data, const int16_t amp[], int len);
static int cng_rx(void *user_data, const int16_t amp[], int len);
static void non_ecm_put_bit(void *user_data, int bit);
-static void non_ecm_put_chunk(void *user_data, const uint8_t buf[], int len);
-static int non_ecm_get_chunk(void *user_data, uint8_t buf[], int len);
+static void non_ecm_put(void *user_data, const uint8_t buf[], int len);
+static int non_ecm_get(void *user_data, uint8_t buf[], int len);
static void non_ecm_rx_status(void *user_data, int status);
static void hdlc_rx_status(void *user_data, int status);
if (len > 0)
{
bit_reverse(buf2, buf, len);
- non_ecm_put_chunk(s, buf, len);
+ non_ecm_put(s, buf, len);
}
fe->timeout_rx_samples = fe->samples + ms_to_samples(MID_RX_TIMEOUT);
break;
s->at_state.rx_signal_present = TRUE;
}
bit_reverse(buf2, buf, len);
- non_ecm_put_chunk(s, buf, len);
+ non_ecm_put(s, buf, len);
}
/* WORKAROUND: At least some Mediatrix boxes have a bug, where they can send HDLC signal end where
they should send non-ECM signal end. It is possible they also do the opposite.
However, I think the early versions of T.38 said the signal end message should not
contain data. Hopefully, following the current spec will not cause compatibility
issues. */
- len = non_ecm_get_chunk(s, buf, fe->octets_per_data_packet);
+ len = non_ecm_get(s, buf, fe->octets_per_data_packet);
if (len > 0)
bit_reverse(buf, buf, len);
if (len < fe->octets_per_data_packet)
}
/*- End of function --------------------------------------------------------*/
-static void non_ecm_put_chunk(void *user_data, const uint8_t buf[], int len)
+static void non_ecm_put(void *user_data, const uint8_t buf[], int len)
{
t31_state_t *s;
int i;
}
/*- End of function --------------------------------------------------------*/
-static int non_ecm_get_chunk(void *user_data, uint8_t buf[], int len)
+static int non_ecm_get(void *user_data, uint8_t buf[], int len)
{
t31_state_t *s;
int i;
if (len > 0)
{
bit_reverse(buf2, buf, len);
- t30_non_ecm_put_chunk(&s->t30, buf2, len);
+ t30_non_ecm_put(&s->t30, buf2, len);
}
/*endif*/
fe->timeout_rx_samples = fe->samples + ms_to_samples(MID_RX_TIMEOUT);
}
/*endif*/
bit_reverse(buf2, buf, len);
- t30_non_ecm_put_chunk(&s->t30, buf2, len);
+ t30_non_ecm_put(&s->t30, buf2, len);
}
/*endif*/
/* WORKAROUND: At least some Mediatrix boxes have a bug, where they can send HDLC signal end where
However, I think the early versions of T.38 said the signal end message should not
contain data. Hopefully, following the current spec will not cause compatibility
issues. */
- len = t30_non_ecm_get_chunk(&s->t30, buf, fe->octets_per_data_packet);
+ len = t30_non_ecm_get(&s->t30, buf, fe->octets_per_data_packet);
if (len < 0)
return -1;
/*endif*/
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t42_encode_check_if_complete(t42_encode_state_t *s)
+SPAN_DECLARE(int) t42_encode_image_complete(t42_encode_state_t *s)
{
return 0;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t42_encode_get_byte(t42_encode_state_t *s)
-{
- return 0;
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t42_encode_get_chunk(t42_encode_state_t *s, uint8_t buf[], int max_len)
+SPAN_DECLARE(int) t42_encode_get(t42_encode_state_t *s, uint8_t buf[], size_t max_len)
{
return 0;
}
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t42_decode_put_byte(t42_decode_state_t *s, int byte)
-{
- return 0;
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t42_decode_put_chunk(t42_decode_state_t *s,
- const uint8_t data[],
- size_t len)
+SPAN_DECLARE(int) t42_decode_put(t42_decode_state_t *s, const uint8_t data[], size_t len)
{
uint8_t *buf;
SPAN_DECLARE(int) t4_rx_put_bit(t4_rx_state_t *s, int bit)
{
+ /* We only put bit by bit for T.4-1D and T.4-2D */
s->line_image_size += 1;
return t4_t6_decode_put_bit(&s->decoder.t4_t6, bit);
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t4_rx_put_byte(t4_rx_state_t *s, uint8_t byte)
-{
- s->line_image_size += 8;
- switch (s->line_encoding)
- {
- case T4_COMPRESSION_ITU_T4_1D:
- case T4_COMPRESSION_ITU_T4_2D:
- case T4_COMPRESSION_ITU_T6:
- return t4_t6_decode_put_byte(&s->decoder.t4_t6, byte);
- case T4_COMPRESSION_ITU_T42:
- return t42_decode_put_byte(&s->decoder.t42, byte);
-#if defined(SPANDSP_SUPPORT_T43)
- case T4_COMPRESSION_ITU_T43:
- return t43_decode_put_byte(&s->decoder.t43, byte);
-#endif
- case T4_COMPRESSION_ITU_T85:
- case T4_COMPRESSION_ITU_T85_L0:
- return t85_decode_put_byte(&s->decoder.t85, byte);
- }
- return T4_DECODE_OK;
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t4_rx_put_chunk(t4_rx_state_t *s, const uint8_t buf[], int len)
+SPAN_DECLARE(int) t4_rx_put(t4_rx_state_t *s, const uint8_t buf[], size_t len)
{
s->line_image_size += 8*len;
switch (s->line_encoding)
case T4_COMPRESSION_ITU_T4_1D:
case T4_COMPRESSION_ITU_T4_2D:
case T4_COMPRESSION_ITU_T6:
- return t4_t6_decode_put_chunk(&s->decoder.t4_t6, buf, len);
+ return t4_t6_decode_put(&s->decoder.t4_t6, buf, len);
case T4_COMPRESSION_ITU_T42:
- return t42_decode_put_chunk(&s->decoder.t42, buf, len);
+ return t42_decode_put(&s->decoder.t42, buf, len);
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_ITU_T43:
- return t43_decode_put_chunk(&s->decoder.t43, buf, len);
+ return t43_decode_put(&s->decoder.t43, buf, len);
#endif
case T4_COMPRESSION_ITU_T85:
case T4_COMPRESSION_ITU_T85_L0:
- return t85_decode_put_chunk(&s->decoder.t85, buf, len);
+ return t85_decode_put(&s->decoder.t85, buf, len);
}
return T4_DECODE_OK;
}
case T4_COMPRESSION_ITU_T4_1D:
case T4_COMPRESSION_ITU_T4_2D:
case T4_COMPRESSION_ITU_T6:
- t4_t6_decode_put_byte(&s->decoder.t4_t6, SIG_STATUS_END_OF_DATA);
+ t4_t6_decode_put(&s->decoder.t4_t6, NULL, 0);
length = t4_t6_decode_get_image_length(&s->decoder.t4_t6);
break;
case T4_COMPRESSION_ITU_T42:
- t42_decode_put_byte(&s->decoder.t42, SIG_STATUS_END_OF_DATA);
+ t42_decode_put(&s->decoder.t42, NULL, 0);
length = t42_decode_get_image_length(&s->decoder.t42);
break;
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_ITU_T43:
- t43_decode_put_byte(&s->decoder.t43, SIG_STATUS_END_OF_DATA);
+ t43_decode_put(&s->decoder.t43, NULL, 0);
length = t43_decode_get_image_length(&s->decoder.t43);
break;
#endif
case T4_COMPRESSION_ITU_T85:
case T4_COMPRESSION_ITU_T85_L0:
- t85_decode_put_byte(&s->decoder.t85, SIG_STATUS_END_OF_DATA);
+ t85_decode_put(&s->decoder.t85, NULL, 0);
length = t85_decode_get_image_length(&s->decoder.t85);
break;
}
break;
case SIG_STATUS_CARRIER_DOWN:
case SIG_STATUS_END_OF_DATA:
- /* Finalise the image */
- if (s->consecutive_eols != EOLS_TO_END_ANY_RX_PAGE)
- {
- /* Push enough zeros (13) through the decoder to flush out any remaining codes */
- put_bits(s, 0, 8);
- put_bits(s, 0, 5);
- }
- if (s->curr_bad_row_run)
- {
- if (s->curr_bad_row_run > s->longest_bad_row_run)
- s->longest_bad_row_run = s->curr_bad_row_run;
- s->curr_bad_row_run = 0;
- }
- /* Don't worry about the return value here. We are finishing anyway. */
- if (s->row_write_handler)
- s->row_write_handler(s->row_write_user_data, NULL, 0);
- s->rx_bits = 0;
- s->rx_skip_bits = 0;
- s->rx_bitstream = 0;
- s->consecutive_eols = EOLS_TO_END_ANY_RX_PAGE;
+ t4_t6_decode_put(s, NULL, 0);
break;
default:
span_log(&s->logging, SPAN_LOG_WARNING, "Unexpected rx status - %d!\n", status);
return TRUE;
}
s->compressed_image_size++;
- return put_bits(s, bit & 1, 1);
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t4_t6_decode_put_byte(t4_t6_decode_state_t *s, int byte)
-{
- if (byte < 0)
- {
- t4_t6_decode_rx_status(s, byte);
- return TRUE;
- }
- s->compressed_image_size += 8;
- return put_bits(s, byte & 0xFF, 8);
+ if (put_bits(s, bit & 1, 1))
+ return T4_DECODE_OK;
+ return T4_DECODE_MORE_DATA;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t4_t6_decode_put_chunk(t4_t6_decode_state_t *s, const uint8_t buf[], int len)
+SPAN_DECLARE(int) t4_t6_decode_put(t4_t6_decode_state_t *s, const uint8_t buf[], size_t len)
{
int i;
uint8_t byte;
+ if (len == 0)
+ {
+ /* Finalise the image */
+ if (s->consecutive_eols != EOLS_TO_END_ANY_RX_PAGE)
+ {
+ /* Push enough zeros (13) through the decoder to flush out any remaining codes */
+ put_bits(s, 0, 8);
+ put_bits(s, 0, 5);
+ }
+ if (s->curr_bad_row_run)
+ {
+ if (s->curr_bad_row_run > s->longest_bad_row_run)
+ s->longest_bad_row_run = s->curr_bad_row_run;
+ s->curr_bad_row_run = 0;
+ }
+ /* Don't worry about the return value here. We are finishing anyway. */
+ if (s->row_write_handler)
+ s->row_write_handler(s->row_write_user_data, NULL, 0);
+ s->rx_bits = 0;
+ s->rx_skip_bits = 0;
+ s->rx_bitstream = 0;
+ s->consecutive_eols = EOLS_TO_END_ANY_RX_PAGE;
+ return T4_DECODE_OK;
+ }
+
for (i = 0; i < len; i++)
{
s->compressed_image_size += 8;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t4_t6_encode_check_bit(t4_t6_encode_state_t *s)
+SPAN_DECLARE(int) t4_t6_encode_image_complete(t4_t6_encode_state_t *s)
{
if (s->bitstream_optr >= s->bitstream_iptr)
{
if (get_next_row(s) < 0)
return SIG_STATUS_END_OF_DATA;
}
- return (s->bitstream[s->bitstream_optr] >> (7 - s->bit_pos)) & 1;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
{
int bit;
- if ((bit = t4_t6_encode_check_bit(s)) < 0)
- return bit;
+ if (s->bitstream_optr >= s->bitstream_iptr)
+ {
+ if (get_next_row(s) < 0)
+ return SIG_STATUS_END_OF_DATA;
+ }
+ bit = (s->bitstream[s->bitstream_optr] >> (7 - s->bit_pos)) & 1;
if (--s->bit_pos < 0)
{
s->bitstream_optr++;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t4_t6_encode_get_byte(t4_t6_encode_state_t *s)
-{
- if (s->bitstream_optr >= s->bitstream_iptr)
- {
- if (get_next_row(s) < 0)
- return 0x100;
- }
- return s->bitstream[s->bitstream_optr++];
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t4_t6_encode_get_chunk(t4_t6_encode_state_t *s, uint8_t buf[], int max_len)
+SPAN_DECLARE(int) t4_t6_encode_get(t4_t6_encode_state_t *s, uint8_t buf[], int max_len)
{
int len;
int n;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t4_tx_check_if_complete(t4_tx_state_t *s)
+SPAN_DECLARE(int) t4_tx_image_complete(t4_tx_state_t *s)
{
switch (s->line_encoding)
{
case T4_COMPRESSION_ITU_T4_1D:
case T4_COMPRESSION_ITU_T4_2D:
case T4_COMPRESSION_ITU_T6:
- return t4_t6_encode_check_bit(&s->encoder.t4_t6);
+ return t4_t6_encode_image_complete(&s->encoder.t4_t6);
case T4_COMPRESSION_ITU_T42:
- return t42_encode_check_if_complete(&s->encoder.t42);
+ return t42_encode_image_complete(&s->encoder.t42);
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_ITU_T43:
- return t43_encode_check_if_complete(&s->encoder.t43);
+ return t43_encode_image_complete(&s->encoder.t43);
#endif
case T4_COMPRESSION_ITU_T85:
case T4_COMPRESSION_ITU_T85_L0:
- return t85_encode_check_if_complete(&s->encoder.t85);
+ return t85_encode_image_complete(&s->encoder.t85);
}
return SIG_STATUS_END_OF_DATA;
}
SPAN_DECLARE(int) t4_tx_get_bit(t4_tx_state_t *s)
{
+ /* We only get bit by bit for T.4 1D and T.4 2-D. */
return t4_t6_encode_get_bit(&s->encoder.t4_t6);
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t4_tx_get_byte(t4_tx_state_t *s)
+SPAN_DECLARE(int) t4_tx_get(t4_tx_state_t *s, uint8_t buf[], size_t max_len)
{
switch (s->line_encoding)
{
case T4_COMPRESSION_ITU_T4_1D:
case T4_COMPRESSION_ITU_T4_2D:
case T4_COMPRESSION_ITU_T6:
- return t4_t6_encode_get_byte(&s->encoder.t4_t6);
+ return t4_t6_encode_get(&s->encoder.t4_t6, buf, max_len);
case T4_COMPRESSION_ITU_T42:
- return t42_encode_get_byte(&s->encoder.t42);
+ return t42_encode_get(&s->encoder.t42, buf, max_len);
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_ITU_T43:
- return t43_encode_get_byte(&s->encoder.t43);
+ return t43_encode_get(&s->encoder.t43, buf, max_len);
#endif
case T4_COMPRESSION_ITU_T85:
case T4_COMPRESSION_ITU_T85_L0:
- return t85_encode_get_byte(&s->encoder.t85);
- }
- return SIG_STATUS_END_OF_DATA;
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t4_tx_get_chunk(t4_tx_state_t *s, uint8_t buf[], int max_len)
-{
- switch (s->line_encoding)
- {
- case T4_COMPRESSION_ITU_T4_1D:
- case T4_COMPRESSION_ITU_T4_2D:
- case T4_COMPRESSION_ITU_T6:
- return t4_t6_encode_get_chunk(&s->encoder.t4_t6, buf, max_len);
- case T4_COMPRESSION_ITU_T42:
- return t42_encode_get_chunk(&s->encoder.t42, buf, max_len);
-#if defined(SPANDSP_SUPPORT_T43)
- case T4_COMPRESSION_ITU_T43:
- return t43_encode_get_chunk(&s->encoder.t43, buf, max_len);
-#endif
- case T4_COMPRESSION_ITU_T85:
- case T4_COMPRESSION_ITU_T85_L0:
- return t85_encode_get_chunk(&s->encoder.t85, buf, max_len);
+ return t85_encode_get(&s->encoder.t85, buf, max_len);
}
return 0;
}
case SIG_STATUS_CARRIER_DOWN:
case SIG_STATUS_END_OF_DATA:
/* Finalise the image */
- s->end_of_data = 1;
- t85_decode_put_chunk(s, NULL, 0);
+ t85_decode_put(s, NULL, 0);
break;
default:
span_log(&s->logging, SPAN_LOG_WARNING, "Unexpected rx status - %d!\n", status);
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t85_decode_put_byte(t85_decode_state_t *s, int byte)
-{
- uint8_t data[1];
-
- if (byte < 0)
- {
- t85_decode_rx_status(s, byte);
- return (s->y >= s->yd) ? T4_DECODE_OK : T4_DECODE_MORE_DATA;
- }
- data[0] = byte;
- return t85_decode_put_chunk(s, data, 1);
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t85_decode_put_chunk(t85_decode_state_t *s,
- const uint8_t data[],
- size_t len)
+SPAN_DECLARE(int) t85_decode_put(t85_decode_state_t *s, const uint8_t data[], size_t len)
{
int ret;
uint32_t y;
size_t cnt;
int i;
+ if (len == 0)
+ {
+ if (s->y >= s->yd)
+ return T4_DECODE_OK;
+ /* This is the end of image condition */
+ s->end_of_data = 1;
+ }
+
s->compressed_image_size += len;
cnt = 0;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t85_encode_check_if_complete(t85_encode_state_t *s)
+SPAN_DECLARE(int) t85_encode_image_complete(t85_encode_state_t *s)
{
if (s->y >= s->yd)
return SIG_STATUS_END_OF_DATA;
}
/*- End of function --------------------------------------------------------*/
-SPAN_DECLARE(int) t85_encode_get_byte(t85_encode_state_t *s)
-{
- if (s->bitstream_optr >= s->bitstream_iptr)
- {
- do
- {
- if (get_next_row(s) < 0)
- return 0x100;
- }
- while (s->bitstream_iptr == 0);
- }
- return s->bitstream[s->bitstream_optr++];
-}
-/*- End of function --------------------------------------------------------*/
-
-SPAN_DECLARE(int) t85_encode_get_chunk(t85_encode_state_t *s, uint8_t buf[], int max_len)
+SPAN_DECLARE(int) t85_encode_get(t85_encode_state_t *s, uint8_t buf[], size_t max_len)
{
int len;
int n;
int result;
if (!have_cpuid_p())
- return 0;
+ return 0;
/*endif*/
__asm__ __volatile__ (
" push %%ebx;\n"
: "=a" (result)
:
: "ecx", "edx");
- return result;
+ return result;
}
/*- End of function --------------------------------------------------------*/
int result;
if (!have_cpuid_p())
- return 0;
+ return 0;
/*endif*/
__asm__ __volatile__ (
" push %%ebx;\n"
: "=a" (result)
:
: "ecx", "edx");
- return result;
+ return result;
}
/*- End of function --------------------------------------------------------*/
int result;
if (!have_cpuid_p())
- return 0;
+ return 0;
/*endif*/
__asm__ __volatile__ (
" push %%ebx;\n"
: "=a" (result)
:
: "ecx", "edx");
- return result;
+ return result;
}
/*- End of function --------------------------------------------------------*/
int result;
if (!have_cpuid_p())
- return 0;
+ return 0;
/*endif*/
__asm__ __volatile__ (
" push %%ebx;\n"
: "=c" (result)
:
: "eax", "edx");
- return result;
+ return result;
}
/*- End of function --------------------------------------------------------*/
printf("SIMD2 is %x\n", result);
result = has_3DNow();
printf("3DNow is %x\n", result);
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
#endif
if (s == NULL)
{
if ((s = (time_scale_state_t *) malloc(sizeof (*s))) == NULL)
- return NULL;
+ return NULL;
/*endif*/
alloced = TRUE;
}
int i;
if (s->current_section < 0)
- return 0;
+ return 0;
for (samples = 0; samples < max_samples; )
{
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit (2);
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
}
}
printf("Test passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
printf("Test passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
dev->factor = expf(-1.0f/((float) SAMPLE_RATE*0.035f));
dev->power = 0;
dev->type = type;
- return dev;
+ return dev;
}
/*- End of function --------------------------------------------------------*/
#endif
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
for (i = 0; i < 256; i++)
{
if (ecm_len[i] > 0)
- t4_rx_put_chunk(&t4_rx_state, ecm_data[i], ecm_len[i]);
+ t4_rx_put(&t4_rx_state, ecm_data[i], ecm_len[i]);
fprintf(stderr, "%d", (ecm_len[i] <= 0) ? 0 : 1);
}
fprintf(stderr, "\n");
fprintf(stderr, " Cannot close audio file '%s'\n", filename);
exit(2);
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
printf("Tests passed\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
printf("%d\n", css_c3[i]);
signal_free(&local_css);
signal_free(&far_css);
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
decode_bitstream(in_file_name);
else
hdlc_tests();
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
}
fftw_destroy_plan(p);
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
printf(" File gave %d hits.\n", hits);
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
/* This mixed echo and far end signal will have been through an A-law munging when it came back into
the digital network. */
rx = codec_munger(rx);
- return rx;
+ return rx;
}
/*- End of function --------------------------------------------------------*/
#endif
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit (2);
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
fi
echo ima_adpcm_tests completed OK
-./image_translate_tests >$STDOUT_DEST 2>$STDERR_DEST
-RETVAL=$?
-if [ $RETVAL != 0 ]
-then
- echo image_translate_tests failed!
- exit $RETVAL
-fi
-echo image_translate_tests completed OK
+#./image_translate_tests >$STDOUT_DEST 2>$STDERR_DEST
+#RETVAL=$?
+#if [ $RETVAL != 0 ]
+#then
+# echo image_translate_tests failed!
+# exit $RETVAL
+#fi
+#echo image_translate_tests completed OK
./logging_tests >$STDOUT_DEST 2>$STDERR_DEST
RETVAL=$?
echo t38_non_ecm_buffer_tests completed OK
rm -f t4_tests_receive.tif
-./t4_tests >$STDOUT_DEST 2>$STDERR_DEST
+./t4_tests -b 0 >$STDOUT_DEST 2>$STDERR_DEST
+RETVAL=$?
+if [ $RETVAL != 0 ]
+then
+ echo t4_tests failed!
+ exit $RETVAL
+fi
+rm -f t4_tests_receive.tif
+./t4_tests -b 1 >$STDOUT_DEST 2>$STDERR_DEST
+RETVAL=$?
+if [ $RETVAL != 0 ]
+then
+ echo t4_tests failed!
+ exit $RETVAL
+fi
+rm -f t4_tests_receive.tif
+./t4_tests -b 10 >$STDOUT_DEST 2>$STDERR_DEST
RETVAL=$?
if [ $RETVAL != 0 ]
then
exit(2);
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
span_schedule_release(&sched);
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
/*endfor*/
printf("Tests completed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
cur = cur->next;
}
/*endwhile*/
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
cur = cur->next;
}
/*endwhile*/
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
}
printf("Tests passed.\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
t30_tests(t38_mode, use_gui, log_audio, test_sending, g1050_model_no, g1050_speed_pattern_no);
printf("Tests passed\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
printf("Decoded as %s %s %s\n", (country) ? country : "???", (vendor) ? vendor : "???", (model) ? model : "???");
printf("Tests passed\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
printf("Tests passed\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
t38_non_ecm_buffer_report_output_status(&buffer, &logging);
printf("Tests passed\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
printf("0x%02x\n", data[i]);
t85_decode_init(&t85_dec, t85_row_write_handler, NULL);
t85_decode_set_comment_handler(&t85_dec, 1000, t85_comment_handler, NULL);
- result = t85_decode_put_chunk(&t85_dec, data, total_len);
+ result = t85_decode_put(&t85_dec, data, total_len);
if (result == T4_DECODE_MORE_DATA)
- result = t85_decode_put_byte(&t85_dec, SIG_STATUS_END_OF_DATA);
+ result = t85_decode_put(&t85_dec, NULL, 0);
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
t85_decode_release(&t85_dec);
t85_dec.min_bit_planes = 1;
t85_dec.max_bit_planes = 8;
data5_ptr = 0;
- result = t85_decode_put_chunk(&t85_dec, data, total_len);
+ result = t85_decode_put(&t85_dec, data, total_len);
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
t85_decode_new_plane(&t85_dec);
data5_ptr = 0;
t85_decode_set_comment_handler(&t85_dec, 1000, t85_comment_handler, NULL);
- result = t85_decode_put_chunk(&t85_dec, data, total_len);
+ result = t85_decode_put(&t85_dec, data, total_len);
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
}
if (result == T4_DECODE_MORE_DATA)
{
printf("More\n");
- result = t85_decode_put_byte(&t85_dec, SIG_STATUS_END_OF_DATA);
+ result = t85_decode_put(&t85_dec, NULL, 0);
}
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
end_of_page = t4_t6_decode_put_bit(&receive_state, bit & 1);
}
break;
- case 1:
- do
- {
- bit = t4_t6_encode_get_byte(&send_state);
- if ((bit & 0x100))
- {
- if (++end_marks > 50)
- {
- printf("Receiver missed the end of page mark\n");
- tests_failed++;
- break;
- }
- }
- end_of_page = t4_t6_decode_put_byte(&receive_state, bit & 0xFF);
- }
- while (!end_of_page);
- break;
default:
do
{
- len = t4_t6_encode_get_chunk(&send_state, chunk_buf, block_size);
+ len = t4_t6_encode_get(&send_state, chunk_buf, block_size);
if (len == 0)
{
if (++end_marks > 50)
chunk_buf[0] = 0xFF;
len = 1;
}
- end_of_page = t4_t6_decode_put_chunk(&receive_state, chunk_buf, len);
+ end_of_page = t4_t6_decode_put(&receive_state, chunk_buf, len);
}
while (!end_of_page);
break;
if (!page_ended)
{
/* We might need to push a few bits to get the receiver to report the
- end of page condition (at least with T.6). */
+ end of page condition (at least with T.6). */
if (++end_marks > 50)
{
printf("Receiver missed the end of page mark\n");
const char *page_header_tz;
tz_t tz;
int opt;
+ int len;
int i;
int bit_error_rate;
int dump_as_xxx;
memset(&send_state, 0, sizeof(send_state));
memset(&receive_state, 0, sizeof(receive_state));
- end_of_page = FALSE;
+ end_of_page = T4_DECODE_MORE_DATA;
if (decode_file_name)
{
if (compression < 0)
{
if (sscanf(&buf[18 + 3*i], "%x", (unsigned int *) &bit) != 1)
break;
- if ((end_of_page = t4_rx_put_byte(&receive_state, bit)))
- break;
+ block[i] = bit;
}
+ end_of_page = t4_rx_put(&receive_state, block, i);
}
else if (sscanf(buf, "HDLC: %x", &pkt_no) == 1)
{
{
if (sscanf(&buf[19 + 3*i], "%x", (unsigned int *) &bit) != 1)
break;
- if ((end_of_page = t4_rx_put_byte(&receive_state, bit)))
- break;
+ block[i] = bit;
}
+ end_of_page = t4_rx_put(&receive_state, block, i);
}
else if (sscanf(buf, "%*d:%*d:%*d.%*d T.38 Rx %d: IFP %x %x", &pkt_no, (unsigned int *) &bit, (unsigned int *) &bit) == 3)
{
{
if (sscanf(&buf[47 + 3*i], "%x", (unsigned int *) &bit) != 1)
break;
- bit = bit_reverse8(bit);
- if ((end_of_page = t4_rx_put_byte(&receive_state, bit)))
- break;
+ block[i] = bit_reverse8(bit);
}
+ end_of_page = t4_rx_put(&receive_state, block, i);
}
else if (strlen(buf) > 2 && sscanf(buf, "T.30 Rx: %x %x", (unsigned int *) &bit, (unsigned int *) &bit) == 2)
{
{
if (sscanf(&buf[22 + 3*i], "%x", (unsigned int *) &bit) != 1)
break;
- bit = bit_reverse8(bit);
- if ((end_of_page = t4_rx_put_byte(&receive_state, bit)))
- break;
+ block[i] = bit_reverse8(bit);
}
+ end_of_page = t4_rx_put(&receive_state, block, i);
}
else if (sscanf(buf, "%04x %02x %02x %02x", (unsigned int *) &bit, (unsigned int *) &bit, (unsigned int *) &bit, (unsigned int *) &bit) == 4)
{
{
if (sscanf(&buf[6 + 3*i], "%x", (unsigned int *) &bit) != 1)
break;
- bit = bit_reverse8(bit);
- if ((end_of_page = t4_rx_put_byte(&receive_state, bit)))
- break;
+ block[i] = bit_reverse8(bit);
}
+ end_of_page = t4_rx_put(&receive_state, block, i);
}
else if (sscanf(buf, "%08x %02x %02x %02x", (unsigned int *) &bit, (unsigned int *) &bit, (unsigned int *) &bit, (unsigned int *) &bit) == 4)
{
{
if (sscanf(&buf[10 + 3*i], "%x", (unsigned int *) &bit) != 1)
break;
- bit = bit_reverse8(bit);
- if ((end_of_page = t4_rx_put_byte(&receive_state, bit)))
- break;
+ block[i] = bit_reverse8(bit);
}
+ end_of_page = t4_rx_put(&receive_state, block, i);
}
else if (sscanf(buf, "Rx bit %*d - %d", &bit) == 1)
{
if (compression_step >= 0)
{
compression = compression_sequence[compression_step++];
- if (compression < 0)
+ if (compression < 0 || (block_size == 0 && compression_step >= 3))
break;
}
t4_tx_set_tx_encoding(&send_state, compression);
break;
if (t4_rx_start_page(&receive_state))
break;
+ detect_page_end(-1000000, compression);
+ page_ended = FALSE;
switch (block_size)
{
case 0:
- do
+ while ((bit = t4_tx_get_bit(&send_state)) >= 0)
{
- bit = t4_tx_get_bit(&send_state);
- if (bit == SIG_STATUS_END_OF_DATA)
+ /* Monitor whether the EOLs are there in the correct amount */
+ if ((res = detect_page_end(bit, page_ended)))
{
- if (++end_marks > 50)
- {
- printf("Receiver missed the end of page mark\n");
- tests_failed++;
- break;
- }
+ printf("Incorrect EOLs - %d\n", res);
+ tests_failed += (res - 1);
+ break;
}
- end_of_page = t4_rx_put_bit(&receive_state, bit & 1);
- }
- while (!end_of_page);
- break;
- case 1:
- do
- {
- bit = t4_tx_get_byte(&send_state);
- if ((bit & 0x100))
+ if (bit >= 0)
{
- if (++end_marks > 50)
+ if (bit_error_rate)
{
- printf("Receiver missed the end of page mark\n");
- tests_failed++;
- break;
+ if ((rand() % bit_error_rate) == 0)
+ bit ^= 1;
}
+ end_of_page = t4_rx_put_bit(&receive_state, bit);
}
- end_of_page = t4_rx_put_byte(&receive_state, bit & 0xFF);
}
- while (!end_of_page);
- if ((t4_tx_get_byte(&send_state) & 0x100) == 0)
+ while (end_of_page != T4_DECODE_OK)
{
- printf("Page ended, but source is not reporting end of data\n");
- tests_failed++;
+ end_of_page = t4_rx_put_bit(&receive_state, 0);
+ if (++end_marks > 50)
+ {
+ printf("Receiver missed the end of page mark\n");
+ tests_failed++;
+ break;
+ }
}
+ /* Now throw junk at the receive context, to ensure stuff occuring
+ after the end of page condition has no bad effect. */
+ for (i = 0; i < 1000; i++)
+ t4_rx_put_bit(&receive_state, (rand() >> 10) & 1);
break;
default:
+ /* Some decoders require a few extra bits before the recognise the end
+ of an image, so be prepared to offer it a few. */
do
{
- bit = t4_tx_get_chunk(&send_state, block, block_size);
- if (bit > 0)
- end_of_page = t4_rx_put_chunk(&receive_state, block, bit);
- if (bit < block_size)
+ len = t4_tx_get(&send_state, block, block_size);
+ if (len > 0)
+ end_of_page = t4_rx_put(&receive_state, block, len);
+ }
+ while (len > 0);
+ while (end_of_page != T4_DECODE_OK)
+ {
+ block[0] = 0;
+ end_of_page = t4_rx_put(&receive_state, block, 1);
+ if (++end_marks > 5)
{
- if (++end_marks > 50)
- {
- printf("Receiver missed the end of page mark\n");
- tests_failed++;
- break;
- }
+ printf("Receiver missed the end of page mark\n");
+ tests_failed++;
+ break;
}
}
- while (!end_of_page);
break;
}
display_page_stats(&receive_state);
if (compression_step >= 0)
{
compression = compression_sequence[compression_step++];
- if (compression < 0)
+ if (compression < 0 || (block_size == 0 && compression_step >= 3))
{
compression_step = 0;
compression = compression_sequence[compression_step++];
switch (block_size)
{
case 0:
- for (;;)
+ while ((bit = t4_tx_get_bit(&send_state)) >= 0)
{
- bit = t4_tx_get_bit(&send_state);
/* Monitor whether the EOLs are there in the correct amount */
if ((res = detect_page_end(bit, page_ended)))
{
+ printf("Incorrect EOLs - %d\n", res);
tests_failed += (res - 1);
break;
}
- if (!page_ended)
+ if (bit_error_rate)
{
- if (bit_error_rate)
- {
- if ((rand() % bit_error_rate) == 0)
- bit ^= 1;
- }
- if (t4_rx_put_bit(&receive_state, bit & 1))
- page_ended = TRUE;
+ if ((rand() % bit_error_rate) == 0)
+ bit ^= 1;
+ }
+ end_of_page = t4_rx_put_bit(&receive_state, bit);
+ }
+ while (end_of_page != T4_DECODE_OK)
+ {
+ end_of_page = t4_rx_put_bit(&receive_state, 0);
+ if (++end_marks > 50)
+ {
+ printf("Receiver missed the end of page mark\n");
+ tests_failed++;
+ break;
}
}
/* Now throw junk at the receive context, to ensure stuff occuring
after the end of page condition has no bad effect. */
for (i = 0; i < 1000; i++)
- {
t4_rx_put_bit(&receive_state, (rand() >> 10) & 1);
- }
break;
- case 1:
+ default:
do
{
- bit = t4_tx_get_byte(&send_state);
- if ((bit & 0x100))
- {
- if (++end_marks > 50)
- {
- printf("Receiver missed the end of page mark\n");
- tests_failed++;
- break;
- }
- }
- end_of_page = t4_rx_put_byte(&receive_state, bit & 0xFF);
- }
- while (!end_of_page);
- if ((t4_tx_get_byte(&send_state) & 0x100) == 0)
- {
- printf("Page ended, but source is not reporting end of data\n");
- tests_failed++;
+ len = t4_tx_get(&send_state, block, block_size);
+ if (len > 0)
+ end_of_page = t4_rx_put(&receive_state, block, len);
}
- break;
- default:
- do
+ while (len > 0);
+ /* Some decoders require a few extra bits before the recognise the end
+ of an image, so be prepared to offer it a few. */
+ while (end_of_page != T4_DECODE_OK)
{
- bit = t4_tx_get_chunk(&send_state, block, block_size);
- if (bit > 0)
- end_of_page = t4_rx_put_chunk(&receive_state, block, bit);
- if (bit < block_size)
+ block[0] = 0;
+ end_of_page = t4_rx_put(&receive_state, block, 1);
+ if (++end_marks > 5)
{
- if (++end_marks > 50)
- {
- printf("Receiver missed the end of page mark\n");
- tests_failed++;
- break;
- }
+ printf("Receiver missed the end of page mark\n");
+ tests_failed++;
+ break;
}
}
- while (!end_of_page);
break;
}
if (dump_as_xxx)
testbuf_len = 0;
max_len = 100;
- while ((len = t85_encode_get_chunk(&t85_enc, &testbuf[testbuf_len], max_len)) > 0)
+ while ((len = t85_encode_get(&t85_enc, &testbuf[testbuf_len], max_len)) > 0)
{
testbuf_len += len;
max_len = 100;
if (comment && comment[0] != 'X')
t85_decode_set_comment_handler(&t85_dec, 1000, comment_handler, NULL);
write_row = 0;
- result = t85_decode_put_chunk(&t85_dec, testbuf, testbuf_len);
+ result = t85_decode_put(&t85_dec, testbuf, testbuf_len);
if (result == T4_DECODE_MORE_DATA)
- result = t85_decode_put_byte(&t85_dec, SIG_STATUS_END_OF_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)
result = T4_DECODE_MORE_DATA;
for (l = 0; l < testbuf_len; l++)
{
- result = t85_decode_put_chunk(&t85_dec, &testbuf[l], 1);
+ result = t85_decode_put(&t85_dec, &testbuf[l], 1);
if (result != T4_DECODE_MORE_DATA)
{
l++;
}
}
if (result == T4_DECODE_MORE_DATA)
- result = t85_decode_put_byte(&t85_dec, SIG_STATUS_END_OF_DATA);
+ result = t85_decode_put(&t85_dec, NULL, 0);
if (l != testbuf_len || result != T4_DECODE_OK)
{
printf("Decode result %d\n", result);
}
}
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
if (periodogram_tests())
exit(2);
printf("Tests passed\n");
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit (2);
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
printf("Test failed\n");
exit(2);
}
- len = t4_tx_get_chunk(&t4_tx_state, image, sizeof(image));
+ len = t4_tx_get(&t4_tx_state, image, sizeof(image));
if (bad_rows)
{
span_log(&s->logging, SPAN_LOG_FLOW, "We need to corrupt the image\n");
exit(2);
}
/*endif*/
- len = t4_tx_get_chunk(&t4_tx_state, image, sizeof(image));
+ len = t4_tx_get(&t4_tx_state, image, sizeof(image));
if (bad_rows)
{
span_log(&s->logging, SPAN_LOG_FLOW, "We need to corrupt the image\n");
exit(2);
}
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
exit(2);
}
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
bit ^= 1;
v42_rx_bit(&caller, bit);
}
- return 0;
+ return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
projects / thirdparty / freeswitch.git / commitdiff
