Run Length Encoder/Decoder

EE113D Project
Authors: Imran Hoque Yipeng Li Diwei Zhang

Introduction What is RLE?

Compression technique
Represents data using value and run length Run length defined as number of consecutive equal values e.g

1110011111

RLE

130215
Values Run Lengths

Introduction - Applications

Useful for compressing data that contains repeated values

e.g. output from a filter, many consecutive values are 0.

Very simple compared with other compression techniques Reversible (Lossless) compression
decompression is just as easy

Introduction - Applications

Image Compression JPEG

Run Length Encoder!

Introduction

Compression effectiveness depends on input Must have consecutive runs of values in order to maximize compression
Best case: all values same

Can represent any length using two values Compressed data twice the length of original!!

Worst case: no repeating values

Should only be used in situations where we know for sure have repeating values

Encoder - Algorithm

Start on the first element of input Examine next value

If same as previous value

Keep a counter of consecutive values Keep examining the next value until a different value or end of input then output the value followed by the counter. Repeat

If not same as previous value

Output the previous value followed by 1 (run length. Repeat

Encoder Matlab Code

% Run Length Encoder % EE113D Project

function encoded = RLE_encode(input)

my_size = size(input); length = my_size(2); run_length = 1; encoded = []; for i=2:length if input(i) == input(i-1) run_length = run_length + 1; else encoded = [encoded input(i-1) run_length]; run_length = 1; end end

if length > 1 % Add last value and run length to output encoded = [encoded input(i) run_length]; else % Special case if input is of length 1 encoded = [input(1) 1]; end

Encoder Matlab Results

>> RLE_encode([1 0 0 0 0 2 2 2 1 1 3]) ans = 1 1 0 4 2 3 1 2 3 >> RLE_encode([0 0 0 0 0 0 0 0 0 0 0]) ans = 0 11 1

>> RLE_encode([0 1 2 3 4 5 6 7 8 9])

ans = 0 1 1 7

1 1

1 8

2 1

1 9

3 1

Encoder

Input from separate .asm file

In the form of a vector
e.g. array .word 4,5,5,2,7,3,6,9,9,10,10,10,10,10,10,0,0

Output is declared as data memory space

Examine memory to get output Originally declared to be all -1.

Immediate Problem
Output size not known until run-time (depends on input size as well as input pattern)

Cannot initialize variable size array

Encoder

Solution
Limit user input to preset length (16) Initialize output to worst case (double input length 32) Initialize output to all -1s (were only handling positive numbers and 0 as inputs) Output ends when -1 first appears or if length of output equals to worst case

Encoder DSP Code

;******************************************************************* ;EE113D Final Project (encoder) ; ;Run Length Encoder: Shortens a series of input data by representing ;consecutive repeated numbers as the repeated number, followed by ;the number of repetitions. ; ;(Written by: Yi-peng Li, Diwei Zhang, Imran Hoque) ; .setsect ".text", 0x500,0 ;Executible code in ".text" ;section will begin at 0x500 ;in program memory ;Numbers to be sorted will ;begin at 0x800 in data memory ;Data section begins ;Reads input values and initialize output ;Executible code section begins. .set 1 .set 15 ;Initialize a counter starting at the number 1 ;Initialize a counter starting at the number 15

.setsect ".data", 0x800,1

.data .copy "e_inputs.asm" .text count1 count2

Encoder DSP Code

AR6 = #array AR3 = #array ;AR6 points to the input data location ;AR3 points to the next input data location

A = *AR3+ A = *AR3 AR5 = A

A = *AR6 AR0 = A AR4 = #output AR2 = #count2

;AR5 represents the actual number stored ;in the memory address AR3 points to ;(the actual number represented in the input) ;AR0 represents the actual number stored ;in the memory address AR6 points to ;AR4 points to the output data location ;AR2 keeps track of how much of the input ;data has been read ;loop1 initializes the count of AR1 to '1'

loop1

AR1 = #count1

;Register AR1 is used to keep track of the ;number of repeated inputs in succession ;loop2 reads through the input data, and keeps ;track of the number of consecutive inputs

loop2 TC = (AR0 != AR5) A = *AR6+ A = *AR3+

;Compares the number stored in AR5 with the ;number stored in AR0 ;Increment the pointer AR6 ;Increment the pointer AR3

Encoder DSP Code

A = *AR3 AR5 = A A = *AR6 AR0 = A if (TC) goto loop3 A = *AR1+ if (*AR2- != 0) goto loop2 A = *AR2+ ;Re-initialize AR5 ;Re-initialize AR0 ;Break loop if next number different ;else continue counting ;Stop encoder if count of AR2 reaches zero ;Leave count of AR2 at zero ;loop3 stores the encoded input, followed by ;its repeated count into the output array loop3 A = *AR6A = *AR6 *AR4+ = A A = AR1 *AR4+ = A A = *AR6+ if (*AR2- != 0) goto loop1 stop nop goto stop .end ;Point back to the last repeated number ;Add the repeated number to output ;Add the count of repeated number to output ;Move pointer back to where it left off ;Stop encoder if count of AR2 reaches zero ;infinite loop

Encoder DSP Results

Input: 4,5,5,2,7,3,6,9,9,10,10,10,10,10,10,0,0 Output: 4,1,5,2,2,1,7,1,3,1,6,1,9,2,10,6,0,2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
Valid Output Output Ends Here

Best Case: Input: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 Output: 0,16,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 Worst Case: Input: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 Output: 0,1,1,1,2,1,3,1,4,1,5,1,6,1,7,1,8,1,9,1,10,1,11,1,12,1,13,1,14,1,15,1

Decoder Matlab Code

% Run Length Decoder % EE113D Project % The input to this function should be the output from Run Length Encoder, % which means it assumes even number of elements in the input. The first % element is a value followed by the run count. Thus all odd elements in % the input are assumed the values and even elements the run counts. % function decoded = RLE_decode(encoded) my_size = size(encoded); length = my_size(2); index = 1; decoded = []; % iterate through the input while (index <= length) % get value which is followed by the run count value = encoded(index); run_length = encoded(index + 1); for i=1:run_length % loop adding 'value' to output 'run_length' times decoded = [decoded value]; end % put index at next value element (odd element) index = index + 2; end

Decoder Matlab Results

>> RLE_decode([0 12]) ans = 0 0 0 0 0 0 0 0 0 0 0 0

>> RLE_decode([0 1 1 1 2 1 3 1 4 1 5 1]) ans = 0 1 2 3 4 5

>> RLE_decode(RLE_encode([0 0 3 1 4 4 5 6 10])) ans = 0 0 3 1 4 4 5 6 10

Decoder DSP Code

;******************************************************************* ;EE113D Final Project (decoder) ; ;Run Length Encoder: Takes as its input, a string of data encoded ;according the the run length encoder algorithm, and outputs it ;as the decoded string of data originally input to the encoder. ;(Written by: Yi-peng Li, Diwei Zhang, Imran Hoque) .setsect ".text", 0x500,0 .setsect ".data", 0x800,1 .data .copy "d_inputs.asm" .text count2 .set 14 ;Executible code in ".text section will begin at 0x500 ;in program memory ;Numbers to be sorted will begin at 0x800 in data memory ;Data section begins ;Get input values and initialze outputs ;Executible code section begins. ;Initialize a counter starting at the number 14 ;AR6 points to the input data location ;AR3 points to the next input data location ;AR5 keeps track of the number of repetitions

AR6 = #array AR3 = #array A = *AR3+ A = *AR3 AR5 = A

Decoder DSP Code

AR4 = #output AR2 = #count2 ;AR4 points to the output data location ;AR0 keeps track of how much of the input ;data has been read ;loop2 reads through the input data to the decoder loop2 if (*AR5- != 0) goto loop3 ;Keep outputting the current input number until ;the following count of that number reaches zero ;Else continue reading thru input ;Increment twice to get next number in output

A = *AR6+ A = *AR6+ A = *AR3+ A = *AR3+ ;Increment twice to get the count of that number A = *AR3 AR5 = A ;Re-initialize AR5 if (*AR2- != 0) goto loop2 ;Stop encoder if count of AR2 reaches zero goto stop ;loop3 stores the decoded output, by expanding the number of repeated inputs loop3 A = *AR6 *AR4+ = A goto loop2 stop nop goto stop .end ;Add the repeated number to output

;infinite loop

Decoder DSP Results

Input: 0,16 Output: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 Input: 1,5,0,11 Output: 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0

Conclusion

Results obtained from DSP match theoretical results as well as Matlab results

Limitations:
Does not handle negative numbers Input to encoder limited to 16 numbers in this implementation

Future Improvements
Variable input lengths Allocate memory for output real-time