Out of all my projects, I like this one a lot. I like it because it brought me out of my comfort zone and into the murky world of hardware design (aided by the Arduino project which does a fine job of making that world accessible to electronics noobs like me). I also like it because it elegantly solves a problem that, in all likelihood, nobody in the world but me has. But most of all, I like it because it has a pair of blinky LEDs on the top which serve no meaningful purpose.

A couple of the songs in my set are played using two Spectrums together, to get an unthinkable 6 (SIX!) channels of sound. At AY Riders concerts in the past, we synchronised them through the low-tech method of having two of us with our fingers poised over the space bar while one of us counted us in. This method has two drawbacks: firstly, if the timing is even slightly out, it’s very noticeable. Secondly, different models of Spectrum have slightly different clock speeds, which causes them to slowly drift out of sync over the duration of the song. My two ‘performance’ Spectrums are an original 128+ and my Speccy2010, which are about as different as you can get – so that wasn’t going to cut it.

The job of the Synchronizatron 3000 is to provide a common external 50Hz clock signal for the two Spectrums to use, in place of their own timers. This signal gets fed in through whichever port happens to be convenient – for the Speccy2010, it’s the joystick port, which handily also provides a +5V line for powering the whole thing – and for the 128+, it’s the cassette (EAR) port. Using the cassette port adds another hurdle, because it’s designed to receive audio-frequency signals, so (presumably due to bandpass filters and other things I don’t understand) it won’t respond to simply flipping the signal high and low every 50th of a second – so instead, it rapidly alternates between generating an 8000Hz tone and silence. The code is really laughably simple:

void setup() {
  // initialize the digital pin as an output.
  pinMode(13, OUTPUT); // clock signal
  pinMode(9, INPUT);   // on/off switch
  pinMode(10, OUTPUT); // off (red) LED
  pinMode(11, OUTPUT); // on (green) LED
}

void loop() {
  if (digitalRead(9)) {  // switched on
    digitalWrite(10, LOW);
    digitalWrite(11, HIGH);
    tone(13, 8000); // burst of high frequency
    delay(5);   // play it for 5ms
    noTone(13); // set signal off
    delay(15);  // wait for 15ms
  } else {  // switched off
    digitalWrite(10, HIGH);
    digitalWrite(11, LOW);
  }
}

The Z80 code on the Spectrum side to listen to those pulses goes something like this – it’s somewhat similar to what the Spectrum’s own tape loading routines do when listening for the end of a ‘beeeeeee’ in ‘beeeeeee bip! beeeeeee bipipipipi…’, except that here it gets done 50 times a second:

	call init_music
loop:
wait_low:
	call get_pulse      ; check for presence of a tone
	jr nz,wait_low      ; don't proceed until the tone has stopped
wait_high:
	call get_pulse      ; now wait for the tone to start up again
	jr z,wait_high      ; - don't proceed until we detect a pulse
	call play_music     ; play the next 'frame' of music -
	                    ; - we want to do this every 1/50s
	jr loop             ; repeat ad infinitum

get_pulse:
	in a,(254)          ; read the cassette port:
	and 0x40            ; - bit 6 of port 254
	ld d,a              ; save its initial value in d
	ld b,255            ; see if it changes over the next 255 iterations over this loop:
get_pulse_loop:
	in a,(254)          ; re-read the cassette port
	and 0x40
	cp d                ; compare with initial value
	ret nz              ; return (with zero flag reset) if there's been a change
	djnz get_pulse_loop
	ret                 ; return (with zero flag set) after 255 iterations with no change

Having successfully proved the concept with the full Arduino board, accompanying breadboard and rats-nest of wires, transferring the whole thing to a standalone circuit on stripboard was dead easy – even easier than the regular instructions for doing that, because the Speccy2010 joystick port already gives us a regulated 5V line that saves us from having to rig one up ourselves on the board.

Thanks to Oleg, Ben and the rest of the Oxford Hack Space crowd for their technical, organisational and moral support while cooking this up!

It all worked splendidly on the night in Eersel, and you’ll be able to witness it in action again if you come along to Ultrachip next month. Go on, you know you want to…

And with everyone’s spirits kept high, it means that when the evening activity kicks off, you have the most awesome audience you could possibly hope for. Big ups to TMC for the video, m0d for the other video which should be surfacing soon, Ziphoid for streaming the gig on SceneSat Radio, and of course Havoc, D-Force and the rest of the Outline team for making it all happen…

Setlist

• 1:51 Gasman – Out Of Neverland
• 6:18 Gasman – Torch Dragon
• 8:41 Celine Dion – My Heart Will Go On
• 10:23 Gasman – Cybernoid’s Revenge
• 14:23 Madonna (arr. TDM + Factor6) – Hung Up
• 20:17 Gasman – Oldskool Crusader
• 23:47 Michael Jackson – Thriller (featuring Okkie)
• 30:30 Purple Motion (arr. TDM + Factor6) – Satellite One

balls, touching

And after all that, I still had some spare energy to do some casual hacking around with sine waves and come up with an entry for the 128 byte intro compo. As you’ll see from the video, 128 byte intros are one of those peculiarly demoscene-ish things that demand a certain frame of mind to be enjoyed properly, to the point where it gets a tad surreal for outsiders. If nothing else, you can certainly count on the Outline audience to provide a soundtrack to a silent production.

balls, touching on Pouët

(…and before you ask, the title does indeed come from an infantile demoscene in-joke about genitalia. I’d actually only planned for there to be one ball, but then one of those fortuitous coding accidents from adding or removing an odd instruction happened, and I knew I had to run with it.)

Download gasman_-_easterbirdie.mp3

Download:

• Easterbirdie (ZX Spectrum .tap format)
• Easterbirdie (MP3 format)

I’m holding back a few of the songs from general release, because they’ll be going towards this month’s exciting musical happening: the Geek Pop virtual festival! Yes, all the greatest musical minds from the worlds of science and technology will be gathered in one place on the internet – and somehow I’ve ended up being one of them, performing on the Comical Flask stage alongside such luminaries as MJ “Hey Hey 16K” Hibbett. And because it’s a virtual festival, you don’t even need to drink beer out of a nasty plastic beaker or walk two miles to the nearest shower. Hurrah! Keep your browsers peeled (or something) at the Geek Pop website for the big unveiling on March 11th, or mosey on down to Wilton’s Music Hall, London on the 10th for the live launch gig.

In the meantime, here’s some almost-as-good-or-equally-good-but-not-as-geeky music I also wrote last month…

Avogadro’s Number by Matt Westcott

Big Conversation by Matt Westcott

In The Future by Matt Westcott

(Looking for the lyrics? Get them at my FAWM profile page)

Burton’s Wagon Wheels (Are Smaller Than They Used To Be) by Matt Westcott

Burtons Wagon Wheels are smaller than they used to be
They’re taking us for suckers at the biscuit factory
The PR guys deny it, but any fool can see
That Burtons Wagon Wheels are smaller than they used to be

Now the marketers at Burtons would have us all believe
That it’s an artefact of questionable childhood memories
And that we have recollections of eating a confection
Disproportionately larger than our hands

But a moment’s contemplation will expose that as a lie
For if it were so, then clearly it would equally apply
To Penguin biscuits, door handles and other random junk
But you never hear anyone complaining that those things have shrunk

And that’s because
Burtons Wagon Wheels are smaller than they used to be
They’re taking us for suckers at the biscuit factory
The PR guys deny it, but any fool can see
That Burtons Wagon Wheels are smaller than they used to be

The Wagon Wheels you get today have a radius suggestive
of the typical dimensions of a Hob-Nob or digestive
It’s a universal standard, that our ancestors have handed
Down through history across the Western world

But we all know that there was one exception to this scheme
‘Cause otherwise, it makes no sense for it ever to have been
A defining characteristic of the Wagon Wheel at all
On which to question our power of recall…

And was there not a line in Orwell’s Nineteen Eighty-Four
About how chocolate rations are reduced from what they were before?
Big Brother claims that they have risen, and by feat of hypnotism
The population takes him at his word

So don’t let us be duped by this dystopian regime
Rise up to fight against the evil biscuit tyranny
And force them to admit the fact that any fool can see:
That Burtons Wagon Wheels are smaller than they used to be

• jasmid on Github
• Online demo

Read on for the complete notes/transcript of the talk (in hopefully more coherent form than the talk itself – next time I promise to spend less time on the flashy demo and more time figuring out exactly what I’m going to say…)

Right now everyone’s jolly excited about the HTML5 audio element. At last we have a standard-compliant way to drop audio clips into web pages that avoids all the gunk with external plugins and replaces it with a simple tag (well, once you’ve fought through the details of which browsers support MP3 versus Ogg anyway). It has a comprehensive API to handle all the details of buffering, programatically pausing, playing and skipping and so on – but one thing it stops short of is being able to generate the audio data on the fly, within the browser.

Why would you want that? Well, I can’t say why you’d want it, but I can tell you what I’m hoping to do with it: I’m involved in the demo scene, a community of programmers, artists and musicians who create digital art – something roughly like music videos, but with visuals generated in real time – and I’m working on a forthcoming website that will showcase those productions. This community originates from the days of the Commodore 64, when people cracked games and added little intro animations to promote themselves, which became more and more elaborate as rival groups tried to outdo each other, until they evolved into full-scale artistic creations and the game cracking side of things took a back seat. And among the artefacts to come out of this community is a hell of a lot of music – we’re talking hundreds of thousands of tracks, all preserved in the native formats of the Commodore 64, and the Amiga, and all sorts of other things. And it would be quite neat to be able to play all of these from within my website.

I’m using this site as an excuse to play around with cool technologies, and at first I figured that this was an ideal job for Amazon EC2 – set up a bunch of instances churning away in the background converting these files to MP3. However, when I started to learn about ways to generate audio in the browser, it made sense to take advantage of that and save myself a whole lot of up-front processing (not to mention bandwidth).

At the forefront of this new development is the Mozilla Audio Data API, available in the latest nightly builds of Firefox. This extends the HTML5 audio API with a few new methods, the central ones being mozSetup – which allows you to initialise an empty audio stream with a specified sample rate and number of channels – and mozWriteAudio, which lets you pass in an array of floats representing some sample data to add to that stream. Like all good up-and-coming browser innovations, we can reasonably assume that once the Mozilla developers have got this API stable enough they’re going to submit it to WHATWG for inclusion in the HTML5 spec – but for the moment, it has somewhat limited adoption. There is a remedy for that though…

At my last Barcamp London, two years ago now, I gave the first public showing of JSSpeccy, my ZX Spectrum emulator written in Javascript, which has been something of a runaway internet hit – and I’ve been somewhat surprised by the number of people taking it seriously, rather than as the crazy pointless hack I built it as (not least, the guy who ripped it off and sold it on the App Store as the first ever iPhone Spectrum emulator, despite it running at about 30% speed *cough*). But one guy who’s picked up the concept of emulation in Javascript and taken it much further than I’d ever dreamed possible is Ben Firshman, who created JSNES, the Javascript SNES NES emulator, featuring a whole host of advanced optimisations and new features, including audio support.

To achieve this, he created the dynamicaudio.js library, which sits on top of Mozilla’s Audio Data API, but also provides an invisible Flash widget for other browsers to fall back upon. Armed with this work, I was able to build the first step towards my goal: jsmodplayer, a player for the MOD music format originally introduced on the Amiga. It’s a rather messy format to implement, with every man and his dog coming up with their own custom extensions to it in a very ad-hoc way, but at its heart it consists of a set of uncompressed wave samples (typically a second or two in length), and a script detailing when to trigger them and at what pitch. Put enough of those trigger events together, throw in some effects like volume control and pitch slide, and you have a song.

Now, as we all know from the Apple versus Adobe tiff, Flash is not exactly universal across the platforms we care about – so we haven’t covered all of our bases yet. However, for certain applications, there’s a possible third path (albeit one that I haven’t properly investigated yet), using another recent browser addition: data: URIs. Unlike typical URLs, which point to some external location that contains the data we want, a data: URI embeds that data directly, as a string of base64 or URL-encoded data. This means that we could generate a string containing a valid WAV file from Javascript (or indeed an MP3 or Ogg file, although generating those from Javascript is a little bit hardcore), and use that as the source of an <audio> element.

This does depend on us being able to generate the audio up-front before starting playback, so it’s arguably not truly ‘real time’ – something like an emulator, which is generating audio in response to user interaction, couldn’t really do this. It’s good enough for our straightforward audio player, though.

For a while there was an unfortunate flaw in this plan: Chrome didn’t currently support WAV as an audio format. The bug tracker ticket relating to this featured some rather flimsy arguments defending this decision, such as “if we support WAV, people will start widely serving audio across the web as uncompressed WAV files” (um… just like everyone on the internet is using BMP files, which are supported by all major browsers, right?). Given the tendency of bug tickets to wander off onto unrelated subjects, it’s hard to tell what the eventual conclusion to this is – but if I’m reading it right, we can happily use WAVs as of Chrome 7.

(At this point, someone rightly mentioned that Internet Explorer imposes a 32K limit on URLs, so that won’t get you much of a wave file – especially with base64 or URL encoding to contend with. As such, all we can really do is hope that IE users will tend to have the Flash option available. Personally, I think it makes a refreshing change that we can even consider IE in our cutting-edge browser hacks once again…)

In fact, there’s another mechanism for feeding data into URLs dynamically, which I’d all but forgotten until I started preparing this talk: if you have a ‘javascript:’ URL which returns a string when executed, that string will be used as the data. This trick was most prominently used in Wolfenstein 5K (long before the wider world caught on to the joys of Javascript size coding contests…), which constructed its display as an XBM image, an obscure text-based format. Before canvas came along, I spent many happy hours trying to replicate that trick with GIF images, discovering along the way that Internet Explorer didn’t like strings containing zero bytes, which sent me down the garden path of constructing valid GIFs containing no zeros. Ah, happy days. In short, I don’t even know if this works at all with <audio>, and even if it does, it’s almost certainly as much of a dead end as it was back in 2004…

One project of mine where I really should have seen the value of generating the audio up-front was Fake Plastic Cubes, a demo I wrote this summer to play around with the size reduction tricks I’d seen coming out of the 10K Apart and JS1k contests, and to try and come up with something audiovisual in as small a size as possible. On the audio side, that meant ditching samples entirely, and doing the synthesis from first principles, building the sound up from plain sine waves – but in a classic case of project management fail, I spent a week building a really wonderful synthesiser framework and rushed everything else at the last minute, meaning that I had no chance to actually make something nice on top of it. As a result, it’s totally unpolished, and the animation keeps stuttering for a split second while it generates the next chunk of audio. It’s only a tiny fraction of the available processor time, but it’s enough to be very, very noticeable. I really should have just generated the entire audio track on startup and then kicked off the visuals – but there was no time for that, or to play around with web workers which would seem to be another potential way to generate audio as a background process…

I also didn’t have time to compose a decent soundtrack, or experiment with the synth enough to come up with interesting sounds, or implement a vaguely sensible way to enter musical notes (as a dodgy workaround, I remapped the names of the notes in the scale to their positions on a QWERTY keyboard and prodded out a melody from those). Fortunately, I didn’t have to let a good routine go to waste: a week or so back, I encountered Sergi Mansilla’s jsmidi project, which provides an easy way to create standard MIDI files from Javascript. However, it turns out that MIDI support in browsers has more or less stagnated – while wave audio goes from strength to strength, MIDI is still stuck in the world of OS-specific plugins – so there was a clear opportunity for some Javascript synthesiser love there. And so I’ve come up with jasmid, a JS library for reading MIDI files and playing them back through its own audio synthesis engine.

A MIDI file consists of a simple header, followed by a list of tracks – each of which is a list of timestamped events, which are usually note on/off events but could be a tempo change, change of instrument or various other things. The timestamps are actually a bit weird: you’d expect them to be given in something like microseconds, but they’re actually expressed as a number of ‘ticks’, where the MIDI file specifies a particular number of ticks per beat, and the tempo of the song is given in beats per second, which can change over time just to add further confusion. Ultimately it probably does make sense, because it means you can accurately use any rational number (within reason) as a tempo, and that’s handy for professional MIDI equipment that has to keep exact time for extended periods – it’s just an initial hurdle that you have to get over. Once you’ve got that in place, a MIDI synthesiser boils down to a set of generator functions that can emit audio waves for as long as you tell them to, and a main loop which picks events off the queue, running the generators until it’s time to process the next event.

For this first release, the generated sounds are not particularly interesting – just plain sine waves with a bit of attack/decay volume control applied – but now that we’ve got the initial framework in place it should be relatively straightforward to add more diverse sounds, and the synth engine should hopefully be flexible enough to support effects like harmonics and reverb.

Finally, as a glimpse of what’s in store for in-browser audio creation in the future, keep an eye on the Mozilla Rainbow project, which provides APIs for capturing audio and video from microphones / webcams. For the last few years I’ve been taking part in February Album Writing Month, a song writing community where collaborations over the internet play a major part – perhaps it won’t be too long until we’re doing that over a Google-Docs-style online equivalent of Audacity / GarageBand…?

A quick heads-up that I’ll be playing my first ever proper not-just-an-open-mic gig this Thursday night as part of the Date Horse comedy and music night at the Vauxhall Griffin, London. Come along for some silly songs about Paris Hilton’s pet monkey and much more (and RSVP on the Facebook event)…

So far it only implements a subset of the possible sample effects, and it demands a very fast Javascript engine – luckily all the new breed of browsers are pretty competitive at that now. Even so, unless your CPU is an absolute behemoth, it’ll probably struggle to keep up – the audio output is fixed at 44100Hz, and that’s rather a lot of numbers for Javascript to crunch, especially when the MOD file gets up to 16 or more channels. Which, amusingly enough, is exactly the situation we had back when we were using Gravis Ultrasounds on 386es. Hurrah for progress!

Update 2010-06-08: Oops. In the process of testing how Safari 5 shapes up, I discovered a rather silly oversight: the audio buffering routine was set up to never use more than 10% of CPU. Now that I’ve fixed it, it turns out that Chrome and Safari (at least) have no trouble at all playing Jugi’s Dope theme in its 28-channel glory. (However, taking the brakes off the buffering does mean that we can’t reliably pause the audio any more. A small price to pay, I think you’ll agree.)

(continues for approx 1500 more lines)

Anyone typing it in in its entirety would be rewarded with this:

Download midibeep_minute_waltz.mp3

Not bad for an evening’s work. Mind you, I did take an ever so teeny shortcut, by writing a Ruby program to convert a MIDI file to BEEP format. (Any .mid file will do, although ones with a single instrument will survive the rather primitive selective-note-butchering process better. Oh, and anything much longer than this one will exceed the 48K Spectrum memory…) And now you can try it out too:

• Midibeep source/downloads at Github
• Midibeep Windows build (thanks to Karl McNeil)
• Minute Waltz (TAP, 38K)

Update 2010-05-26: Karl McNeil has adapted Midibeep into a variant called Mid2ASM, which outputs an assembler listing rather than Basic – this enables the data to be packed much more efficiently, paving the way for altogether longer pieces of music. Download Mid2ASM (453K, Windows EXE included)

Update 2010-06-02: Another update from Karl, featuring a Windows GUI, more space-saving tweaks, and embedding the output in a Basic REM statement. Download Mid2ASM v2 (3.4Mb)

Update 2011-04-09: Karl McNeil has released the last version of Mid2ASM for a while, version 3.2 – featuring primitive importing from .sid .psg and .wav, and the choice of Basic or assembly output. The source archive also contains the command-line version, midibeep2.

This makes it a good excuse for some experimentation with generative music. The secret is in the scale – it’s equivalent to playing only the black notes on a piano, and presumably has roots in oriental music (I previously rediscovered it while working on Haiku). To make it into something like a proper demo, rather than just a throwaway routine, I added a bit of subtle progression Cyberpunks Unity style, so it drifts in and out of randomness as the graphical effects change. It even has a proper ending…

In recent months Yerzmyey has been pushing for the revival of the 16K Speccy as a platform, so I’m pleased to announce that this demo is – so we believe – the third ever demo to run on it.

• Download Spectrumori-on (TAP, 4Kb)
• Spectrumori-on on Pouet