Printable View
Now that's the SN being used the way I like it, with that sweet bass. Good post segarule.
Unfortunately...
"You must spread some Reputation around before giving it to segarule again."
Alas. Well, here's some AY (not from any video game):
https://soundcloud.com/mmcm/muzafuckabit
https://soundcloud.com/c-jeff/single-notes
Or youtube:
https://www.youtube.com/watch?v=6nVV-UoddqU
Yes the AY is this much better than the SN :p.
My favorite is his PSG+SCC cover of Wild Arms intro..Quote:
Originally Posted by GeckoYamori
Master system:
Sonic 3D
https://www.youtube.com/watch?v=DzFEJUh5MT4
I wrote this TurboGrafx-16 tune with a friend
https://soundcloud.com/txai/the-wisdom-of-gaia
Besides Asuka 120%, Genocide 2, Dinosaur, Princess Maker 2 and Doukyusei 1-2, are there any other impressive YM2612 soundtracks for the FM Towns?
Edit suggestions (new info is in red):
Quote:
Originally Posted by Kamahl
A PC Engine pixel artist recently started experimenting with deflemask and has had some great results. He said that he isolated Genesis audio channels and looked at the shapes of the wav files to recreate tyem as closely as possible. After his early versions of some tracks, he began to customize them to sound better more than going more for authenticity.
http://youtu.be/At9dpMcoHwY
http://youtu.be/behCCkSEvBk
https://youtu.be/YNVQeYZz3SE
Sa'eed doesn't use CSM. It might sound like it, but it doesn't.
Sorry for not properly maintaining this thread, I will clean up the list eventually (worrying about too many things lately). I've added Barone's stuff to the first post.
He used the PCE´s freq in deflemask?Quote:
A PC Engine pixel artist recently started experimenting with deflemask and has had some great results.
IMO not had great results in SOR2 case (compared with original) and SC IV.
So:
SOR - Great;
SOR - Good but not great;
SC IV - + or -.
That's the "Beatmix" version of the SOR2 track. I believe that his first versions of Go Straight were based on the original.Quote:
Originally Posted by segarule
Here is the Genesis version of the "Beatmix" Go Straight:
http://youtu.be/jK77WJZNniI
That particular revision of the SCIV track uses zero samples and is pure chip sound.
OK this is a long thread and I only checked out the first post. A couple things:
Devil Crash was done by Toshiaki Sakoda, not Noriyuki Iwadare.
The 32X would be nice to see listed. There are some games that use the 32X entirely for their sound. Blackthorne doesn't have a single peep made by the Genesis itself, for example. I believe Kolibri is the same way. There might be one or two other games.
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 should be a good start:
Quote:
Originally Posted by kool kitty89
Quote:
Originally Posted by kool kitty89
Quote:
Originally Posted by Chilly Willy
Quote:
Originally Posted by kool kitty89
Quote:
Originally Posted by Chilly Willy
https://forums.sonicretro.org/index....dpost&p=692662Code: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=692998Code: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.
You should consider updating YouTube links in the article as many leads nowhere now.
Also try listing tracks from one source. For example in Genesis section there's a mess of recordings from emulators, from good hardware, from bad hardware and
and
Time Trax track is so low quality I can't even figure out from what it's recorded of and of how many compressions it got through.
Otherwise thread is very nice and well made. Thanks.
When this thread was made there was a nasty lack of options for genesis recordings (and others too for that matter). Time Trax wasn't even released yet! That low quality recording of that one track was all that was available.
The few tracks I could find real hardware recordings of I used, otherwise I got what I could. Heck, the one youtube channel that would let me get all the genesis songs from a single place was 'Professor G's (I forgot the original name) and they were all extremely poorly emulated.
Heh, I thought so, it's alright.Quote:
Originally Posted by Kamahl
Professor G's recordings are indeed emulated and, meh..
I can record all mentioned Genesis tracks separately, upload them on YouTube (except homebrew tracks like IF - Sa'eed, because video linked is already from the maker of that track) and give you links, if you want/don't mind.
I would appreciate it, but I'm planning on doing a big overhaul to the first post when I have the time (and will likely change some songs around), so maybe after that?
That's a deal.
It would be great if when you know what songs you'll change, you could PM me.
:)
Updated the Genesis section, big thanks to Peeteris for the real hardware recordings :).
I will get to the others... eventually.
This is pure funny and true at the same time. :DQuote:
Originally Posted by Kamahl
Nice, and thanks for the shoutout. :)
Superb update and contribution of all guys involved. Thank you very much!
Wow, this is crazy, are there any examples of this kind of beeper usage + AY simultaneous to make music for 128k?Quote:
Originally Posted by Kamahl
I guess there wouldn't be enough cpu power spare to do both at once?
Here's a rymcast export and vgm of the SoM track if it's of any interest: https://files.fm/u/6tgw887x
None that I know of I'm afraid, but CPU power is probably not that big of a deal, depending on how complex the beeper usage is. With the AY picking up a lot of the slack you don't have to try and get the beeper to do 8 simultaneous channels or other craziness like that.Quote:
Originally Posted by Thenewguy
The track selection here is so great.Quote:
Originally Posted by Kamahl
I think this one could also be there if we weren't limited to five tracks:
Magician's Domain - https://youtu.be/TXw0Zx5jlw8?t=31m31s
Actually, a Peeteris' recording of that track in the same way he did for the others would make me happy. To be able to visualize (thanks to Stef's player) how it uses the sound hardware and compare it to the other orchestral tracks (especially Devilish's Seaside which sounds similar IMO).
Maybe there are some other tracks you want me to record and upload this way, Barone?
I'll post links there when I'll be done with uploading them on YT, but that will take some time.
Thanks for the very kind offer.Quote:
Originally Posted by Peeteris
Here's my list:
http://project2612.org/details.php?id=399#19-requiem
http://project2612.org/details.php?i...-sirius-castle
http://project2612.org/details.php?id=81#06-stage-5
http://project2612.org/details.php?i...elevator-shaft
http://project2612.org/details.php?i...19-final-level
World of Illusion, Shining Force, King Colossus and even Golden Axe were others I considered for the section. I ended up going nearly full Sakimoto just because he is easily the best at it.
EDIT: It's such a shame the POKEY never got the chance to be properly used in games back in the day, this is really impressive:
https://www.youtube.com/watch?v=ufWvi4q0ZSY
I love the metallic sounds the POKEY makes.
Here you go, Barone.Quote:
Originally Posted by Barone
https://youtu.be/UUiKdhEVdP8
I apologize that it took so long for me to finish it earlier.
None of your chosen tracks use PCM, so no cool waves for this compilation.
P.S. Please reply when you can so I know that you saw this post. :)
Its unfortunate the Amstrad CPC existed really :D, Atari XL, MSX, or even the Electron would've been better for 3rd place in the UK IMO.Quote:
Originally Posted by Kamahl
At least with the Electron development wouldn't have been stretched as thin, given that the Beeb was already being somewhat supported anyway.
MSX would've given us more access to Japanese games, Atari XL possibly more colourful than C64 whilst not being dog slow like Amstrad.
I still hate the fact that the MSX2 was not the MSX2+ as it should have been, and that the MSX3 never came to be.Quote:
Originally Posted by Thenewguy
The Atari XL is better on paper than it is in practice, wringing good colour out of it is pretty hard. You can only use a total of 9 colors, 4 of which are split into 4 one colour sprites, and 1 is shared between the background and a special "5th" sprite.
I guess you could do nice lionheart-ish looking games on it, "monochromatic" but with a gradient on top.
You must spread some Reputation around before giving it to Peeteris again.
Awesome! Thanks you very much!
That was on purpose.Quote:
Originally Posted by Peeteris
As my ears improve in mileage, I realize more and more that the use of PCM drums kind of break the FM atmosphere of the tracks.
I mean, in the MD they are usually played at much lower sample rate and with noticeable distortion... So, as much as the YM2612 tends to struggle with snares, I've grown tired of the PCM drums for the most part.
I don't think I ever really properly understood the Atari XL graphics back when we all used to talk about this stuff (even moreso than the other machines). Its hard for me to judge the complexity in making something like Crownland as I have such little programming experience. Koolkitty was always super positive about the hardware though.Quote:
Originally Posted by Kamahl
Is it fairly easy to do tons of interrupts on the XL machines? For instance could you draw a four colour status bar, do an interrupt, do a four colour sky, do an interrupt, do a four colour mountain background, do another interrupt, do a 4 colour forest background under it, do another interrupt, do a four colour strip of grass, do another interrupt, four colour strip of ground etc etc without losing much speed?
Actually, looking a Crownland again I take it they are overlaying sprites a lot, that would really limit your sprite numbers (and explains all the flicker).
Yeah you can do tons of interrupts, but that only helps if you can make really obvious cuts in the background.
The sprites are an even bigger challenge though: only 4 single colour sprites, 8 pixels wide (though they are usually doubled in size).
That's why Crownland flickers so much, it is using 2 sprites per character out of 4, so only 2 characters in a line before flicker happens.
Yeah, I just read through a C64 vs Atari thread and they seem to think that C64 would've had better colour in most games regardless.
I'll go back to keeping Amstrad as being third place I think.
Apparently the Atari XL does have a 5 colour mode, it seems to come with a bunch of rules though.
BTW, were you going to add any sample-based C64 examples (ie like Turbo Outrun, US Afterburner, Polly Wants a Tracker or something similar).