/*
* The pitch (F0) is determined by finding two periods whose
* inner product accounts for almost all of the energy. Let X and Y
* be adjacent vectors of length N in the sample stream. Then,
* if 2X*Y > threshold * (X*X + Y*Y)
* then the period is given by N
* In the algorithm, we compute different sizes until we find a
* peak above threshold. Then, we use cubic interpolation to get
* a precise value. If no peak above threshold is found, we return
* the first peak. The second channel returns the value 2X*Y/(X*X+Y*Y)
* which is refered to as the "harmonicity" -- the amount of energy
* accounted for by periodicity.
*
* Low sample rates are advised because of the high cost of computing
* inner products (fast autocorrelation is not used).
*
* The result is a 2-channel signal running at the requested rate.
* The first channel is the estimated pitch, and the second channel
* is the harmonicity.
*
* This code is adopted from multiread, currently the only other
* multichannel suspension in Nyquist. Comments from multiread include:
* The susp is shared by all channels. The susp has backpointers
* to the tail-most snd_list node of each channel, 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 yin 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 yin_fetch(yin_susp_type susp, snd_list_type snd_list)
{
int cnt = 0; /* how many samples computed */
int togo = 0;
int n;
sample_block_type f0;
sample_block_values_type f0_ptr = NULL;
sample_block_type harmonicity;
sample_block_values_type harmonicity_ptr = NULL;
register sample_block_values_type s_ptr_reg;
register sample_type *fillptr_reg;
register sample_type *endptr_reg = susp->endptr;
if (susp->chan[0]) {
falloc_sample_block(f0, "yin_fetch");
f0_ptr = f0->samples;
/* 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[0]) {
ffree_sample_block(f0, "yin_fetch");
f0 = NULL; /* make sure we don't free it again */
f0_ptr = NULL; /* make sure we don't output f0 samples */
} else if (!susp->chan[0]->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 yin_free(susp) will have been called, and susp->chan[0]
* will now be NULL!
*/
if (!susp->chan[0]) {
ffree_snd_list(snd_list, "yin_fetch");
} else {
susp->chan[0]->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[0]) {
susp->chan[0]->block = f0;
/* check some assertions */
if (susp->chan[0]->u.next->u.susp != (snd_susp_type) susp) {
nyquist_printf("didn't find susp at end of list for chan 0\n");
}
} else if (f0) { /* we allocated f0, but don't need it anymore due to GC */
ffree_sample_block(f0, "yin_fetch");
f0_ptr = NULL;
}
}
/* Now, repeat for channel 1 (comments omitted) */
if (susp->chan[1]) {
falloc_sample_block(harmonicity, "yin_fetch");
harmonicity_ptr = harmonicity->samples;
if (!susp->chan[1]) {
ffree_sample_block(harmonicity, "yin_fetch");
harmonicity = NULL; /* make sure we don't free it again */
harmonicity_ptr = NULL;
} else if (!susp->chan[1]->block) {
snd_list_type snd_list = snd_list_create((snd_susp_type) susp);
if (!susp->chan[1]) {
ffree_snd_list(snd_list, "yin_fetch");
} else {
susp->chan[1]->u.next = snd_list;
}
}
if (susp->chan[1]) {
susp->chan[1]->block = harmonicity;
if (susp->chan[1]->u.next->u.susp != (snd_susp_type) susp) {
nyquist_printf("didn't find susp at end of list for chan 1\n");
}
} else if (harmonicity) { /* we allocated harmonicity, but don't need it anymore due to GC */
ffree_sample_block(harmonicity, "yin_fetch");
harmonicity_ptr = NULL;
}
}
while (cnt < max_sample_block_len) { /* outer loop */
/* first, compute how many samples to generate in inner loop: */
/* don't overflow the output sample block */
togo = (max_sample_block_len - cnt) * susp->stepsize;
/* don't run past the s input sample block */
susp_check_term_log_samples(s, s_ptr, s_cnt);
togo = min(togo, susp->s_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo/susp->stepsize) {
togo = (susp->terminate_cnt - (susp->susp.current + cnt)) * susp->stepsize;
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop = 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the output block)
*/
if (to_stop < togo/susp->stepsize) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we can set
* the logical stop flag on this output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new block a the LST */
togo = to_stop * susp->stepsize;
}
}
n = togo;
s_ptr_reg = susp->s_ptr;
fillptr_reg = susp->fillptr;
if (n) do { /* the inner sample computation loop */
*fillptr_reg++ = *s_ptr_reg++;
if (fillptr_reg >= endptr_reg) {
float f0;
float harmonicity;
yin_compute(susp, &f0, &harmonicity);
if (f0_ptr) *f0_ptr++ = f0;
if (harmonicity_ptr) *harmonicity_ptr++ = harmonicity;
cnt++;
fillptr_reg -= susp->stepsize;
}
} while (--n); /* inner loop */
/* using s_ptr_reg is a bad idea on RS/6000: */
susp->s_ptr += togo;
susp->fillptr = fillptr_reg;
susp_took(s_cnt, togo);
} /* outer loop */
/* test for termination */
if (togo == 0 && cnt == 0) {
snd_list_terminate(snd_list);
} else {
snd_list->block_len = cnt;
susp->susp.current += cnt;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* yin_fetch */
/*
* 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 */
/*
* If a channel terminates early, we must be careful: continuing to
* fetch will return pointers to the zero_block, but this will
* indicate termination to whoever is fetching from multiseq. We
* must check the pointers and substitute internal_zero_block to
* avoid premature termination.
*/
void multiseq_advance(multiseq_type ms, time_type target)
{
int i;
time_type new_horizon;
time_type new_low_water;
D nyquist_printf("multiseq_advance: %x->low_water %g, target %g\n",
ms, ms->low_water, target);
while (ms->low_water < target - 0.000001) {
new_horizon = 0.0;
D nyquist_printf("multiseq_advance loop: target %g low_water %g horizon %g\n",
target, ms->low_water, ms->horizon);
/* new_low_water will be a minimum over every
* channel, so start with a big number */
new_low_water = target;
for (i = 0; i < ms->nchans; i++) {
snd_list_type snd_list = ms->chans[i];
add_susp_type susp = (add_susp_type) snd_list->u.susp;
time_type my_hor;
time_type my_low_water;
D nyquist_printf("chans[%d]: ", i);
/* fetch up to horizon */
/* see if susp has an unprocessed block (test on susp->s1_ptr
* is probably not necessary, in fact, it isn't initialized
* until the first block is fetched, but s1_cnt is
*/
if (susp->s1_cnt && susp->s1_ptr &&
susp->s1_ptr == susp->s1_bptr->samples) {
/* do nothing, unprocessed block already there as a
* result of the initiating fetch
*/
} else if (susp->s1_cnt != 0) {
stdputstr("multiseq_advance: s1_cnt != 0\n");
EXIT(1); /* this should never happen */
} else { /* otherwise fetch it */
D stdputstr("prefetching samples ");
susp_get_block_samples(s1, s1_bptr, s1_ptr, s1_cnt);
if (susp->s1_ptr == zero_block->samples) {
susp->terminate_bits = 1;
susp->s1_bptr = internal_zero_block;
susp->s1_ptr = internal_zero_block->samples;
}
/* see if we've reached a logical stop
* (I can't believe this code block is in 3 places -
* there must be a better way... RBD)
*/
if (!susp->logical_stop_bits) {
if (susp->s1->logical_stop_cnt != UNKNOWN) {
if (susp->susp.current + susp->s1_cnt >=
susp->s1->logical_stop_cnt) {
susp->logical_stop_bits = 1;
susp->susp.log_stop_cnt =
susp->s1->logical_stop_cnt;
ms->not_logically_stopped_cnt--;
D nyquist_printf(
"snd_make_multiseq: Logical stop reached, not_logically_stopped_cnt %d\n",
ms->not_logically_stopped_cnt);
}
}
}
}
D nyquist_printf(" current %d cnt %d ",
susp->susp.current, susp->s1_cnt);
/* while the susp has prefetched a block that ends at or
* before horizon, put the block on the snd_list and
* prefetch another block
*/
while (susp_time(susp, ms) < ms->horizon + 0.000001) {
snd_list->block = susp->s1_bptr;
snd_list->block_len = (short) susp->s1_cnt;
susp->susp.current += susp->s1_cnt;
(susp->s1_bptr->refcnt)++;
susp->s1_cnt = 0;
#ifdef MULTISEQ_GC_DEBUG
nyquist_printf(
"multiseq: output block %x%s on snd_list %x to chan %d\n",
susp->s1_bptr,
(susp->s1_bptr == internal_zero_block ?
" (INTERNAL ZERO BLOCK)" : ""),
snd_list, i);
#endif
snd_list->u.next = snd_list_create(&(susp->susp));
#ifdef MULTISEQ_GC_DEBUG
snd_list_debug(snd_list, "multiseq_advance");
#endif
ms->chans[i] = snd_list = snd_list->u.next;
susp_get_block_samples(s1, s1_bptr, s1_ptr, s1_cnt);
if (susp->s1_ptr == zero_block->samples) {
susp->terminate_bits = 1;
susp->s1_bptr = internal_zero_block;
susp->s1_ptr = internal_zero_block->samples;
}
if (susp->s1_ptr != susp->s1_bptr->samples) {
stdputstr("bug in multiseq_advance\n");
EXIT(1);
}
/* see if we've reached a logical stop
* (I can't believe this code block is in 3 places -
* there must be a better way... RBD)
*/
if (!susp->logical_stop_bits) {
if (susp->s1->logical_stop_cnt != UNKNOWN) {
if (susp->susp.current + susp->s1_cnt >=
susp->s1->logical_stop_cnt) {
susp->logical_stop_bits = 1;
susp->susp.log_stop_cnt =
susp->s1->logical_stop_cnt;
ms->not_logically_stopped_cnt--;
D nyquist_printf(
"snd_make_multiseq: Logical stop reached, not_logically_stopped_cnt %d\n",
ms->not_logically_stopped_cnt);
}
}
}
D nyquist_printf("\n\toutput block, current %d cnt %d ",
susp->susp.current, susp->s1_cnt);
}
if (!susp->logical_stop_bits)
my_hor = susp_time(susp, ms);
else my_hor = susp_log_stop_time(susp, ms);
if (new_horizon < my_hor) {
D nyquist_printf("new_horizon %g ", my_hor);
new_horizon = my_hor;
}
if (ms->not_logically_stopped_cnt == 0) {
ms->horizon = new_horizon; /* pass t0 to multiseq_convert */
D stdputstr("Calling multiseq_convert\n");
multiseq_convert(ms);
return;
}
my_low_water = susp_low_water(susp, ms);
if (my_low_water < new_low_water) {
new_low_water = my_low_water;
}
D stdputstr("\n");
}
ms->low_water = new_low_water;
if (new_horizon <= ms->horizon) {
stdputstr("no progress in multiseq_advance\n");
EXIT(1);
} else {
ms->horizon = new_horizon;
}
}
}
