Fixed Bit Length Encoding

A byte is 8 bits and can have a value from 0-255. But let's pretend your data only uses the values 0-7. In this case, you don't need a whole 8 bits to represent each data item. You only need 3 bits. Fixed Bit Length Encoding will compress your data by packing it into the minimum number of bits needed to represent all possible values for your data. Using our 3-bit example, let's say we have this sequence of data:

7 1 2 4 7 7 7 1 1 1 2 3 4.

In binary, that's:

00000111, 00000001, 00000010, 00000100, 00000111, 00000111, 00000111,
00000001, 00000001, 00000001, 00000010, 00000011, 00000100

Those left 5 bits are always zero, so we can chop them off. Let's compress this data using Fixed Bit Length Encoding (3-bit). 00000111 will become 111, 00000001 will become 001, etc. to give us this:

11100101, 01001111, 11111001, 00100101, 0011100x

That's some nice savings!

4-bit Encoding

The most common type of Fixed Bit Length Encoding is 4-bit or "nibble" encoding. 4-bit encoding is really easy to work with. Each byte will have exactly two data items: the left nibble is one data item, the right nibble is another. Here is one way to pull the two data items out of a byte that is 4-bit encoded:

    ;left nibble
    lda data, y                ;read a byte from our data stream
    lsr
    lsr
    lsr
    lsr                        ; right shift four times to get the left nibble
    jsr do_stuff                

    ;right nibble
    lda data, y                ;read a byte from our data stream
    and #$0F                   ; ANDing with #$0F zeros out the left side, 
    jsr do_stuff

5-bit Encoding Example

4-bit encoding works out nice because two data items fit cleanly into one byte. But other Fixed Bit Length Encodings will have data items bleed into more than one byte. Let's look at an example.

Dragon Warrior 2 uses Fixed Bit Length Encoding (5-bit) to compress its text (modified and coupled with a dictionary, but nevermind). Using 5 bits allows the data to have values in the range 0-31 ($00-$1F). Let's say we have this sequence of data:

$02, $17, $16, $1F.

In binary, that's:

00000010, 00010111, 00010110, 00011111

Let's compress this using 5-bit encoding (ie, chop off the left 3 bits and smoosh them together):

00010101 11101101 1111xxxx

Notice that some of our data items bleed across two bytes:

[00010][101   11][10110][1   1111]xxxx

This makes decompressing the data more complicated. To decompress we will need to:

• read 2 bytes from the data stream at a time instead of one
• keep track of the bit position within the first byte
• have a different bit-extraction routine for each possible bit position

Code Example

Let's look at a code example that will decompress data encoded with Fixed Bit Length Encoding (5-bit):

; if we have the following values we want to compress:
;    14, 08, 07, 00, 1C, 06, 1E, 1F
;    01, 0F, 0C, 1F, 1F, 1F, 00, 13
;
; this is how they look in binary: 
;    00010100, 00001000, 00000111, 00000000, 00011100, 00000110, 00011110, 00011111
;    00000001, 00001111, 00001100, 00011111, 00011111, 00011111, 00000000, 00010011
;
;below are these values compressed in Fixed Bit Length Encoding (5bit):
  
compressed_data:
    .byte %10100010, %00001110, %00001110, %00011011, %11011111
    .byte %00001011, %11011001, %11111111, %11111100, %00010011

 
;;;;;;;;;;;;;;;;;;;;;;;
;
;  Reads two bytes from the data stream.
;  Called everytime bit_position crosses from byte1 to byte2
;       When that happens, the old byte2 becomes the new byte1
;       and a new byte2 is read from the data stream.
;
get_next_2_bytes:
    lda compressed_data, y
    sta byte1
    iny
    lda compressed_data, y
    sta byte2
    rts

;;;;;;;;;;;;;;;;;;;;;;;;;
;
;  This routine is called after every 5-bit value is extracted from the data.
;  It finds the starting point for the next 5-bit value
;
update_bit_position:
    lda bit_position
    clc
    adc #$05            ;next bit position is 5 bits later
    and #$07            ;keep the value between 0 and 7
    sta bit_position
    cmp #$05            ;in the case of updating 0->5, 1->6, or 2->7,
                        ;we are still in the first byte.
                        ;We don't need to change anything
    bcs @skip
    jsr get_next_2_bytes ;bit position updates of 3->0, 4->1, 5->2, 6->3, or 7->4
                         ;indicate that we have jumped from byte1 to byte2, 
                         ;so we need to make byte2 the new byte1 
                         ;and grab the next byte from the data stream (the new byte2)
@skip:
    rts

;;;;;;;;;;;;;;;;;;;;;;;
;
;  depending on our bit position, we will enter this subroutine from a different spot. 
;  we will use the [[RTS Trick]] to enter this subroutine (avoids a ridiculous 8-way branch)
;   
;  temp1 is a copy of byte1,
;  temp2 is a copy of byte2
;  register A holds the value of byte1
;
bitposition0:        ;[xxxxx]xxx xxxxxxxx   shift right 3 times to get our 5 bits
    lsr
bitposition1:        ;x[xxxxx]xx xxxxxxxx   shift right 2 times, AND with #$1F
    lsr
bitposition2:        ;xx[xxxxx]x xxxxxxxx   shift right once, AND with #$1F
    lsr
bitposition3:        ;xxx[xxxxx] xxxxxxxx   AND with #$1F
    jmp done
bitposition7:        ;xxxxxxx[x xxxx]xxxx   roll left 4 times, AND with #$1F
    asl temp2
    rol temp1
bitposition6:        ;xxxxxx[xx xxx]xxxxx   roll left 3 times, AND with #$1F
    asl temp2
    rol temp1
bitposition5:        ;xxxxx[xxx xx]xxxxxx   roll left 2 times, AND with #$1F
    asl temp2
    rol temp1
bitposition4:        ;xxxx[xxxx x]xxxxxxx    roll left once, AND with #$1F
    asl temp2
    rol temp1
    lda temp1
done:
    and #$1F
    rts

bit_pos_table:
    .word bitposition0-1    ;subtract 1 from the address because we are doing the [[RTS Trick]]    
    .word bitposition1-1    ;(ie push the address-1 onto the stack and rts to it)
    .word bitposition2-1
    .word bitposition3-1
    .word bitposition4-1
    .word bitposition5-1
    .word bitposition6-1
    .word bitposition7-1

;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;  this subroutine take an address from bit_pos_table, pushes it on the stack, and rts to it
;  this trick saves us from having a long 8-way conditional branch
;  (see [[RTS Trick]] for more details)
;
extract_5bits:
    lda bit_position
    asl
    tax
    lda bit_pos_table+1, x
    pha
    lda bit_pos_table, x
    pha

    lda byte2        ;make temporary copies of byte1 and byte2
    sta temp2
    lda byte1
    sta temp1        ;byte1 is in A when we start extracting
   
    rts                  ;return to the address we just pushed

main:                   ;use this as your reset code to try it out
    lda #$00
    sta bit_position
    sta ram_index       ;init variables
   
    tay
    jsr get_next_2_bytes ;grab the first 2 bytes from the data stream

@loop:   
    jsr extract_5bits    ;pull out the next 5-bit value
    ldx ram_index
    sta $200, x          ;output the result to RAM
    inx
    stx ram_index

    jsr update_bit_position
 
    cpx #$10             ; loop 16 times (because we are extracting 16 bytes.)
    bne @loop
forever:
    jmp forever