JPH0993138A - Data compressor and data decoder - Google Patents

Abstract

PROBLEM TO BE SOLVED: To configure the high speed data compressor and decoder by packing data of processing object in the unit of a prescribed integer multiple in the case of conducting data compression and decoding processing based on a dictionary by a moving window so as to arrange the codes at bit boundary. SOLUTION: The compressor is made up of an input file 1, a dictionary retrieval means 3, a coding means 4, an output file 5, a dictionary management means 6, a dictionary management data 7, a window buffer 11, and an advance read buffer 12. In the data compression decoding processing of the dictionary base by a moving window, dictionary reference codes are configured. The bit number of index of the dictionary, the sum of bit number of a longest matching length, and the bit number of generating data are selected to be a multiple of 8, a flag representing the dictionary reference code and a flag denoting raw data are packed in the unit of multiple of 8, then all the codes are arranged to a bit boundary of a multiple of 8 and the boundary matching processing in the unit of bits is not required.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a data compressing device and a data decompressing device for compressing and decompressing data based on a moving window dictionary.

[0002]

2. Description of the Related Art A dictionary-based data compression method using an operating window is disclosed, for example, in "The Data Compression Book Featuring".
fast, efficient data compression techniques in C "
(MarkNelson, M & T Publishing, 1992), based on the data to be compressed, as described in Chapters 7 to 8 of the Japanese title "Data Compression Handbook: Introduction of Compression Techniques for C Programmers" (Toppan). If the dictionary constitutes data and data to be compressed exists in the dictionary, compression is performed by encoding the index and the matching length in the dictionary.

At the time of decompression, a dictionary is constructed on the basis of the decompressed data as in the case of compression, and the decompression is performed by referring to the dictionary.

[0004]

However, in the above-mentioned conventional data compression method, since the code of the number of bits which is not an integral multiple of 8 is used to increase the compression rate, the data processing of the central processing unit (CPU) is One code is formed across the boundary of 1 byte (= 8 bits) which is the minimum unit. For this reason, there is a problem in that a boundary alignment process is required at the time of compression / decompression, which reduces the processing speed.

The present invention has been made in view of the above problems, and an object of the present invention is to provide a data compression apparatus and a data decompression apparatus which have a high processing speed without reducing the compression rate.

[0006]

In order to achieve the above object, the present invention provides a data compression apparatus which searches a dictionary in which predetermined reference data is stored and compresses input data. A search means for searching for the longest match between the input data and the reference data, and a first coding means for coding the first data if the search means finds the longest match. A second encoding means for encoding the second data when the longest match cannot be retrieved by the retrieval means, and means for storing the encoded data and managing the capacity of the dictionary. Equipped with
The first data and the second data are packed and encoded in a predetermined integer unit and output.

According to another aspect of the invention, in a data decompression device for decompressing encoded data stored in a buffer, a determining means for determining a type of the encoded data, and the determining means determines that the encoded data is If it is determined that the encoded data is the first data, the means for performing the first decoding with reference to the buffer; and if the determination means determines that the encoded data is the second data, the second And a means for performing the decoding of the first data and the second data are data packed in a predetermined integer unit.

[0008]

Embodiments of the present invention will be described below in detail with reference to the accompanying drawings.

First, the principle of the LZSS compression method will be described.

FIG. 2 is a diagram for explaining the principle of the LZSS compression method, and here shows a state during the compression process.

In FIGS. 2A and 2B, reference numeral 11 is a window buffer, which stores the last 4079 bytes of the raw data for which the compression code has already been output. A read-ahead buffer 12 stores the first 17 bytes of the raw data for which the compression code has not been output yet.

The dictionary is composed of a window buffer 11 and a look-ahead buffer 12. This dictionary has a window buffer 11
The data of 4079 are registered from the position 1 to the position 4079. The length of each data is the read-ahead buffer 12
The size is “17”. The data in the prefetch buffer 12 may not be the head of the dictionary, but may be the subsequent data. For example, the data at position 1 is "FABCDEF ..." And the remaining 16 bytes are in the prefetch buffer 12.

The encoding is performed as follows.

In FIG. 2A, "... ABCDFFFFF" is stored in the window buffer 11, and "ABCDEF ..." Is stored in the prefetch buffer 12. First, the dictionary composed of the window buffer 11 and the look-ahead buffer 12 is searched to find the data that matches the data stored in the look-ahead buffer 12 at the longest.

As a result of this search, when the longest matching data having a length of 2 or more is found, a flag (= 0) indicating that the dictionary is referred to, window buffer 1 of the longest matching data.
The position at 1 and the match length are encoded respectively. The range of the matching length is 2 to 17, and therefore, 2 is subtracted from this at the time of encoding to encode a code in the range of 0 to 15. In FIG. 2A, the longest matching data is “ABCD”, the position in the window buffer 11 is 9, and the matching length is 4.

Next, the data stored in the window buffer 11 and the look-ahead buffer 12 are left-shifted by the number of bytes of the encoded raw data, that is, the matching length. The data overflowing from the prefetch buffer 12 (“ABCD” in FIG. 2A) is stored in the window buffer 11 from the right side. Further, the raw data not yet stored in the prefetch buffer 12 is stored in the prefetch buffer 12 from the right side by the number of bytes of the raw data encoded from the beginning (see (b) of FIG. 2). Data overflowing from the left side of the window buffer 11 is lost.

As a result of the above search, if the longest matching data having a length of 2 or more is not found, a flag (= 1) indicating that it is raw data and 1 byte of raw data are encoded. In FIG. 2B, the prefetch buffer 1
Since the first data “E” of 2 does not exist in the window buffer 11 and the longest match is not found, the 1-byte raw data to be encoded is “E”.

Then, as in the case where the longest matching data having a length of 2 or more is found, the data stored in the window buffer 11 and the look-ahead buffer 12 is converted into the number of bytes of the encoded raw data, that is, only 1. The left shift is performed, and further, the first 1 byte of the raw data not yet stored in the prefetch buffer 12 is stored in the prefetch buffer 12 from the right side.

FIGS. 3A, 3B and 3C show LZS.
It is a figure which shows the example of the code of the S compression method. In the figure, 13 is an identification file, and when it is "1", it indicates that the code is raw data, and when it is "0", it indicates that it is a dictionary reference.

Reference numeral 14 is a position field having a length of 12 bits, which indicates the position of the longest matched data in the window buffer 11. Reference numeral 15 is a length field having a length of 4 bits and indicates the amount of matching of the longest matching data. 16 is a raw data field having a length of 8 bits and indicates raw data.

In the case of FIG. 2 (a), as shown in FIG. 3 (a), 0 is set in the identification field 13 to indicate that it is a dictionary reference. Also, position field 1
4 is the position of the longest matching data in the window buffer 9 (in binary notation, “00000000100”).
1 ") is set. In the length field 15, 2 (" 0010 "in binary notation) which is a value obtained by subtracting 2 from the matching length 4 of the longest matching data is set.

In the case of FIG. 2 (b), FIG. 3 (b)
As shown in, the identification field 13 is set to 1 indicating that the code is raw data, and the raw data field 16 is set to raw data “E” (binary notation 01000101).

According to the above method, when the longest match having a length of 2 or more is found, the data is compressed because it is encoded with a smaller number of bits than the raw data. In the example above,
4 bytes (32 bits) of "ABCD" are compressed into one code (17 bits).

Further, as shown in FIG. 3C, the code represented by "0" in the identification field 13, the position field 14, and the length field 15 is a special code indicating the end of the data. It is output at the end of the compression code.

Next, the restoration method will be described.

At the time of restoration, the window buffer 1
1 is used but the look-ahead buffer 12 is not used. The window buffer 11 stores the last 17 bytes of the already restored raw data.

In FIG. 2A, when the code shown in FIG. 3A is input, the identification field 13 is checked first. Since the identification field 13 is set to indicate that the code is a dictionary reference, the position field 14 is used to obtain 9 which indicates the position of the longest matching data in the window buffer 11, and the length field 15 is used. 3 is taken out and the value 2 subtracted at the time of compression is added to this to obtain 4 as the matching length.

The position 9 of the longest matching data in the window buffer 11 and the matching length 4 obtained here are used to refer to the window buffer 11 to obtain "AB" as the restored raw data.
CD ″ is obtained, and the data stored in the window buffer 11 is left-shifted by the restored number of bytes, that is, the matching length. Further, the restored data is stored in the window buffer 11 from the right side (see FIG. 2). (B)) In Fig. 2 (b), when the code shown in Fig. 3 (b) is input, first, the identification field 13 is checked, and it is confirmed that the code is raw data. Since the value 1 is set, the raw data “E” (“01000101” in binary notation) is extracted from the raw data field, and the data stored in the window buffer 11 is restored by the number of bytes, that is, 1 Just shift left,
Further, the restored data is stored in the window buffer 11 from the right side.

FIG. 1 is a block diagram showing a functional configuration of a compression device according to an embodiment of the present invention. In the figure, 1 is an input file in which data to be compressed is stored. 12 is a read-ahead buffer, of the data that has not been compressed yet,
Store the top data. 11 is a window buffer,
The last data of the already compressed data is stored in the raw data format. The window buffer 11 constitutes a dictionary together with the look-ahead buffer 12.

Reference numeral 3 is a dictionary retrieval means, which refers to the dictionary management data 7 to retrieve the position of the window buffer 12 which is the longest match with the data stored in the prefetch buffer 11, and which is the longest match position of the window buffer 12. And the match length is output. Reference numeral 4 denotes an encoding unit which, when the dictionary search unit 3 searches for the longest match, encodes a flag indicating the dictionary reference code, an index indicating the position of the searched dictionary, and the longest match length. Turn into. When the longest match is not searched by the dictionary search means 3, the coding means 4 codes the flag indicating the raw data code and the head data of the prefetch buffer 11 as the raw data.

Further, 5 is an output file, which stores the code output by the encoding means 4, 6 is dictionary management means, which stores the already compressed data in the window buffer 11, and the dictionary search means 3 searches. Maintain dictionary management data 7 required for
to manage. As the dictionary management data 7, data necessary for the dictionary search means 3 to search the dictionary is stored.

FIG. 4 is a block diagram showing a schematic configuration of the compression apparatus according to this embodiment. In the figure, reference numeral 21 denotes a CPU, which controls the entire compression apparatus according to a control program stored in the ROM 24. Reference numeral 22 denotes a magnetic disk, which has an input file 1 and an output file 5 shown in FIG.
including. Reference numeral 23 denotes a RAM, which includes the look-ahead buffer 12, the window buffer 11, and the dictionary management data 7 shown in FIG.

The ROM 24 stores the programs constituting the dictionary retrieval means 3, the encoding means 4 and the dictionary management means 6 shown in FIG.

FIG. 5 shows an example of codes processed by the compression apparatus according to this embodiment. Here, the code is composed of 1 block = 17 words (1 word = 2 bytes), and one block includes 16 codes.

One word at the head of each block shown in FIG. 5A is a flag word 31, and whether the code included in this block is a dictionary reference code (when 0) or raw data. (When 1) is shown. The remaining 16 words become the dictionary reference code when the bit of the flag word 31 corresponding to each word is 0, and the raw data when the bit is 1.

Reference numeral 32 is a dictionary reference code, and as shown in FIG. 5B, a position field 14 having a length of 12 bits,
It consists of a length field 15 of length 4 bits. This position field 14 indicates the position of the longest-matching window buffer, as in the case of FIG. 3A, and in the example of FIG.
(Binary notation "000000001001"). Further, the length field 15 indicates a value obtained by subtracting 2 from the matching length of the longest matching data, as in the case of FIG. 3B. In the example of FIG. 001
0 ").

Reference numeral 33 is a raw data code, which is a raw data code having a length of 16 bits, as shown in FIG. 5C. Here, raw data "EF" (in binary notation "010") is used.
0010101000110 "). 34 is an end code, which is a special dictionary reference code in which both the position field 14 and the length field 15 are 0, as shown in FIG. Therefore, it is output at the end of the compression code.

FIG. 6 is a diagram showing the configurations of the window buffer 11 and the look-ahead buffer 12. The BUF shown in FIG.
It has an array that stores 13 words, 0 to 4112
With an index of. This BUF is treated as a ring buffer that stores 4096 words. Therefore, the data next to BUF [4095] is BUF [0].

In the prefetch buffer 12, the head position is indicated by the register CP and the number of words is indicated by the register SIZE. Then, the value of the register CP changes as the compression process progresses, and the position in the BUF changes accordingly.

In the example shown in FIG. 6A, CP = 10
0, SIZE = 17, and in this case, the prefetch buffer 12 is composed of BUF [100] to BUF [116]. In addition, the window buffer 11 has a position immediately after the prefetch buffer 12 as a head, and the prefetch buffer 12
The position immediately before is the last. In the example of FIG. 6A, the window buffer 11 has BUF [117] to BUF [409].
5] and BUF [0] to BUF [99]. That is, the example of FIG. 6A is logically configured as shown in FIG.

BUF [4096] to BUF [4112]
The 17 words are the guard buffer 41, and the same data as the first 17 words of the BUF is always stored in order to eliminate the need for the return processing of the ring buffer at the time of data comparison at the time of search.

7 and 8 are diagrams showing the structure of the dictionary management data 7 of FIG. As shown in FIG. 7, the dictionary management data 7 includes PARENT, YOUNGER, and ELDE.
It is composed of three sequences of R.

When the dictionary searching means 3 searches the dictionary, the entries 0 to 4095 of BUF are treated as a 17-word data string starting at that position. The above three arrays PARENT, YOUNGER, and ELDER form an "aligned binary search tree" according to the size relationship of the data strings stored in the BUF.

PARENT has an array for storing 4097 words and stores the number of the parent node of each node of the sorted binary search tree. An unused node stores 4096, which is a special number indicating that it is unused.

YOUNGER has an array for storing 4097 words and stores the number of a small child node of each node of the sorted binary search tree. If you don't have a small child,
It stores 4096 which is a special number indicating that the child does not exist. ELDER is an array that stores 4354 words, and stores the number of the large child node of each node of the sorted binary search tree. When there is no large child, 4096 which is a special number indicating that there is no large child is stored.

It should be noted that PARENT [4096], YOU
NGAER [4096] and ELDER [4096] are
It is an entry that is used to facilitate processing when it is unused or has no children, and is not used. In addition, ELDER [4
The entries 257 of 097] to ELDER [4353] are entries for indicating the root node of the sorted binary search tree. In the present embodiment, there are 257 aligned binary search trees classified by the hash function.

The example of FIG. 7 shows a case where the register CP = 5, and five data strings starting with BUF [0] to BUF [4] form an aligned binary search tree. Here, for convenience of explanation, these five data strings have the same hash function, and are therefore assumed to be included in the same sorted binary search tree.

As shown in FIG. 8, ELDER [409
7] indicates 0 which is the root node of the sorted binary search tree. The value held by this node is BUF, as shown in FIG.
"DDEEBBAAC" which is a data string starting from [0]
In addition, ELDER [0] indicates C, which is a large child node of node 0, and YOUNGER [0].
Indicates 2 which is a small child node of node 0.
The values of these nodes are "EEBBAACC ..." Starting from BUF [1] and "BBAACC ..." Starting from BUF [2], respectively.

Also, node 1 has no children and ELDER
[1] and YOUNGER [1] store 4096, which is a special value indicating that there are no children.

The processing procedure in the compression apparatus according to this embodiment will be described in detail below.

9 to 11 are flow charts showing the procedure of the compression process (the program stored in the ROM 24 shown in FIG. 4) in the compression device according to the present embodiment. In the following description, the buffer BUF, parent node PARENT, large child node ELDER, small child node YOUNGER, current pointer CP,
Bit pattern register BIT, flag register FLA
G, data buffer DATA, match length register LEN,
It is assumed that the coincidence position pointer MP, the data index I, the counter COUNT, and the node register T are configured on the RAM 23.

The flag register FLAG is a 16-bit flag indicating whether the code is a dictionary reference code or raw data. The data buffer DATA is a 16-word array that stores a dictionary reference code or raw DATA.

When the compression process shown in the flow charts of FIGS. 9 and 10 is started, the initialization process is performed in step S1. Specifically, the input file 1 and the output file 5 are opened, the current pointer CP, the match length register LEN, the data index I, and the flag register F.
0 is stored in LAG, and 32768 is stored in the bit pattern register BIT (in binary notation, “1000000000000000”).
000 "). Also, the parent node PARENT,
Large child node ELDER, small child node YOUNG
Each entry of ER stores 4096, which is a special value indicating that it is unused or has no children.

In the following step S2, 17 words are read from the input file 1 and are read in the buffer BUF [0].
-Stored in BUF [16]. At the same time, the same data is sent to the guard buffer 41, that is, BUF [4096] to B.
Store in UF [4112]. In step S3, the number of words read in step S2 is stored in the prefetch buffer size SIZE. The number of words is normally 17, but when the size of the input file 1 is smaller than 17 words, it becomes smaller accordingly.

In step S4, node 0 is inserted into the sorted binary search tree. In a succeeding step S5 (FIG. 10), the prefetch buffer size is compared with 0, and if it is not 0, the compression has not been completed yet, so the process is performed in the step S
Proceed to 6.

In step S6, the match length register LEN
Is checked, and if it is smaller than 2, raw data is output, and the process proceeds to step S7. In step S7,
The flag register FLAG and the bit pattern register BIT are set to set a flag indicating that the data is raw data.
Is stored in the flag register FLAG. Then, in step S8, BUF [CP], that is, the head data of the prefetch buffer is used as raw data, and DATA is set.
Store in [I].

Next, in step S9, the counter C
The number of processed words, 1 is stored in OUNT, and the process proceeds to step S12.

On the other hand, when the value of the match length register LEN is 2 or more in step S6, the dictionary reference code is output. Therefore, in step S10, the match position pointer MP is first subtracted from the current pointer CP. Is converted to a relative index from the current pointer CP. Then 4095 (in binary notation "00001111"
11111111 ″) and the lower 12 bits are taken out and further multiplied by 16 to shift left by 4 bits. Then, by adding a value obtained by subtracting 2 from the match length register LEN to this. , The dictionary reference code is encoded and stored in DATA [I].

Next, in step S11, the value of the match length register LEN is stored in the counter COUNT, and the process proceeds to step S12. In this step S12, 1 is added to the data index I, and in the following step S13, the node (CP + 17) and 4095, which is the position where the data read in step S14 is stored, is deleted from the aligned binary search tree. Then, in step S14, one word is read. If the data read here is valid, it is determined in step S15 that the file has not ended, and the process proceeds to step S16.

In step S16, the data read in step S14 is BUF [(CP + 17) and 4095], which is 17 words ahead of the current pointer CP.
To be stored. Here, the ring buffer is folded back by taking the logical product with 4095. Further, since data is stored in the guard buffer 41, BUF [C
The same data is stored in [P + 17]. Then, the process proceeds to step S18.

If the data read in step S14 is invalid, it is determined in step S15 that the file has ended, and in step S17 there is no new data, so the read-ahead buffer size is reduced in order to reduce the read-ahead buffer size. Subtract 1 from SIZE and proceed to step S18.

At step S18, the current pointer C
By adding 1 to P and taking the logical product with 4095,
Advance the start of the prefetch buffer by one. Continuing step S1
In 9, the value of the prefetch buffer size SIZE is determined,
If it is 0, the process proceeds to step S21. However, if the buffer size is not 0, the longest match of the node CP is searched and inserted at the same time. The longest match is stored in LEN, and the matched node number is stored in MP (step S20).
The details of the processing in step S20 will be described later.

The above processing steps may be executed a plurality of times in the loop from step S13 to step S22, but since LEN and MP are overwritten each time, the last value of LEN and MP is set. Remains.

In step S21 of FIG. 9, the counter CO
Subtract 1 from UNT, and if it is determined in step S22 that the counter COUNT is not 0, the process returns to step S13. However, if the counter COUNT is 0, since new data has been added to the prefetch buffer 12 by the number of encoded words, the process proceeds to step S23.

In step S23, the bit pattern register BIT is right-shifted by dividing it by 2. In the following step S24, the value of the bit pattern register BIT is checked, and if it is not 0, the process is returned to step S5. However, when the value is 0, since the code of 16 is output, the process proceeds to step S25 and the flag register FL
The AG and the data buffer DATA are written in the output file 5. Then, in step S26, the data index I, 0 is stored in the flag register FLAG, 32768 is stored in the bit pattern register BIT, and the process returns to step S5.

When it is determined in the above step S5 that the prefetch buffer size SIZE is 0, the compression has been completed, so the flow advances to step S27, and DATA [I] is set to 0 in order to output the end code. Store. Then, in step S28, the flag register FLAG and the data buffer DATA are written in the output file 5. In the following step S29, the input file 1 and the output file 5
The end processing such as closing is performed, and the main compression processing is ended.

FIG. 11 is a detailed flowchart of the search / insert processing of step S20 shown in FIG.

In FIG. 11, first, in step S41, 0 is stored in the match length register LEN. Next, in step S42, the hash value of the node CP is calculated, and the value obtained by adding 4097 is stored in the node register T as the node number indicating the root node of the sorted binary search tree.
The hash function for calculating the above hash value is (BUF [CP] * 65536 + BUF [CP + 1])% 257 (1). Here,% indicates a remainder operation, and the left side of% is 25
The remainder divided by 7 becomes the hash function value.

Next, in step S43, ELDER
Compare [T] with 4096. ELDER [T] is 40
If it is 96, the aligned binary search tree is empty, so the node CP
In order to form an aligned binary search tree having as a root, the process proceeds to step S56. However, ELDER [T] is 4
If it is smaller than 096, there is a root node, so in step S44, ELDER [T], that is, the node number of the root node is stored in T, and the flow proceeds to step S45.

In step S45, the matching length between the node CP and the node T is obtained. In a succeeding step S46, the match length is compared with the already obtained longest match length LEN. If the match length obtained in step S45 is not greater than LEN, the process proceeds to step S51.

If the match length obtained in step S45 is larger than LEN, it is determined that a new longest match length is obtained, the process proceeds to step S47, and the match length obtained in step S45 is stored in LEN. , And stores the value of the node register T in MP. In the following step S48,
Match length register LEN and prefetch buffer size SIZ
Compare with E. If the determination here is that LEN ≧ SIZE, a longer match cannot be obtained, so the flow advances to step S49 to set the value of the prefetch buffer size SIZE to L.
Store in EN. Then, in step S50, since the node CP and the node T are the same data string, the node T is replaced with the node C, the node T is deleted, and this search insertion processing is ended.

On the other hand, in step S48, LEN <SI
If it is determined to be ZE, a longer match may be found, so the process proceeds to step S51. In this step S51, the data string of the node CP and the data string of the node T are compared.

That is, if the data sequence of the node CP> the data sequence of the node T, the process proceeds to step S52 to trace a large child node, and ELDER [T] and 409
Compare 6 Then, if ELDER [T] = 4096, then there is no large child in node T, so node C
To make P a large child of node T, step S56
Proceed to. However, if ELDER [T] ≦ 4095, the node T has a large child, so the process proceeds to step S53, and the node number of the large child, that is, ELDER
The value of [T] is stored in T, and the process returns to step S54.

If the data sequence of the node CP <the data sequence of the node T in step S51, the process proceeds to step S54 to trace the small child node, and YOUNG
Compare ER [T] with 4096. YOUNGER
If [T] = 4096, the node T has no small child. Therefore, in order to make the node CP a small child of the node T, the value of CP is YOUNGER in step S57.
Store in [T] and proceed to step S58.

On the other hand, in step S54, YOUNGE
If it is determined that R [T] <4096, the node [T] has a small child. Therefore, the process proceeds to step S55, and the node number of the small child, that is, the value of YOUNGER [T] is set to T.
And the process returns to step S54.

In step S56, the value of CP is set to ELDER in order to make node CP a large child of node T.
Store in [T]. In the following step S58, the node C
The value of T is PAR so that the parent node of P is the node T.
Store in ENT [CP]. Further, in order to have both child nodes of the node CP, ELDER [CP], YOUN is set to 4096, which is a special value indicating that there are no children.
After storing in GER [CP], this search insertion processing ends.

Next, the restoration device according to the embodiment of the present invention will be described. .

FIG. 12 is a block diagram showing a functional configuration of the restoration device according to the embodiment of the present invention. In the figure, 51 is an input buffer, which stores the compression code shown in FIG.
Reference numeral 52 denotes a decoding means, which refers to the compressed code stored in the input buffer 51 and the restored data stored in the output buffer 53 to decode the compressed code. The output buffer 53 stores the data restored by the decoding means 52.

FIG. 13 is a block diagram showing a specific structure of the restoration device according to the present embodiment. In the figure, 54 is an input interface for receiving a compression code from the outside. Reference numeral 55 denotes a CPU, which controls the entire restoration apparatus according to a control program stored in the ROM 57.
56 is a RAM, which is the input buffer 51 shown in FIG.
It includes an output buffer 53. The ROM 57 stores the program forming the decryption means 52.

FIG. 14 is a diagram showing the structure of the input buffer 51 of FIG. As shown in FIG. 14A, the input buffer 51 is composed of an array IBUF. Each entry of this IBUF is composed of the structure shown in FIG. 14B, that is, the structure shown in FIG. 14B, that is, a 1-word FLAG and a 16-word array DATA.

The FLAG of the J-th entry of IBUF shown in FIG. 14A is IBUF [J]. It is described as FLAG. Also, the DAT of the J-th entry of IBUF
The I-th entry of A is IBUF [J]. DATA
[I] is described. However, in the flowchart shown in FIG. 15, which will be described later, FLAG and DATA are respectively set.
It is abbreviated as [I].

Next, the processing procedure in the restoration apparatus according to this embodiment will be described with reference to the flowchart shown in FIG. In the following description, the input buffer IBUF, the output buffer BUF, the current pointer C
P, bit pattern register BIT, match length register L
EN, coincidence position pointer MP, data index I,
The input index J is configured on the RAM 56 of FIG. Further, the compression code received by the input interface 54 is stored in advance in the input buffer IBUF.

First, initialization is performed in step S101 of FIG. Specifically, 0 is stored in the current pointer CP and the input index J. Next step S102
, 0 is stored in the data index I, and 32768 (binary notation “100” is stored in the bit pattern register BIT).
0000000000 ") is stored.

In step S103, IBUF [J].
The logical product of FLAG and the bit pattern register BIT is taken, and if the result is 0, it is a dictionary reference code,
The process proceeds to step S106. However, if the result is not 0, the code is a raw data code, and the process proceeds to step S104, and IBUF [J]. DATA [I] is stored in the output buffer BUF [CP] as raw data. Then, in step S105, 1 is added to the current pointer CP,
Then, the process proceeds to step S112.

If it is determined in step S103 that it is the dictionary reference code, in step S106, IBUF
[J]. Compare DATA [I] with 0. This IBUF
[J]. When BUF [I] is 0, it is an end code, so
It proceeds to step S115. However, IBUF [J]. B
If UF [I] is not 0, the process proceeds to step S107, and IBUF [J]. By taking the logical product of DATA [I] and 15 (“00000000000011111” in binary notation), the lower 4 bits are extracted, and further,
The match length is obtained by adding 2 and is stored in the match length register LEN.

At step S108, IBUF [J].
Divide DATA [I] by 16 to shift right by 4 bits and take out the upper 12 bits. The match position is obtained by subtracting this value from the current pointer CP, and this is stored in the match position pointer MP. Continuing step S10
At 9, the value of BUF [MP] is stored in BUF [CP],
In the next step S110, 1 is added to the current pointer CP and the match position pointer MP, and the match length register LE is added.
The process of subtracting 1 from N is performed. Then, step S11
At 1, the match length register LEN is compared with 0.

If it is determined in step S111 that LEN> 0, the transfer has not been completed.
Return to 09. However, if LEN = 0, step S
Proceed to 112. In this step S112, 1 is added to the data index I, and the bit pattern register BIT is divided by 2 to shift right by 1 bit.

In step S113, 0 is compared with the bit pattern register BIT. If BIT ≠ 0,
Returning to step S103, if BIT = 0, 1
Since the code of 6 has been restored, the process proceeds to step S114, 1 is added to the input index J, and step S10 is performed.
It returns to the process of 2.

In step S106, IBUF
[J]. If DATA [I] = 0, the code is an end code, so the process advances to step S115 to perform end processing such as outputting the data restored in the output buffer BUF to the output interface 58, and the present restoration processing ends.

As described above, according to the present embodiment, in the dictionary-based data compression / decompression process using the moving window, the number of bits of the index of the dictionary and the number of bits of the longest matching length that constitute the dictionary reference code. And the number of bits of raw data are both multiples of 8, and by packing the flag indicating that it is a dictionary reference code and the flag indicating that it is raw data in units of multiples of 8, all codes Can be aligned with a bit boundary that is a multiple of 8, and the alignment processing in bit units is not required, so that the processing speed can be increased.

In the above embodiment, the number of bits of raw data = 16, the number of bits of the index field of the dictionary reference code + the number of bits of the length field = 1
6, the number for packing the flag for distinguishing whether the dictionary reference code is raw data = 16, but is not limited to this, and for example,
These are variable multiples of 8 and the raw data bit number = 3
It may be 2 or the like.

Further, in the above-mentioned embodiment, the number for packing the flag for distinguishing between the dictionary reference code and the raw data is fixed. However, for example, this is set to a variable multiple of 8 and the flag is added before the flag. The number, or the number of bytes, the number of words or the like corresponding thereto may be indicated.

The present invention may be applied to a system composed of a plurality of devices or an apparatus composed of a single device. Further, it goes without saying that the present invention can be applied to the case where it is implemented by supplying a program to a system or an apparatus. In this case, the storage medium storing the program according to the present invention constitutes the present invention. Then, by reading the program from the storage medium into the system or device, the system or device operates in a predetermined manner.

[0094]

As described above, according to the present invention,
When performing data compression / decompression processing based on a moving window dictionary, by packing the data to be processed in units of a specified integer multiple, the code can be aligned on a byte (or word) boundary, Since it is not necessary to perform the unit alignment processing, a high speed data compression / decompression device can be configured.

[0095]

[Brief description of drawings]

FIG. 1 is a block diagram showing a functional configuration of a compression device according to an embodiment of the present invention.

FIG. 2 is a diagram for explaining the principle of the LZSS compression method.

FIG. 3 is a diagram illustrating an example of codes of the LZSS compression method.

FIG. 4 is a block diagram showing a schematic configuration of a compression device according to the present embodiment.

FIG. 5 is a diagram showing an example of codes processed by the compression apparatus according to the embodiment.

FIG. 6 is a diagram showing configurations of a window buffer and a prefetch buffer.

FIG. 7 is a diagram showing a structure of dictionary management data.

FIG. 8 is a diagram showing a structure of dictionary management data.

FIG. 9 is a flowchart showing a procedure of a compression process in the compression device according to the embodiment.

FIG. 10 is a flowchart showing a procedure of compression processing in the compression device according to the embodiment.

FIG. 11 is a detailed flowchart of a search insertion process.

FIG. 12 is a block diagram showing a functional configuration of a restoration device according to an embodiment.

FIG. 13 is a block diagram showing a specific configuration of the restoration device according to the embodiment.

14 is a diagram showing a configuration of an input buffer of FIG.

FIG. 15 is a flowchart showing a processing procedure in the restoration device according to the embodiment.

[Explanation of symbols]

 1 Input File 3 Dictionary Search Means 4 Encoding Means 5 Output File 6 Dictionary Management Means 7 Dictionary Management Data 11 Window Buffer 12 Lookahead Buffer 13 Identification Field 14 Position Field 15 Length Field 16 Raw Data Field 21,55 CPU 22 Magnetic Disk 23 , 56 RAM 24, 57 ROM 31 flag word 32 dictionary reference code 33 raw data code 34 end code 41 guard buffer 51 input buffer 52 decoding means 53 output buffer 54 input interface 58 output interface

Claims (6)

[Claims] 1. A data compression apparatus that searches a dictionary in which predetermined reference data is stored to compress input data, and searches the dictionary to find the longest match between the input data and the reference data. A first encoding unit that encodes the first data when the longest match can be searched by the searching unit; and a second coding unit that can search the longest match by the searching unit. Second encoding means for encoding the data, and means for storing the encoded data and managing the capacity of the dictionary, wherein the first data and the second data are A data compression device characterized by being packed in a predetermined integer unit, coded, and output. 2. The first data is composed of a flag indicating the reference code of the dictionary, an index indicating the retrieved data of the dictionary, and data indicating the length of the longest match, The data compression apparatus according to claim 1, wherein the second data is composed of raw data in an uncompressed state and a flag indicating the raw data. 3. The data compression apparatus according to claim 1, wherein the predetermined integer unit is an arbitrary multiple of 8. 4. A data decompression device for decompressing encoded data stored in a buffer, wherein a determination unit determines a type of the encoded data, and the determination unit causes the encoded data to be first data. If it is determined that the first decoding is performed by referring to the buffer, and if the determination unit determines that the encoded data is the second data, the second decoding is performed. A data recovery device, wherein the first data and the second data are data packed in a predetermined integer unit. 5. The flag indicating that the first data is a reference code of a dictionary in which predetermined reference data is stored,
An index indicating the data of the reference dictionary, and data indicating the length of the data of the reference dictionary,
The data restoration device according to claim 4, wherein the second data is composed of raw data and a flag indicating that the second data is the raw data. 6. The data restoration apparatus according to claim 4, wherein the predetermined integer unit is an arbitrary multiple of 8.