ALSA: emu10k1: fix wavetable playback position and caching, take 2

Compensate for the cache lag of 64 frames, and actually populate the
cache. Without these, the playback would start with garbage (which
would be (mostly?) masqueraded by the note's attack phase).

Note that we set the starting address only 61 frames ahead, to
compensate for the interpolator's epsilon. Unlike for PCM playback, we
don't even need to manually silence-fill the first frames in the cache,
because we insert some silence in front of each sample anyway.

A challenge are extremely short samples with a loop end below the cache
size, because a) we'd have to wrap the current address to be within the
loop and b) automatic pre-filling of the cache with the right data does
not work in this case.

We could pre-fill the cache manually, but that's slow, requires
additional code for each sample width, and is made even more complex by
the driver's virtual address space having no contiguous mapping for the
CPU.

We could have the engine fill the cache piece-wise (which is really what
happens when playback is running), but that would also be complex, and
we'd need to wait for the engine to handle each piece, so it wouldn't be
that much faster than the manual fill.

For the case of requiring only one loop iteration prior to reaching the
cache size, we could leverage the engine's looping mechanism around
CCR_CACHELOOPFLAG, but this special case doesn't seem worth the
complexity.

So we just unroll the loop as far as necessary to be able to play back
the sample without any fiddling.

Pedantically, this would be incorrect for loop-until-release samples
with a low loop end which are released very quickly, but that would be
relatively harmless, is not a plausible use case in the first place, and
SoundFont sample mode 3 isn't actually implemented anyway (it's
conflated with mode 1, infinite looping).

Signed-off-by: Oswald Buddenhagen <oswald.buddenhagen@gmx.de>
Message-ID: <20240406064830.1029573-16-oswald.buddenhagen@gmx.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

diff --git a/sound/pci/emu10k1/emu10k1_callback.c b/sound/pci/emu10k1/emu10k1_callback.c
index 5f6c47cbb809b1fcc4290cb71ab231d31a68e549..ef26e4d3e2a3bcf1e4f362780b9d142b25233e81 100644 (file)
--- a/sound/pci/emu10k1/emu10k1_callback.c
+++ b/sound/pci/emu10k1/emu10k1_callback.c
@@ -255,7 +255,7 @@ lookup_voices(struct snd_emux *emu, struct snd_emu10k1 *hw,
                /* check if sample is finished playing (non-looping only) */
                if (bp != best + V_OFF && bp != best + V_FREE &&
                    (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
-                       val = snd_emu10k1_ptr_read(hw, CCCA_CURRADDR, vp->ch);
+                       val = snd_emu10k1_ptr_read(hw, CCCA_CURRADDR, vp->ch) - 64 + 3;
                        if (val >= vp->reg.loopstart)
                                bp = best + V_OFF;
                }
@@ -364,7 +364,7 @@ start_voice(struct snd_emux_voice *vp)
 
        map = (hw->silent_page.addr << hw->address_mode) | (hw->address_mode ? MAP_PTI_MASK1 : MAP_PTI_MASK0);
 
-       addr = vp->reg.start;
+       addr = vp->reg.start + 64 - 3;
        temp = vp->reg.parm.filterQ;
        ccca = (temp << 28) | addr;
        if (vp->apitch < 0xe400)
@@ -432,6 +432,9 @@ start_voice(struct snd_emux_voice *vp)
                /* Q & current address (Q 4bit value, MSB) */
                CCCA, ccca,
 
+               /* cache */
+               CCR, REG_VAL_PUT(CCR_CACHEINVALIDSIZE, 64),
+
                /* reset volume */
                VTFT, vtarget | vp->ftarget,
                CVCF, vtarget | CVCF_CURRENTFILTER_MASK,

diff --git a/sound/pci/emu10k1/emu10k1_patch.c b/sound/pci/emu10k1/emu10k1_patch.c
index 481fe03fef4dea611165bd7c5cc7fa0a2889b9d7..2a13fb32c1d20633d455a5098268a7bb4904b944 100644 (file)
--- a/sound/pci/emu10k1/emu10k1_patch.c
+++ b/sound/pci/emu10k1/emu10k1_patch.c
@@ -31,6 +31,7 @@ snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
        int shift;
        int offset;
        int truesize, size, blocksize;
+       int loop_start, loop_end, loop_size, data_end, unroll;
        struct snd_emu10k1 *emu;
 
        emu = rec->hw;
@@ -64,12 +65,35 @@ snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
                }
        }
 
+       loop_start = sp->v.loopstart;
+       loop_end = sp->v.loopend;
+       loop_size = loop_end - loop_start;
+       if (!loop_size)
+               return -EINVAL;
+       data_end = sp->v.end;
+
        /* recalculate offset */
        sp->v.start += BLANK_HEAD_SIZE;
        sp->v.end += BLANK_HEAD_SIZE;
        sp->v.loopstart += BLANK_HEAD_SIZE;
        sp->v.loopend += BLANK_HEAD_SIZE;
 
+       // Automatic pre-filling of the cache does not work in the presence
+       // of loops (*), and we don't want to fill it manually, as that is
+       // fiddly and slow. So we unroll the loop until the loop end is
+       // beyond the cache size.
+       // (*) Strictly speaking, a single iteration is supported (that's
+       // how it works when the playback engine runs), but handling this
+       // special case is not worth it.
+       unroll = 0;
+       while (sp->v.loopend < 64) {
+               truesize += loop_size;
+               sp->v.loopstart += loop_size;
+               sp->v.loopend += loop_size;
+               sp->v.end += loop_size;
+               unroll++;
+       }
+
        /* try to allocate a memory block */
        blocksize = truesize << shift;
        sp->block = snd_emu10k1_synth_alloc(emu, blocksize);
@@ -89,12 +113,26 @@ snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
        offset += size;
 
        /* copy provided samples */
-       size = sp->v.size << shift;
-       if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size, xor)) {
-               snd_emu10k1_synth_free(emu, sp->block);
-               sp->block = NULL;
-               return -EFAULT;
+       if (unroll && loop_end <= data_end) {
+               size = loop_end << shift;
+               if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size, xor))
+                       goto faulty;
+               offset += size;
+
+               data += loop_start << shift;
+               while (--unroll > 0) {
+                       size = loop_size << shift;
+                       if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size, xor))
+                               goto faulty;
+                       offset += size;
+               }
+
+               size = (data_end - loop_start) << shift;
+       } else {
+               size = data_end << shift;
        }
+       if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size, xor))
+               goto faulty;
        offset += size;
 
        /* clear rest of samples (if any) */
@@ -102,6 +140,11 @@ snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
                snd_emu10k1_synth_memset(emu, sp->block, offset, blocksize - offset, fill);
 
        return 0;
+
+faulty:
+       snd_emu10k1_synth_free(emu, sp->block);
+       sp->block = NULL;
+       return -EFAULT;
 }
 
 /*