On Fri, Jun 15, 2012 at 3:34 AM, Matt Barber <brbrof...@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 _______________________________________________ Pd-list@iem.at mailing list UNSUBSCRIBE and account-management -> http://lists.puredata.info/listinfo/pd-list