KR20180006659A - HANGUL ON UTF-8 character set COMPRESSION Method and Appratus Thereof - Google Patents

Abstract

According to the present invention, in social network service (SNS) of Korea, the Unicode including Hangeul ranges from U+AC00 to U+D7AF on SNS, and a header of a UTF-8 byte is 1110. The Hangeul appears frequently in Korean-based SNS services, so a shorter compressed header bit is mapped to 10. In this case, a header of a byte 1 does not have any benefit or cause any damage to other characters that do not appear. However, for a region including the Hangeul, a header bit is replaced to 10 in a first high byte to obtain a gain of 2 bits, and the 1 to 3 bits are further compressed while the header bit is combined with 4 bits of a residual bit of the byte 1 so as to obtain a benefit of 3 to 5 bits in total. Of course, it is designed that for a byte 2, 2 to 4 benefits can be obtained, and for a 3 to 6 byte, there is always the gain of 2 bits. In the UTF_8 code system, according to the range of the value of the Unicode, the header bit of the byte 1 changes, the 2 to 6 byte can be read variably, and from the byte 2 onward, 10 is regularly placed before the most significant bit.

Description

[0001] The present invention relates to a method and apparatus for concentrating a Hangul message through 3 to 5 bit compression on BYTE 1 and a 2- to 4- Method and Appratus Thereof}

Short text compression, SNS compression, bit operation

Short text compression, SNS compression, bit operation

Detailed description of specific embodiments for carrying out the invention

Detailed description of specific embodiments for carrying out the invention

Detailed description of specific embodiments for carrying out the invention

In UTF_8 code system, byte 2 ~ byte 6 can be read variably by changing the header bit of byte 1 according to the range of Unicode value as follows,

From byte 2 onward, it is a code that adds "10" regularly before the most significant bit.

In the table below, the part marked with x is the Unicode pointer First code point ~ Last code point

The binarized bits indicate the contents in order.

For example, U + 07FF is a total of 11 bits with 111 1111 1111 in binary,

110 xxxxx 10 xxxxxx in the form of 110 11111 10 111111 and converted to 2-byte UTF code

It is a principle.

bits of First Last Bytes in Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 코드 포인트 코드 포인트 코드 포인트 sequence 7 U + 0000 U + 007F One 0xxxxxxx 11 U + 0080 U + 07FF 2 110xxxxx 10xxxxxx 16 U + 0800 U + FFFF 3 1110xxxx 10xxxxxx 10xxxxxx 21 U + 10000 U + 1FFFFF 4 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 26 U + 200000 U + 3FFFFFF 5 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 31 U + 4000000 U + 7FFFFFFF 6 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

In accordance with another aspect of the present invention, the present invention provides a UTF-8

By converting the header bits (0, 110, 1110, 11110, 111110, 1111110) of byte 1 defined in the code into bits of a specific pattern as shown in Table 2 below and removing the most significant 2 bits " .

The header bit in byte 1 of UTF-8. 코드 포인트 코드 포인트 Compressed header bits of byte 1 0 U + 0000 U + 007F 0 110 U + 0080 U + 07FF 110 1110 U + 0800 U + FFFF 10 11110 U + 10000 U + 1FFFFF 1110 111110 U + 200000 U + 3FFFFFF 11110 1111110 U + 4000000 U + 7FFFFFFF 111110

However, in the present invention

Especially, in Korea, the range of Unicode including Hangul is (U + AC00 ~ U + D7A3), and the header of UTF-8 byte is "1110" in Korea. In Korean based SNS service, And maps the shorter compressed header bits to " 10 ". This mapping can actually be applied to characters that correspond to U + 8000 to U + FFFF.

In this case, as shown in Table 3 below, the header of BYTE 1 does not benefit other characters that do not appear on the road (of course, there is no harm), but the header bit is set to "10" As shown in Table 4, after combining the 4 bits of the remaining bits of the byte 1, one bit is further compressed to obtain a total of 3 bits.

The header bit in byte 1 of UTF-8. 코드 포인트 코드 포인트 Compressed header bits of byte 1 0 U + 0000 U + 007F 0 110 U + 0080 U + 07FF 110 1110 U + 0800 U + 7FFF 1110 1110 U + 8000 U + FFFF 10 11110 U + 10000 U + 1FFFFF 11110 111110 U + 200000 U + 3FFFFFF 111110 1111110 U + 4000000 U + 7FFFFFFF 1111110

A closer look at this process

In case of Hangul, Unicode is U + AC00 ~ U + D7AF,

Binary numbers are in the range of 1010 1100 00000000 to 1101 0111 10101111,

Especially, the part to watch carefully is the point where the most significant 4 bits of each Hangul Unicode start with "1".

More generally, in the U + A000 ~ U + DFFF region including the Korean Unicode,

The four most significant bits of Unicode are "1010", "1011", "1100", and "1101".

On the other hand, according to the UTF-8 standard rule, the Hangul in which the Unicode is located at U + AC00 ~ U + D7AF is configured as follows according to the UTF8 code rule.

1110 1010 10 110000 10 000000 ~ 1110 1101 10 011110 10 101111.

Now, the header bits constituting BYTE 1 are changed to compressed header bits in the same manner as in Table 3, and then BYTE 1 is compressed by combining the remaining bits of BYTE 1, and then the most significant 2 bits of the bytes are removed and compressed As follows.

1110 1010 10 110000 10 000000 ~ 1110 1101 10 011110 10 101111

===>

10 1010 110 000 000000 1101 011 110 101 111 ~ 10.

At this time, from the compression result, the intermediate compression result of each Hangul code is

10 1 010 110000 000000 ~ 10 1 101 011110 101111.

101 XXX in the case of the first Hangul, such as 101 must start with.

Therefore, when the compressed header bit is compressed to "10" for U + AC00 to U + D7AF, the BYTE 1 portion always starts with "101"

If this part is further changed to "101" ==> "10", it will start again with "10" even if 1 bit is further compressed as shown below.

10 1 010 110000 000000 ~ 10 1 101 011110 101111.

1 0 010 110000 000000 ~ 1 0 101 011110 101111.

Now, from the above results, if we look at 3 bits after being compressed to "10 " as shown below,

1 0 010 110000 000000 ~ 1 0 101 011110 101111.

In the case of Hangul, the 4 bits following the header bit 1110 of the most significant byte of the UTF-

Since there are only four "1010", "1011", "1100", and "1101"

There are only four types of "010", "011", "100" and "101". In AC00 to D7AF,

Since A and D are only C, D, F and 0, 1, 2, 3, 4, 5, 6, and 7, respectively, the number of cases is less than that of B and C.

Accordingly, "0" and "10" are assigned to "1011" corresponding to B and "1100" corresponding to C, and "110" and "111" There are more compressible types.

010 ==> 110

011 ==> 0

100 ==> 10

101 ==> 111

Of course, the above mapping can be adjusted according to the code that appears most often.

100 ==> 110

101 ==> 10

011 ==> 0

010 ==> 111

May be mapped as shown in FIG.

This will be compressed as shown below. There is no gain in further compression when starting with A and D.

1 0 010 110000 000000 ~ 1 0 101 011110 101111.

1 0 111 110000 000000 ~ 1 0 111 011110 101111.

If you start with B, you can add 2 more bits as shown below.

1 0 011 ==> 10 0

If we further examine the compression of byte 1 in the U + 0800 ~ U + FFFF area other than the Hangul area

In the case of U + 8000 to U + 9fff,

Following the most significant bit "1110 ", the lower four bits start with" 1000 ", "1001"

In the case of U + E000 to U + FFFF,

Since the most significant bit "1110 ", the lower four bits start with" 1110 ", &

100 "," 101 "," 110 ", and" 1 "are assigned to each of the three bits starting with" 1 " "111"

"1110" (compressed header) + "1000" ==> "1110" + "100"

"1110" (compressed header) + "1001" ==> "1110" + "101"

"1110" (compressed header) + "1110" ==> "1110" + "110"

"1110" (compressed header) + "1111" ==> "1110" + "111"

In the case of U + 8000 to U + 9fff and in the case of U + E000 to U + FFFF

 You can compress 1 bit by 1 byte.

In the remaining U + 0800 to U + 7fff area, all the bits start from "0000" (0) to "0111" (7), so 4 bits are added to the compressed header (1110) .

In byte 1, there is no gain in compression above. Similarly, in the case of the header bits 11110, 111110, and 1111110 of BYTE 1, the compressed header bits remain unchanged, and the remaining bits of BYTE 1 are also retained, so that there is no gain in compression in BYTE 1.

 In this case, however, the compression effect exists (ie, when byte 1 of UTF-8 is retained, but when the byte 2 through byte 6 are composed, the uppermost bit "10" of the " 10 "

In summary, the compression effect of BYTE 1 in U + 0800 ~ U + FFFF areas where they are located from the viewpoint of the characters (Korean, Japanese, Chinese) is great.

Also U + 0080 ~ U + 00FF  For areas, BYTE 1 of  Additional compression is possible,

This area is a part of the U + 0080 to U + 7FF area and the header bit of BYTE 1 starts with "110". The area after the "10" in bold in the area below is the BYTE 2 area.

U + 0080 ~ U + 008F: 110 000 10 10 00 0000 ~ 110 000 10 10 00 1111

U + 0090 ~ U + 009F: 110 000 10 10 01 0000 ~ 110 000 10 10 01 1111

U + 00A0 to U + 00AF: 110 000 10 10 10 0000 to 110 000 10 10 10 1111

U + 00B0 ~ U + 00BF: 110 000 10 10 11 0000 ~ 110 000 10 10 11 1111

U + 00C0 ~ U + 00CF: 110 000 11 10 00 0000 ~ 110 000 11 10 00 1111

U + 00D0 to U + 00DF: 110 000 11 10 01 0000 to 110 000 11 10 01 1111

U + 00E0 ~ U + 00EF: 110 000 11 10 10 0000 ~ 110 000 11 10 10 1111

U + 00F0 to U + 00FF: 110 000 11 10 11 0000 to 110 000 11 10 11 1111

For the 5 bits following the surface 110, it can be seen that the fourth most significant bit is always "1 ", thus removing this bit and further compressing one bit in BYTE1. And if the start bit of BYTE 2 equally removes the "10" of the two most significant bits,

In other words, In the U + 0080 ~ U + 00FF area, BYTE 1 can compress 3 bits by compressing 2 bits from 1 bit BYTE 2.

U + 0080 ~ U + 008F: 110 000 0 00 0000 ~ 110 000 0 00 1111

U + 0090 ~ U + 009F: 110 000 0 01 0000 ~ 110 000 0 01 1111

U + 00A0 to U + 00AF: 110 000 0 10 0000 to 110 000 0 10 1111

U + 00B0 ~ U + 00BF: 110 000 0 11 0000 ~ 110 000 0 11 1111

U + 00C0 to U + 00CF: 110 000 1 00 0000 to 110 000 1 00 1111

U + 00D0 to U + 00DF: 110 000 1 01 0000 to 110 000 1 01 1111

U + 00E0 ~ U + 00EF: 110 000 1 10 0000 ~ 110 000 1 10 1111

U + 00F0 to U + 00FF: 110 000 1 11 0000 to 110 000 1 11 1111

Therefore, it is possible to increase the efficiency of BYTE 1 by adjusting and mapping the compressed header according to the language characteristics according to the range of Unicode as follows.

Table 4 below is a table summarizing the above process,

The header bit in byte 1 of UTF-8. 코드 포인트 코드 포인트 Compression of Byte 1 (first byte) Compressed header bits of byte 1 After the header bit of Byte 1 Final compression result of Byte 1 Number of compressed bits Remarks 0 U + 0000 U + 007F 0 xxxxxxx 0xxxxxxx 0 No change 110 U + 0080 U + 00FF 110 000 1 x 110000x One 110 Next, in the 5 bits, it can be seen that the fourth most significant bit is always "1 ", and therefore this bit is removed to add 1 bit in BYTE1 110 U + 0100 U + 07FF 110 xxxxx 110xxxxx 0 No change 1110 U + 0800 U + 7FFF 1110 0xxx (0 to 7) 1110 0xxx 0 No change 1110 U + 8000 U + 8FFF 1110 1000 (8) 1110 100 One Since the top of the 4 bits always starts with "1" after the header bit of Byte 1,
After removing "1", it is reassigned to 3 bits starting with 1, which is 100, 101 respectively, 1110 U + 9000 U + 9FFF 1110 1001 (9) 1110 101 One Since the top of the 4 bits always starts with "1" after the header bit of Byte 1,
After removing "1", it is reassigned to 3 bits starting with 1, which is 100, 101 respectively, 1110 U + A000 U + AFFF 10 1010 (A) 10 110 3 Since the most significant 4 bits following the header bit of BYTE 1 are always "1", the most significant "1" is removed and the remaining 3 bits are mapped to "110", "0", "10" 1110 U + B000 U + BFFF 10 1011 (B) 10 0 5 Since the most significant 4 bits following the header bit of BYTE 1 are always "1", the most significant "1" is removed and the remaining 3 bits are mapped to "110", "0", "10" 1110 U + C000 U + CFFF 10 1100 (C) 10 10 4 Since the most significant 4 bits following the header bit of BYTE 1 are always "1", the most significant "1" is removed and the remaining 3 bits are mapped to "110", "0", "10" 1110 U + D000 U + DFFF 10 1101 (D) 10 111 3 Since the most significant 4 bits following the header bit of BYTE 1 are always "1", the most significant "1" is removed and the remaining 3 bits are mapped to "110", "0", "10"
1110 U + E000 U + EFFF 1110 1110 (E) 1110 110 One Since the top of the 4 bits always starts with "1" after the header bit of Byte 1,
After removing "1 ", it is reallocated to 3 bits starting with 1, which is 110 and 111 respectively, 1110 U + F000 U + FFFF 1110 1111 (F) 1110 111 One Since the top of the 4 bits always starts with "1" after the header bit of Byte 1,
After removing "1 ", it is reallocated to 3 bits starting with 1, which is 110 and 111 respectively, 11110 U + 10000 U + 1FFFFF 11110 xxx 11110xxx 0 No change 111110 U + 200000 U + 3FFFFFF 111110 xx 111110xx 0 No change 1111110 U + 4000000 U + 7FFFFFFF 1111110 x 1111110x 0 No change

Now, we will explain the additional compression method of BYTE 2 in Hangul.

In the case of BYTE 2, from U + AC00, which is the Unicode point of Hangul to U + D7AF,

AC00 ==> 1010 1100 0000 0000 and converting it to UTF8, it will appear as below.

1110 1010 10 1100 00 10 00 0000

BYTE 1 is compressed according to Table 4 above,

The BYTE 2 part,

Considering that the first 8 bits of the Unicode point are from AC to D7,

AC, AD, AE, AF

B0, B1, B2, ..., BF

C0, C1, C2, ..., CF

D0, D1, D2, D3, D4, D5, D6, and D7.

In other words,

AC == > 1010 (A) 1100 (C)

AD == > 1010 (A) 1101 (D)

AE == > 1010 (A) 1110 (E)

AF == > 1010 (A) 1111 (F)

C, D, E, and F occupy 4 bits following the most significant 2 bits of the second byte, i.e., "10 ".

In this case, after removing the most significant 2 bits "10" of the second byte, the most significant bit starts with "11" in the next 4 bits, so that "11" is further removed. That is, in the following Unicode pointer U + AC00

In UTF8 code, the compression result of BYTE 1 is 10110, the compression of BYTE 2 is as described above, and the compression of BYTE 3 is finished by removing the most significant 2 bits of "10". In other words,

1110 1010 10 1100 00 10 00 0000

(BYTE 1) (BYTE 2) (BYTE 3)

   1 0110 00 00 00 0000 ==> 10110 0000 000000 That is, the 24-bit Hangul is represented by 15 bits with 9 bits reduced.

A similar case appears between D0 and D7,

D0 == > 1101 (D) 0000 (0)

D1 == > 1101 (D) 0001 (0)

D2 == > 1101 (D) 0010 (0)

D3 == > 1101 (D) 0011 (0)

D4 == > 1101 (D) 0100 (0)

D5 == > 1101 (D) 0101 (0)

D6 == > 1101 (D) 0110 (0)

D7 == > 1101 (D) 0111 (0)

Since the next 4 bits of the most significant 4 bits always start with "0", one more bit can be further compressed by removing "0".

For example, U + D7AF, the Unicode pointer of the last character in Hangul

D7AF ==> 1101 0111 1010 1111 and mapping it to the UTF8 code,

1110 1101 10 011110 10 101111

When compressed,

BYTE 1 is according to Table 4, BYTE 2 is according to the above rules, BYTE 3 is compressed by removing only the two most significant bits,

1110 1101 10 011110 10 101111

(BYTE1) (BYTE2) (BYTE3)

    10111 11110 101111 ==> 1011111110101111 In other words, it is possible to express 24-bit Hangul with only 16 bits because 8 bits are reduced.

The compression of BYTE 2 in the Hangul area from U + B000 to U + CFFF is the same as BYTE 3 compression. That is, only a compression effect of 2 bits is expected.

Compression of BYTE 2 is summarized in Table 5 below.

The header bit in byte 2 of UTF-8. 코드 포인트 코드 포인트 Compression of Byte 2 (first byte) Compressed header bits of byte 2 After the header bit of Byte 2 (6 bits) Final compression result of Byte 2 Number of compressed bits Remarks 10 U + AC00 U + ACFF Removed 1100xx  00xx 4 The top of 6 bits after the most significant 2 bits of BYTE 2 must start with "11" and be removed together, 10 U + AD00 U + ADFF Removed 1101xx  01xx 4 The top of 6 bits after the most significant 2 bits of BYTE 2 must start with "11" and be removed together, 10 U + AE00 U + AEFF Removed 1110xx  11xx 4 The top of 6 bits after the most significant 2 bits of BYTE 2 must start with "11" and be removed together, 10 U + AF00 U + AFFF Removed 1111xx  11xx 4 The top of 6 bits after the most significant 2 bits of BYTE 2 must start with "11" and be removed together, 10 U + B000 U + CFFF Removed xxxxxx  xxxxxx 2 By removing only the two most significant bits of BYTE 2, you get only 2 bits of profit 10 U + D000 U + D0FF Removed 0000xx   000xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together, 10 U + D100 U + D1FF Removed 0001xx   001xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together, 10 U + D200 U + D2FF Removed 0010xx   010xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together, 10 U + D300 U + D3FF Removed 0011xx   011xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together, 10 U + D400 U + D4FF Removed 0100xx   100xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together, 10 U + D500 U + D5FF Removed 0101xx   101xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together, 10 U + D600 U + D6FF Removed 0110xx   110xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together, 10 U + D700 U + D7FF Removed 0111xx   111xx 3 Since the most significant 2 bits of BYTE 2 and the 6 bits of the most significant bits always start with "0" and are removed together,

The UTF-8 code part of the region where Hangul exists compresses 3 to 5 bits in byte 1, ~ 4 bits in byte 2 to 2 bits in compression, and 7 to 9 bits in total every 2 bits in byte 3 In Korea, which is intensively used and uses Hangul, the compression effect increases.

In the U + 0080 to U + 07FF area (that is, when the header bit of the first byte of UTF-8 is 110, BYTE 2 can be compressed.

Especially, various conventional compression algorithms, such as standard arithmetic coding, Huffman coding, deflate, and 7zip,

Through this algorithm, it is possible to obtain a compression gain of 7 bits to 9 bits for each Korean speaker quickly and easily. In addition, 5-bit compression can be obtained for both Chinese characters and Japanese characters. Especially, some Chinese characters can get 7 bit ~ 9 bit compression effect like Hangul.

Especially, since it is not dictionary type, definition of mutual dictionary is unnecessary, and the compression ratio is largely overcome according to the sentence.

[Decompress BYTE 1]

In the case of decompression,

[1] If the first most significant bit of the first byte 1 is "0", then the next 7 bits are read to make 8 bits,

[2] If the first bit starts with "1"

1) Read the header bit until "0" is first encountered. In the case of "11110", "111110", "1111110", there is no compression for separate byte1. Then, each 3 bits, 2 bits and 1 bit are read Byte by 1, and then the bytes are further read by the number of bytes to be read in accordance with the header bit according to the rule of UTF-8, and then the uppermost " 10 " is added for each 6-bit chunk, Uncompress.

2) However, in case of "1110"

When the next three bits are "100", "101", "110", and "111"

Are decompressed into 4 bits by 1000 (8), 1001 (9), 1110 (E), and 1111 (F)

In the case of "1110 100, 1110 101, 1110 110, 1110 111"

1110 1000 "," 1110 1001 "," 1110 1110 "," 1110 1111 "

If the next 4 bits start with 0, such as 0XXX, it is set to BYTE 1 as it is. That is, there is no separate compression effect.

In other words,

"1110 0000" ==> "1110 0000"

"1110 0001" ==> "1110 0001"

"1110 0010" ==> "1110 0010"

"1110 0011" == "1110 0011"

"1110 0100" ==> "1110 0100"

"1110 0101" ==> "1110 0101"

"1110 0110" ==> "1110 0110"

"1110 0111" ==> "1110 0111"

3) In the case of "10", exceptionally

[1] If 1 bit is "0", then only 1 bit is additionally read, and if the mapping is as follows during compression,

010 ==> 110

011 ==> 0

100 ==> 10

101 ==> 111

Then, after "10" is added after "10"

10/0 ==> 10 011 ==> 10 1011

By converting "10" at the top level to "1110", BYTE1 is decompressed as shown below.

10 1011 ==> 1110 1011

[2] If the two bits are "10", then only two bits are read in addition, and compression is released as follows.

10/10 ==> 10 100 ==> 10 1100 ==> 1110 1100

[3] If 3 bits are later than "110", only 3 bits are additionally read, and compression is released as follows.

10/110 ==> 10 100 ==> 10 1100 ==> 1110 1100

[4] If the 3 bits are "111", then only 3 bits are additionally read, and compression is released as follows.

10/111 ==> 10 010 ==> 10 1010 ==> 1110 1010

4) Meanwhile In case of 110 days ,

U + 0080 ~ U + 008F: 110 000 0 00 0000 ~ 110 000 0 00 1111

U + 0090 ~ U + 009F: 110 000 0 01 0000 ~ 110 000 0 01 1111

U + 00A0 to U + 00AF: 110 000 0 10 0000 to 110 000 0 10 1111

U + 00B0 ~ U + 00BF: 110 000 0 11 0000 ~ 110 000 0 11 1111

U + 00C0 to U + 00CF: 110 000 1 00 0000 to 110 000 1 00 1111

U + 00D0 to U + 00DF: 110 000 1 01 0000 to 110 000 1 01 1111

U + 00E0 ~ U + 00EF: 110 000 1 10 0000 ~ 110 000 1 10 1111

U + 00F0 to U + 00FF: 110 000 1 11 0000 to 110 000 1 11 1111

  The next three bits are read, and if it is "000", "1" is added after "000", and the remaining one bit is further read and then the header bit "110" Lt; / RTI >

In other words, if 110 000 0 00 0000, then "110" is followed by 3 bits "000", followed by "1" and the remaining 1 bit read to decompress BYTE 1 to 110 000 1 0, 2 reads the same 6 bits, then decompresses BYTE 2 by adding "10" to the top.

If the 3 bits after "110" are not "000", then 5 bits are read afterwards and added to "110" to make 8 bits to decompress BYTE 1 (ie there is no gain in compression at BYTE 1).

[Decompress BYTE 2]

The decompression scenario of BYTE 2 differs depending on what the lower 4 bits constitute as a result of decompression of BYTE 1.

If the lower four bits are 1010 (A), 1011 (B), 1100 (C), and 1101 (D)

First, if the lower 4 bits of byte 1 after decompression are "1010", 4 bits are read, then "11" is added to the top, and "10" is added to the top. This process is summarized in Table 6 below.

Decompressed
BYTE 1 upper 4 bits Decompressed
Lower 4 bits of BYTE 1 BYTE 2 Number of bits to read after BYTE 1 for decompression Final compression result of Byte 2 Intermediate decompression of Byte 2 Final decompression result of BYTE 2 1110 1010 4    00xx 1100xx 10 1100xx 1110 1010 4      01xx 1101xx 10 1101xx 1110 1010 4    11xx 1110xx 10 1110xx 1110 1010 4     11xx 1111xx 10 1111xx 1110 1011 6  xxxxxx xxxxxx 10 xxxxxx 1110 1100 6   xxxxxx xxxxxx 10 xxxxxx 1110 1101 5   000xx 0000xx 10 0000xx 1110 1101 5   001xx 0001xx 10 0001xx 1110 1101 5   010xx 0010xx 10 0010xx 1110 1101 5   011xx 0011xx 10 0011xx 1110 1101 5   100xx 0100xx 10 0100xx 1110 1101 5   101xx 0101xx 10 0101xx 1110 1101 5   110xx 0110xx 10 0110xx 1110 1101 5   111xx 0111xx 10 0111xx Decompressed
BYTE 1 header bit Decompressed
Lower bit after header bit of BYTE 1 BYTE 2 Number of bits to read after BYTE 1 for decompression Final compression result of Byte 2 Intermediate decompression of Byte 2 Final decompression result of BYTE 2 0 xxxxxxx Not applicable Not applicable Not applicable Not applicable 110 xxxxx 6 yyyyyy Not applicable 10 yyyyyy 11110 xxx 6 yyyyyy Not applicable 10 yyyyyy 111110 xx 6 yyyyyy Not applicable 10 yyyyyy 1111110 x 6 yyyyyy Not applicable 10 yyyyyy

[Decompression of BYTE 3 ~ BYTE 6]

If the header bits of BYTE 1 are 1110, 11110, 111110, and 1111110, BYTE 3 to BYTE 6 are decompressed by 3, 4, 5, Since we know the number of bytes to be additionally generated according to the header bit, read 6 bits of each variable to make the number of variable bytes, and then add "10" to the top.

For example, since the header bit "11110" of BYTE 1 is a 4-byte variable type, BYTE1 and BYTE2 are decompressed according to the above rules, two chunks are read out by 6 bits for BYTE3 and BYTE4, 10 "is added to decompress it.

Now repeat the above process from the next bit and decompress.

When the present invention is used, particularly in the case of Hangul, 3-bit compression is performed on the first byte, and 4-bit is compressed after two to four bytes are compressed, thereby transmitting and receiving Hangul in compressed form substantially in UTF-8 Therefore, it can significantly contribute to traffic reduction of Hangul message.

Claims (1)

As an earlier application for domestic priority claims, no separate claims are listed.