void nyx_susp_fetch(register nyx_susp_type susp, snd_list_type snd_list)
{
sample_block_type out;
sample_block_values_type out_ptr;
long n;
int err;
falloc_sample_block(out, "nyx_susp_fetch");
out_ptr = out->samples;
snd_list->block = out;
n = max_sample_block_len;
if (susp->susp.current + n > susp->len)
n = susp->len - susp->susp.current;
err = susp->callback(out_ptr, susp->channel,
susp->susp.current, n, susp->userdata);
if (err)
longjmp(nyx_cntxt.c_jmpbuf, 1);
snd_list->block_len = n;
susp->susp.current += n;
if (n == 0) {
/* we didn't read anything, but can't return length zero, so
convert snd_list to pointer to zero block */
snd_list_terminate(snd_list);
}
else if (n < max_sample_block_len) {
/* should free susp */
snd_list_unref(snd_list->u.next);
/* if something is in buffer, terminate by pointing to zero block */
snd_list->u.next = zero_snd_list;
}
}
void read__fetch(snd_susp_type a_susp, snd_list_type snd_list)
{
read_susp_type susp = (read_susp_type) a_susp;
long n; /* jlh Changed type to long, trying to make move_samples_... work */
sample_block_type out;
register sample_block_values_type out_ptr;
/* allow up to 4 bytes/sample: jlh -- does this need to be 8? */
/* FIX -- why 8? for doubles? Maybe it should be sizeof(sample). I think
this buffer was here to allow you to input any format and convert to
float. The assumption was no sample would be longer than 4 bytes and
after conversion, samples would be 4 byte floats.
*/
long in_count; /* jlh Trying to make move_samples_... work */
falloc_sample_block(out, "read__fetch");
out_ptr = out->samples;
snd_list->block = out;
in_count = sf_readf_float(susp->sndfile, out_ptr, max_sample_block_len);
n = in_count;
/* don't read too many */
if (n > (susp->cnt - susp->susp.current)) {
n = susp->cnt - susp->susp.current;
}
snd_list->block_len = (short) n;
susp->susp.current += n;
if (n == 0) {
/* we didn't read anything, but can't return length zero, so
convert snd_list to pointer to zero block */
snd_list_terminate(snd_list);
} else if (n < max_sample_block_len) {
/* this should close file and free susp */
snd_list_unref(snd_list->u.next);
/* if something is in buffer, terminate by pointing to zero block */
snd_list->u.next = zero_snd_list;
}
} /* read__fetch */
LOCAL void nyx_susp_fetch(register nyx_susp_type susp, snd_list_type snd_list)
{
sample_block_type out;
sample_block_values_type out_ptr;
long n;
int err;
falloc_sample_block(out, "nyx_susp_fetch");
out_ptr = out->samples;
snd_list->block = out;
n = max_sample_block_len;
if (susp->susp.current + n > susp->len) {
n = susp->len - susp->susp.current;
}
err = susp->callback(out_ptr, susp->channel,
susp->susp.current, n, 0, susp->userdata);
if (err) {
// The user canceled or some other error occurred, so we use
// xlsignal() to jump back to our error handler.
xlsignal(NULL, NULL);
// never get here.
}
snd_list->block_len = (short)n;
susp->susp.current += n;
if (n == 0) {
/* we didn't read anything, but can't return length zero, so
convert snd_list to pointer to zero block */
snd_list_terminate(snd_list);
}
else if (n < max_sample_block_len) {
/* should free susp */
snd_list_unref(snd_list->u.next);
/* if something is in buffer, terminate by pointing to zero block */
snd_list->u.next = zero_snd_list;
}
}
/*
* The susp is shared by all channels. The susp has backpointers
* to the tail-most snd_list node of each channels, and it is by
* extending the list at these nodes that sounds are read in.
* To avoid a circularity, the reference counts on snd_list nodes
* do not include the backpointers from this susp. When a snd_list
* node refcount goes to zero, the multiread susp's free routine
* is called. This must scan the backpointers to find the node that
* has a zero refcount (the free routine is called before the node
* is deallocated, so this is safe). The backpointer is then set
* to NULL. When all backpointers are NULL, the susp itself is
* deallocated, because it can only be referenced through the
* snd_list nodes to which there are backpointers.
*/
void multiread_fetch(snd_susp_type a_susp, snd_list_type snd_list)
{
read_susp_type susp = (read_susp_type) a_susp;
int i, j;
int frames_read = 0; /* total frames read in this call to fetch */
int n;
sample_block_type out;
// char input_buffer[input_buffer_max];
float input_buffer[input_buffer_samps];
int file_frame_size;
/* when we are called, the caller (SND_get_first) will insert a new
* snd_list node. We need to do this here for all other channels.
*/
for (j = 0; j < susp->sf_info.channels; j++) {
/* nyquist_printf("multiread_fetch: chan[%d] = ", j);
print_snd_list_type(susp->chan[j]);
stdputstr("\n");
*/
if (!susp->chan[j]) { /* ignore non-existent channels */
/* nyquist_printf("multiread_fetch: ignore channel %d\n", j);*/
continue;
}
falloc_sample_block(out, "multiread_fetch");
/* nyquist_printf("multiread: allocated block %x\n", out); */
/* Since susp->chan[i] exists, we want to append a block of samples.
* The block, out, has been allocated. Before we insert the block,
* we must figure out whether to insert a new snd_list_type node for
* the block. Recall that before SND_get_next is called, the last
* snd_list_type in the list will have a null block pointer, and the
* snd_list_type's susp field points to the suspension (in this case,
* susp). When SND_get_next (in sound.c) is called, it appends a new
* snd_list_type and points the previous one to internal_zero_block
* before calling this fetch routine. On the other hand, since
* SND_get_next is only going to be called on one of the channels, the
* other channels will not have had a snd_list_type appended.
* SND_get_next does not tell us directly which channel it wants (it
* doesn't know), but we can test by looking for a non-null block in the
* snd_list_type pointed to by our back-pointers in susp->chan[]. If
* the block is null, the channel was untouched by SND_get_next, and
* we should append a snd_list_type. If it is non-null, then it
* points to internal_zero_block (the block inserted by SND_get_next)
* and a new snd_list_type has already been appended.
*/
/* Before proceeding, it may be that garbage collection ran when we
* allocated out, so check again to see if susp->chan[j] is Null:
*/
if (!susp->chan[j]) {
ffree_sample_block(out, "multiread_fetch");
continue;
}
if (!susp->chan[j]->block) {
snd_list_type snd_list = snd_list_create((snd_susp_type) susp);
/* Now we have a snd_list to append to the channel, but a very
* interesting thing can happen here. snd_list_create, which
* we just called, MAY have invoked the garbage collector, and
* the GC MAY have freed all references to this channel, in which
* case multread_free(susp) will have been called, and susp->chan[j]
* will now be NULL!
*/
if (!susp->chan[j]) {
nyquist_printf("susp %p Channel %d disappeared!\n", susp, j);
ffree_snd_list(snd_list, "multiread_fetch");
} else {
susp->chan[j]->u.next = snd_list;
}
}
/* see the note above: we don't know if susp->chan still exists */
/* Note: We DO know that susp still exists because even if we lost
* some channels in a GC, someone is still calling SND_get_next on
* some channel. I suppose that there might be some very pathological
* code that could free a global reference to a sound that is in the
* midst of being computed, perhaps by doing something bizarre in the
* closure that snd_seq activates at the logical stop time of its first
* sound, but I haven't thought that one through.
*/
if (susp->chan[j]) {
susp->chan[j]->block = out;
/* check some assertions */
if (susp->chan[j]->u.next->u.susp != (snd_susp_type) susp) {
nyquist_printf("didn't find susp at end of list for chan %d\n", j);
}
} else { /* we allocated out, but don't need it anymore due to GC */
ffree_sample_block(out, "multiread_fetch");
}
}
file_frame_size = susp->sf_info.channels;
/* now fill sample blocks with frames from the file
until eof or end of blocks */
while (true) {
/* compute how many frames to read to fill sample blocks */
long frame_count = max_sample_block_len - frames_read;
long actual; /* how many frames actually read */
/* make sure frames will fit in buffer */
if (frame_count * file_frame_size > input_buffer_samps) {
frame_count = input_buffer_samps / file_frame_size;
}
actual = sf_readf_float(susp->sndfile, input_buffer, frame_count);
n = actual;
/* don't read too many */
if (n > (susp->cnt - susp->susp.current)) {
n = susp->cnt - susp->susp.current;
}
/* process one channel at a time, multiple passes through input */
for (j = 0; j < susp->sf_info.channels; j++) {
register sample_block_values_type out_ptr;
/* offset by channel number: */
float *float_ptr = input_buffer + j;
/* ignore nonexistent channels */
if (!susp->chan[j]) continue;
/* find pointer to sample buffer */
out_ptr = susp->chan[j]->block->samples + frames_read;
/* copy samples */
for (i = 0; i < n; i++) {
*out_ptr++ = *float_ptr;
float_ptr += susp->sf_info.channels;
}
susp->chan[j]->block_len = frames_read + n;
}
/* jlh BECAUSE, at this point, all the code cares about is
that n frames have been read and the samples put into their
appropriate snd_node buffers. */
frames_read += n;
susp->susp.current += n;
if (frames_read == 0) {
/* NOTE: this code should probably be removed -- how could we
ever get here? Since file formats know the sample count, we'll
always read frames. When we hit the end-of-file, the else
clause below will run and terminate the sound, so we'll never
try and read samples that are not there. The only exception is
an empty sound file with no samples, in which case we could omit
this if test and execute the else part below.
This code *might* be good for formats that do not encode a
sample count and where reading the end of file is the only way
to detect the end of the data.
Since it seeems to work, I'm going to leave this in place.
One tricky point of the algorithm: when we get here, we set up
susp->chan[j] to point to the right place and then call
snd_list_terminate(). This deletes the snd_list that chan[j]
is pointing to, but not before calling multiread_free(), which
upon detecting that the sound is being freed, sets chan[j] to
NULL. This works sequentially on each channel and than last
time, this susp is freed because no channels are active.
*/
/* we didn't read anything, but can't return length zero, so
* convert snd_list's to pointer to zero block. This loop
* will free the susp via snd_list_unref().
*/
for (j = 0; j < susp->sf_info.channels; j++) {
if (susp->chan[j]) {
snd_list_type the_snd_list = susp->chan[j];
/* this is done so that multiread_free works right: */
susp->chan[j] = susp->chan[j]->u.next;
/* nyquist_printf("end of file, terminating channel %d\n", j); */
/* this fixes up the tail of channel j */
snd_list_terminate(the_snd_list);
}
}
return;
} else if (susp->cnt == susp->susp.current || actual < frame_count) {
/* we've read the requested number of frames or we
* reached end of file
* last iteration will close file and free susp:
*/
for (j = 0; j < susp->sf_info.channels; j++) {
snd_list_type the_snd_list = susp->chan[j];
/* nyquist_printf("reached susp->cnt, terminating chan %d\n", j); */
if (the_snd_list) {
/* assert: */
if (the_snd_list->u.next->u.susp != (snd_susp_type) susp) {
stdputstr("assertion violation");
}
/* this is done so that multiread_free works right: */
susp->chan[j] = the_snd_list->u.next;
snd_list_unref(the_snd_list->u.next);
/* terminate by pointing to zero block */
the_snd_list->u.next = zero_snd_list;
}
}
return;
} else if (frames_read >= max_sample_block_len) {
/* move pointer to next list node */
for (j = 0; j < susp->sf_info.channels; j++) {
if (susp->chan[j]) susp->chan[j] = susp->chan[j]->u.next;
}
return;
}
}
} /* multiread__fetch */
