Efficient verification method based on Zdelta compression algorithm

Abstract

The invention relates to the technical field of compression algorithm verification, in particular to an efficient verification method based on a Zdelta compression algorithm. The method comprises the following steps of: restoring compressed data into uncompressed data according to a recorded data compression rate; and during testing, according to the compressed data format, generating a test vector. The invention provides a verification method designed and realized by a Zdelta compression algorithm. According to the verification method, the design verification personnel can efficiently generate the test excitation capable of specifying the compression size of the image data according to the test scene. Verification scenes are greatly enriched, defects existing in design implementation are found in advance, automatic solving is achieved through SV constraints, test vectors can be generated quickly and efficiently, the size of a test vector compression result can be specified, the precision of the test vectors is high, values of some pixels in the test vectors can be specified, and the flexibility is high.

Description

Technical Field

[0001] This invention relates to the field of compression algorithm verification technology, and more specifically, to an efficient verification method based on the Z_delta compression algorithm. Background Technology

[0002] With advancements in sensor technology and computer vision applications, we can capture high-resolution depth image data. This data is not only massive in size but also filled with complex spatial information and potential noise. Depth images also contain a large number of invalid or void regions, making it difficult for traditional compression algorithms to effectively process this type of data. Existing compression algorithm verification methods are generally suitable for text or ordinary two-dimensional images, but they are not entirely suitable for the unique needs of depth images. For example, depth images may contain a large number of null values ​​and inaccuracies due to sensor noise. In addition, real-time applications (such as augmented reality and autonomous driving) require compression and decompression processes to be fast and resource-efficient to ensure user experience and system response speed. Therefore, this paper proposes an efficient verification method based on the Z_delta compression algorithm. Summary of the Invention

[0003] The purpose of this invention is to provide an efficient verification method based on the Z_delta compression algorithm, so as to solve the problems of low efficiency and difficult verification of traditional compression algorithms mentioned in the background art.

[0004] To achieve the above objectives, the present invention aims to provide an efficient verification method based on the Z_delta compression algorithm, comprising the following steps:

[0005] S1. Calculate the predicted value for each pixel;

[0006] S2. Based on the pixel-based prediction value, the delta value of each pixel is obtained;

[0007] S3. Based on the pixel delta value, obtain the predicted delta value for each pixel;

[0008] S4. Obtain the symbol value based on the size of the delta value;

[0009] S5. Based on the symbol value, the final pre-compressed data is obtained;

[0010] S6. Based on the recorded data compression ratio, restore the compressed data to its uncompressed state. During testing, generate test vectors according to the compressed data format.

[0011] S7. During testing, generate test vectors according to the compressed data format.

[0012] As a preferred technical solution of the present invention, S7 specifically includes the following steps:

[0013] The first step is to randomly compress the data format;

[0014] The second step is random compression mode;

[0015] The third step is to randomly adjust the compression ratio.

[0016] The fourth step is to randomly compress the number of bits in the data;

[0017] Step 5: Randomize the position of the first non-FC pixel;

[0018] Step 6: Randomize the total encoding length of each pixel;

[0019] Step 7: Randomize the value of stage0 for each pixel;

[0020] Step 8: Randomize the length and value of each pixel in each stage;

[0021] Step 9: Randomize the first non-FC pixel value;

[0022] Step 10: Calculate the stage data;

[0023] Step 11: Assemble the data from each stage;

[0024] Step 12: Based on the compression ratio, pad the high-order bits of the compressed data with 0s and perform 32-bit alignment.

[0025] As a preferred technical solution of the present invention, the compressed data format in the first step is 0 or 1, where 0 represents a 16-bit pixel mode and 1 represents a 24-bit pixel mode.

[0026] As a preferred technical solution of the present invention, the compression mode in the second step is 0 or 1, where 0 represents a 128B pixel mode and 1 represents a 256B pixel mode.

[0027] As a preferred technical solution of the present invention, in the third step, if the compression mode is 0, the internal compressed bytes are {[0:3]}; if the compression mode is 1, the internal compressed bytes are {[0:7]}; where, in [0:3], 0 represents a data compression rate of 32B, 1 represents 64B, 2 represents 96B, and 3 represents 128B; in [0:7], 0 represents a data compression rate of 32B, 1 represents 64B, 2 represents 96B, and 3 represents 128B; 4 represents a data compression rate of 160B; 5 represents a data compression rate of 192B; 6 represents a data compression rate of 224B; and 7 represents a data compression rate of 256B.

[0028] Relationship between total length of compressed data and compression ratio

[0029] Compression ratio Total length 32B 0~256bit 64B 257~512 bits 96B 513~768bit7 128B 769~1024 bits 160B 1025~1280bit 192B 1281~1536bit 224B 1537~1792 bits fail 1793~2048bit

[0030] As a preferred technical solution of the present invention, in the fifth step, if the compression mode is 0 and the compressed data format is 1, then the position of the first non-FC pixel is {[0:31]}, otherwise the position of the first non-FC pixel is {[0:63]}.

[0031] As a preferred technical solution of the present invention, in the sixth step, if the compression mode is 0 and the compressed data format is 0, then the sum of pixel stage value [0] to pixel stage value

[63] plus 16 and 10 equals comp_bits, where 10 is the number of bits of N0 in the compressed data format, and the value of N0 is the total length of compression algorithm stage3 divided by 2; 16 is the number of bits of N1 in the compressed data format, and the value of N1 is the value of the first Non_FC pixel;

[0032] If the compression mode is 0 and the compressed data format is 1, then the sum of pixel stage values ​​[0] to pixel stage values ​​

[31] plus 24 and 10 equals comp_bits, where 10 is the number of bits of N0 in the compressed data format, and the value of N0 is the total length of compression algorithm stage3 divided by 2; 24 is the number of bits of N1 in the compressed data format, and the value of N1 is the value of the first Non_FC pixel;

[0033] If the compression mode is 1 and the compressed data format is 0, then the sum of pixel stage values ​​[0] to pixel stage values ​​

[63] plus 16 and 10 equals comp_bits, where 10 is the number of bits of N0 in the compressed data format, and the value of N0 is the total length of stage3 of the compression algorithm divided by 2; 16 is the number of bits of N1 in the compressed data format, and the value of N1 is the value of the first Non_FC pixel;

[0034] If the compression mode is 1 and the compressed data format is 1, then the sum of pixel stage values ​​[0] to pixel stage values ​​

[63] plus 24 and 10 equals comp_bits, where 10 is the number of bits of N0 in the compressed data format, and the value of N0 is the total length of compression algorithm stage3 divided by 2; 24 is the number of bits of N1 in the compressed data format, and the value of N1 is the value of the first Non_FC pixel;

[0035] If the compressed data format is 0, then the pixel stage value belongs to {1, 3, 6, [8:18], 22};

[0036] If the compressed data format is 1, then the pixel stage value belongs to {1, 3, [7:14], 16, [18:25], 31}.

[0037] As a preferred technical solution of the present invention, in the seventh step, stage0 data[I] is traversed. If I is less than the position of the first non-FC pixel, then stage0 data[I] is 0; otherwise, if I is equal to the position of the first non-FC pixel, then stage0 data[I] is 1; otherwise, if pixel stage[I] is equal to 1, then stage0 data[I] is 0.

[0038] As a preferred technical solution of the present invention, the length occupied by each pixel in each part is divided into the following types:

[0039] If it only exists in stage0, then the pixel encoded as 0 in stage0 and the first pixel encoded as 1 have a total encoding length of 1.

[0040] If it only exists in stage0 and stage1, then the encoding in stage0 is 1, and except for the first pixel with an encoding of 1, the total encoding length of this pixel is 3.

[0041] It exists in stage0, stage1, and stag2, at which point the total length of the pixel encoding is 7.

[0042] It exists in the case of stage0+stage1+stage2+(one or two of stage3, stage4).

[0043] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0044] This efficient verification method based on the Z_delta compression algorithm automatically solves the SV constraint, which can generate test vectors quickly and efficiently. The size of the compressed test vector result can be specified, the test vector accuracy is high, and the value of certain pixels in the test vector can be specified, which is highly flexible. Attached Figure Description

[0045] Figure 1 This is a flowchart illustrating the overall method of the present invention;

[0046] Figure 2 This is a flowchart illustrating how the present invention generates test vectors according to a compressed data format. Detailed Implementation

[0047] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0048] An efficient verification method based on the Z-delta compression algorithm includes the following steps:

[0049] S1. Calculate the predicted value for each pixel (as shown in Table 1 below);

[0050] S2. Based on the pixel-based prediction value, the delta value of each pixel is obtained;

[0051] S3. Based on the pixel delta value, obtain the predicted delta value for each pixel;

[0052] S4. Obtain the symbol value based on the size of the delta value;

[0053] S5. Based on the symbol value, the final pre-compressed data is obtained;

[0054] S6. Based on the recorded data compression ratio, restore the compressed data to its uncompressed state. During testing, generate test vectors according to the compressed data format.

[0055] S7. During testing, generate test vectors according to the compressed data format.

[0056] Table 1 shows the predicted value matrix for each pixel:

[0057]

[0058] As a preferred technical solution of the present invention, S7 specifically includes the following steps:

[0059] The first step is to randomly compress the data format;

[0060] The second step is random compression mode;

[0061] The third step is to randomly adjust the compression ratio.

[0062] The fourth step is to randomly compress the number of bits in the data;

[0063] Step 5: Randomize the position of the first non-FC pixel;

[0064] Step 6: Randomize the total encoding length of each pixel;

[0065] Step 7: Randomize the value of stage0 for each pixel;

[0066] Step 8: Randomize the length and value of each pixel in each stage (specific rules are shown in Table 2 below);

[0067] Step 9: Randomize the first non-FC pixel value;

[0068] Step 10: Calculate the stage data;

[0069] Step 11: Assemble the data from each stage;

[0070] Step 12: Based on the compression ratio, pad the high-order bits of the compressed data with 0s and perform 32-bit alignment.

[0071] Table 2: Length and numerical rules of pixels in a stage:

[0072]

[0073] In the table, the total length of the pixel encoding represents the total length of the compressed data after the pixel is compressed, and its value is stg0_len + stg1_len + ... + stg4_len;

[0074] Stg0_len~stg4_len represent the length of the pixel in each stage of encoding;

[0075] Stg0_data~stg4_data represent the value range of this pixel in each stage (empty indicates that there is no corresponding stage encoding). As a preferred technical solution of the present invention, the compressed data format in the first step is 0 or 1, where 0 represents a 16-bit pixel mode and 1 represents a 24-bit pixel mode.

[0076] As a preferred technical solution of the present invention, the compression mode in the second step is 0 or 1, where 0 represents a 128B pixel mode and 1 represents a 256B pixel mode.

[0077] As a preferred technical solution of the present invention, in the third step, if the compression mode is 0, the internal compressed bytes are {[0:3]}; if the compression mode is 1, the internal compressed bytes are {[0:7]}; where, in [0:3], 0 represents a data compression rate of 32B, 1 represents 64B, 2 represents 96B, and 3 represents 128B; in [0:7], 0 represents a data compression rate of 32B, 1 represents 64B, 2 represents 96B, and 3 represents 128B; 4 represents a data compression rate of 160B; 5 represents a data compression rate of 192B; 6 represents a data compression rate of 224B; and 7 represents a data compression rate of 256B.

[0078] As a preferred technical solution of the present invention, in the fifth step, if the compression mode is 0 and the compressed data format is 1, then the position of the first non-FC pixel is {[0:31]}, otherwise the position of the first non-FC pixel is {[0:63]}.

[0079] As a preferred technical solution of the present invention, in the sixth step, the compression mode is 0 and the compressed data format is 0, then the sum of pixel stage value [0] to pixel stage value

[63] plus 16 and 10 equals comp_bits, where 10 is the length of N0 in the compressed data format, and N0 is the total length of compression algorithm stage3 divided by 2 (the composition of compressed data is N0~N6).

[0080] Furthermore, N0 to N6 represent the bit lengths of each component in the compressed data, specifically defined as follows:

[0081] N0: Stg3_len (a field representing the total length of Stg3_data in compressed data), fixed at 10 bits;

[0082] N1: Raw_data (raw data of the first non-reference pixel), fixed at 24 bits (when Data_format=1) or 16 bits (when Data_format=0).

[0083] N2: Stg0_data (encoded data of all pixels in Stage0), with a length of the number of pixels × 1 bit (e.g., 64 bits for 64 pixels).

[0084] N3: Stg1_data (encoded data of all pixels in Stage 1), with a length of 2 × the number of pixels marked as 1 in Stage 0;

[0085] N4: Stg2_data (encoded data of all pixels in Stage2), with a length of 4 × the number of pixels that meet the conditions (Stage0=1 and Stage1≠01 / 11 must be satisfied).

[0086] N5: Stg3_data (encoded data of all pixels in Stage3), with a length of 2×Stg3_len (i.e., dynamically calculated based on the Stg3_len field);

[0087] N6: Stg4_data (encoded data of all pixels in Stage 4), the length of which is the remaining part of the compressed package (derived by subtracting the length of other parts from the total length);

[0088] The formula for total length is:

[0089] N = N0 + N1 + N2 + N3 + N4 + N5 + N6;

[0090] If the compression mode is 0 and the compressed data format is 1, then the sum of pixel stage values ​​[0] to pixel stage values ​​

[31] plus 24 and 10 equals comp_bits, where 16 and 24 are the lengths of N1 in the compressed data format, and N1 is the first Non_FC pixel;

[0091] If the compression mode is 1 and the compressed data format is 0, then the sum of pixel stage values ​​[0] to pixel stage values ​​

[63] plus 16 and 10 equals comp_bits;

[0092] If the compression mode is 1 and the compressed data format is 1, then the sum of pixel stage values ​​[0] to pixel stage values ​​

[63] plus 24 and 10 equals comp_bits;

[0093] If the compressed data format is 0, then the pixel stage value belongs to {1, 3, 6, [8:18], 22};

[0094] If the compressed data format is 1, then the pixel stage value belongs to {1, 3, [7:14], 16, [18:25], 31}.

[0095] As a preferred technical solution of the present invention, in the seventh step, stage0 data[I] is traversed. If I is less than the position of the first non-FC pixel, then stage0 data[I] is 0; otherwise, if I is equal to the position of the first non-FC pixel, then stage0 data[I] is 1; otherwise, if pixel stage[I] is equal to 1, then stage0 data[I] is 0.

[0096] As a preferred technical solution of the present invention, the length occupied by each pixel in each part is divided into the following types:

[0097] If it only exists in stage0, then the pixel encoded as 0 in stage0 and the first pixel encoded as 1 have a total encoding length of 1.

[0098] If it only exists in stage0 and stage1, then the encoding in stage0 is 1, and except for the first pixel with an encoding of 1, the total encoding length of this pixel is 3.

[0099] It exists in stage0, stage1, and stag2, at which point the total length of the pixel encoding is 7.

[0100] This can exist in the case of stage0+stage1+stage2+(one or two of stage3 and stage4). The reason why the total encoding length is 1, 3, or 7 is as follows: the encoding length of each pixel in stage0 is 1, the encoding length in stage1 is 2, and the encoding length in stage2 is 3 or 4 (3 in 16-bit mode and 4 in 24-bit mode).

[0101] The length occupied by each pixel in each part is divided into the following types:

[0102] It only exists in stage0, that is, the pixel encoded as 0 in stage0 and the first pixel encoded as 1. At this time, the total length of the pixel's encoding is 1.

[0103] It only exists in stage0 and stage1, that is, it is encoded as 1 in stage0, and except for the first pixel encoded as 1, the total length of the encoding of this pixel is 3 (stage0 1 + stage1 2).

[0104] The pixels that exist in stage0, stage1, and stag2, as shown in the table below, have symbols of 00000, 00001, and 11110. At this time, the total encoding length of the pixel is 7.

[0105] The case exists in stage0 + stage1 + stage2 + (one or two of stage3 and stage4);

[0106] The first step is to randomly compress the data format, where data_format=0,1, where 0 represents a 16-bit pixel mode and 1 represents a 24-bit pixel mode;

[0107] The second step is to set a random compression mode, where comp_mode, 0 represents 128B mode and 1 represents 256B mode.

[0108] Step 3, random compression ratio:

[0109] omp_mode=0->comp_bytes inside{[0:3]};comp_mode=1->comp_bytesinside{[0:7]}

[0110] omp_mode=0 -> comp_bytesinside{[0:3]};

[0111] comp_mode=1 -> comp_bytesinside{[0:7]}

[0112] The fourth step is to randomly compress the number of bits in the data;

[0113] Step 5: Randomize the position of the first non-FC pixel, First_nonFc_index

[0114] Comp_mode=0&&data_format==1->First_nonFc_index inside{[0:31]};

[0115] Else -> First_nonFc_index inside {[0:63]};

[0116] Step 6: Randomize the total encoding length of each pixel:

[0117] Comp_mode==0,data_format==0->pixel_all_stg_size,pixel_all_stg_size[0]+ … +pixel_all_stg_size

[63] +16+10==comp_bits

[0118] Comp_mode==0,data_format==1->pixel_all_stg_size,pixel_all_stg_size[0]+…+pixel_all_stg_size

[31] +24+10==comp_bits

[0119] Comp_mode==1,data_format==0->pixel_all_stg_size,pixel_all_stg_size[0]+…+pixel_all_stg_size

[63] +16+10==comp_bits

[0120] Comp_mode==1,data_format==1->pixel_all_stg_size,pixel_all_stg_size[0]+…+pixel_all_stg_size

[63] +24+10==comp_bits

[0121] Data_format==0->pixel_all_stg_size[i] inside {1,3,6,[8:18],22}

[0122] Data_format==1->pixel_all_stg_size[i] inside{1,3,[8:14],16,[18:25],31}

[0123] First_NOnFc_index>=i->pixel_all_stg_size[i]==1

[0124] Step 7: Randomize the value of stage0 for each pixel:

[0125] Foreach(stage0_data_pixel [i])

[0126] If(I < First_nonFc_index)->stg0_data[i]==0

[0127] Else If(I==first_nonFc_index)->stg0_data[i]==1

[0128] Else If(pixel_all_stg_size[i]==1)->stg0_data[i]==0

[0129] Else stg0_data[i]==1

[0130] Step 8: Randomize the length and value of each pixel in each stage, as shown in Table 2.

[0131] Step 9: Randomize the first non-FC pixel value, raw_data;

[0132] Step 10, Calculation:

[0133] stage3_len,stage3_len=(stg3_len[0]+…+stg3_len[n]),n=32or64

[0134] Step 11: Combine the data from each stage;

[0135] Comp_mode=0&&data_format==1,pixel_num==32

[0136] Else pixel_num==64

[0137] Comp_data[9:0]==stage3_len / 2,data_index=10

[0138] If(Data_format==0)Comp_data[data_index+16:16]=raw_data[15:0],data_index=data_index+16

[0139] ElseIf(Data_format==1)Comp_data[data_index+24:24]=raw_data[15:0],data_index+24

[0140] For(j=0;j<pixel_num / 32)begin

[0141] For(i=0;I<32;i++)begin

[0142] Pixel_index=32*j+I;

[0143] If(stg1_len[pixel_index]!=0)begin

[0144] Comp_data[data_index+:2]= stg1_data[pixel_index]

[0145] Data_index=data_index+1;

[0146] end

[0147] end

[0148] end

[0149] For(j=0;j<pixel_num / 32)begin

[0150] For(i=0;I<32;i++)begin

[0151] Pixel_index=32*j+I;

[0152] If(stg2_len[pixel_index]!=0)begin

[0153] Comp_data[data_index+:3or4]=stg2_data[pixel_index][2:0]or[3:0]

[0154] data_index = data_index+3or4

[0155] end

[0156] end

[0157] end

[0158] For(j=0;j<pixel_num / 32)begin

[0159] For(i=0;I<32;i++)begin

[0160] Pixel_index=32*j+I;

[0161] If(stg3_len[pixel_index]!=0)begin

[0162] Comp_data[data_index+:stage3_len[pixel_index]]=stg3_data[pixel_index];

[0163] data_index=data_index+stage3_len[pixel_index];

[0164] end

[0165] end

[0166] end

[0167] For(j=0;j<pix_num / 32)begin

[0168] For(i=0;I<32;i++)begin

[0169] Pixel_index=32*j+I;

[0170] If(stg4_len[pixel_index]!=0)begin

[0171] Comp_data[data_index+:stage4_len[pixel_index]]= stg4_data[pixel_index];

[0172] data_index =data_index+stage4_len[pixel_index];

[0173] end

[0174] end

[0175] end

[0176] Step 12, 32B alignment of compressed data: Based on the compression ratio, pad the high bits of comp_data with 0 to align it to 32B.

[0177] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The embodiments and descriptions in the specification are merely preferred examples and are not intended to limit the invention. Various changes and modifications can be made to the invention without departing from its spirit and scope, and all such changes and modifications fall within the scope of the claimed invention.

Claims

1. A highly efficient verification method based on the Z-delta compression algorithm, characterized in that, Includes the following steps: S1. Calculate the predicted value for each pixel; S2. Based on the pixel-based prediction value, the delta value of each pixel is obtained; S3. Based on the pixel delta value, obtain the predicted delta value for each pixel; S4. Obtain the symbol value based on the size of the delta value; S5. Based on the symbol value, the final pre-compressed data is obtained; S6. Based on the recorded data compression ratio, restore the compressed data to its uncompressed state. S7. During testing, generate test vectors according to the compressed data format.

2. The efficient verification method based on the Z-delta compression algorithm according to claim 1, characterized in that: S7 specifically includes the following steps: The first step is to randomly compress the data format; The second step is random compression mode; The third step is to randomly adjust the compression ratio. The fourth step is to randomly compress the number of bits in the data; Step 5: Randomize the position of the first non-FC pixel; Step 6: Randomize the total encoding length of each pixel; Step 7: Randomize the value of stage0 for each pixel; Step 8: Randomize the length and value of each pixel in each stage; Step 9: Randomize the first non-FC pixel value; Step 10: Calculate the data for each stage; Step 11: Assemble the data from each stage; Step 12: Based on the compression ratio, pad the high-order bits of the compressed data with 0s and perform 32-bit alignment.

3. The efficient verification method based on the Z-delta compression algorithm according to claim 2, characterized in that: In the first step, the compressed data format is 0 or 1, where 0 represents a 16-bit pixel mode and 1 represents a 24-bit pixel mode.

4. The efficient verification method based on the Z-delta compression algorithm according to claim 2, characterized in that: In the second step, the compression mode is 0 or 1, where 0 represents 128B pixel mode and 1 represents 256B pixel mode.

5. The efficient verification method based on the Z-delta compression algorithm according to claim 2, characterized in that: In the third step, if the compression mode is 0, the internal compressed bytes are {[0:3]}; if the compression mode is 1, the internal compressed bytes are {[0:7]}. In [0:3], 0 represents a data compression rate of 32B, 1 represents 64B, 2 represents 96B, and 3 represents 128B; in [0:7], 0 represents a data compression rate of 32B, 1 represents 64B, 2 represents 96B, and 3 represents 128B; 4 represents a data compression rate of 160B; 5 represents a data compression rate of 192B; 6 represents a data compression rate of 224B; and 7 represents a data compression rate of 256B.

6. The efficient verification method based on the Z-delta compression algorithm according to claim 2, characterized in that: In the fifth step, if the compression mode is 0 and the compressed data format is 1, then the position of the first non-FC pixel is {[0:31]}; otherwise, the position of the first non-FC pixel is {[0:63]}.

7. The efficient verification method based on the Z-delta compression algorithm according to claim 2, characterized in that: In the sixth step, the compression mode is 0 and the compressed data format is 0. Then the sum of pixel stage value [0] to pixel stage value [63] plus 16 and 10 equals comp_bits, where 10 is the length of N0 in the compressed data format and N0 is the total length of compression algorithm stage3 divided by 2. If the compression mode is 0 and the compressed data format is 1, then the sum of pixel stage values ​​[0] to pixel stage values ​​[31] plus 24 and 10 equals comp_bits, where 16 and 24 are the lengths of N1 in the compressed data format, and N1 is the first Non_FC pixel; If the compression mode is 1 and the compressed data format is 0, then the sum of pixel stage values ​​[0] to pixel stage values ​​[63] plus 16 and 10 equals comp_bits; If the compression mode is 1 and the compressed data format is 1, then the sum of pixel stage values ​​[0] to pixel stage values ​​[63] plus 24 and 10 equals comp_bits; If the compressed data format is 0, then the pixel stage value belongs to {1, 3, 6, [8:18], 22}; If the compressed data format is 1, then the pixel stage value belongs to {1, 3, [7:14], 16, [18:25], 31}.

8. The efficient verification method based on the Z-delta compression algorithm according to claim 2, characterized in that: In step 7, iterate through stage0 data[I]. If I is less than the position of the first non-FC pixel, then stage0 data[I] is 0; otherwise, if I is equal to the position of the first non-FC pixel, then stage0 data[I] is 1. Otherwise, if pixel stage[I] equals 1, then stage0 data[I] is 0.

9. The efficient verification method based on the Z-delta compression algorithm according to claim 3, characterized in that: The length occupied by each pixel in each part is divided into the following types: If it only exists in stage0, then the pixel encoded as 0 in stage0 and the first pixel encoded as 1 have a total encoding length of 1. If it only exists in stage0 and stage1, then the encoding in stage0 is 1, and except for the first pixel with an encoding of 1, the total encoding length of this pixel is 3. It exists in stage0, stage1, and stag2, at which point the total length of the pixel encoding is 7. It exists in the case of stage0+stage1+stage2+.

Images