JPH03270417A - Data compressing and decoding system - Google Patents

Abstract

PURPOSE:To improve the rate of compression between character strings by preparing a dictionary to register a partial character string to be followed for each final character string of the preceding partial character string or for each group formed by the final character and applying the registration number of the character string to be registered to the dictionary for each dictionary. CONSTITUTION:In belonging relation with the preceding final character, the codes of current partial character strings ab and abc are applied. A tree 11 is composed of the head character and the developed character for respective final characters (a)-(c) of the preceding character string, and the numbers (indexes) of the respective character strings ab and abc are applied for each tree 11. Therefore, when the respective characters (a)-(c) appear with the equal probability, the length of the index (of the registration numbers of the respective partial character strings ab and abc in the tree 11 of each dictionary 2) is made short. Thus, the length of the code to identify the partial character strings ab and abc is made short and the rate of compression is improved.

Description

[Detailed Description of the Invention] [Summary] Data compression and decompression method using LZW code The compression ratio between character strings is increased by incorporating the dependency relationship between the encoded character string and the last character of the immediately preceding character string into a dictionary. With the aim of A column registration number is assigned to each individual dictionary, and when encoding a string, the current character is assigned based on the registration number of the corresponding character substring in the individual dictionary that corresponds to the last character or final character group of the previous string. It has a configuration that creates and outputs a code word for a subsequence.

[Industrial application field]

When handling large amounts of data, such as in computers, data communications, etc., by eliminating redundant parts of the data and compressing the data, it is possible to reduce storage capacity and speed up communication speed. Become.

As a data compression method, an input character string is sequentially encoded and stored for each character substring, and the current character substring is encoded as a copy of the longest previously encoded character substring. There are compression methods.

In such conventional data compression methods, when a character string is divided into different character substrings and encoded, the current character substring to be encoded is assumed to appear independently of the character string that appeared. It was encoded.

In actual data such as sentences, there is a correlation between each character substring, and as mentioned above, conventional encoding methods do not use the history of character substrings to appear, but rather Dependency of a substring with character substrings that appeared in the past was not taken into consideration, so it was left as a redundancy in data compression.

The present invention provides an incremental decomposition type that reduces redundancy in data compression in a character substring and increases the compression rate by taking the dependency relationship between the encoded character substring and the last character of the immediately preceding character string in a dictionary. LZ W (Ziv-Lea+pel-
The present invention relates to a data compression and decompression method using Welch) codes.

[Prior art]

Data compression using the LZW code involves dividing a character string into different character substrings by searching for the longest-dispersed character string among character strings that have appeared in the past and are registered in a dictionary, and encoding the string using its number. At the same time, a character string that is one character longer than the longest matched character string is registered in the dictionary as a newly appearing character string.

The conventional LZW encoding method will be explained with reference to FIGS. 12 to 14.

Figures 12(a), (b), and (C) are for simplicity,
a, b.

The case where data is encoded and compressed and the case where it is decoded are shown for the case of three characters of C.

In the LZW code, encoding is started after a character string consisting of one character for each character is registered in a dictionary as an initial value in advance.

Then, from the character string, the longest sub-sequence of characters registered in the dictionary is searched, and the registered code ω is outputted as the code.

On the other hand, in the dictionary, a character string obtained by adding the next character (extended character K) that does not match to the longest scattered character string is added, and the character string is represented as a pair (ω, K) and registered in the dictionary. do.

Decoding is the inverse of encoding. That is, the input code ω
Find a set of character string representations (ωK) corresponding to . next,
Similarly, a set of character string representations corresponding to ω° is obtained, and the obtained extended character K is stacked.

This procedure is repeated until the number ω reaches one character, and the last stacked character is output, and each character string is decoded.

Then, the combination (ω, K) of the previously used code ω and the first character of the character string restored this time is registered in the dictionary, and the restoration dictionary is updated.

Referring to FIGS. 12(a) and 12(b), a case in which the conventional (7) LZW encoding method consists of only three characters a, b, and c will be specifically explained.

First, - characters a, b, and c are first registered in the dictionary as shown in Figure (b).

(1) In the input character string shown in Figure (a), first input the first character a. Since a is in the dictionary, the code of a is 1, so we set ω=1 and input the next character b (K=b). Since the character substring ab (=b in ω=1.) is not registered in the dictionary, a is output and ab(Ib)
is registered in the dictionary with registration code 4.

(2) Next, input the next character a (K=a) with the b you just input as the first character of the character string (ω=2).

Therefore, the created character substring ba (ω=2°K=a)
is not registered in the dictionary, so output b and ba (2
Register a) as registration code 5.

(3) Furthermore, input the next character b (K=b) with a, which was input in (2), as the beginning of the character string (ω=1).

Since the character string ab has already been registered with the registration code 4, the following character C is input with ω as the registration code 4 of the current character substring ab (ω−4°K=c).

Since the character string abc is unregistered, the longest matching character substring ab is output with the registration code 4, and the character string abc(4c
) in the dictionary with registration code 6.

(4) Then, the character C that has just been input is set as the first character of the character string (ω=3), and the following character S is input (K=b).

The character string cb (3b) is not registered in the dictionary, so the character C
is output as registration code 3 (registered in initialization), and the character string ab (3b) is registered as registration code 7 in the dictionary.

Following the same procedure, the following character strings will be output using the registered code of the longest matching character substring from the registered character substrings, and unregistered character substrings will be registered in the dictionary with a new registration code. and update the dictionary.

Figure (b) shows a reference dictionary created using the LZW code for the input character string in figure (a).

When decoding the input code, for example, the code 8
When 8-5b is input, the conversion table shown in the figure
Then, since 5=28, 8=2ab is read, and then the character string bab is decoded from 2=b.

Figure (C) shows a decoding method for the LZW code.

Figure (C) shows the case where the output code of the character string in Figure (a) is decoded.

Decoding is the reverse of the encoding procedure.

During initialization and initialization, the registered dictionary contains one character a,
b and c are registered as codes 1, 2.3, respectively.

When decoding the input code shown, the conventional LZW
The code decoding procedure will be explained.

(1) First, when the first input code 1 is input,
Output the character a by referring to the dictionary.

Here, input code 1 is the previous code register (Oldc
ode).

(2) Next, output b using input code 2.

At this time, the code 1b of the input code l in the process of (1) and the character string b just decoded is registered in the dictionary as code 4.
Register as and restore the dictionary.

Input code 2 is then saved in 01dcode.

(3) Next, refer to the dictionary using the input code code 4 and
Read b and further decode the character string ab from lb.

Then, the first characters a and 01d of the character string restored in (2)
With code 2, conversion code 2a is registered in the dictionary as registration code 5.

Input code 4 is moved to 01dcode and saved.

(4) Enter the next input code 3.

3 is already registered in the dictionary as C, so restore the letter C,
Using the code 4 of 01dcode and the character C just restored, the conversion code 4c is registered in the dictionary as the registration code 6.

Then, input code 3 is moved to 01dcode and saved.

(5) Read the next input code 5.

Since input code 5 has already been registered as conversion code 2a, character substring ba is decoded from 2a.

Then, the first character of the character substring just decoded is 01dc
3b is registered in the dictionary with the registration code 7 using the code 3 stored in ode. Input code 5 is 01dcode
and save it.

The same sequence is repeated to sequentially decode the input codes and update the dictionary.

FIG. 13 shows a coding diagram of the conventional LZW coding method.

The flow will be explained by taking as an example the case where the above character string ababc is encoded.

(2) During initialization, - characters a, b+C are registered in the dictionary (a=1, b=2, c=3) *At the same time, the starting address n of the dictionary is set.

The flow in the figure is for a case where there are 256 characters, so we set n=256 as the first address, but in this case, we are considering a case where there are only three characters a and bC, so n=256. Consider 4 as the initial value.

(1) ■ Let the first character K (K=a) of the character string be ω of the initial character string.

(2)　■　Read the next letter.

■ If the last character of the input string has been processed, the next character does not exist, so proceed to end processing.

Now that we have an input string, proceed to ■.

■ Now ω=a, ni=b, and the character substring ω=ab is not found in the dictionary, so proceed to ■.

■ Output 1 as the registration code (code (ω)) for ω=a.

■ Move the registration code of the input character to ω, and at the same time advance the dictionary address n by one.

(3) Return to ■ again and input the next character a. now,
Since ω=2, check ω=1b with the dictionary in ■. Since it is unregistered, use ■ to register b's registration code 2 (code (ω)
) is output. Then, use ■ to register ω = 2 a in the dictionary with registration code 5 (n = 5). Furthermore, the code 1 of the character a that was just input is transferred to ω. Then return to ■ again.

(4) Enter the next character.

In this case, as determined in step (2), since ω=1b has already been registered, proceed to step (2) and set ω=1b to ω. Therefore,
Return to ■.

(5) Input the next character C as K and perform the subsequent processing.

■ is a case where the final character has already been input, and the final character has been input to ω in the process of ■, so the code (
The code (ω)) is output, and the code creation process ends.

FIG. 14 shows the flow of the conventional LZW encoding method.

The flow will be explained using the output code of the character string explained as an example in FIG.

For decoding, input code memory (lNcode) =
Input memory (INcode) that stores input codes.

Memory for storing the previous code (Oldcode),
Memory that stores the first character of restored characters (FINchar
) A memory (stack) is used to temporarily store decoded characters that are sequentially restored.

■ By initialization, the code for the - character is created in advance.

(1)! lRead the first code (in this case, l)
. Insert the read code into 01dcode.

Referring to the input code (1) and the dictionary registration code, output a as a character.

Move a to FINchar and save it temporarily.

(2) ■ Read the following code (CODE) and
Put it in de.

■ If no code is found after reading up to the last code, the process ends.

■In this case, there is the next code 2, so proceed to ■.

■ Move K to the stack. In the case of a code where 8 is 5b and 5 is 2a, such as the registered code 8 in FIG. 12(b), input the letter K in ω into the stack sequentially,
The process is repeated by sequentially converting ω until ωK becomes one character.

In the present example, b corresponding to code 2 is stored on the stack.

■ Output the characters stored in the stack.

■ The first character of the decoded character, in this case the character FrN
Store in char.

■ Register the pair (Oldcode, K) in the dictionary.

In this case, the code l of the first character a of the character string read during initialization is stored in 01dcode. Also, since =b, store lb with registration code 4 (registration address (=registration code) n of character substring to be newly registered)
shall start from 4).

Increment n by l.

Move INcode data to @01dcode.

In this case, the INcode data is 2, so it is 0.
1dcode is set to 2.

(3) Then, return to ■ and read the next code.

The next code is 4. Therefore, when referring to the dictionary, the code 4 is
Since is lb, by sequentially writing a to the stack from ω=1b with ■, output the character ab with ■. moreover,
3 stores the first character a of the decrypted character string in FINchar. And now 01dcode is 2 and the first decoded character
By setting the character to =a and using the combination (2, a), the code 2a is registered in the dictionary with the registration code 5 (n=5).

Then, n is incremented by 1.

Furthermore, the input code is moved to 01dcode, and 01dcode is set to 4 in any case. Then, repeat the process from ① onwards.

As mentioned above, decode the input code, memorize the code of the decoded string, and use the next input code to correspond to the stored code at the time the next string is decoded. An unregistered character substring that is one character longer than the character substring is registered in the dictionary, and the dictionary is restored.

In the flowchart in the figure, ■ is a case of exceptional processing.

As mentioned above, in the compression process using the LZW code, when the encoding of the character substring of interest is completed, the character substring with the - character extended can be registered in the dictionary.
In decoding.

When extending the character string of interest by one character, it is registered in the dictionary along with the first character of the next character substring, so registration cannot be performed until the decoding of the next character string is completed.

Therefore, a registration code necessary for decoding an input code may not be registered in the dictionary. In such a case, the input code cannot be decoded, but 0 is used to perform decoding processing in that case.

For example, consider a case where an input code IO is input in the input codes shown in FIG. 12(C).

At this time, 01dcode is 1 and FINchar is a.

At this point, registration codes up to 9 have been registered in the dictionary, and 10 has not been registered.

Therefore, the input code 10 cannot be restored.

Therefore, by ■, FINchar's a and 01d
With code 1, input 1a to INcode.

After that, by the same process as in the normal case after ■, a
a can be output and 1a can be registered in the dictionary with the code 10.

[Problem to be solved by the invention]

In the conventional LZW encoding method, when an input character string is divided into different character substrings and encoded, each character substring currently being encoded is assumed to have appeared independently of character substrings that have appeared in the past. It was encoding.

This method has no problem encoding memoryless information sources (real-time input data), but many data such as actual sentences are considered memory information sources, and LZW codes make full use of the history of occurrences of character strings. However, even after data compression, the lack of consideration of dependencies in the appearance of character strings remains as redundancy.

The present invention can be applied to a character substring to be encoded, such as determining the code of the current character string in relation to the immediately preceding character string, such as the last character of the immediately preceding character string, and registering it in a dictionary. This method attempts to reduce redundancy between character strings and increase the compression rate by incorporating the dependency relation between the last character of the immediately preceding character string into the dictionary.

[Means for solving the problem] Means for solving the problem will be explained with reference to FIG.

In the figure, (a) shows a dictionary tree using the conventional LZW code, and Φ) shows the relationship between each character string in the encoding of character strings using the conventional LZW code.

Conventionally, a dictionary tree has been created using character substrings as shown in Figure (a) for each first character of each character substring shown in Figure (b).

For example, as shown in the figure, a number from 0 to 256 was attached to each of the 256 first characters, and a character string with each - character as the first character was developed from each first character.

For example, for a character string in which the - character "a" is 0 and "a" is the first character, for example, as shown in the figure, "rab" is 2
57, "ac" is 259, racaJ is 258 rac
Each character string was given a number as a hierarchy below J, with the entire dictionary being treated as one dictionary tree.

In this case, there is no connection between the first character strings, and each first character is connected to the root of the dictionary tree whose roots are wart and sky. This indicates that the history of the strings that have appeared has not been considered.

According to such conventional methods, different numbers must be assigned to identify each character string for different character strings, and registration numbers for each character substring for setting code words must also be assigned. Moreover, redundancy remains, such as setting without taking into consideration the appearance frequency of character strings.

Next, the diagram shows the method of intercepting the dictionary tree and encoding the character string according to the present invention (
This is explained by C) and (d).

In the present invention, as shown in Figure (d), the code of the current character substring is attached in the subordinate relationship with the immediately preceding final character.

Then, as shown in Figure (C), for each last character of the previous character string, the first character and its expansion characters are used to steal a tree, and each tree is given a number for each character string. .

For example, if the immediately preceding character is "a" and the - character ra is appended, that "a" is set to index 1 in the tree, and the character string rab" for the immediately preceding character "a" is index 7, immediately preceding One letter "b" for the letter ra,
is number 2. In addition, when the immediately preceding character string is "b", one character ra is the tree number 1 of the immediately preceding character string "bj", "ab
” is index 4 in the tree, so that each character string is indexed for each tree whose root is the previous character string.

By doing this, when each character appears with equal probability, the length of the index (registration number of each partial character string in each dictionary tree) can be set to 1/256.

Normally, the size of an individual tree is a tenth of the size of the entire tree, which is the sum of all individual trees, so the length of the code that identifies a character substring can be shortened. It becomes possible to increase the compression ratio.

The basic configuration for encoding of the present invention will be explained with reference to FIG.

The figure exemplarily shows a case where a dictionary is created for each last character of the immediately preceding character string in a character string that is limited to only three characters a, b, and c.

In the figure, 1 is an input character string, 2 is a dictionary in which indexes (1(n)) of registered character substrings are registered for each tree whose root is the final character, for example, a character substring ab in a tree whose root is a. , abc indicate that each index is 0.1, 3 is a character sequence output stage that reads the input string one character at a time, 4 is the current character substring to be targeted, 5
8 is a dictionary reference means that refers to a dictionary for the current character substring and reads the maximum length character substring that matches the current character substring from the registered character substrings, and 8 is the maximum number of characters in the read character string. Code the part based on the index registered in the dictionary, and set an index for each final character of the previous character string in the newly appeared current character substring that extends the next character of the character string to the maximum number of characters. Encoding means, 9
is a dictionary registration means for registering in the current character string partial dictionary, 10 is a final character storage means for storing the last character part of the maximum-several character partial string, and 11 is an example of a dictionary tree whose root is the last character of the immediately preceding character string. It is.

[Effect]

The operation of the basic configuration shown in FIG. 1 will be specifically explained by taking as an example a case where an input character string is encoded as ababcb....

In the present invention, for example, when outputting a as a character substring, the last character of the immediately preceding character substring is a following a,
For a following b, each must be output separately as a of the tree whose root is a and a of the tree whose root is b.

In order to output one character in each set, we need to output the combination of each character, which is the root of the tree, and one character (aa, ab, ac
, ba-), etc., on both the encoding side and the decoding side, and use that code to distinguish and output a following a, a following b, etc. If a character attached to the root of a tree like this newly appears, a method must be adopted in which one character (raw data) is output.

Here, we will explain the case where the latter one character (raw data) is output directly to the root of the tree of the last character of the immediately preceding character string.

(1) The character string succession means 3 reads the first character a and sets it as a character substring 4. The dictionary reference means 5 refers to the dictionary and confirms that a is unregistered.

The encoding means 8 sets index 0 in the dictionary.

The dictionary registration means 9 registers a in the last character 0 tree of the immediately preceding character string at the dictionary registration position (n=1) with index 0.

At the same time, the character a is output.

Then, a is stored as the last character of the immediately preceding character string.

(2) Next, read the second character.

Therefore, a dictionary is referred to for a character string ab formed by the last character a of the immediately preceding character string and the input character. Since ab is unregistered, the character string "ab" is placed at registration position 2 in the dictionary and index 0 as the first registered character substring of the tree whose root is a.
Define and register.

Then, since the b that has just been input is a character that appears in the tree whose root is a, b is output as raw data and b is stored as the final character of the immediately preceding character string.

(3) Similarly, input the third character a.

Therefore, the dictionary is referred to for the character string ba formed by the last character of the immediately preceding character string and the read a.

Since there is no ba, the character substring rba is set at index 0 as the first character of the tree whose root is the last character of the immediately preceding character string, and is registered at registration position 3 (n=3) in the dictionary.

The final character a of the output character substring is stored as the final character of the immediately preceding character string.

(4) Next, read the fourth character.

Therefore, the character string ab formed by the last character a of the immediately preceding character string and the read b is referred to in the dictionary.

Since ab is registered at registration position 3, the next character C is read.

Since the character string abc is not registered in the dictionary, the encoding means 8
encodes and outputs the maximum-component character string "ab" as a code representing the fourth character with index 0 of "rab" in the tree whose root is a, and at the same time inserts a new character string into the dictionary at registration position 4. The character string "abc" that appears is registered at index 1 as the second character string in the tree whose root is a.

The last character of the output maximum-composed character string is stored as the last character of the immediately preceding character string.

(5) Similarly, read the fifth character C.

Character string bc of memorized final character C and read b
is unregistered, so the character string bc is registered as the first character substring of the tree with b as the root at index 0 and the dictionary registration value W5 (n index 5).

Since C is a character connected to the root of the dictionary tree whose root is the last character of the immediately preceding character string, the character C is output as raw data.

Below, proceed with the same procedure and output code abaoc...
・ Obtain.

Next, a method for decoding a data compression code into a character string will be explained with reference to FIG.

FIG. 2 shows the basic configuration of the decoding method of the present invention.

In the figure, 21 is an input code, 22 is a dictionary restored from the input code, 23 is an input code reading means, 24 is an index represented by the input code and the last character of the restored immediately preceding character string, 25 is a dictionary reference means, and 26 is a dictionary character substring decoding means for decoding a character string from a registered character string in the dictionary corresponding to the index and the last character of the immediately preceding character string; 27 is a restored character output means for outputting decoded characters from the restored character string; 28;
29 is a final character storage means for storing the last character of the restored character string, and 29 is a character storage means for storing the character string consisting of the decoded character string and the first character of the decoded character string to be decoded next. This is a dictionary restoration means that registers in a tree using an index.

Next, a code 0aObOalO... which encodes the operation of the basic configuration of the decoding system shown in FIG.
A case of decoding will be specifically explained as an example.

(1) First, the input code reading means 23 reads the input code a. Since it is raw data, the character substring decoding means 26 decodes the character a and outputs it. Then, the character a is registered at the registration position 1 of the restoration dictionary 22 as a tree of the last character 0 of the immediately preceding character string with the index l.

At the same time, the final character a of the decoded character string is stored.

(2) Similarly, read the next code lb, decode and output the character string since it is raw data, and create a string ab of the memorized character a and the b you just read, with a as the root. It is registered at index 1 in registration position 2 of the tree dictionary.

Furthermore, the last character of the decoded character substring is stored.

(3) In the same way, read the next code a, restore the character string a, and register the character string ba between the last character, which is memorized, and the just read b, in the tree dictionary with b-t-m. value N3,
Register with index 1.

Then, the restored a is stored.

(4) Next, read the fourth code 0.

Now, the last character of the previous character substring is a and the input code is O
Therefore, the dictionary reference means 25 refers to the dictionary and reads out the character substring ab. Then, character substring decoding means 26
decodes the character substring "ab". Furthermore, based on the decoded character substring and the final character a of the previous final character string,
The decoded character output means 27 outputs characters.

The final character storage means 28 stores the final character of the decoded character string.

(5) Next, read the fifth code C.

Since it is raw data, the character C is decoded, and the character string abc is registered in the dictionary of the tree whose root is a at position 4, using the character substring ab decoded in the previous step (4) and the character C just decoded. Register with index 2 and restore the dictionary.

In the above explanation, we have explained the case where a dictionary tree is created for each final character of the previous character string, but the final characters are grouped according to their type, etc., and a dictionary tree is created for each group. A character substring may also be registered.

〔Example〕

The data compression method of the present invention will be explained with reference to FIGS. 3 to 5.

FIG. 3 shows an apparatus configuration for implementing the present invention.

In this embodiment, the dictionary is divided into an overall dictionary in which substrings of characters are registered, and an individual dictionary in which substrings of subsequent characters are registered by index in association with the registration position in the overall dictionary for each final character of the immediately preceding character string. It is created separately.

In the figure, 30 is a memory that stores an input character string K for encoding the input character string, and 31 is a character substring code ω.
32 is the last character P of the immediately preceding character substring.
K storage memory, 33 is a storage memory for 1 for the last character of the current character string to be encoded, 34 is an overall dictionary D(n) that is more powerful than the memory, and 35 is an individual dictionary consisting of memories Q
, a, b, c, etc. 256, 36 is a counter that measures the depth of the registration hierarchy of character substrings in the dictionary tree, 37-O to 37-255 are individual Each index m(0) to m(25
5) counter; 38 is a counter for the registration number n of the overall dictionary; 39 is dictionary reference and creation means for referencing the dictionary and further creating a dictionary; 40 is code creation means for encoding the read character partial string; 41 is a code output means for outputting the code of the created character partial string, and 42 is a CPU that executes and controls data encoding processing according to a program.

FIG. 4 shows a flowchart of the apparatus configuration for the encoding shown in FIG.

Figures 5(a) and (b) each show aba as a character string.
The configuration of an embodiment of the entire dictionary and individual dictionaries when bcbaba... is encoded is shown.

FIG. 6(a) shows an example of an individual dictionary tree when the above character string is encoded.

In this embodiment, when a character directly connected to the root of the last character tree of the immediately preceding character string appears for the first time, that one character (raw data) is sent.

FIG. 6(b) shows an embodiment of the code word of the present invention, and mode 1 shows the case where a new character directly connected to the root of each individual dictionary tree mentioned above newly appears.

In mode 1, a set of index 0 (designating raw data) and character raw data is sent as a code word.

When a character or character string other than mode l appears, the index of that character string in the Zenbon is sent as a code word, as shown in the figure.

The flow shown in FIG. 4 will be explained with reference to FIGS. 5 and 6.

In the initial condition setting step (■) in the figure, the individual dictionary is
Although the case is shown in which 56 characters are provided, for the sake of simplicity, the character a is used as a character string.

Consider the case where a character string ababc... consisting of only three characters bc is encoded.

Now, initialize the entire device (■).

As an initial condition, (1) the last character PK of the immediately preceding character string is 0.
shall be. (2) The first M (iI of the character string code storage memory is set to 0 in this case (256 in Fig. 4),
(3) Set the measurement counter for the dictionary tree depth DP to 0.

(4) In this case, the start address indicating the first registration position of the entire dictionary is set to 4 (in FIG. 4, it is set to 256). The number of indexes in each individual dictionary is set to 0. In this case, since the individual dictionary consists of four O5a, -b, and c, the number of indexes registered in each dictionary is m(0).

Let m(a), m(b), m(c) be 0.

(1) Read the first character a of the input character string ababcbaba-- (■).

The decision in (2) is whether to read the entire character string and end the process, so proceed to (2).

Since the character string a following the immediately preceding character string 0 is not registered in the overall dictionary, the process proceeds to ■.

Now, the depth DP is 0, so proceed to @.

In this case, it corresponds to the above mode l, so with m (0) = 0 and raw data a, Oa is used as a code word.
Outputs (@).

Therefore, the character string a that was just input into the overall dictionary D(n-4)
(The initial value of ω is O, so Oa) is registered, and the index I (n=4) is registered in the individual dictionary 0 (PK=0).
Then, the number of registered indexes m (0) of the individual dictionary 0 is incremented by 1, and 1 (there was no registered character in the tree of the individual dictionary 0) is registered ([phase]).

Next, the registration position n of the entire dictionary is incremented by 1 (
[phase]).

Next, the final character string PK is the a that has just been read, and the character string code ω is the code of the read character a (1, which was set in the initial conditions).

(2) Read the second character below.

ω 1b is not registered in the dictionary, so proceed to ■ and enter D
Since P=0, proceed to @.

So now, m(a)-0, mode 1 of the raw character
Since this is the case, lb is output to the outside.

Therefore, ω=1b is registered in dictionary D (n=5), and index I (n=5) is added to individual dictionary a (PK-a) in the individual dictionary, and the number of indexes registered in individual dictionary a is Increment m (a) by 1 and register ■ (there were no registered characters in the tree of individual dictionary a) ([
phase]), increment n by 1 (0), and set the last character PK to b, which was just read, and input character code ω.
Let it be code 2 of b, which is set as the initial condition.

(3) Next, read the third character a.

= 2b is not registered in ω, so proceed to ■. Since DP = 0, set mode l in ■, and m(b) = 0 (there is no string in the individual dictionary tree of b yet). Since there is, 111b with raw data b is output.

Then, register ω=2b in D(n-6) in the overall dictionary, and at the same time, add index I in the individual dictionary b (PK=b).
Assuming (n=6), m (b) is incremented by one, and l (there was no registered character in the individual dictionary tree) is registered (@).

Next, increment m by 1 (0) and set PK to a
Read the next character with 1ω=1.

(4) Next, read the fourth character.

In the judgment of (2), if ω-1b is referred to the general dictionary, it is already registered with code n-5, so proceed to (2).

Therefore, ω is set to n=5 which was just read from the entire dictionary, the depth of the hierarchy DP is incremented by 1 to DP-1, and b which is just read is stored to 1 in the final character storage memory.

(5) Read the next fifth character C.

Next, at ■, it is determined whether ω=5c is registered in the overall dictionary.

Since ω=5c is unregistered, proceed to ■.

Now, since DP=1, proceed to ■.

In (2), refer to the individual dictionary corresponding to ω = 5 (n - 5) and output index I (n = 5) = 1 as the code word (mode 2) of b following the last character a of the immediately preceding character string. .

Next, in (2), ω=5b (abc) is registered at the n=7 registration position in the overall dictionary. At the same time, separate dictionary a and n
-7, increment m(PK) by one,
Register index I(n-7)-2 (individual dictionary a
).

Then, n is incremented by 1 and the depth DP is set to 0.

Further, let PK be b stored in the final character storage memory Kl, and let ω be the code 2 of 1. Then, in (2), it is determined whether or not ω=2c is registered in the overall dictionary, with the fifth character C just read as K being set as K.

Since 2c is not registered in the general dictionary, proceed to ■ and set DP=
Since it is O, the process proceeds to @ and outputs the code word ob of mode l using the character C as raw data.

Therefore, 12c is registered in ω in the general dictionary with n=8, and now PK=b, so the individual dictionary is n=8, m (b)
Increment by 1 and register ■(n=8)=l (the second character string in the tree of b).■).

Furthermore, increment n by 1, set PK to C that was just read, and set ω = 3 (value under the initial condition of c),
Read next character.

Similarly, the input character string ababcbabaa...
0aObOalOcOb113・- as the output sign of ・
・Obtain.

Next, a method for decoding a character string using the above code will be explained.

FIG. 7 shows an embodiment of a device configuration for decoding according to the present invention.

In the figure, 71 is an input code storage memory, 72 is a memory (INω) that stores a restoration code obtained by restoring the input code sent as a code word according to the index of the individual dictionary to the character string code in the overall dictionary, and 73 is the restoration code. memory (OLDω) for storing the immediately preceding character substring, 74
is a memory (PK) that stores the last character of the character substring immediately before being restored, 75 is the last character storage memo IJ (PKI) of the immediately previous character substring, and 76 is the first character storage memory (PKI) of the restored character string. Kl), 77 is the entire dictionary D (n) that is restored at any time from the character substring restored from the input code, 7B is the individual dictionary q (PK, index) that is restored at any time from the restored character string, 79-0 to 79-255 is a counter for the number of indexes of 255 individual dictionaries, 80 is a dictionary reference means for referring to the individual dictionary from the input code, 81 is a character segment decoding means for decoding a character segment from the entire dictionary, and 82 is a character segment decoding means for decoding a character segment from the decoded character segment. Dictionary restoring means 83 for restoring character substrings into the entire dictionary and corresponding individual dictionaries is a CPU that proceeds with the decoding process according to a program.

Figures 8 to 10 show the flow of subsequent encoding, and Figure 8 determines whether the input code is defined from initialization, and if the input code is defined, it is determined individually. The flow of referring to a dictionary and converting it into a code representing a character string in the entire dictionary is shown.

FIG. 9 shows a flow when decoding a mode I code.

FIG. 1O shows a flow when a character string is decoded from the registered code of the general dictionary.

The flowcharts in FIGS. 8 to 1O will be explained by taking as an example the case where the above-mentioned code 0aObOalOC... is input as the input code.

First, initialize the device.

In the initial conditions in the figure, the individual dictionaries are set to 256 (i
ll, and for 256 single characters, 0~
The initial conditions are as follows, given the initial value of 255.
The initial value of PK=O5ω is 256, the start address of the entire PK1=O dictionary is n=256.0LDa+=0, and m(0) to m(255) of each individual dictionary are 0.

Here, in order to simplify the explanation, we will consider a case consisting of only three characters, a, b, and c, and set codes 12.3 for each of a, b, and c as initial conditions. Furthermore, the initial value of ω is set to 0.

(1) Input the first input code 1a (■).

Since the code is undefined in the judgment of (2), proceed to (2).

Judgment (①) is based on mode 1, which generates a code directly attached to the root of the dictionary tree of the immediately preceding character string, or when there is an undefined code input that occurs exceptionally in the LZW encoding process. .

Since we are currently in mode 1, we proceed to A in FIG.

At ■ in FIG. 9, the input code Oa is input as =a to the raw data, and the character a is output (■).

Now, since there is no previous character string, proceed to step (2), register Oa in the overall dictionary D(n-4) from the restored character string a and PK=O, and restore the entire dictionary. Furthermore, m (0) is incremented and the individual dictionary l is restored with PK=0 and m (0)=O1n=4.

Furthermore, n is incremented @), and a, PK=0, which has just been restored to PK, is transferred to OLDω.

(2) Next, read the second input code ob.

In this case as well, since it is a mode 1 code, the process proceeds from ■ to ■, and then to A.

In the same way as in the case of processing 1a of (1) in the flow of FIG.
Register ab in 5. Furthermore, n=5 and index l are added to the individual dictionary a corresponding to the last character a of the immediately preceding character substring.
Register and restore individual dictionaries.

(3) Next, input the third input code Oa. code O
Since a is also in mode l, the above process is repeated, a is output as the restoration code, ba is written in the overall dictionary, and n=6 and index=1 are written in the individual dictionary.

Therefore, m(b)-1, n=7, PK=a.

As OLDω-, read the next code.

(4) The fourth code is l.

Since the code 0 has been defined, the process proceeds to (■) in FIG.

Now, the previous character string is a and the input sign is 1, so
Refer to the restored individual dictionary and check the registration position of the corresponding overall dictionary.

As a result, convert the input code to n = 5, ω = 1b,
Write to INω and proceed to B.

B is a flow of decoding processing in the LZW code.

[Phase] and [Phase] are the same methods as the conventional LZW code decoding method.

That is, code lb is sequentially encoded onto the stack using ■.
Store them in the order of a, leave the last stored a and output the top b.

Now, the previous character substring is registered in the dictionary, so
Proceeding to [phase], write PK=a in the last character storage memory of the immediately previous character string, write the last character of the decoded character string ab to PK, and write the first character a of the decoded character substring to Kl.

At the same time, the decoding code 1b (INω) is written to LDω, and the next code is read.

(5) Next, read the fifth code OC.

Since it is a mode l code, the process proceeds to FIG. 9A, and in 2, C is output.

In this case, the previous character substring has not been registered in the dictionary, so in ■, register the character string abc at position n-7 of the entire dictionary using lb of OLDω and the C you just input, At the same time, m(a) is incremented by one and index=2 is written in the individual dictionary a.

In [phase], n is incremented by 1, and in (2), the current character string (the character string bc at the time when C is read in the final character) is registered. At the same time, registration processing to the individual dictionary is performed.

Following the same procedure, all input codes can be read and decoded.

Note that the steps ① and [phase] in the flowchart of FIG. 9 are the same as those described above, which represent the processing described as an exception to LZW encoding in the prior art, so their explanation will be omitted.

Note that in the above embodiment, a case has been explained in which raw data is output for one character at the root of each individual dictionary tree, but the possible combinations of one character following the root of each individual dictionary tree are The code may be created on the encoding side and the decoding side, and the above-mentioned one character may be output based on the created code.

In addition, the code word to be output is always a set of [one character K of the individual index 01 of the character string of interest], and the [next one character] therein is used as the last character of the immediately preceding character string, and the next one is used as the final character of the previous character string. Characters may also be encoded.

In this case, the flow of encoding and decoding becomes a simple configuration.

〔Effect of the invention〕

According to the present invention, since the history of past character strings is incorporated into the character string to be encoded, it is possible to determine code words by considering the frequency between character strings, etc., and redundancy in data compression can be reduced. can be reduced.

In addition, because the dictionary is divided into multiple parts and code words are created using the indexes of the divided dictionaries, the index value becomes small, and even when the amount of data is large and the number of registered character strings increases, the data can be stored using short code words. Since compression can be performed, the compression ratio improves.

[Brief explanation of drawings]

FIG. 1 is a diagram showing the basic configuration of the compression encoding method of the present invention. FIG. 2 is a diagram showing the basic configuration of the decoding method of the present invention. FIG. 3 is a diagram showing an embodiment of an apparatus configuration for encoding according to the present invention. FIG. 4 is a diagram showing an embodiment of the encoding flow of the present invention. FIG. 5 is a diagram showing an example of the dictionary. FIG. 6 is a diagram showing an example of a dictionary tree and code words. FIG. 7 is a diagram showing an example of a device configuration for decoding. FIG. 8 is a diagram showing the decoding flow (1). FIG. 9 is a diagram showing the decoding flow (2). FIG. 1O is a diagram showing the decoding flow (3). FIG. 11 is an explanatory diagram of means for solving the problems of the prior art. FIG. 12 is a diagram showing a decoding method for compression encoding of a conventional LZW code. FIG. 13 is a diagram showing the flow of the conventional LZW encoding method. FIG. 14 is an explanatory diagram of the flow of the conventional LZW decoding method. In the drawings, l: input character string, 2: dictionary, 3: character string reading means, 5: dictionary reference means, 8: encoding means, 9: dictionary registration means, 10: final character storage means, ll: immediately preceding character. Dictionary tree whose root is the last character of the string, Binyan example of the overlapping structure of encoding Figure 3 (input x string a'oa'ocba'oaa ・=-)1
(n) Actual flow of dictionary Figure 5 Example of conventional LZW encoding universal formula Figure 13 (a) Compression code with L ZW code (b) Structure of reference dictionary (C) LZW code t1 Conventional LZW Code compression row coding voice code method % formula % Conventional LZW decoding method F0- Fig. 14

Claims (1)

[Claims] 1) Sequentially encode each different character substring of an input character string, and use the current character substring as a copy of the matching maximum length character substring among the encoded past character substrings. In a data compression device for encoding, for any two consecutive character substrings, a dictionary is created in which the following character substrings are registered for each final character of the previous character substring or for each group of final characters, and the dictionary is A data compression method characterized in that a registration number of a character string to be registered is assigned to each of the above-mentioned final characters or groups of final characters, and a code word of the current character substring to be encoded is created based on the above-mentioned registration number. method. 2) From the input code created by the compressed data method according to claim 1, a dictionary is restored for each final character or final character group of the immediately preceding decoded character substring, and A compressed data restoration method characterized by decoding an input code into a character substring by referring to a restored dictionary from the final character and the current input code.