Run Length Encoder/Decoder

1. Run Length Encoder/Decoder EE113D Project Authors: Imran Hoque Yipeng Li Diwei Zhang

2. 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 1 3 0 2 1 5 RLE Values Run Lengths

3. 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

4. Introduction - Applications • Image Compression – JPEG Run Length Encoder!

5. 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 • Worst case: no repeating values • Compressed data twice the length of original!! • Should only be used in situations where we know for sure have repeating values

6. 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

7. 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

8. 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 1 >> RLE_encode([0 0 0 0 0 0 0 0 0 0 0]) ans = 0 11 >> RLE_encode([0 1 2 3 4 5 6 7 8 9]) ans = 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 1

9. 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

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

11. 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 .setsect ".data", 0x800,1 ;Numbers to be sorted will ;begin at 0x800 in data memory .data ;Data section begins .copy "e_inputs.asm" ;Reads input values and initialize output .text ;Executible code section begins. count1 .set 1 ;Initialize a counter starting at the number 1 count2 .set 15 ;Initialize a counter starting at the number 15

12. Encoder – DSP Code AR6 = #array ;AR6 points to the input data location AR3 = #array ;AR3 points to the next input data location A = *AR3+ A = *AR3 AR5 = A ;AR5 represents the actual number stored ;in the memory address AR3 points to ;(the actual number represented in the input) A = *AR6 AR0 = A ;AR0 represents the actual number stored ;in the memory address AR6 points to AR4 = #output ;AR4 points to the output data location AR2 = #count2 ;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) ;Compares the number stored in AR5 with the ;number stored in AR0 A = *AR6+ ;Increment the pointer AR6 A = *AR3+ ;Increment the pointer AR3

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

14. 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… 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 Valid Output Output Ends Here

15. 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

16. 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

17. 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 ;Executible code in ".text“ section will begin at 0x500 ;in program memory .setsect ".data", 0x800,1 ;Numbers to be sorted will begin at 0x800 in data memory .data ;Data section begins .copy "d_inputs.asm" ;Get input values and initialze outputs .text ;Executible code section begins. count2 .set 14 ;Initialize a counter starting at the number 14 AR6 = #array ;AR6 points to the input data location AR3 = #array ;AR3 points to the next input data location A = *AR3+ A = *AR3 AR5 = A ;AR5 keeps track of the number of repetitions

18. Decoder – DSP Code AR4 = #output ;AR4 points to the output data location AR2 = #count2 ;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 A = *AR6+ ;Else continue reading thru input A = *AR6+ ;Increment twice to get next number in output 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 ;Add the repeated number to output goto loop2 stop nop goto stop ;infinite loop .end

19. 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

20. 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