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
