More than 4 sound channels - how it works?

[chaos]

Any kind of interpolation is faking the data you don't have - that is, you are guessing what might the data between the sampled points you have be. Of course, you can make good guesses, considering typical band-limited signal, so no big changes possible between samples, etc.

There are many ways how to do 'interpolation'. One is just repeating the existing samples some n-times (this is definitely the worst way). A little better is linear interpolation between samples (this also allows fractional upsampling). The best is of course a properly-designed low-pass filter. (In theory, all these methods are actually a sort of a filter, either a Zero-Order Hold, a weighted moving average, or a (windowed) FIR/IIR).

But, just zero stuffing (A0B0...) is *not* enough for proper upsampling without the accompanying filter.

[Mrs Beanbag]

Originally Posted by pandy71

ABCDEF > A0B0C0D0E0F0 > (lowpass) > AaBbCcDdEeFf but AABBCCDDEEFF is also valid (albeit spectrum after upsampling will be slightly different http://www.dsprelated.com/showarticle/761.php).

But amplitude will be reduced by the zeroes. Can also do a low pass filter on the second example, that will not reduce the amplitude but should otherwise be the same.

Problem with sinc is that it is suboptimal from human perception perspective as it introduce ringing.

True, you can actually see it sometimes on images rescaled with such a technique, it is worse with a large window, and much better on smooth functions, not so great on square waves but fine for interpolating sine waves.

I have used a convolution kernel [0, -27, 0, 155, 256, 155, 0, -27, 0] to good effect for upsampling by a factor of 2.

[pandy71]

Originally Posted by Mrs Beanbag

But amplitude will be reduced by the zeroes. Can also do a low pass filter on the second example, that will not reduce the amplitude but should otherwise be the same.

Yes but this is easily corrected by applying gain to product (i.e. multiplying by constant and usually power of 2).

In frequency domain there is a subtle difference - spectral replicas are distributed differently.

Originally Posted by Mrs Beanbag

True, you can actually see it sometimes on images rescaled with such a technique, it is worse with a large window, and much better on smooth functions, not so great on square waves but fine for interpolating sine waves.

I have used a convolution kernel [0, -27, 0, 155, 256, 155, 0, -27, 0] to good effect for upsampling by a factor of 2.

256? so on 9 bits (+ sign)?

Originally Posted by chaos

Any kind of interpolation is faking the data you don't have - that is, you are guessing what might the data between the sampled points you have be. Of course, you can make good guesses, considering typical band-limited signal, so no big changes possible between samples, etc.

This is not about real or fake data - as you pointed - this is bandlimited world.

Originally Posted by chaos

There are many ways how to do 'interpolation'. One is just repeating the existing samples some n-times (this is definitely the worst way). A little better is linear interpolation between samples (this also allows fractional upsampling). The best is of course a properly-designed low-pass filter. (In theory, all these methods are actually a sort of a filter, either a Zero-Order Hold, a weighted moving average, or a (windowed) FIR/IIR).

But, just zero stuffing (A0B0...) is *not* enough for proper upsampling without the accompanying filter.

Fully agree but my point was that you can prepare data already by applying proper low pass filter and decimation is all you need.

[Mrs Beanbag]

Originally Posted by pandy71

256? so on 9 bits (+ sign)?

I am multiplying sample values by these numbers and right-shifting 8 places, the multiples of 0 and 256 optimise out though, and 155 = 128+27.

[buggs]

My apologies for hijacking a concluded thread but I thought I might have something worth sharing in terms of nearest-neighbor resampling. Of course, with fast hardware one might think about filtered resampling. On the other hand, to reproduce the "original" Amiga sound on Paula hardware (for good or bad, which depends on the individual point of view), nearest neighbor is the way to go.

I recently got hooked up to 68k Asm again, started tinkering around with my old code and shortly thereafter stumbled upon this thread. Out of my own (historical) knowledge, I first saw the "addx/add" combo for the position update in Jarno Paananen's PS3M. That one is already quite runtime efficient (though not as accurate as Bresenham), even on 68000. Out of my personal experience, I wouldn't recommend step tables. One might save registers but that comes at the cost of the mov from memory which is more costly than two simple adds.

That being said, my tinkering led to a routine that doesn't need the second add of the well known "addx/add" combo.

My first-stage 8 Bit mixing main loop looks like this (with 68000 cycle annotations):
A0=input array
D0=fractional position (upper 16 bits), byte position (lower 16 bits), D4=fractional increment (upper 16 bits), byte increments (lower 16 bits), D2=pointer to current volume table (upper 24 bits), where the lower 8 Bits come from each sample and are addressed as "unsigned"
A2=output
A5=remaining bytes in the output-16
D6=remaining bytes in the input

.mix_fastloop 
                rept    8
                 move.b (a0,d0.w),d2                               ;14
                 addx.l d4,d0                                           ;8
                 move.l d2,a3                                           ;4
                 move.b (a0,d0.w),d2                                    ;14
                 move.b (a3),d3                                         ;8
                 addx.l d4,d0                                           ;8
                 move.l d2,a3                                           ;4
                 swap   d3                                              ;4
                 move.b (a3),d3                                         ;8
                 move.l d3,(a2)+                                        ;12
                                                                        ;=84 cycles for two bytes (42 cyc per byte w/o check)
                endr
                lea     -16(a5),a5      ; no condition codes changed    ;8
                move.l  a5,d1                                           ;
                swap    d1      ; if( remaining_output_bytes < 16 ) 0xffff else 0x0000
                or.w    d6,d1   ; if( remaining_output_bytes < 16 ) -1 else
                                ;                                   remaining_input_bytes
                lea     (A1,D0.l),A3    ; input: processed bytes
                cmp.w   A3,d1   ; if( D1 < A3 ) -> stop
                bgt.w   .mix_fastloop                              ;48 cycles
                                            ; total 8*68+48 / 16 = 37 cycles/byte

The trick is: I crafted the code to avoid operations that change the "x" bit. Hence, I can leave out the second "add" in the usual "addx/add" combo. The prerequisite is the combination "sub.w d4,d0" "add.l d4,d0" before entering the main loop, thus having the proper state of the "x" bit for the first "addx".

This part of my mixing loop shown above is the "copy" loop, called for the first mixed channel. It doesn't require clearing of the output array (A2). For additional channels to be mixed with said first channel, just two more instructions are added in my routine instead of move.l d3,(a2)+:

move.l (a2),a6
adda.l  d3,a6
move.l a6,(a2)+

This way, one can mix an arbitrary number of channels into an intermediate 16 bit representation. Please note that I mix to an "unsigned" output format in my intermediate representation which changes the "zero point" with each added channel. I keep track of the number of mixed channels and perform the compensation in the output to ChipRAM stage.

This main loop is quite a bit faster than the old code I used (derived from PS3M) on 68000 and also performs nicely on 68060.

Downsides: The volume table shown in this sniplet is 8 Bit deep. For low volume channels, this method introduces quantization noise in the mixing stage that would be an annoyance when 14 or 16 Bit output of the mixed channels is desired.

Maybe that stuff is of some use to someone. At least, I had fun coding on 68000 again.

[Toni Galvez]

Originally Posted by Mrs Beanbag

I am multiplying sample values by these numbers and right-shifting 8 places, the multiples of 0 and 256 optimise out though, and 155 = 128+27.

Hello,

I think, it will be hard to make a fast mixing routine for games, but at least, we can use OCTAMED/OKTALYZER 8 channels for MENUS and other places where is not in-game.

I think, you probably know this amazing fixed frequency sound routine that is quite fast: [ Show youtube player ]

I had the idea to use this fixed frequency routine to make music, how?
Well, having the sample for each note, you may think is crazy, but, it could be 32byte samples or some sort of small sample, it would not take much memory (and this mixer mixes the samples stored on fast ram, so, not taking chip ram).

So, you need to adapt a music tracker to get to use this 3 real channels and other 4 mixed channels, so, you will be able to use it into a game. This mixing routine take very short amount of raster time.

We are using it on out Amiga game, but in this configuration:

Real channels:
- Channel 1. Bass+Drums
- Channel 2. Chords.
- Channel 3. Main lead.
- Channel 4. Main lead echo.

Mixed channels interrupt channel 4 to fire the sound effects.

So, we can have 4 sound effects mixed on channel 4.

That's 7 channels.

[copse]

Originally Posted by Toni Galvez

Hello,

I think, it will be hard to make a fast mixing routine for games, but at least, we can use OCTAMED/OKTALYZER 8 channels for MENUS and other places where is not in-game.

I think, you probably know this amazing fixed frequency sound routine that is quite fast: [ Show youtube player ]

I had the idea to use this fixed frequency routine to make music, how?
Well, having the sample for each note, you may think is crazy, but, it could be 32byte samples or some sort of small sample, it would not take much memory (and this mixer mixes the samples stored on fast ram, so, not taking chip ram).

So, you need to adapt a music tracker to get to use this 3 real channels and other 4 mixed channels, so, you will be able to use it into a game. This mixing routine take very short amount of raster time.

We are using it on out Amiga game, but in this configuration:

Real channels:
- Channel 1. Bass+Drums
- Channel 2. Chords.
- Channel 3. Main lead.
- Channel 4. Main lead echo.

Mixed channels interrupt channel 4 to fire the sound effects.

So, we can have 4 sound effects mixed on channel 4.

That's 7 channels.

Are you working on this? Any estimate on when we can see it?

[Toni Galvez]

Originally Posted by copse

Are you working on this? Any estimate on when we can see it?

Yes, I am working with my friends @Nandiusc and @DJMetune on an OCS game, all I can say, the game is using this fixed frequency sound mixer and the performance on a 7mhz OCS Amiga is really good.

You will know about the game when the game is ready to show up.

[no9]

Originally Posted by Toni Galvez

So, you need to adapt a music tracker to get to use this 3 real channels and other 4 mixed channels, so, you will be able to use it into a game.

Actually no need to adapt a tracker. You just need to write the music having the limitations in mind, in any tracker. Any XM compatible tracker will be well suited for this purpose.

[saimon69]

Originally Posted by no9

Actually no need to adapt a tracker. You just need to write the music having the limitations in mind, in any tracker. Any XM compatible tracker will be well suited for this purpose.

Just need to remember not to use the XM volume control tags and the 8xx commands

[no9]

There is more to this, but I don't see the issue with a volume.