Quantcast

Page 18 of 18 FirstFirst ... 81415161718
Results 256 to 257 of 257

Thread: Soundchip Tribute

  1. #256
    Smith's Minister of War Hero of Algol Kamahl's Avatar
    Join Date
    Jan 2011
    Location
    Portugal
    Age
    27
    Posts
    7,887
    Rep Power
    119

    Default

    True, if the GBA is in, the 32X should also be. I'm not too familiar with PWM though, I will read up on it a bit first.
    This thread needs more... ENGINEERS

  2. #257
    Hard Road! ESWAT Veteran Barone's Avatar
    Join Date
    Aug 2010
    Location
    Brazil
    Posts
    6,770
    Rep Power
    140

    Default

    This should be a good start:

    Quote Originally Posted by kool kitty89 View Post
    In terms of sound you had the Genesis hardware plus PWM... PWM could have been really useful for some things with the DMA feature it has, but it wasn't documented for developers to use for some unknown reason. Though Chilly Willy got it working quite well: http://gendev.spritesmind.net/forum/...c80b40dce24b69

    With DMA you have WAY less CPU overhead to deal with and could easily have something on par or better than the NDS's sound system. (DS is 8 channels up to 32 kHz with stereo PWM output at 9-bit resolution, 32x resolution/max sample rate are variable, but at 9-bit resolution you could have 44.1 kHz) The PWM is stereo and variable resolution/sample rate as mentioned, see: http://sega-16.com/forum/showthread....090#post145090
    It's only 1 channel with stereo output (also a mono mode), the rest is up to software mixing, but with DMA and the resource in the 32x you can mange a lot. (chilly willy's sample synthesizer being worked on is 32 channels using DMA and mixing with the slave SH2)
    PWM also has artifacting, especially at low sample rates (squealing sound), resistor DACs as used in the SNES, Sega CD, etc (most things -and onboard the Genesis), you didn't have that problem.

    However, without DMA (as all developers were stuck), you could only do software/interrupt driven PWM playback, so tons of CPU resource, and you'd be lucky to manage 8 22 kHz channels with the slave SH2. (more likely 4, unless you dropped to lower sample rate too -and PWM sounds particularly bas as sample rate drops) For that reason, it was often worse off than the SNES... plus if you had to use the slave SH2 for other things, you were even worse off. Actually, due to the PWM as it was, it wasn't really better than what the Genesis already had with the bare 8-bit resistor DAC (no PWM artifacting ) except it had stereo and it didn't disable the 6th FM channel on the YM2612. (otherwise, without DMA, it was only better because of the added resource)

    Quote Originally Posted by kool kitty89 View Post
    Several problems, without DMA (which IRL 32x games never used) it was VERY CPU intensive to use PWM, it ate up the slave SH2's power to do 4-8 22 kHz channels and added artifacting as I said. (it's arguably worse than what the Genesis already had -it's stereo and you can do higher resolution samples, but for a lot of stuff, the YM DAC could sound better, it's the SH2 resource that gets you the difference)

    PWM is sort of nasty, especially as the 32x, GBA, and DS use it, though the higher the sample rate the less the artifacting. (the Jaguar had a rather nice PWM set-up though) 32x with PWM and 9-bit 44.1 kHz output would have been better than the DS though, save for need of software mixing vs 8 hardware channels. (DS is limited to 32 kHz 9-bit output)
    Also remember there's no hardware compression, so you use larger, lower-quality, or software decompression for audio samples on the cart. (depending on the scheme used you could do a lot higher ratio compression than the SNES's 4-bit ADPCM, though not as high quality output -the schemes chilly willy and TmEE have been working with are higher ratio and less resource intensive than ADPCM and some sounds pretty good) See: http://gendev.spritesmind.net/forum/viewtopic.php?t=586
    Quote Originally Posted by Chilly Willy View Post
    PWM was easy - add a three counters and two small FIFOs to the interface chip along with a tiny amount of logic to handle the flags and DMA/INT assertion. Feed the output to a simple low-pass filter.

    As to why 32X games didn't use DMA, the developer units had a number of bugs that required work-arounds that probably affected the DMA. For example, there was an interrupt issue that required developers to use the free-running timer in the SH2 plus extra code in all interrupt handlers to keep the SH2s from freezing up (on the dev units... no such issue occurs in the consumer units). The only place you find DMA audio is in the 32X diagnostic cartridge SEGA made... and a look at the code shows the routine waits on a timeout and errors with the DMA, not the DMA transfer done. That seems to indicate they had issues with the developer units not terminating the DMA the way they were supposed to.

    I think we have better 32X development tools NOW than developers had THEN. I can compile/assemble 68000 and SH2 code with modern GCC, and immediately test on a flash cart on an actual consumer 32X. No hardware debugging, but many programmers prefer logging as their form of debugging in any case (I do for sure).
    Quote Originally Posted by kool kitty89 View Post
    Some of that also limits the 32x: namely ROM DMA contention (more so if using PWM DMA in some respects), though if your game uses only 32x graphics, or fairly fixed (rarely updated) Genesis graphics, you're OK, but VDMA to ROM can screw stuff up.


    ---CD Audio is 44.1 kHz 16-bit stereo linear PCM: the Genesis only has an 8-bit DAC to work with, so you're down to 8-bit mono right there. Tiido also mentioned that you can't go past ~26 kHz on the YM2612 DAC without getting missed writes, so that's the practical limit as well.
    -SNES can do stereo, but only accepts ADPCM up to 32 kHz (with 12-bit output per channel and 16-bit combined output iirc)
    -Ricoh chip does stereo 8-bit PCM up to 32 kHz with 16-bit combined output (8-bit limit is what's important though)
    -Amiga (using DMA and standard video resolution) is limited to 8-bit stereo PCM up to ~29 kHz, though there's tricks to get closer to 12-bit by pairing channels. (double that sample rate at VGA resolutions)
    -STE is 8-bit stereo up to 50 kHz
    -NDS is 8-bit 32 kHz stereo with 9-bit PWM output.
    -32x can do 44.1 kHz stereo PWM at 9-bit resolution (22 at 10 bits, 88.2 8-bit)
    -Jaguar can do 14-bit stereo at over 200 kHz using PWM. (but a much nicer set-up than the GBA/DS/32x)
    -Atari Falcon can do 50 kHz 16-bit stereo. (8 hardware DMA sound channels too)
    Quote Originally Posted by Chilly Willy View Post
    YM2612 DAC:
    ===========
    A single 8 bit DAC that can be output to the left, right, or both. There's no timing or volume. You enable the DAC, set L/R/M, then start storing the PCM to the DAC register.

    Pros: Very easy.
    Cons: No volume - if you need volume control, it has to be done in software, which reduces the accuracy. No timing - your routine sets the sample rate... which means the routine has to account for cycles or your sample rate will vary, causing distortion in the sound. No DMA - the CPU has to set every single sample.

    So while the YM2612 DAC is simple, it also doesn't give good results unless you write very tight and clean code.

    CD PCM:
    =======
    Eight 8 bit PCM channels with 8 bit volume control and 8 bit pan control (4 bit left & 4 bits right). Waveforms are stored in PCM RAM, you have very good timing up to 32 kHz, and the ability to loop waveforms.

    Pros: Eight channels with volume and panning, and a decent sample rate (for the time). Samples can be looped. The samples are fetched by the PCM chip, so very little CPU time is consumed to play the samples.
    Cons: A bit more work to use. You have to load the sample into the PCM RAM, of which you have 64 KB. The small size of the RAM limits the size and number of samples you can play without needing to reload the RAM. The samples themselves are a little odd: they are 8 bit sign/magnitude samples. The msb is the sign (positive or negative), and the other seven bits are the magnitude (amplitude) of the sample. That's not a very widespread format, so all your samples will need to be converted. Also, 255 is reserved as the loop marker. When 255 is fetched from the sample RAM, the sample address is set to the loop address and sampling begins at that new location. That means if a sample DOESN'T loop, you need to store an extra zero sample and set the loop address to it.

    So the CD PCM is a bit more complicated, but worth the extra effort as you get the ability to play samples at almost any rate with no jitter, and with very little CPU usage. The main limitation is the amount of sample RAM.

    32X PWM:
    ========
    Two channels of audio, left and right. There is a "mono" channel, but all it does is set both the left and right channels to the data written into the mono channel. There is no volume control. The timing is set by setting a count, which is the main CPU clock divided by the sample rate. The left and right channels can be any value from 1 up to the count. So the "bits" of the channels isn't set like the other sound sources. The samples can be set using any CPU (including the Z80), or by DMA (I had problems using the DMA, so I'm not 100% sure if you really can use the DMA). The sound channels have a FIFO and status bits so that an even sample rate can be maintained, even with sloppy code.

    Pros: You can have better than 8 bit samples, and high sample rates. Relatively easy to program.
    Cons: No volume - like the YM2612, if you want volume, you have to do it in software. The sample format is a bit odd. You have to convert the samples into PWM format. For example, let's say you want to output at 22050 Hz. That gives a count of (NTSC) 23.01 MHz / 22050 Hz = 1043. This means that samples can be 1 through 1043, where 1 will give the lowest amplitude, and 1043 the highest. So you COULD make your samples 10 bits (10 bits gives 0 to 1023), or you COULD take four 8 bit channels and add then together (8 bits gives 0 to 255, so four of them gives 0 to 1020). That is generally what you see games do - add together multiple 8 bit channels in software, then offset them a little for the PWM output.

    So 32X PWM can be rather flexible about the sample rate and samples. It can generate a decent output with little/moderate/heavy CPU overhead (depending on if you're adding channels and/or doing volume). However, it's even more odd than the CD audio. However, it's worth a little extra study.

    Code:
    You have one rate control - samples play at the master clock rate divided by rate value + 1. The master clock in the 32X is three times the 68000 clock, which is different for NTSC and PAL. Here's how I set the rate:
    
        if (MARS_VDP_DISPMODE & MARS_NTSC_FORMAT)
            MARS_PWM_CYCLE = (((23011361 << 1)/SAMPLE_RATE + 1) >> 1) + 1; // for NTSC clock
        else
            MARS_PWM_CYCLE = (((22801467 << 1)/SAMPLE_RATE + 1) >> 1) + 1; // for PAL clock
    
    
    
    Think of that rate as the mixer rate. You can play samples of any other rate, but you have to resample them to the mixer rate on the fly in software (I do that with the slave sh2). The number of bits in the PWM sample depends on the rate. That rate value you calculate above? That's a terminal COUNTER VALUE used for the pulse width modulation - it's the maximum width in sh2 clocks. So if the value was 1040, that the maximum value a sample can have. You also can't use the value 0 as a sample. You need to add half the cycle width to samples to set the center value, and limit samples to +/- one half the (cycle width - 2).
    
    1048 is about 22kHz sample rate, which is VERY popular in 32X games. Most samples the time are 8 bit, which is -128 to 127 for signed samples. Four of those added together gives -512 to 508. The center value for that rate would be 524, so PWM samples would range from 524 - 512 = 12, up to 524 + 508 = 1032. So your four 8-bit samples added together fit nicely in the cycle width for 22kHz.
    
    You have three sample registers that are emptied at the cycle width rate: you have a left channel, a right channel, and a mono channel; HOWEVER! the mono channel isn't a real channel - it merely writes both the left and right channel registers with the same value. There's a control register that let's you do things like turn off the channels, or flip the channels, but most folks just route the left channel to left out, and the right channel to right out. You have to store PWM samples to the channels, NOT PCM! The values must be 1 to (cycle width) to create any output. The channels have a FIFO so that you can store samples to the channel until the FIFO fills, and wait for it to empty. The FIFO empties at the rate specified, so unless you don't keep the FIFO at least partly full, the samples play at a steady rate (unlike the bare DAC in the YM2612). When you read the channel register, bit 15 is set is the FIFO is full, and bit 14 is set if the FIFO is empty.
    
    The 32X can interrupt either SH2 after X samples have been played (X being 1 to 15). SEGA's 32X sound sample code all used interrupt driven sample playing, supposedly because there were some bugs using the DMA for sound in the first developer units. Consumer 32Xs don't have these bugs, so I prefer to use DMA driven audio. In that case, we don't need to worry about interrupts or FIFOs. Instead, we initialize the DMA channel in the sh2 and fill the PWM FIFOs:
    
        // init DMA
        SH2_DMA_SAR0 = 0;
        SH2_DMA_DAR0 = 0;
        SH2_DMA_TCR0 = 0;
        SH2_DMA_CHCR0 = 0;
        SH2_DMA_DRCR0 = 0;
        SH2_DMA_SAR1 = 0;
        SH2_DMA_DAR1 = 0x20004034; // storing a long here will set left and right
        SH2_DMA_TCR1 = 0;
        SH2_DMA_CHCR1 = 0;
        SH2_DMA_DRCR1 = 0;
        SH2_DMA_DMAOR = 1; // enable DMA
    
        // init the sound hardware
        MARS_PWM_MONO = 1;
        MARS_PWM_MONO = 1;
        MARS_PWM_MONO = 1;
        if (MARS_VDP_DISPMODE & MARS_NTSC_FORMAT)
            MARS_PWM_CYCLE = (((23011361 << 1)/SAMPLE_RATE + 1) >> 1) + 1; // for NTSC clock
        else
            MARS_PWM_CYCLE = (((22801467 << 1)/SAMPLE_RATE + 1) >> 1) + 1; // for PAL clock
        MARS_PWM_CTRL = 0x0185; // TM = 1, RTP, RMD = right, LMD = left
    
    
    
    Fill the first sound buffer, and enter your loop with starting to play the first buffer, then immediately fill the second buffer, wait on the dma, start the second buffer playing, fill the first buffer, wait for the dma, and loop:
    
            if (MARS_SYS_COMM6 == 0)
            {
                MARS_SYS_COMM6 = 1; // sound subsystem running
                // fill first buffer
                fill_buffer((unsigned long)&snd_buffer);
            }
    
            // only do sound when sound subsytem initialized and unlocked
            while (MARS_SYS_COMM6 == 1)
            {
                // start DMA on first buffer and fill second
                SH2_DMA_SAR1 = ((unsigned long)&snd_buffer) | 0x20000000;
                SH2_DMA_TCR1 = NUM_SAMPLES; // number longs
                SH2_DMA_CHCR1 = 0x18E1; // dest fixed, src incr, size long, ext req, dack mem to dev, dack hi, dack edge, dreq rising edge, cycle-steal, dual addr, intr disabled, clear TE, dma enabled
    
                fill_buffer((unsigned long)&snd_buffer + MAX_NUM_SAMPLES * 4);
    
                // wait on DMA
                while (!(SH2_DMA_CHCR1 & 2)) // wait on TE
                {
                    if (MARS_SYS_COMM4)
                        task_handler();
                }
    
                // start DMA on second buffer and fill first
                SH2_DMA_SAR1 = ((unsigned long)&snd_buffer + MAX_NUM_SAMPLES * 4) | 0x20000000;
                SH2_DMA_TCR1 = NUM_SAMPLES; // number longs
                SH2_DMA_CHCR1 = 0x18E1; // dest fixed, src incr, size long, ext req, dack mem to dev, dack hi, dack edge, dreq rising edge, cycle-steal, dual addr, intr disabled, clear TE, dma enabled
    
                fill_buffer((unsigned long)&snd_buffer);
    
                // wait on DMA
                while (!(SH2_DMA_CHCR1 & 2)) // wait on TE
                {
                    if (MARS_SYS_COMM4)
                        task_handler();
                }
            }
    
    
    You can find all this code in my MOD player example, or the Yeti3D examples.
    
    Notice in the code how we are DMAing longs (32 bits). We DMA them to the left channel. A long is two words, the first word gets DMAed to the left channel, and the second word to the right channel. So we are doing stereo samples from the buffer, stored LEFT then RIGHT. You could set the DMA to words, and then set the destination to the mono channel for mono audio playback. The the buffer would be nothing but mono PWM samples.
    
    Notice in the code above that while waiting on the DMA done, the code checks the comm4 register to see if the other sh2 is signalling another task for the slave to handle. You don't need that if all you are using the slave for is mixing/playing the audio.
    https://forums.sonicretro.org/index....dpost&p=692662


    Code:
    In my drivers, I convert 8-bit samples to 16 bit, scale them for pan (left/right), and add them together as a 16-bit stream. At the very end, I convert the 16-bit stream to what the 32X uses (10-bit). It sounds really good. You should be able to add 8 to 16 channels without significant noise, depending on your software volume... I really think people should leave it at full volume and use the volume on the TV/stereo to control how loud it is. That gives the best quality out from the 32X as it doesn't have it's own analog volume control.
    
    A bit more precise detail:
    
    Look at the code I use to add a sample voice to the output stream:
    
    ! Uses:  r0 = scratch
    !        r1 = scratch
    !        r2 = voices
    !        r3 = current buffer pointer
    !        r4 = buffer pointer (passed in from _fill_buffer)
    !        r5 = voice count
    !        r6 = sample count
    !        r7 = wave
    !        r8 = index
    !        r9 = step
    !        r10 = loop
    !        r11 = length
    !        r12 = left volume
    !        r13 = right volume
    !        r14 = sample
    
    process_svc:
            mov.l   ps_svc_pause,r1
            mov.w   @r1,r0
            cmp/pl  r0
            bt      proc_snd_exit           /* paused - just exit */
    
            sts.l   pr,@-r15                /* save return address */
    
            mov     r4,r3
            bsr     _SVC_Lock
            mov     #3,r4                   /* locked by SSH2 */
            mov     r3,r4
    
            mov.l   ps_svc_purge,r1
            mov.w   @r1,r0
            cmp/eq  #0,r0
            bt      do_svc_voices
            /* flush svc voices */
            mov     #NUM_VOICES,r2
            mov.l   ps_flush_voices,r3
            mov     #0,r0
    1:
            mov.l   r0,@(0x00,r3)
            mov.l   r0,@(0x10,r3)
            dt      r2
            bf/s    1b
            add     #vc_sizeof,r3
            mov.w   r0,@r1
    
    do_svc_voices:
            mov.l   ps_voices,r2
            mov     #NUM_VOICES,r5
    0:
            /* check if voice playing */
            mov.w   @(vc_flags,r2),r0
            tst     #VF_PLAYING,r0
            bt      4f                      /* not playing - next voice */
            /* playing, check if belongs to module and paused */
            shlr8   r0
            tst     #VF_MODULE,r0
            bt      1f                      /* not a module voice - play */
            mov.l   ps_mod_pause,r1
            mov.w   @r1,r0
            cmp/pl  r0
            bt      4f                      /* module paused - next voice */
    1:
            /* process samples */
            mov     r4,r3                   /* start of sample buffer */
            mov.l   ps_num_samples,r1
            mov.w   @r1,r6
            mov.l   @(vc_wave,r2),r7
            mov.l   @(vc_index,r2),r8
            mov.l   @(vc_step,r2),r9
            mov.l   @(vc_loop,r2),r10
            mov.l   @(vc_length,r2),r11
            mov.w   @(vc_left,r2),r0
            shlr2   r0
            mov     r0,r12
            mov.w   @(vc_right,r2),r0
            shlr2   r0
            mov     r0,r13
    2:
            add     r9,r8                   /* index += step */
            cmp/hs  r11,r8
            bt      5f                      /* index >= length */
    3:
            /* process one sample */
            mov     r8,r0
            shlr8   r0
            shll2   r0
            shlr8   r0
            mov.b   @(r0,r7),r14
            /* scale sample for left output */
            muls.w  r14,r12
            mov.w   @r3,r1
            sts     macl,r0
            shlr8   r0                      /* now 13-bit sample - no overflow with 8 voices */
            exts.w  r0,r0
            add     r0,r1
            mov.w   r1,@r3
            add     #2,r3
            /* scale sample for right output */
            muls.w  r14,r13
            mov.w   @r3,r1
            sts     macl,r0
            shlr8   r0
            exts.w  r0,r0
            add     r0,r1
            mov.w   r1,@r3
            add     #2,r3
            /* next sample */
            dt      r6
            bf      2b
            mov.l   r8,@(vc_index,r2)
    4:
            /* next voice */
            dt      r5
            bf/s    0b
            add     #vc_sizeof,r2
    
            bsr     _SVC_Unlock
            nop
            lds.l   @r15+,pr                /* restore return address */
            rts
            nop
    5:
            /* check if loop sample */
            mov.w   @(vc_flags,r2),r0
            shlr8   r0
            tst     #VF_LOOPS,r0
            bt/s    6f                      /* no looping */
            sub     r11,r8
            bra     3b
            add     r10,r8                  /* index = index - length + loop */
    6:
            /* check if one-shot sample */
            tst     #VF_ONESHOT,r0
            bt      7f                      /* not oneshot - leave enabled */
            mov     #0,r0                   /* voice disabled */
    7:
            shll8   r0
            mov.w   r0,@(vc_flags,r2)       /* voice not playing (and possibly disabled) */
    
            /* next voice */
            dt      r5
            bf/s    0b
            add     #vc_sizeof,r2
    
            bsr     _SVC_Unlock
            nop
            lds.l   @r15+,pr                /* restore return address */
    
    proc_snd_exit:
            rts
            nop
    
    
    Okay, let's do a little discussion on bits of it... the left and right volume values are 0 to $7FFF, or 15 bits. I shift the volume right 2 bits, making it 13 bits. I then multiply the 8 bit sample by the volume and shift the result 8 bits. That leaves the final sample as 13 bits with no loss of info. That allows me to add eight channels together before it has a chance of overflowing on a 16-bit stream. So I have a 16-bit stream with no noise for up to 8 channels. Now let's look at how the stream is converted for output:
    
            /* handle sample processing */
    handle_voices:
            /* clear sound buffer */
            mov     r14,r3
            mov.l   fb_num_samples,r1
            mov.w   @r1,r2
            mov     #0,r0
    1:
            mov.l   r0,@r3
            dt      r2
            bf/s    1b
            add     #4,r3
    
            /* process sample voices */
            bsr     process_svc
            mov     r14,r4
    
    !       convert buffer from signed 15-bit samples (4 signed 13-bit samples)
    !       to unsigned PWM samples (4 to 516 @44kHz or 8 to 1032 @22kHz)
    !       only assumes eqv of 4 full-range samples for better volume, this
    !       may result in clipping
    
            mov     r4,r3
            mov.l   fb_num_samples,r1
            mov.w   @r1,r2
            mov.w   fb_sample_center,r1
            mov.w   fb_sample_max,r6
            mov.w   fb_sample_min,r5
    2:
            /* process left sample */
            mov.w   @r3+,r0
            /* shift sample */
            .ifndef CD_SAMPLE_RATE
            shlr2   r0                      /* 13 bits */
            shlr2   r0                      /* 11 bits */
            shlr    r0                      /* 10 bits */
            exts.w  r0,r0
            .else
            shll2   r0                      /* 17 bits */
            shlr8   r0                      /*  9 bits */
            exts.w  r0,r0
            .endif
            /* clamp sample */
            cmp/ge  r5,r0
            bf      5f                      /* clamp to minimum sample */
            cmp/gt  r6,r0
            bt      6f                      /* clamp to maximum sample */
    3:
            add     r1,r0
            mov.w   r0,@r4
    
            /* process right sample */
            mov.w   @r3+,r0
            /* shift sample */
            .ifndef CD_SAMPLE_RATE
            shlr2   r0                      /* 13 bits */
            shlr2   r0                      /* 11 bits */
            shlr    r0                      /* 10 bits */
            exts.w  r0,r0
            .else
            shll2   r0                      /* 17 bits */
            shlr8   r0                      /*  9 bits */
            exts.w  r0,r0
            .endif
            /* clamp sample */
            cmp/ge  r5,r0
            bf      7f                      /* clamp to minimum sample */
            cmp/gt  r6,r0
            bt      8f                      /* clamp to maximum sample */
    4:
            add     r1,r0
            mov.w   r0,@(2,r4)
    
            dt      r2
            bf/s    2b
            add     #4,r4
    
    
    
    Notice that I assume four channels at max volume for the scaling - I was adding eight channels in the mixing, so IF I had more than four voices loud enough to overflow, the scaling won't be enough. But, if you notice, I clamp the samples to 10 bits. A single voice was 13 bits after volume scaling (if you remember), and I scale the output stream by 5 bits. That gives me perfect quality for 8-bit samples... as long as we don't get too many voices at full volume. Then you get a clamped signal.
    
    This is actually fine as it's pretty rare that ANY channel is at full volume, much less more than four of them. Eight channels at half volume won't cause a sample to clamp. So most of the time, all eight channels mixed will sound just fine. On the rare occasions the stream overflows 10 bits, the clamped sample adds less noise than scaling the samples lower to avoid the clamped sample. Anywho, you get more noise from aliasing from low sample rate instruments than from scaling the samples. I'm not saying this is perfect, but it sounds really good under most conditions, and the conditions under which it might not sound as good naturally masks the noise.
    
    Think about it - when would you have more than four channels at full volume? When the music is at full volume AND your sound effects are at full volume AND you are using ALL the channels. So tell me, are you going to notice a clamped sample when you have the music playing full blast AND four sound effects going off at the same time at full volume? Hell no! The ear cannot handle that. That's partly how modern audio compression works - loud sounds drown out soft ones, so they discard the soft sounds to make it compress better, and give the loud sound less bit since the ear has trouble handling loud sounds.
    https://forums.sonicretro.org/index....dpost&p=692998

Thread Information

Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •