SPAN_DECLARE(int) super_tone_rx_add_tone(super_tone_rx_descriptor_t *desc)
{
if (desc->tones%5 == 0)
{
desc->tone_list = (super_tone_rx_segment_t **) span_realloc(desc->tone_list, (desc->tones + 5)*sizeof(super_tone_rx_segment_t *));
desc->tone_segs = (int *) span_realloc(desc->tone_segs, (desc->tones + 5)*sizeof(int));
}
desc->tone_list[desc->tones] = NULL;
desc->tone_segs[desc->tones] = 0;
desc->tones++;
return desc->tones - 1;
}
SPAN_DECLARE(int) span_schedule_event(span_sched_state_t *s, int us, span_sched_callback_func_t function, void *user_data)
{
int i;
for (i = 0; i < s->max_to_date; i++)
{
if (s->sched[i].callback == NULL)
break;
/*endif*/
}
/*endfor*/
if (i >= s->allocated)
{
s->allocated += 5;
s->sched = (span_sched_t *) span_realloc(s->sched, sizeof(span_sched_t)*s->allocated);
}
/*endif*/
if (i >= s->max_to_date)
s->max_to_date = i + 1;
/*endif*/
s->sched[i].when = s->ticker + us;
s->sched[i].callback = function;
s->sched[i].user_data = user_data;
return i;
}
static int write_tiff_t85_image(t4_rx_state_t *s)
{
uint8_t *buf;
uint8_t *buf2;
int buf_len;
int len;
int image_len;
t85_encode_state_t t85;
packer_t packer;
/* We need to perform this compression here, as libtiff does not understand it. */
packer.buf = s->tiff.image_buffer;
packer.ptr = 0;
if (t85_encode_init(&t85, s->metadata.image_width, s->metadata.image_length, row_read_handler, &packer) == NULL)
return -1;
//if (t->compression == T4_COMPRESSION_T85_L0)
// t85_encode_set_options(&t85, 256, -1, -1);
buf = NULL;
buf_len = 0;
image_len = 0;
do
{
if (buf_len < image_len + 65536)
{
buf_len += 65536;
if ((buf2 = span_realloc(buf, buf_len)) == NULL)
{
if (buf)
span_free(buf);
return -1;
}
buf = buf2;
}
len = t85_encode_get(&t85, &buf[image_len], buf_len - image_len);
image_len += len;
}
while (len > 0);
if (TIFFWriteRawStrip(s->tiff.tiff_file, 0, buf, image_len) < 0)
{
span_log(&s->logging, SPAN_LOG_WARNING, "%s: Error writing TIFF strip.\n", s->tiff.file);
return -1;
}
t85_encode_release(&t85);
span_free(buf);
return 0;
}
static int tiff_row_write_handler(void *user_data, const uint8_t buf[], size_t len)
{
t4_rx_state_t *s;
uint8_t *t;
s = (t4_rx_state_t *) user_data;
if (buf && len > 0)
{
if (s->tiff.image_size + len >= s->tiff.image_buffer_size)
{
if ((t = span_realloc(s->tiff.image_buffer, s->tiff.image_buffer_size + 100*len)) == NULL)
return -1;
s->tiff.image_buffer_size += 100*len;
s->tiff.image_buffer = t;
}
memcpy(&s->tiff.image_buffer[s->tiff.image_size], buf, len);
s->tiff.image_size += len;
}
return 0;
}
SPAN_DECLARE(int) super_tone_rx_add_element(super_tone_rx_descriptor_t *desc,
int tone,
int f1,
int f2,
int min,
int max)
{
int step;
step = desc->tone_segs[tone];
if (step%5 == 0)
{
desc->tone_list[tone] = (super_tone_rx_segment_t *) span_realloc(desc->tone_list[tone], (step + 5)*sizeof(super_tone_rx_segment_t));
}
desc->tone_list[tone][step].f1 = add_super_tone_freq(desc, f1);
desc->tone_list[tone][step].f2 = add_super_tone_freq(desc, f2);
desc->tone_list[tone][step].min_duration = min*8;
desc->tone_list[tone][step].max_duration = (max == 0) ? 0x7FFFFFFF : max*8;
desc->tone_segs[tone]++;
return step;
}
static int write_tiff_t43_image(t4_rx_state_t *s)
{
uint8_t *buf;
uint8_t *buf2;
int buf_len;
int len;
int image_len;
t43_encode_state_t t43;
packer_t packer;
packer.buf = s->tiff.image_buffer;
packer.ptr = 0;
if (t43_encode_init(&t43, s->metadata.image_width, s->metadata.image_length, row_read_handler, &packer) == NULL)
return -1;
buf = NULL;
buf_len = 0;
image_len = 0;
do
{
if (buf_len < image_len + 65536)
{
buf_len += 65536;
if ((buf2 = span_realloc(buf, buf_len)) == NULL)
{
if (buf)
span_free(buf);
return -1;
}
buf = buf2;
}
len = t43_encode_get(&t43, &buf[image_len], buf_len - image_len);
image_len += len;
}
while (len > 0);
if (TIFFWriteRawStrip(s->tiff.tiff_file, 0, buf, image_len) < 0)
span_log(&s->logging, SPAN_LOG_WARNING, "%s: Error writing TIFF strip.\n", s->tiff.file);
t43_encode_release(&t43);
span_free(buf);
return 0;
}
int main(int argc, char *argv[])
{
void *a;
void *b;
void *c;
if (span_mem_allocators(memalign,
malloc,
realloc,
free))
{
printf("Failed\n");
exit(2);
}
a = span_aligned_alloc(8, 42);
b = span_alloc(42);
c = span_realloc(NULL, 42);
printf("%p %p %p\n", a, b, c);
span_free(a);
span_free(b);
span_free(c);
}
static int pre_encoded_put(no_decoder_state_t *s, const uint8_t data[], size_t len)
{
uint8_t *buf;
if (s->buf_len < s->buf_ptr + len)
{
s->buf_len += 65536;
if ((buf = span_realloc(s->buf, s->buf_len)) == NULL)
{
if (s->buf)
{
span_free(s->buf);
s->buf = NULL;
s->buf_len = 0;
}
return -1;
}
s->buf = buf;
}
memcpy(&s->buf[s->buf_ptr], data, len);
s->buf_ptr += len;
return T4_DECODE_MORE_DATA;
}
static int add_super_tone_freq(super_tone_rx_descriptor_t *desc, int freq)
{
int i;
if (freq == 0)
return -1;
/* Look for an existing frequency */
for (i = 0; i < desc->used_frequencies; i++)
{
if (desc->pitches[i][0] == freq)
return desc->pitches[i][1];
}
/* Look for an existing tone which is very close. We may need to merge
the detectors. */
for (i = 0; i < desc->used_frequencies; i++)
{
if ((desc->pitches[i][0] - 10) <= freq && freq <= (desc->pitches[i][0] + 10))
{
/* Merge these two */
desc->pitches[desc->used_frequencies][0] = freq;
desc->pitches[desc->used_frequencies][1] = i;
make_goertzel_descriptor(&desc->desc[desc->pitches[i][1]], (float) (freq + desc->pitches[i][0])/2, SUPER_TONE_BINS);
desc->used_frequencies++;
return desc->pitches[i][1];
}
}
desc->pitches[i][0] = freq;
desc->pitches[i][1] = desc->monitored_frequencies;
if (desc->monitored_frequencies%5 == 0)
{
desc->desc = (goertzel_descriptor_t *) span_realloc(desc->desc, (desc->monitored_frequencies + 5)*sizeof(goertzel_descriptor_t));
}
make_goertzel_descriptor(&desc->desc[desc->monitored_frequencies++], (float) freq, SUPER_TONE_BINS);
desc->used_frequencies++;
return desc->pitches[i][1];
}
