JP3117760B2 - Data restoration method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a data restoring method for decoding compressed data, and more particularly to a data restoring method for LZW-compressed data as an improvement of an incremental decomposition type which is a kind of universal encoding. .

In recent years, various types of data such as character codes, vector information, and image data have been handled by computers, and the amount of data handled has rapidly increased. When dealing with a large amount of data, it is desirable to reduce the storage capacity or to transmit data at high speed by omitting redundant portions in the data and compressing the data amount.

[0003] Universal encoding has been proposed as a method of compressing such various data by one method. Zi is a typical universal coding method.
Methods using v-Lempel codes are known (for example, Seiji Munakata, "Ziv-Lempel Data Compression Method", Information Processing, p
p.2-6, Vol.26, No.1,1985). Ziv-Lempe
For the l code, the universal type and the incremental decomposition type (Increment
al persing) have been proposed.

The present invention relates to a further improved decoding of data compressed by an LZW (Lempel-Ziv-Welch) code in which an incremental decomposition type algorithm is improved. In addition, "Character (Character)" and "character string (Char
In addition to the definition of "acter String", the data conforms to JIS-C6230 and follows the name used in information theory. Data composed of one word is called "character", and data composed of an arbitrary word is defined. The present invention will be described as a "character string" as it relates to the decoding of compressed data.

[0005]

2. Description of the Related Art According to a conventional LZW code encoding algorithm, an input character string is divided into different partial character strings and encoded, and the correspondence between these partial character strings and codes is registered in a dictionary and the input character string is input. The character string is compared with the partial character string registered in the dictionary, and the partial character string having the maximum length is selected from the partial character strings that match the input character string, and the code corresponding to the selected partial character string is used. Encode the input string,
Thus, data is compressed.

FIG. 7 is a diagram showing a specific example in which an input character string 71 composed of, for example, a combination of only three characters a, b, and c is encoded by an LZW encoding algorithm. In the dictionary, only one character a, b, and c are registered in association with the codes 1, 2, and 3, respectively, by initialization.

First, the input character string 71 is read one character at a time from left to right. Read the first letter a, and let this a be a prefix string. Next, the second character b
Is read, and ab obtained by adding the b to the initial letter a is compared with the registered character string in the dictionary. Since there is no character string that matches ab in the dictionary, refer to the dictionary at this time and
The corresponding code 1 is output as an encoded output (output code field 72), and the character string ab is registered in the dictionary in association with the code 4 (registration content field 73). Then, the second input character b is set as the initial character.

Next, the third character a of the input character string 71 is read, and ba obtained by adding the letter a to the initial character b is compared with the registered character string in the dictionary. Since there is no character string matching ba in the dictionary, the corresponding code 2 of the initial character b is output from the dictionary as an encoded output and the character string ba is
And register it in the dictionary. Then, the third input character a is set as the initial character.

Further, the fourth character b is read, and ab obtained by adding the b to the initial letter a is compared with the registered character string in the dictionary. In the dictionary, there is a character string that matches ab. In this case, ab is used as the initial character string, then the fifth input character c is read, and abc obtained by adding this c to the initial character string ab is written in the dictionary. Matches with the registered character string of. Since there is no character string that matches abc in the dictionary, the initial character string ab
Is output as an encoded output, and the character string abc is registered in the dictionary in correspondence with the code 6. Then, let c be the initial letter.

[0010] Similarly, encoding and dictionary registration are continued by such an algorithm. In this manner, encoding is performed on the input character strings a, b, a, b, c,..., And codes 1, 2, 4, 3,.
Is output as an encoded output. And FIG.
The correspondence between the registered character string 91 and the corresponding code 92 as shown in (A) is registered in the dictionary.

FIG. 10 is a flowchart showing a processing procedure for encoding the LZW code exemplified above. In the figure, S
The number following "" indicates a step number. [S101] By initialization, a code is registered in the dictionary in such a manner that a code is associated with all the characters that may be input. The address n to be registered next in the dictionary
Is set to, for example, 256 (4 in the example of FIG. 7). n is
Codes 0, 1, 2,... Corresponding to the character strings registered in the dictionary
-When it is added, it corresponds to the total number of registered character strings. Further, the input character string is read, and the first character input is set as a prefix string ω.

[S102] The next input character K is read. [S103] In step S102, it is determined whether or not the input character data exists. Step S1 if present
Go to step S05, if not, go to step S104.

[S104] The initial character string ω is collated with the dictionary, the corresponding code code (ω) is read, and output as an encoded output. The number of bits of the code code (ω) at this time corresponds to the smallest integer equal to or greater than log ₂ n. In this step, since no character string is input, the present processing procedure is terminated after executing this step.

[S105] Step S is added to the initial character string ω.
The character string ωK to which the character K read in 102 is added is collated with the dictionary, and it is determined whether or not the character string ωK is registered in the dictionary. If registered, the process proceeds to step S106. If not registered, the process proceeds to step S107.

[S106] The character string ωK is newly set as the initial character string ω. Then, the process returns to step S102 again. By repeating steps S102 to S106, a character string having the maximum length among the character strings registered in the dictionary is searched for as a character string that matches the input character string.

[S107] The initial character string ω is collated with the dictionary, the corresponding code code (ω) is read, and output as an encoded output. The number of bits of the code code (ω) at this time corresponds to the smallest integer equal to or greater than log ₂ n. Further, the value of n is associated with the character string ωK and registered in the dictionary (actually, the character string ωK is stored at the address n of the dictionary). Further, the character K read in step S102 is set as the initial character string ω, and the dictionary address n is incremented to prepare for execution of the next new input character string from step S102.

FIG. 8 is a diagram showing a specific example in which the encoded output shown in FIG. 7 is decoded this time. In the dictionary on the decoding side, only codes 1, 2, and 3 are registered in association with characters a, b, and c, respectively, by initialization.

First, input codes 81 are read one by one from left to right. The first code 1 is read, and the character string a is restored with reference to the dictionary (restored character string column 821). The first sign is
It is always registered in the dictionary by initialization. Next, the second code 2 is read, and the character string b is restored with reference to the dictionary. At this time, code 4 is associated with (1b), which is a combination of the previous input code 1 and the first character b of the currently decoded character string (although the current decoded character string is simply character b), and stores it in the dictionary. Register (registered content column 83).

Next, the third code 4 of the input character string 81 is read, the corresponding 1b is read with reference to the dictionary, and the code 1 of 1b is read with reference to the dictionary, and the corresponding character a is read with reference to the dictionary. A series of read repetition operations is referred to as "recursive decoding" (see recursive decoding column 82). As a result, the character string ab is output as a decrypted character string (restored character string column 831). At the same time, the combination of the previous input code 2 and the first character a of the currently decoded character string (2a) is registered in the dictionary in association with the code 5 (registered content column 83).

Hereinafter, decoding and dictionary registration are continued by using such an algorithm. In this manner, the input codes 1, 2, 4, 3, 5,... Are decoded, and the character strings a, b, a shown in the restored character string column 821 in FIG.
are output as decoded outputs. Then, the correspondence between the registration code 93 and the corresponding character string 94 as shown in FIG. 9B is registered in the dictionary.

FIG. 11 is a flowchart showing the procedure of the decoding process exemplified above. In the figure, numbers following S indicate step numbers. [S111] Characters are registered in the dictionary in advance by associating characters with codes which may be input by initialization. Further, the address n to be registered next in the dictionary is set to, for example, 256 (4 in the example of FIG. 8). n is a code 0, 1, 2,... corresponding to a character string registered in the dictionary.
Is equivalent to the total number of registered character strings. Next, the input code is read, and the first input code CODE (binary code) is converted into a decimal input code ω (ω was an input character string in the encoding of FIG. Note that it is a sign). This ω is set to OLDω, and since the code to be input first is already registered in the dictionary, a character D (ω) corresponding to the input code ω is searched from the dictionary and output as a decoded character. In addition,
The output character is set in FINchar for exception processing in step S116 described later.

[S112] The next input code CODE is read. [S113] In step S112, it is determined whether or not the input code data exists. Step S1 if present
The process proceeds to step 15, and if not present, this processing procedure ends.

[S114] The input code CODE is converted into the input code ω and the input code ω is converted to INω
Set to. [S115] The input code ω is compared with n. This step determines whether the input code is registered in the dictionary (ω ≧ n)
Is to be determined. It is normal that ω is smaller than n. At this time, the process proceeds to step S117, and when ω is equal to or more than n (the case where the input code column 81 in FIG. 8 is “8” corresponds to this), the process proceeds to step S116.

[S116] OLD ω and FINchar set in step S111 or last time in step S119
(OLD ω, FINchar) is replaced with ωK. That is, the value set to OLD ω is set to ω, and the value set to FINchar is set to K. Then, K is pushed on the stack (PUSH). ω is decoded in step S117. (When the input code field 81 in FIG. 8 is "8", OL
Dω (ω) is 5 and FINchar (K) is b. [S117] Normally, since the input code ω has been registered in the dictionary in the previous processing, the character string D corresponding to the input code ω
(Ω) is read from the dictionary. Character string D (ω) read
Is decomposed into ω _i K. ω _i is a sign and K is a decoded character. Then, it is determined whether or not the character string D (ω) is one character that cannot be decomposed into ω _i K. If D (ω) can be decomposed into ω _i K, the process proceeds to step S118, where D (ω) is 1
If it is a character, the process proceeds to step S119.

[0025] [S118] to push the character K to temporarily stack, also the sign ω _i as a new ω, returns to step S117 again. The execution of steps S117 and S118 is repeated until D (ω) reaches one character. The processing in steps S117 and S118 is referred to as “recursive decoding” as described above.

[S119] Each character pushed on the stack in step S118 is transferred to the LIFO (Last In Fast Out).
Pop (POP) in the format and output the restored character string. For example, if the input code field 81 in FIG. 8 is “5”,
The data is pushed onto the stack in the order of a and b, and a restored character string ba is output. At the same time, the first character of the restored string is set to FINchar, and the previously set OLDω and
A character string composed of a pair with FINchar (OLDω, FINchar) is registered in the dictionary in correspondence with the value of n (actually, this character string is stored at the address n of the dictionary). Furthermore, n
Is incremented and set in step S114.
INω is set to OLDω to prepare for the execution of the next step S112 and subsequent steps.

As described above, in the conventional decoding, the data before encoding is restored by repeatedly performing steps S117 to S119 in FIG. That is, since the input code ω has been registered in the dictionary in the previous processing, the character string D (ω) corresponding to the input code ω is read from the dictionary. Further, the read character string D (ω) is represented by ω _i K
And the character K is temporarily evacuated to the stack. Then, the character string D (ω) corresponding to the input code ω is read from the dictionary again, using the code ω _i as a new input code ω. These procedures are recursively repeated until the new input code ω becomes one character. Then, the character saved in the stack is popped and output in the LIFO format.

[0028]

However, in such a system, as described above, recursive processing must be performed each time even for the same character string restored many times. Therefore, a series of processes such as reading from the dictionary, temporarily saving to the stack, and popping the saved characters are required, and there is a problem that useless time is spent for this process.

The present invention has been made in view of the above points, and provides a data restoration method which effectively utilizes a character string once restored by recursive decoding processing and shortens decoding processing time. The purpose is to do.

[0030]

According to the present invention, in order to achieve the above object, as shown in FIG. 1, a first decoding means 2 for recursively decoding an input code using a first dictionary. When,
A first dictionary registering means for pairing a previously input code and a first character of a currently decoded character string with a new code corresponding to the set and registering the new code in a first dictionary; A second dictionary registration unit 4 and a second decoding unit 3 for registering a character string decoded on the basis of.

The second decoding means 3 has a search means 3a and a character string output means 3b. That is, the search means 3a
Searches for an input code from the second dictionary before performing decoding based on the first decoding means 2. When the input code is detected by the search means 3a, the character string output means 3b
And outputting a decoded character string corresponding to the input code from the second dictionary.

Further, a reference frequency indicating the frequency of referring to the input code registered in the first dictionary is further provided, and the second dictionary registration means 4 receives the new input code every time a new input code is input. The character string output unit 3b includes a counting unit that counts a reference frequency corresponding to the input code, and the character string output unit 3b, when the reference frequency exceeds a predetermined value, decodes the decoded character string corresponding to the input code from the second dictionary Is provided.

Further, the search means 3a searches for the input code only once from the second dictionary and searches for the input code from the first dictionary. Then, the second dictionary registration unit 4, the search unit 3a, and the character string output unit 3b all access the second dictionary based on the hash function.

Then, the second dictionary registering means 4 determines that the character string corresponding to the input code already exists in the second dictionary and that the character string registered in the second dictionary is decoded this time. If the extracted character string is a longer character string, the currently decoded character string is registered in the second dictionary.

[0035]

The first decoding means 2 recursively decodes the input code using the first dictionary. First dictionary registration means 1
Sets a previously input code and the first character of the currently decoded character string as a set, and associates the set with a new code and registers it in the first dictionary.

On the other hand, the second dictionary registration means 4 registers the finally decoded character string based on the input code in the second dictionary together with the input code. The second decoding unit 3 includes a search unit 3a and a character string output unit 3b. Before decoding by the first decoding unit 2, a character string corresponding to an input code is registered in a second dictionary. If this is the case, output this string. That is, the search unit 3a searches the second dictionary for an input code before performing decoding based on the first decoding unit 2. Then, when the input code is detected by the search means 3a, the character string output means 3b outputs a decoded character string corresponding to the input code from the second dictionary.

Further, a reference frequency indicating the frequency of referring to the input code registered in the first dictionary is further provided, and the second dictionary registering means 4 receives this new input code every time a new input code is input. Counting means is provided for counting the reference frequency corresponding to the input code. The character string output means 3b is provided with a selection means for outputting a decoded character string corresponding to the input code from the second dictionary when the reference frequency exceeds a predetermined value. Minimize.

Further, the search means 3a sets the input code to the second
Is searched only once, and then the first dictionary is searched, thereby effectively utilizing the character strings stored in the first dictionary.

Then, the second dictionary registration unit 4, the retrieval unit 3a, and the character string output unit 3b access the second dictionary based on the hash function, and register the second dictionary. And reduce the processing speed of the search.

Then, the second dictionary registration means 4 determines that the character string corresponding to the input code already exists in the second dictionary, and that the character string registered in the second dictionary is decoded this time. If the extracted character string is a longer character string, the newly decoded character string is registered in the second dictionary,
Increase decoding efficiency.

[0041]

An embodiment of the present invention will be described below with reference to the drawings. FIG. 2 is a flowchart showing the processing procedure of the first embodiment of the decoding. In the figure, steps having the same contents as the steps shown in FIG. 11 are assigned the same step numbers as those in FIG. 11, and the description thereof is omitted. However, all the dictionaries described in FIG. 11 are the first dictionaries.
The number following S indicates a step number.

[S21] A hash address H (ω) corresponding to the input code ω is obtained based on the hash function.
Is determined whether or not the input code ω is registered in the dictionary. If the input code ω is registered (YES), the process proceeds to step S22. If the input code ω is not registered (NO), the process proceeds to step S117. Note that the hash address H (ω) is calculated by the remainder obtained by dividing the input code ω by the maximum registrable number of the second dictionary.

[S22] The restored character string corresponding to the input code ω is read from the second dictionary. That is, step S2
The registered character string registered at the hash address H (ω) obtained in step 1 is read. After the reading, the process proceeds to step S24.

[S23] Each character pushed on the stack in step S118 is popped in the LIFO format to output a restored character string. Step S21 on the second dictionary
The restored character string is registered in the second dictionary together with the input code ω in the hash address H (ω) obtained in (1). That is, in FIG. 6 described later, the input code ω is the code code (H
(Ω)), the restored character string is registered as str (H (ω)).

[S24] The first character of the character string restored this time is set to FINchar, and OLDω and FINchar set last time are set.
Is registered in the first dictionary corresponding to the value of n (actually, this character string is registered at the address n of the first dictionary). Further, n is incremented, and INω set in step S114 is set to OLDω, and the next step S11
Prepare for execution after 2.

However, in FIG. 11, the step following step S118 is step S117, whereas in the first embodiment, the step following step S118 is step S21. Thereby, the second dictionary is sequentially accessed based on the hash function, and can be obtained faster than in the conventional decoding.

FIG. 3 is a flowchart showing a processing procedure of the second embodiment of the decoding. In the figures, FIG. 2 and FIG.
Steps having the same contents as the steps shown in FIG. 1 are denoted by the same step numbers as in FIG. 2 and FIG. 11, and the description thereof is omitted. However, all the dictionaries described in FIG. 11 are the first dictionaries. The number following S indicates a step number.

The difference from the first embodiment shown in FIG. 2 is that the step following step S118 is step S21 in FIG. 2, whereas step S118 is executed in the second embodiment.
Is a step S117. Thus, access to the second dictionary is performed only for the first input code ω. The processing time required for step S21 increases as the number of registered second dictionaries increases. Therefore, by eliminating step S21, the restoration processing time can be reduced, and a restored character string can be obtained faster than in the first embodiment.

FIG. 4 is a flowchart showing the processing procedure of the third embodiment of the decoding. In the figures, FIG. 3 and FIG.
Steps having the same contents as the steps shown in FIG. 1 are denoted by the same step numbers as in FIG. 3 and FIG. 11, and the description thereof is omitted. However, all the dictionaries described in FIG. 11 are the first dictionaries. The number following S indicates a step number.

[S41] Each character pushed on the stack in step S118 is popped in the LIFO format to output a restored character string. Then, after outputting the characters, step S42 is executed.
Proceed to.

[S42] Two types of discrimination are performed. That is,
One is the input code ω and the code code (H of the reference number registered in the hash address H (ω) obtained in step S21 in the content of the second dictionary shown in FIG.
(Ω)) is the same or not. The other is whether the length of the character string restored this time is longer than the length of the registered character string str (H (ω)) registered at the hash address H (ω) also corresponding to the input code ω. It is a judgment of whether or not. If the input code ω and the code code (H (ω)) are not the same, and the length of the character string restored this time is the registered character string str (H (ω)) registered in the second dictionary. If it is longer (YES), the process proceeds to step S43, and if shorter (NO), the process proceeds to step S24.

[S43] At the hash address H (ω) obtained in step S21, the character string restored this time is registered in the second dictionary together with the input code ω as a restored character string. That is, in FIG. 6 described later, the input code ω is a code code
(H (ω)), the restored character string is str (H (ω))
Registered as After the dictionary is registered, the process proceeds to step S24.

Therefore, when registering in the second dictionary based on the hash function, a longer character string is registered in the same registration location in the second dictionary. Obtainable.

FIG. 5 is a flowchart showing a processing procedure of the fourth embodiment of the decoding. In the figures, FIG. 2 and FIG.
Steps having the same contents as the steps shown in FIG. 1 are denoted by the same step numbers as in FIG. 2 and FIG. 11, and the description thereof is omitted. However, all the dictionaries described in FIG. 11 are the first dictionaries. The number following S indicates a step number. Then, the first dictionary is further provided with a reference frequency c (ω) representing the frequency of referring to the already registered input code ω.

[S51] The reference frequency c (ω) corresponding to the input code ω is read from the first dictionary, and it is determined whether or not it is larger than a predetermined value T. If the reference frequency c (ω) is a predetermined value T
If it is larger (YES), the process proceeds to step S21, and if the reference frequency c (ω) is smaller than the predetermined value T (NO), the process proceeds to step S117.

[S52] The reference frequency c (ω) corresponding to the input code ω is incremented. Then, step S5
Return to 1. However, in FIG. 11, the step following step S118 is step S117.
In the embodiment, the step following step S118 is step S52. Therefore, since the second dictionary is accessed in correspondence only with the input code ω having a high reference frequency, the second dictionary can be accessed efficiently and the decoding process can be performed quickly.

FIG. 6 is a diagram showing an example of the contents of the second dictionary. The second dictionary includes a reference number and a registered character string based on the hash address H (ω). The reference number corresponds to the input code ω, and the registered character string is a character string decoded by the decoding process. Note that the hash address H (ω) is obtained by the remainder obtained by dividing the input code ω by the maximum number of dictionaries that can be registered (1000 in FIG. 6).

In the above description, the second dictionary is constructed based on the hash function, but may be constructed based on another construction method. For example, a second dictionary is constructed by a binary tree method, and a binary search is performed.
May be used to search for a restored character string.

Each of the above embodiments is applied to the restoration of data obtained by compressing character codes, vector information, image data, and the like in a workstation or the like, and the storage capacity can be greatly reduced. Further, the present invention can be applied to data transmission / reception (for example, a modem, a facsimile, etc.) using a communication line, and the communication time can be reduced.

[0060]

As described above, according to the present invention, the input code is searched from the second dictionary by the search means of the second decoding means, and if it is detected, the character string output means is searched from the second dictionary. A decoded character string corresponding to the input code is output, and if not detected, the first decoding means recursively decodes and outputs the input code using the first dictionary, and then outputs the second dictionary registration means Is configured to apply a predetermined process to this decoded character string, register it in the second dictionary, and prepare for the next decoding process, so that the restored character string corresponding to the input code can be obtained much faster. Can be.

Since the final restored character string is registered in the second dictionary, a restored character string can be obtained without performing recursive decoding processing each time. Moreover, since the registration of the second dictionary is performed based on the hash function, the restored character string can be obtained even faster.

[Brief description of the drawings]

FIG. 1 is a diagram illustrating the principle of the present invention.

FIG. 2 is a diagram showing a procedure of a first decoding process.

FIG. 3 is a diagram showing a procedure of a second decoding process.

FIG. 4 is a diagram showing a procedure of a third decoding process.

FIG. 5 is a diagram showing a fourth decryption processing procedure.

FIG. 6 is a diagram showing an example of the contents of a second dictionary.

FIG. 7 is a diagram illustrating a specific example of LZW encoding.

FIG. 8 is a diagram illustrating a specific example of decoding.

FIG. 9 is a diagram showing a correspondence relationship between a character string and a code.

FIG. 10 is a diagram showing a conventional encoding processing procedure.

FIG. 11 is a diagram showing a conventional decoding processing procedure.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 1st dictionary registration means 2 1st decoding means 3 1st decoding means 3a search means 3b character string output means 4 2nd dictionary registration means

────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Hirotaka Chiba 1015 Kamiodanaka, Nakahara-ku, Kawasaki City, Kanagawa Prefecture Inside Fujitsu Limited (56) References JP-A-60-116228 (JP, A) JP-A-3-68219 (JP, A) JP-A-3-179520 (JP, A) JP-A-3-204233 (JP, A) JP-A-3-204235 (JP, A) (58) Fields investigated (Int. Cl. ⁷⁾ , DB name) H03M 7/40

Claims (5)

(57) [Claims] A first decoding means (2) for recursively decoding an input code using a first dictionary, and combining a previously input code with a first character of a currently decoded character string. A first dictionary registering means (1) for registering a new code in the first dictionary in association with the set, and in a data restoration method for decoding the input code, A second dictionary registration unit (4) for registering the decoded character string together with the input code in a second dictionary; and before performing decoding based on the first decoding unit (2), Search means (3a) for searching for an input code from the second dictionary; and when the input code is detected by the search means (3a), the decoded code corresponding to the input code is detected from the second dictionary. Character string output means (3b) for outputting a character string Data recovery method, characterized in that it comprises a Goka means (3), the. 2. The method according to claim 1, wherein the first dictionary further includes a reference frequency indicating a frequency of referring to the registered input code, and the second dictionary registration unit (4) determines whether a newly input code is newly input. The character string output means (3b) includes a counting means for counting the reference frequency corresponding to the new input code every time the reference frequency is input. 2. The data restoration method according to claim 1, further comprising selecting means for outputting the decoded character string corresponding to the input code from the dictionary of (1). 3. The data restoration method according to claim 1, wherein said search means (3a) searches said input code only once from said second dictionary and searches said first code from said first dictionary. 4. The second dictionary registration unit (4), the search unit (3a), and the character string output unit (3b) all access the second dictionary based on a hash function. The data restoration method according to claim 1, 2, or 3, wherein 5. The method according to claim 1, wherein the second dictionary registration unit (4) is configured to determine whether the character string corresponding to the input code already exists in the second dictionary and the character string registered in the second dictionary. 5. The data restoration method according to claim 4, wherein when the character string decoded this time is longer than the character string decoded this time, the character string decoded this time is registered in the second dictionary.