I know I shouldn’t bother reading internet conversation around any news related to multimedia technology. And if I do read it, I shouldn’t waste any effort getting annoyed about them. But here are some general corrections:

• ALAC is not in the same league as — nor is it a suitable replacement for — MP3/AAC/Vorbis or any other commonly used perceptual audio codec. It’s not a matter of better or worse; they’re just different families of codecs designed for different purposes.
• Apple open sourced ALAC, not AAC– easy mistake, though there’s nothing to ‘open source’ about AAC (though people can, and will, argue about its absolute ‘open-ness’).
• There’s not much technical room to argue between ALAC and FLAC, the leading open source lossless audio compressor. Both perform similarly in terms of codec speeds (screamingly fast) and compression efficiency (results vary slightly depending on source material).
• Perhaps the most frustrating facet is the blithe ignorance about ALAC’s current open source status. While this event simply added an official “open source” status to the codec, ALAC has effectively been open source for a very long time. According to my notes, the ALAC decoding algorithm was reverse engineered in 2005 and added into FFmpeg in March of the same year. Then in 2008, Google — through their Summer of Code program — sponsored an open source ALAC encoder.

From the multimedia-savvy who are versed in these concepts, the conversation revolves around which would win in a fight, ALAC or FLAC? And who between Apple and FFmpeg/Libav has a faster ALAC decoder? The faster and more efficient ALAC encoder? I contend that these issues don’t really matter. If you have any experience working with lossless audio encoders, you know that they tend to be ridiculously fast to both encode and decode and that many different lossless codecs compress at roughly the same ratios.

As for which encoder is the fastest: use whatever encoder is handiest and most familiar, either iTunes or FFmpeg/Libav.

As for whether to use FLAC or ALAC — if you’ve already been using one or the other for years, keep on using it. Support isn’t going to vanish. If you’re deciding which to use for a new project, again, perhaps choose based on software you’re already familiar with. Also, consider hardware support– ALAC enjoys iPod support, FLAC is probably better supported in a variety of non-iPod devices, though that may change going forward due to this open sourcing event.

For my part, I’m just ecstatic that the question of moral superiority based on open source status has been removed from the equation.

Code-wise, I’m interested in studying the official ALAC code to see if it has any corner-case modes that the existing open source decoders don’t yet account for. The source makes mention of multichannel (i.e., greater than stereo) configurations, but I don’t know if that’s in FFmpeg/Libav.

Background
Cinepak is a video codec that saw widespread use in the early days of digital multimedia. To date, we have cataloged 4 variants of Cinepak in the wild. This distinction is useful when trying to write and maintain an all-in-one decoder. The variants are:

1. The standard type: Most Cinepak data falls into this category. It decodes to a modified/simplified YUV 4:2:0 planar colorspace and is often seen in AVI and QuickTime/MOV files.
2. 8-bit greyscale: Essentially the same as the standard type but with only a Y plane. This has only been identified in AVI files and is distinguished by the file header’s video bits/pixel field being set to 8 instead of 24.
3. 8-bit paletted: Again, this is identified by the video header specifying 8 bits/pixel for a Cinepak stream. There is essentially only a Y plane in the data, however, each 8-bit value is a palette index. The palette is transported along with the video header. To date, only one known sample of this format has even been spotted in the wild, and it’s classified as NSFW. It is also a QuickTime/MOV file.
4. Sega/FILM CPK data: Sega Saturn games often used CPK files which stored a variant of Cinepak that, while very close the standard Cinepak, couldn’t be decoded with standard decoder components.

So, a flexible Cinepak decoder has to identify if the file’s video header specified 8 bits/pixel. How does it distinguish between greyscale and paletted? If a file is paletted, a custom palette should have been included with the video header. Thus, if video bits/pixel is 8 and a palette is present, use paletted; else, use greyscale. Beyond that, the Cinepak decoder has a heuristic to determine how to handle the standard type of data, which might deviate slightly if it comes from a Sega CPK file.

The Fifth Variant?
Now, regarding this fifth variant– the reason this issue came up is because of that aforementioned heuristic. Basically, a Cinepak chunk is supposed to store the length of the entire chunk in its header. The data from a Sega CPK file plays fast and loose with this chunk size and the discrepancy makes it easy to determine if the data requires special handling. However, a handful of files discovered on a Macintosh game called “The Journeyman Project: Pegasus Prime” have chunk lengths which are sometimes in disagreement with the lengths reported in the containing QuickTime file’s stsz atom. This trips the heuristic and tries to apply the CPK rules against Cinepak data which, aside from the weird chunk length, is perfectly compliant.

Here are the first few chunk sizes, as reported by the file header (stsz atom) and the chunk:

size from stsz = 7880 (0x1EC8); from header = 3940 (0xF64)
size from stsz = 3940 (0xF64); from header = 3940 (0xF64)
size from stsz = 15792 (0x3DB0); from header = 3948 (0xF6C)
size from stsz = 11844 (0x2E44); from header = 3948 (0xF6C)

Hey, there’s a pattern here. If they don’t match, then the stsz size is an even multiple of the chunk size (2x, 3x, or 4x in my observation). I suppose I could revise the heuristic to state that if the stsz size is 2x, 3x, 4x, or equal to the chunk header, qualify it as compliant Cinepak data.

Of course it feels impure, but software engineering is rarely about programmatic purity. A decade of special cases in the FFmpeg / Libav codebases are a testament to that.

What’s A Variant?
Suddenly, I find myself contemplating what truly constitutes a variant. Maybe this was just a broken encoder program making these files? And for that, I assign it the designation of distinct variation, like some sort of special, unique showflake?

Then again, I documented Magic Carpet FLIC as being a distinct variant of the broader FLIC format (which has an enormous number of variants as well).

2 years ago at LinuxTag, I gave a fairly general presentation regarding FFmpeg and open source multimedia hacking (I just noticed that the main page still uses a photo of me and my presentation). I theorized that one problem our little community has when it comes to attracting new multimedia hacking talent is that the field seems scary and mathematically unapproachable. I have this perception that this is what might happen when a curious individual wants to get into multimedia hacking:

I wonder how multimedia compression works?

Well, I’ve heard that everyone uses something called MPEG for multimedia compression.

Further, I have heard something about how MPEG is based around the discrete cosine transform (DCT).

Let’s look up what the DCT is, exactly…

Clever photo cribbed from a blog actually entitled Discrete Cosine

At which point the prospective contributor screams and runs away from the possibility of ever being productive in the field.

Now, the original talk discussed how that need not be the case, because DCT is really a minor part of multimedia technology overall; how there are lots and lots of diverse problems in the field yet to solve; and how there is room for lots of different types of contributors.

The notion of DCT’s paramount importance in the grand scheme of multimedia compression persists to this day. While reading the HTML5 spec development mailing list, Sylvia Pfeiffer expressed this same line of thinking vis-à-vis Theora:

Even if there is no vendor right now who produces an ASIC for Theora, the components of the Theora codec are not fundamentally different to the components of other DCT based codecs. Therefore, AISCs [sic] that were built for other DCT based codecs may well be adaptable by the ASIC vendor to support Theora.

This prompted me to recall something I read in the MPEG FAQ a long time ago:

MPEG is a DCT based scheme?

The DCT and Huffman algorithms receive the most press coverage (e.g. “MPEG is a DCT based scheme with Huffman coding”), but are in fact less significant when compared to the variety of coding modes signaled to the decoder as context-dependent side information. The MPEG-1 and MPEG-2 IDCT has the same definition as H.261, H.263, JPEG.

A few questions later, the FAQ describes no less than 18 different considerations that help compress video data in MPEG; only the first one deals with transforms. Theora is much the same way. When I wrote the document about Theora’s foundation codec, VP3, I started by listing off all of the coding methods involved: DCT, quantization, run length encoding, zigzag reordering, predictive coding, motion compensation, Huffman entropy coding, and variable length run length Booleans. Theora adds a few more concepts (such as encoding the large amount of stream-specific configuration data).

I used to have the same idea, though: I was one of the first people to download On2′s VpVision package (the release of their VP3 code) and try to understand the algorithm. I remember focusing on the DCT and trying to find DCT-related code, assuming that it was central to the codec. I was surprised and confused to find that a vast amount of logic was devoted to simply reversing DC coefficient prediction. At the end of a huge amount of frame reconstruction code was a small, humble call to an IDCT function.

What I would like to get across here is that Theora is rather different than most video codecs, in just about every way you can name (no, wait: the base quantization matrix for golden frames is the same as the quantization matrix found in JPEG). As for the idea that most DCT-based codecs are all fundamentally the same, ironically, you can’t even count on that with Theora– its DCT is different than the one found in MPEG-1/2/4, H.263, and JPEG (which all use the same DCT). This was likely done in On2′s valiant quest to make everything about the codec just different enough from every other popular codec, which runs quite contrary to the hope that ASIC vendors should be able to simply re-use a bunch of stuff used from other codecs.

I happened to be looking back over the ZMBV (DOSBox) video codec today. The last time I looked at ZMBV, I thought of a slightly better method for computing error between 2 blocks. My method involved summing the number of pixels that differed between 2 blocks. Michael promptly did me one better by implementing a "0^th-order entropy approximator". When I took a closer look at the method today, I thought it was functionally identical to my algorithm. It is XOR'ing 2 vectors of pixels, maintaining a histogram of the results (i.e., the number of pixel pairs whose bitwise XOR was 1, 2, etc.), then summing the numbers in the histogram array.

Except not quite. A closer examination of the summation revealed "sum+= score_tab[histogram[i]]", and it occurs on elements 1..255. What is score_tab[]? Why, it's:

(ZMBV_BLOCK = 16, M_LN2 = ln(2)).

I want pictures. Pictures help me a lot. I don't do a lot of heavy duty math lifting and am not up to date on modern tools. But I figured that in this day and age, there must be plenty of graphing tools on the web. This is the top Google hit for "graph a function" and it offers the following graph:

So that's interesting. Now it's time to reconcile this with Kostya's helpful description of the method:

First of all, Michael’s code explained: he used table to estimate entropy (well, base term from the Shannon’s theory of information) of the XOR’ed block. In other words, the higher count of the same symbols, the lower entropy and the better compression of the block. 0-th order means he didn’t use context to estimate entropy.

I think I might be starting to understand. My method was predicated on trying to generate an error vector that had as many 0s as possible grouped into strings of 8 bits. I.e., I was trying to maximize 0 bytes without regard to what the non-zero bytes contained. Michael's method is also concerned with maximizing 0 bytes but also cares about what is happening in those non-zero bytes. That graph indicates that the method prefers values at the top and bottom of the unsigned 8-bit range. Why would that be? I suspect that it may have something to do with the fact that the higher and lower values have longer strings of repeating symbols (e.g., 1 = 00000001; 255 = 11111111).

Or I might be completely wrong.

Sorry if this is kindergarten-level stuff to some of you readers. But you know I like to use this space as a personal technical journal for working out these lessons.

Moving right along, I got to another set of QuickTime samples that were filed under 'gain' video codec. This appears to be another meta-codec and this is what it looks like in action:

I decided to post this pretty screenshot here since I didn't feel like creating another Wiki page for what I perceive to be not a "real" video codec. The foregoing CumulusQuickTimeSlideshow.mov sample comes from here and actually contains 5 separate trak atoms: 2 define 'jpeg' data, 1 is 'gain', 1 is 'dslv' and the last is 'text', which defines ASCII strings containing the filenames on the bottom of the slideshow. I have no idea what the dslv atom is for, but something, somewhere in the file defines whether this so-called alpha gain effect will use a cross fade (as seen with the Cumulus shapes) or if it will use an Iris transitional effect (as seen in the sample na_visit03.mov here).

So much about the QuickTime format remains a mystery.

No, that's not entirely true. Some video codecs operate on RGB video natively. A majority of modern codecs use some kind of YUV colorspace. We will get to that. Since many programmers are familiar with RGB pixel formats, let's use that as a starting point.

RGB Colors

To review, computers generally display RGB pixels. These pixels have red (R), green (G), and blue (B) components to them. Here are the various combinations of R, G, and B components at their minimum (0) and maximum (255/0xFF) values:

YUV Colors
If you are used to dealing with RGB colors, YUV will seem a bit unintuitive at first. What does YUV stand for? Nothing you would guess. It turns out Y stands for intensity. U stands for blue and V stands for red. U is also denoted as C_b and V is also denoted as C_r. So YUV is sometimes written as YC_bC_r.

Here are the various combinations of Y, U, and V components at their minimum (0) and maximum (255/0xFF) values:

Y	U/ Cb	V/ Cr	color	notes
0x00	0x00	0x00
0x00	0x00	0xFF
0x00	0xFF	0x00
0x00	0xFF	0xFF
0xFF	0x00	0x00		full green
0xFF	0x00	0xFF
0xFF	0xFF	0x00
0xFF	0xFF	0xFF
0x00	0x80	0x80		full black
0x80	0x80	0x80
0xFF	0x80	0x80		full white

So, all minimum and all maximum components do not generate intuitive (read: similar to RGB) results. In fact, all 0s in the YUV colorspace result in a dull green rather than black. That last point is useful to understand when a video is displaying a lot of green block errors-- that probably means that the decoder is skipping blocks of data completely and leaving the underlying YUV data as all 0.

Further Reading:

• YC_bC_r at the MultimediaWiki
• YC_bC_r Formats category page at the MultimediaWiki

Problem statement: Many multimedia formats -- typically older formats -- need to deal with color palettes alongside compressed video. There are generally three situations arising from paletted video codecs:

1. The palette is encoded in the video codec's data stream. This makes palette handling easy since the media player does not need to care about ferrying special data between layers. Examples: Autodesk FLIC and Westwood VQA.
2. The palette is part of the transport container's header data. Generally, a modular media player will need to communicate the palette from the file demuxer layer to the video decoder layer via an out-of-band/extradata channel provided by the program's architecture. Examples: QuickTime files containing Apple Animation (RLE) or Apple Video (SMC) data.
3. The palette is stored separately from the video data and must be transported between the demuxer and the video decoder. However, the palette could potentially change at any time during playback. This can provide a challenge if the media player is designed with the assumption that a palette would only occur at initialization. Examples: AVI files containing paletted video data (such as MS RLE) and Wing Commander III MVE.

Transporting the palette from the demuxer layer to the decoder layer is not the only be part of the battle. In some applications, such as FFmpeg, the palette data also needs to travel from the decoder layer to the video output layer, the part that creates a final video frame to either be displayed or converted. This used to cause a problem for the multithreaded ffplay component of FFmpeg. The original mechanism (that I put into place) was not thread-safe-- palette changes ended up occurring sooner than they were supposed to. The primary ffmpeg command line conversion tool is single-threaded so it does not have the same problem. xine is multi-threaded but does not suffer from the ffplay problem because all data sent from the video decoder layer to the video output layer must be in a YUV format, thus paletted images are converted before leaving the layer. I'm not sure about MPlayer these days, but when I implemented a paletted format (FLIC), I rendered the data in higher bit depths in the decoder layer. I would be interested to know if MPlayer's video output layer can handle palettes directly these days.

I hope this has been educational from a practical multimedia hacking perspective.

A specific example of VQ in 3D graphics hardware is the Sega Dreamcast with its PowerVR2 graphics hardware. Textures can be specified in a number of pixel formats including, but not limited to, RGB555, RGB565, and VQ. In the VQ mode, a 256-entry vector codebook is initialized somewhere in video RAM. Each vector is 8 bytes large and specifies a 2x2 block of pixels in either RGB555 or RGB565 (can't remember which, or it might be configurable). For the texture in video RAM that is specified as VQ, each byte is actually an index into the codebook. Instant 8:1 compression, notwithstanding the 2048-byte codebook overhead which can be negligible depending on how many textures leverage the codebook and how large those textures are.

RoQ operates in a YUV 4:2:0 space. However, it was developed for a game released in the late 1994/early 1995 timeframe. Back then, cutting edge video was 640x480 at 256 colors or maybe 64K colors. and it was not feasible to take a large video frame and convert the entire thing from YUV -> RGB 30, 24, or even 15 times per second. However, RoQ's design solved some of these problems.

The first RoQ frame contains a full vector codebook. The codebook contains 2x2 pixel vectors and 4x4 pixel vectors. The remainder of the encoded stream contains codes for tiling these vectors in order to reconstruct an image. Further, interframes can take advantage of motion compensation. Frames also have the option of transmitting new vectors to be used in the codebook.

An important design decision is that the vectors are decoded into the codebook in advance of decoding and can be converted to any format necessary. I.e., if the graphic hardware demanded RGB555 or RGB565, as was probably the original assumption for the codec, the decoder can convert all the vectors from YUV 4:2:0 to the appropriate colorspace during the file initialization. Then it can simply tile using these vectors without concerning itself with further colorspace conversion unless replacement vectors show up in successive frames.

However, since it is a proper YUV colorspace, FFmpeg just decodes and outputs the raw YUV 4:2:0 data.

Wired ran a portion of the codec's creator's diary (one Graeme Devine) that describes how imperative it was to squeeze performance out of the encoder. When you have a lot of video to encode and you wish to meet a shipping deadline, AND you are encoding using VQ, performance tweaks count:

A technical Daily Report. Sorry, it's the way I'm thinking right now.

Well, I didn't think that I could meet my goal of knocking a second out of drawing 100 dense quad structures, but I did. Twice. Tonight it's down to 5.7 seconds. A total of two seconds faster.

What does this mean? A dense quad is around 10 times larger than a typical frame chunk quad - it contains essentially lossless data. These dense quads make good profiling data, since they overload the overhead in the decoder nicely.

Most of the speedups came by fixing 486 CPU stalls. The 486 will "stall" and wait for a cycle if the previous machine instruction is somehow required for the next. Fixing stalls is tricky. Writing stall-free code is almost impossible. You have to think below the assembly-code level and think about how the CPU is dealing with data.

An observation regarding the inversely proportional complexities of the encoder and the decoder:

Verrry, verry tricky right now. The encoder is now getting as complex as a MPEG encoder, which is making decoding simpler (as opposed to MPEG). Basically cutting down drastically on memory usage per frame for the same rez frame.

VQ houses at the time were obsessive about getting ahold of the fastest hardware on the market at the time (things like high-end 486 computers or very early Pentiums):

Encoding is going slowly because if we add machines it crashes. Those super-fast HP systems would make a real difference right now - we need some number crunchers online asap!

...and...

Encoding video is one of the few problems you can throw fast hardware at and get results.

Today we got in 3 HP 735/125 systems. They run fast, not just fast in fact, but stinkingly disgustingly fast. Around three times the speed of a 90-MHz Pentium, probably faster if they were not network and disk i/o bound. It's the fastest piece of hardware I've ever used. Between the Envoy and the 735, this has been a great week for new toys. The 735 machines will allow 11h to ship much sooner.

And here's the part where he must have added the code to convert the YUV 4:2:0 vectors to RGB24 when unpacking, along with the appropriate copying code:

Tonight I added true 24-bit support for 640-by-320-by-30fps at 24-bit from a 150K/second drive. Of course, you'll need a Pentium system for this to work, but it looks unbelievable. 24-bit support gives us better-than-TV color depth and a picture that finally looks non-blocky, non-pixelly, and about as good as it gets. This makes The 11th Hour the first game with true full-motion video software playback at 30fps and the first 24-bit fmv on a home-class computer.

After all the R&D, these were the final specs decided for the shipping version of The 11th Hour:

At first we supported all the way from 32-bit color down to 8-bit color, but, after surveying the video cards sold, installed bases, and how the game looks, we're only going to support those with a 16-bit or 24-bit DAC at 640-by-320 or 320-by-160.

SVQ1 is a stark contrast to our last subject, Cinepak. SVQ1 does not store its codebooks in the encoded video bitstream. Rather, the codebooks are a hardwired characteristic of the coding scheme. That's actually a really good thing considering that the algorithm is a hierarchical multistage vector quantizer.

"Whoa! Just when I was getting over my aversion to the words 'vector' and 'quantizer' strung together, they throw in 'hierarchical' and 'multistage'." Don't worry, it's also pretty simple even though it sounds complicated. "Hierarchical", in this context, simply means that a block of pixels is broken down into smaller blocks of pixels. In SVQ1, the block size starts at 16x16. The encoder may decide to encode a block at that size, or slice it in half, into 2 16x8 blocks, and code each of those individually. The encoder may further subdivide the blocks to obtain 8x8, 8x4, 4x4, and 4x2 sizes.

The "multistage" word refers to the fact that SVQ1 has several layers, or stages, of codebooks that can be combined in order to reconstruct a given vector. In fact, for each block size from 4x2 up through 8x8, there are 6 stages of codebooks for each size, and each codebook contains 16 vectors.

SVQ1 has one trick up its sleeve that I have never seen used anywhere else so far: Vector mean removal. Again, this may sound fancy, but all it means is to average all the numbers in a vector and subtract the average from each number. If all of the numbers in the vector are relatively similar, the mean-removed vector will have rather small components and thus be more efficient to code.

Remember how a major problem in VQ deals with matching vectors from a source image to the best possible vector from a generated codebook? This problem is exacerbated in SVQ1 due to the layers of codebooks that the encoder must evaluate in combination with the hierarchy. The encoder must remove the mean for a vector of samples and encode the mean using the sum of between 0 and 6 vectors from different layers of codebooks, or decide to split the block in half and repeat the process, or find some combination of hierarchical encoding combined with codebook sequences, and then move on to the next vector.

SVQ1 interframes can also take advantage of motion vectors and the residual between a block from the previous frame and the current frame is encoded with the same intraframe hierarchical multistage method.

It all sounds like a lot of trouble to encode, but the reward was that relatively slow machines from the 1998-1999 timeframe could easily play back, e.g., 480x212 video on CPUs that would still struggle with MPEG-type data at a similar resolution, and the files were feasibly distributable via the dialup-dominated internet.

Where do the codebooks come from? As mentioned, the codebooks are a hardcoded component of the SVQ1 coding scheme. I strongly suspect (or would like to think) that the codebooks were constructed as a result of a long and arduous design phase that involved countless pieces of sample media drawn from numerous diverse genres of material. So out of the 2 classic VQ problems (finding optimal codebooks and matching source material to the codebooks), at least that's one less problem that the encoder needs to worry about. I, for one, am thankful for that since SVQ1 is, to date, the only encoder I have written for the FFmpeg project. Encoding the codebooks would also incur huge overhead in the final encoded bitstream.

SVQ1 has a few weaknesses, to be sure (or "trade-offs" to be neutral about it). I never appreciated the fact the various planes are stored separately. All the Y data is encoded in the stream, followed by all the U data, and then the V data. This means that the entire frame must be decoded before any of it may be processed (e.g., converted to RGB) before display. Owing to its large vector size (16x16) and also its native colorspace (YUV 4:1:0, where a 4x4 block shares one U and one V sample), I can understand why it would be implausible to chop the data into macroblock-type units. However, it might have been nice for the bitstream header to encode relative offsets to the start of the U and V data segments. A decoder could have made use of this to optimize for things like slice dispatch.

Another problem (that I perceive, and I'm pretty sure the guru agrees with me on this point) is that SVQ1 uses a breadth-first algorithm for traversing the vector hierarchy, vs. a depth-first algorithm. It's a technical nitpick, sure, and I can't remember all the details. But I strongly recall that it was a headache for coding.

Through it all, SVQ1 is still one of my favorite codecs.

Further Reading:

• Description of the Sorenson Video 1 codec at the MultimediaWiki