I'm trying to half-fill a table. I'm using tabwrite~ within a patch that has block~ set to half the table-length. The results are good with a block size above 64, but below that, it fully fills the table. I know pd's default block size is 64. Is this related? Or is there something I'm missing?

I notice if i down-sample the block, I can get the results I want. downsampling to .5 gets desired results at 64, and .25 gets me 32. I feel like there's something basic about dsp that I'm not getting. I don't understand why I need to downsample?

I've attached a simple example patch, but it doesn't do the downsampling (just add .5 or .25 at end of [$1 1] message in pd zero_pad

paddedTest.pd

@mbbaker I don't know why, but I know that you are not the first to bang your head against this problem (I think it probably does have to do with the [block 64] communication between the patch and the sub-patch).
Have a look at these threads, which looked at solving the problem in a different way.......
Hann window.... https://forum.pdpatchrepo.info/topic/3649/how-to-zero-pad-an-fft-with-block
Multiply by zero..... https://forum.pdpatchrepo.info/topic/12342/zero-padding-fft-to-increase-frequency-resolution/3
David.

@mbbaker I never use downsampling so I can't explain that behavior off the top of my head, but I know that the fastest [bang~] will output is once every 64 samples, which you can see documented in {bang~] help. That explains the behavior when there's no downsampling.
I modified your patch to display a ramp that goes from 0 to 1 every 64 samples to see what's going on: tabwrite~ half table.pd Now I can see that 128 1 1 is equivalent to 64 1 0.5, but I'm struggling to understand why.

If you're more interested in doing rather than knowing, try substituting [tabsend~] for [tabwrite~]. That consistently writes the first half of the table but I'm not sure if it is excerpting the signal in the way you expect. Unlike @Maelstorm's windowing solution that @whale-av linked to, it doesn't overwrite the second half of the table. [tabsend~] outputs continuously so if you need to initiate it with a bang then you should look into [switch~]

it's simply because [bang~] doesn't go lower than 64. Unfortunately I don't think the 'stop' message to [tabrwrite~] has sub-block accuracy.
actually, [bang~] can go lower than 64, it just can't go lower than 64 per the root patch samplerate.

when you use downsampling you're only writing every other or every 4th sample, that's why it appears to work. for instance at .5 downsampling with blocksize 32 it gets [bang~]s at the same rate as the parent patch, but only writes half of the table because it's running half as fast.

when at downsampling 0.25 and parent blocksize of 64 you get bangs at 1/2 the frequency of the parent, because [block~] outputs at half the speed (since the blocksize is 1/2 of the parent as well, so it's 2*1/4 = 1/2). so the subpatch gets triggered every 128 samples of the parent, and writes all of its samples until it gets retriggered (but only writes 32 samples because it's downsampled by 4x)

@seb-harmonik.ar Lovely explanation, thanks, but can you say more about

actually, [bang~] can go lower than 64, it just can't go lower than 64 per the root patch samplerate.

How can I make [bang~] output (and execute control rate logic) after each 32 (for instance) sample audio block is processed?

(Apologies to @mbbaker for hijacking topic)

@jameslo well as soon as you change the [set( message to [block~] to have a 0.5 downsampling value then that's the case. (as you can see if you hook up a timer.. the downsampled 32-block patch with [bang~] will put out bangs at the same rate as the parent patch that has a 64 sample block.)
Actually in this situation another limitation is also due to [tabwrite~] not being able to do anything at fewer than 64-block size either afaict

@seb-harmonik.ar In other words "technically 32 but really 64" since the effective sample rate inside the blocked patch is half. Sort of like agreeing to repay double your loan but waiting until inflation has eroded the dollar to one half its value.