The code blocks are done with code snippet, which uses geshi and [code] tags. For pretty colors, you can use lang=”…”; cpp for C/C++ and gccarm for ARM assembly are the most common for me.

I’d love to have a preview, but my webscript-fu is still somewhat weak, so I’m not sure how to implement it … yet. Of course, if one should suddenly find itself in my mailbox, I would consider it (hint, hint).

You’ve got those beautiful code blocks up there–now I have to go reading… Is there a good reference on what WordPress will tolerate? Or at least a well-hidden preview? ^_^;

Don’t you just love that barrel shifter? ^_^.

I feel so weird working with x86 anymore! I guess it’s partly a matter of perspective. (e.g.: Memory operands and register renaming as a form of code compression..)

6502 is my second favorite to ARM. Didn’t try much, but I always found the simplicity refreshing. Though a funny thing about it is that if you set the low two opcode bits, supposedly you get an “ALU + shifter” op, like ORA + ASL (“ASO”). Sound familiar? These are the “illegal” ops the chip is so infamous for. I couldn’t say whether that’s where ARM got the idea, but it’s very nifty indeed.

And now I’m curious about that whole thing too, but I’m fighting the urge to ask for details.

Er, I’ll try to be brief then. (It’s not my strong point.)

Some background: Yamaha’s OPL2/3 series cropped up in tons of 1990s-era sound boards. So many, that I wonder if lame OPL instruments are THE reason some folks associate MIDI with “crap music.” But used on children of the 80′s, good “FM” tunes–like the NES and C64–should induce spine-shivering waves of nostalgia. ;-)

Other excuses include a burning curiosity regarding MAME’s spaghettiesque OPL driver (from which I got the algorithms), and a nice, complete set of instrument patches (ah, wasted youth!).

 while(numSamples--) {
     // Envelopes (among other settings) modulate the wave amplitude.
     if((envTimer0 -= dt) < 0) updateEnv0();  // Branchy state machine
     if((envTimer1 -= dt) >N] wraps properly.
     feedb   = out0 + out0_pr;
     out0_pr = out0;             // wave0 can modulate its own phase.

     // wave0 modulates wave1 phase (or can just be mixed--not shown)
     // note: amp and wave tables use log values (hence the adds).
     out0    = wave0[ (phase0 + (feedb <> F_BITS ];
     out0    = expTable[ amp0 + out0 ];
     out1    = wave1[ (phase1 + (out0  <> F_BITS ];
     out1    = expTable[ amp1 + out1 ];

     *pMix++ += out1;  // 32 bits (clamping and dither done later)
 }

This is pseudocode for the meat of it. As you can see, it’s not truly FM, but it’s close. Topping out (at 18 voices, 32Khz stereo) uses ~75% of the ARM9.

Right now it’s playing MIDIs, but I’d love to see a Mario Paint sorta thing…

Niiiice. I never had to cram several variables in a single word like you’re doing for r0 here, but I’ve always been fond of abusing ROR. For example, on some occasions you can split a coordinate into the divident and the modulo by using ROR 3 instead of LSR 3. In later instructions you can use either part with further shifts, usually without getting into trouble.

I also came across a nice bit for the tail-end of a large fill routine. When you’re down to less than 32 bytes, you can do a word-loop, unroll the word-loop, or go for a nifty stmvariant like this:

But you can actually test two bits at once if you shift them into the sign and carry bit:

Don’t you just love that barrel shifter? ^_^.

This came from some Adlib/OPL2 emulation. Desparate enough? Well, that wasn’t the end of it, and there are _still_ LDM’s in there for lack of registers. Though not all of this was used in the end. I ditched sample-accurate envelopes, and I still can’t break ~80 ARM9 cycles/sample. :|

And now I’m curious about that whole thing too, but I’m fighting the urge to ask for details.

In the spirit of Not Helping(tm), I’ll throw in my favorite ARM perversions:

mov timers, timer_1
orr timers, timer_2, lsl #16
mov r0, shiftCount
orr r0, someSpareFlags, lsl #8
orr r0, counter, lsl #12
…
loop:
rsbs timers, dt, timers, ror #16 ; decrement and test high half < 0
blt infrequent_complex_event_1
rsbs timers, dt, timers, ror #16 ; decrement and test low half < 0
blt pesky_distraction_2
…
mov foo, bar, lsl r0 ; uses low 8 bits of r0
…
orr/bic../tsts r0, someBit ; toy with spare flags
…
subs r0, #(1<<12) ; decrement and test counter
blt loop

This came from some Adlib/OPL2 emulation. Desparate enough? Well, that wasn’t the end of it, and there are _still_ LDM’s in there for lack of registers. Though not all of this was used in the end. I ditched sample-accurate envelopes, and I still can’t break ~80 ARM9 cycles/sample. :|