On Fri, Jun 15, 2012 at 3:34 AM, Matt Barber brbrofsvl@gmail.com wrote:
If it used the same interpolator as tabread4~, you could in principle do approach B -- you'd need a struct that held on the the last samples of the previous block, and offset it by a sample.
So, let's say you have a blocksize of 4, the first block of incoming signal is [-0.3, 0.4, 0.6, -0.8], and the index block is [0.2, 1.4, 3.0, 5.8]. The way this could work would be to imagine a previous signal block of [0, 0, 0, 0]. Put the "last 0" of that block at index 0.2 and the -0.3 at index 1.4. This crosses sample 1, so you find out where that sample sits as a fraction of the difference between those two indices (in this case 0.66666), use [0, 0, -0.3, 0.4] as the four points for interpolation between 0 and -0.3, writing sample one as though you were reading from a table with those four points at 0.66666 between the 0 and the -0.3 (so far so good?).
Then you put 0.4 at index 3.0. Now your interpolation points are [0, -0.3, 0.4, 0.6] to interpolate between -0.3 and 0.4. Index 2 occurs 0.375 between these samples so you run the interpolation function for that fractional index and write sample at index 2, and then you go ahead and write the 0.4 to index 3.
Finally, you put 0.6 at index 5.8. You're interpolating between 0.4 and 0.6, and the points are [-0.3, 0.4, 0.6, -0.8]. Index 4 occurs 0.357143 between the two samples and index 5 occurs 0.714286 between, so you run the interpolator twice for those fractional indices, write those samples.
Then you save 0.4, 0.6 and -0.8 (the last the samples of the current block of incoming signal), and 5.8 (the last written index) for the next block. When you have the next block you'll have enough info to interpolate between 0.6 and -0.8 from the last block and between -0.8 and the first sample of this one (these steps were actually implied the first time around), and then you're good to go for the next four samples.
If I haven't forgotten a step, the same principle ought to work for any blocksize 4 or larger, and you'd need specialized policies for blocksizes of 1 or 2.
Sorry for the length, but sometimes detailed examples can be helpful to get things straight.
After reading through it several times, I think I understand your example, and how this could be expressed and implemented generally:
- an outer perform loop iterates over N input signal samples / float
write indexes, where N = blocksize
- an inner loop iterates over all integer write indexes inbetween
float write indexes stored at [n] and [n+1] (there could be none, one, or more than one integer index in that interval)
- for each integer write index, calculate the corresponding read index
as a fraction of the interval between the two enclosing float indexes
- based on that fraction, do the four point interpolation to calculate
the sample that must be written
Not sure if I got it right, and if this would give correct results for all cases.
Also, there would be no natural bound on the amount of samples written. Imagine a user feeding large random numbers to the write index inlet... There could be a user-settable bound on resampling factor. For moderate resampling purposes it could be an efficient model. Seems we're getting close to an implementation of [tabwrite4~].
Katja