42 Years of programming – The Amiga

I’m doing a retrospective of 42 years on programming, concentrating on how the various computer differ from the current ones. Today I will talk about the Amiga.

I never owned an Amiga, nor did I ever program one. Still, this was for me a very influential computer for me, it was the machine I desired when I had a Commodore 64, and the other 68K computer when I had a Macintosh. More generally, I always considered the Amiga hardware like a trilobite, or a Horseshoe crab, a strange design, another branch of computer evolution. This fascination led me to implement a JavaScript decoder for Amiga images (ILBM). Here is what made the Amiga so interesting for me.

The Chipset

The Amiga used a Motorola 68000 CPU, like the Macintosh or the Atari ST, what made it special were the various chips that handled a good part of the sound and graphics processing. It is tempting to make the analogy with a modern GPU or a sound-card, but the Amiga chipset was different: the chips were specialised in different tasks, and the were connected in a different way. The Agnus chip controlled access to the chip memory, the memory which the chipset could access (as opposed to the fast RAM, which only the CPU could access). Agnus had two sub-components, Blitter and Copper, which were specialised in bit-blit operations, and updating registers depending on the screen refresh timing. The Denise chip would generate the screen signal. The Paula chip would control sound, but also the floppy drive and the serial ports.

Planars Graphics

These days, most frame-buffers are in chunky format, that is, all the bits for a given pixel are grouped together. So for instance if a pixel as a depth of 16 bits, the pixel will be represented by 2 bytes in memory, and the following pixel will be the next two bytes. The Amiga used planar graphics, where each pixel was represented by multiple pixel planes, and the pixel would be one bit in each pixel plane. This had multiple advantages:

• It allowed bit depth that were not powers of two, for instance 3 bit depth.
• It simplified bit-blit operations, as transparency and collision information would be in a single plane.
• It allowed to change the buffer depth, for instance the top screen could be 1 bit (black/white) controls, and the lower part a colour image.
• As each plane can be compressed independently, algorithms like PackBit work better

Weird Graphics Modes

You would think that having odd bit depth would just yield special palette sizes, right? Wrong. The original chipset had a 32 registers that could hold a 12 bit colour (4 bits per RGB channel), but one graphic mode used 6 bits per pixel instead of the necessary 5. The additional bit was used to select the Halfbrite mode, which allowed to select the half brightness variant of any of colour in the palette.
A stranger graphical mode was HAM (Hold and Modify). The Amiga’s graphic circuit was originally made to work with a YUV colour representation. In this model, it is common to have multiple pixel share the hue (U + V components), so it made sense to have hardware that could flip only one channel between pixels. In the end, the Amiga worked in RGB, but the circuit logic remained. In HAM-6, the two top bits act as control bits: one control code selects a palette colour with the index encoded in the following 4 bits, the three others hold the colour of the previous pixel and modify it by replacing the value of one channel, red, green or blue, with the value contained in the 4 following bits. Later versions of the chipset (AGA) introduced HAM-8 mode.

Interlaced Graphics

While the graphical abilities of the Amiga where amazing, and it was used for video work like adding sub-titles, because the graphic system could sync to an external source, other features were less successful. In particular, the maximum screen resolution (640 × 512) was only reachable in interlaced mode. In this mode, each screen refresh would only update half of the lines on the screen. The result was flickering, which would hurt the eyes a lot, and so if you did not have a monitor that could compensate for the flickering, this mode was unusable. This was particularly problematic as this mode was the best suited for productivity applications.

Modules

While the PC could basically beep, the Amiga had some impressive sound capacities: stereo 8-bit PCM with two channels for left/right stereo output. The chipset was able to play a full sample with no CPU intervention. In fact the CPU could crash and the music would still play. What was interesting is the way music was represented: module files. In some way, this could be seen as the music equivalent of vector graphics: instructions on how to build the actual sound by combining pre-existing elements, in this case samples. The mod format was different from MIDI in the sense that it contained its samples, and did not require any external hardware for playback. The format is still popular in the demo-scene.

Commodore Amiga 1000 personal computer with 1081 RGB monitor. (1985) CC BY-SA 3.0