PVM. Data Compression: RLE

Transcription

1 PVM Data Compression: RLE

2 Run Length Encoding RLE is very simple compression algorithm In order to compress, it must make some assumptions about input data The GQU compression algorithm assumed certain pairs appear more often than others RLE assumes that long runs of the same bytes occur often RLE is used in some image formats: drawn images do have long stretches of the same colour (TGA, PCX, fax machines)

3 Run Length Encoding aaaaabbbbccccccccaaaaaaaaddd How to make use of this structure to compress the data? Why not encode each series xxx...x } {{ } n as This yields nx 5a4b8c8a3d

4 Compressing Lonely Bytes abcd How to encode this using RLE? Can t we just compress this to abcd? This is rather dubious: it would mean that there is no input data that would be compressed to something larger RLE would be usable on all data: in the worst case, the compressed form would be as large as the original data This breaks a fundamental principe of compression What s the problem? Did we break maths?

5 Compressing Lonely Bytes abcd Text must be encoded using ASCII/Unicode/... character ASCII code a 97 b 98 c 99 d 100 abcd is represented by the bytes The decompression algorithm will interpret this as Repeat b 97 times Repeat d 99 times

6 Compressing Lonely Bytes Decompressor cannot make difference between Byte representing how many times next byte needs to be repeated Byte representing actual data Decompressor expects that compressed data is structured as pairs of bytes n, B, meaning repeat B n times. abcd needs to be compressed to or, in bytes (decimal) or, in bytes (hexadecimal) 1a1b1c1d

7 Shortcomings of RLE We found the Achilles heel of RLE It can compress runs of bytes well It utterly fails on solitary bytes Maths were right all along Huzzah for maths!

8 Variations Many variations possible For example, how to encode n Currently, we encode n as a single byte Two problems n = 0 is useless: inefficient n can t be greater than 255: longer series to be split up

9 Variations: Dealing with n = 0 n = 0 is useless We waste a perfectly good code We can adapt the algorithm so as to make n = 0 useful One possibility: interpret n = 0 as n = 256, so that you can support runs of 256 long Other possibility: use n = 0 to deal with solitary bytes by saying that n = 0 means that the following two bytes are solitary

10 Variations: Dealing with n s Maximum Value We could use more bytes for n 1 byte: n can go up to bytes: n can go up to bytes: n can go up to Is this interesting? Using 1: good when there are many short runs Using 4: good when there are at least a few very long runs

11 Variations: Dealing with n s Maximum Value We could use variable length n n = 255 could mean that the next byte should be interpreted as a count-byte and added to the current n For example, consider text aaa...a bbb...b } {{ }} {{ } 50 (260) In our original encoding, this would become (in decimal) } {{ } 50 a } {{ } 255 b 5 98 }{{} 5 b In our variable length n encoding, we would get } {{ } 50 a } {{ } (255+5) b

12 Variations: Variable Length n MIDI and UT8 Support integers of arbitrary length Bits of the integers are split in groups of 7 bits Each encoded byte contains a first group of 7 bit. The eighth bit is used to indicate whether the following byte also belongs to the same integer Encoding in binary: bits needed Only one byte needed: means integer ends here

13 Variations: Variable Length n MIDI and UT8 Support integers of arbitrary length Bits of the integers are split in groups of 7 bits Each encoded byte contains a first group of 7 bit. The eighth bit is used to indicate whether the following byte also belongs to the same integer Encoding in binary: bits needed Two bytes needed: means integer continues in next byte

14 Variations: Variable Length n MIDI and UT8 Support integers of arbitrary length Bits of the integers are split in groups of 7 bits Each encoded byte contains a first group of 7 bit. The eighth bit is used to indicate whether the following byte also belongs to the same integer Encoding in binary: bits needed Three bytes needed: