AppleRLEEncoder (MultiShow 2.43)

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

ch.randelshofer.media.quicktime
Class AppleRLEEncoder

java.lang.Object
  ch.randelshofer.media.quicktime.AppleRLEEncoder

public class AppleRLEEncoder
extends java.lang.Object
extends java.lang.Object

Implements the run length encoding of the Apple QuickTime Animation (RLE) format.

An RLE-encoded frame has the following format:

 Header:
 uint32 chunkSize

 uint16 header 0x0000 => decode entire image
               0x0008 => starting line and number of lines follows
 if header==0x0008 {
   uint16 startingLine at which to begin updating frame
   uint16 reserved 0x0000
   uint16 numberOfLines to update
   uint16 reserved 0x0000
 }
 n-bytes compressed lines

The first 4 bytes defines the chunk length. This field also carries some other unknown flags, since at least one of the high bits is sometimes set.
If the overall length of the chunk is less than 8, treat the frame as a NOP, which means that the frame is the same as the one before it.
Next, there is a header of either 0x0000 or 0x0008. A header value with bit 3 set (header & 0x0008) indicates that information follows revealing at which line the decode process is to begin:

 2 bytes    starting line at which to begin updating frame
 2 bytes    unknown
 2 bytes    the number of lines to update
 2 bytes    unknown

If the header is 0x0000, then the decode begins from the first line and continues through the entire height of the image.
After the header comes the individual RLE-compressed lines. An individual compressed line is comprised of a skip code, followed by a series of RLE codes and pixel data:

  1 byte     skip code
  1 byte     RLE code
  n bytes    pixel data
  1 byte     RLE code
  n bytes    pixel data

After the skip byte is the first RLE code, which is a single signed byte. The RLE code can have the following meanings:

equal to 0: There is another single-byte skip code in the stream. Again, the actual number of pixels to skip is 1 less than the skip code. Therefore, the maximum skip byte value of 255 allows for a maximum of 254 pixels to be skipped.
equal to -1: End of the RLE-compressed line
greater than 0: Run of pixel data is copied directly from the encoded stream to the output frame.
less than -1: Repeat pixel data -(RLE code) times.

The pixel data has the following format:

8-bit data: Pixels are handled in groups of four. Each pixel is a palette index (the palette is determined by the Quicktime file transporting the data).
If (code > 0), copy (4 * code) pixels from the encoded stream to the output.
If (code < -1), extract the next 4 pixels from the encoded stream and render the entire group -(code) times to the output frame.
16-bit data: Each pixel is represented by a 16-bit RGB value with 5 bits used for each of the red, green, and blue color components and 1 unused bit to round the value out to 16 bits: xrrrrrgg gggbbbbb. Pixel data is rendered to the output frame one pixel at a time.
If (code > 0), copy the run of (code) pixels from the encoded stream to the output.
If (code < -1), unpack the next 16-bit RGB value from the encoded stream and render it to the output frame -(code) times.
24-bit data: Each pixel is represented by a 24-bit RGB value with 8 bits (1 byte) used for each of the red, green, and blue color components: rrrrrrrr gggggggg bbbbbbbb. Pixel data is rendered to the output frame one pixel at a time.
If (code > 0), copy the run of (code) pixels from the encoded stream to the output.
If (code < -1), unpack the next 24-bit RGB value from the encoded stream and render it to the output frame -(code) times.
32-bit data: Each pixel is represented by a 32-bit ARGB value with 8 bits (1 byte) used for each of the alpha, red, green, and blue color components: aaaaaaaa rrrrrrrr gggggggg bbbbbbbb. Pixel data is rendered to the output frame one pixel at a time.
If (code > 0), copy the run of (code) pixels from the encoded stream to the output.
If (code < -1), unpack the next 32-bit ARGB value from the encoded stream and render it to the output frame -(code) times.

References:
http://multimedia.cx/qtrle.txt

Version:: 1.0 2011-01-05 Created.
Author:: Werner Randelshofer

Constructor Summary
`AppleRLEEncoder()`

Method Summary
`void`	`writeDelta16(javax.imageio.stream.ImageOutputStream out, short[] data, short[] prev, int offset, int length, int step)` Encodes a 16-bit delta frame.
`void`	`writeDelta24(javax.imageio.stream.ImageOutputStream out, int[] data, int[] prev, int offset, int length, int step)` Encodes a 24-bit delta frame.
`void`	`writeDelta32(javax.imageio.stream.ImageOutputStream out, int[] data, int[] prev, int offset, int length, int step)` Encodes a 32-bit delta frame.
`void`	`writeKey16(javax.imageio.stream.ImageOutputStream out, short[] data, int offset, int length, int step)` Encodes a 16-bit key frame.
`void`	`writeKey24(javax.imageio.stream.ImageOutputStream out, int[] data, int offset, int length, int step)` Encodes a 24-bit key frame.
`void`	`writeKey32(javax.imageio.stream.ImageOutputStream out, int[] data, int offset, int length, int step)` Encodes a 32-bit key frame.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail