A method and system for encoding and decoding a self-referencing string

Abstract

The present invention is a coding and decoding method and device for splitting a self-referencing string directly above into at least two non-self-referencing strings with the same or different string vectors. According to the characteristics of the self-referencing string directly above with a high probability of occurrence, the self-referencing string directly above is adaptively split into at least two non-self-referencing strings with the same or different string vectors, and the number of non-self-referencing strings obtained after splitting is further reduced under the premise of maintaining low complexity, thereby further improving coding efficiency.

Description

Technical Field

[0001] The invention belongs to the field of data compression, and in particular to a self-reference string encoding and decoding method and system. Background Art

[0002] Typical representatives of the coding mode based on string as the primitive include the latest international video standard VVC (Versatile Video Coding) standard and my country's AVS3 (the third generation of Audio Video Coding Standard) standard and the Palette (PLT) mode and string matching (also called string prediction or intra-frame string copy, ISC) mode in the previous versions of the standard.

[0003] The string is composed of sample values, also called elements, arranged in a predetermined scanning manner. The sample values ​​include pixels or pixel components, referred to as components, or pixel indices, referred to as indices, or pixel units. The pixel unit is an array of mxn pixels or components or indices, where m and n are predetermined positive integers including 1, 2, 4, 8, and 16, respectively. When m and n are 1, the pixel unit is a pixel or a pixel component or a component or a pixel index or an index.

[0004] Scanning modes include raster scanning and back-and-forth (also called arcuate) scanning. In raster scanning, all rows or columns have the same scanning direction, generally from left to right or from top to bottom. In back-and-forth scanning, adjacent rows or columns have opposite scanning directions, that is, if one row or column is from left to right or from top to bottom, the adjacent row or column is from right to left or from bottom to top.

[0005] The ISC mode is a mode based on strings, with a sample value also called an element (such as a pixel unit or pixel) as the smallest copy unit. According to a predetermined scanning order, in a given reference pixel set, if the optimal reference sample value (such as a pixel unit or pixel) string can be found in the reference pixel set, the coding parameter string displacement vector and length (Length) are used to represent the positional relationship between the reference sample value string (referred to as the reference string) and the current sample value string to be encoded (also referred to as the current string) and the length of the reference string, respectively, otherwise the current incompletely matched sample value (such as an incompletely matched pixel unit, the incompletely matched pixel unit is a pixel unit in which there is at least one unmatched pixel or component or index of the reference sample value that cannot be found among its mxn pixels or components or indexes). Generally, the string displacement vector (OffsetX, OffsetY) is equal to the starting position of the reference string minus the starting position of the current string.

[0006] In the existing coding standards, in order to further reduce the complexity of the decoding end, the current string and the reference string are not allowed to overlap, and at the same time, hardware constraints must be met, such as the total number of non-overlapping strings in a codec block must be less than 1 / 4 of the total number of pixel units in the codec block. The current string and the reference string have no overlapping parts, that is, the reference pixels are not pixels in the current string, which is called a non-self-referenced string or a non-overlapping string; the current string and the reference string have overlapping parts, that is, a part of the reference pixels are reconstructed pixels in the current string before the current encoding or decoding position, which is called a self-referenced string or an overlapping string. In the existing AVS3 standard string prediction method, the self-referenced string in the codec block is split into the same scheme, that is, a scheme of splitting into at least two consecutive non-self-referenced strings with the same string vector. However, the scheme of dividing all self-referenced strings into at least two consecutive non-self-referenced strings with the same string vector does not take into account the unique properties of the self-referenced string directly above, and has the defect of low coding efficiency. Summary of the invention

[0007] The technical problem to be solved by the present invention is that the coding efficiency of the existing algorithm is low.

[0008] The present invention provides a self-referencing string encoding and decoding method and system.

[0009] A method for encoding a self-referencing string comprises the following steps:

[0010] Step 1, input a coding block encoded by string prediction or string matching, split the self-referencing string directly above the coding block into two or more non-self-referencing strings with the same or different string vectors, and calculate the number of non-self-referencing strings;

[0011] Step 2: write part or all of the information of the encoding parameters of the self-reference string before splitting into the data code stream.

[0012] A system for encoding self-referencing strings, comprising:

[0013] Code block splitting module: used to split the self-referencing string in the code block into non-self-referencing strings and calculate the number of non-self-referencing strings;

[0014] Data code stream generation module: used to write part or all of the information of the encoding parameters of the self-reference string before splitting into the data code stream.

[0015] A method for decoding a self-referencing string comprises the following steps:

[0016] Step 1, input a decoding block decoded by using string prediction or string matching, parse the decoding block, and obtain partial or complete information representing encoding parameters of the string;

[0017] Step 2: split the self-referencing string directly above the decoded block into two or more non-self-referencing strings having the same or different string vectors according to the information obtained in step 1.

[0018] A decoding device for a self-referencing string, comprising:

[0019] Data code stream parsing module: used to parse the decoded block to obtain part or all of the information of the encoding parameters representing the string;

[0020] Decoding block splitting module: used to split the self-referencing string in the decoding block into at least two non-self-referencing strings.

[0021] A self-referenced string decoding system includes a self-referenced string decoding method or a self-referenced string decoding device, wherein the string prediction or string matching includes: a common string sub-mode; or a non-common string sub-mode; or an equivalent string and unit base vector string sub-mode; or an inter-frame string prediction sub-mode; or any combination of the above four modes.

[0022] Furthermore, the scanning mode of the decoding block includes horizontal scanning and vertical scanning, and the method of splitting the self-reference string into non-self-reference strings is any one of the following two methods:

[0023] The first one:

[0024] In horizontal scanning, for a self-referencing string whose string vector is (0, OffsetY) and whose string length is Length, a preset splitting method is used to split it into at least two non-self-referencing strings, whose string vectors are the same or different, and whose lengths of all non-self-referencing strings are equal to the length of the self-referencing string; in vertical scanning, for a self-referencing string whose string vector is (OffsetX, 0) and whose string length is Length, a preset splitting method is used to split it into at least two non-self-referencing strings, whose string vectors are the same or different, and whose lengths of all non-self-referencing strings are equal to the length of the self-referencing string;

[0025] Second type:

[0026] In horizontal scanning, for a self-referencing string with a string vector of (0, OffsetY) and a string length of Length, it is split into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are different, the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string, and except for the last string, the absolute values ​​of the Y components of the other string vectors are monotonically increasing; in vertical scanning, for a self-referencing string with a string vector of (OffsetX, 0) and a string length of Length, it is split into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are different, the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string, and except for the last string, the absolute values ​​of the X components of the other string vectors are monotonically increasing.

[0027] Furthermore, in step 2, the self-referencing string directly above is split into at least two non-self-referencing strings having the same or different string vectors, and the remaining self-referencing strings are split into at least two non-self-referencing strings having the same string vector.

[0028] Furthermore, the preset method is any one of the following two:

[0029] The first one:

[0030] In horizontal scanning, a self-referencing string with a string vector of (0, OffsetY) is split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string in order; wherein, the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY* (i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (0, OffsetY*K);

[0031] In vertical scanning, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string; wherein, the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the second non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string and the length of the K non-self-referencing strings; the string vector is (OffsetX*K, 0);

[0032] Wherein, K is a positive integer, 1≤i≤K.

[0033] Second type:

[0034] In horizontal scanning, if the starting position of the current string is at the leftmost or rightmost of the decoding block, a self-referencing string with a string vector of (0, OffsetY) is sequentially split into the first non-self-referencing string, K non-self-referencing strings, and the last non-self-referencing string; wherein the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (0, OffsetY*K);

[0035] If the starting position of the current string is not at the leftmost or rightmost position of the decoding block, a self-referencing string with a string vector of (0, OffsetY) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string; wherein the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th (1-K) string of the middle K non-self-referencing strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string and the middle K non-self-referencing strings, and the string vector is (0, OffsetY*K);

[0036] In vertical scanning, if the starting position of the current string is at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string; wherein the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (OffsetX*K, 0);

[0037] If the starting position of the current string is not at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is split into the first non-self-referencing string, the second non-self-referencing string, the middle K non-self-referencing strings and the last non-self-referencing string (N = K + 3) in order; wherein the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the first non-self-referencing string is the length of the first column of the self-referencing string The length of the first non-self-referencing string plus the length of the entire column |OffsetX|-1, the string vector is (OffsetX, 0); the length of the i-th (1~K) string of the middle K non-self-referencing strings is the length of the entire column |OffsetX|*(i+1), the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string, the second non-self-referencing string and the middle K non-self-referencing strings; the string vector is (OffsetX*K, 0)

[0038] Furthermore, the string vector of the non-self-referencing string and the length of the non-self-referencing string are calculated by any one of the following two methods:

[0039] The first one:

[0040] In horizontal scanning, the calculation is performed as follows:

[0041] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen,RemainingStrLen), wherein, if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise, firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv);

[0042] RemainingStrLen decrements NoOverlapStrLen[1];

[0043] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]=min(|ySv|× width,RemainingStrLen)NoOverlapOffset[2]=(0,ySv); NoOverlapStrNum=2; i=1;

[0044] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0045] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0046] b. NoOverlapStrNum increases by 1; i increases by 1;

[0047] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0048] If, |ySv|

[0049] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i),

[0050] Wherein, let the string vector of the self-referential string be (0, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string be NoOverlapStrLen[n], and n is a positive integer;

[0051] In vertical scanning, the calculation is performed as follows:

[0052] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv);

[0053] RemainingStrLen decrements NoOverlapStrLen[1];

[0054] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]= min(|ySv|×width,RemainingStrLen)NoOverlapOffset[2]=(0,ySv); NoOverlapStrNum=2; i=1;

[0055] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0056] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0057] b. NoOverlapStrNum increases by 1; i increases by 1;

[0058] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0059] If |ySv|

[0060] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOver lapStrNum]=(0,ySv*i),

[0061] In which, let the string vector of the self-referential string be (xSv, 0), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string is NoOverlapStrLen[n], and n is a positive integer.

[0062] Second type:

[0063] In horizontal scanning,

[0064] Let the string vector of the self-referential string be (0, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string be NoOverlapStrLen[n], n is a positive integer,

[0065] If xStartPos == 0 or xStartPos == width - 1, perform the following steps:

[0066] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv);

[0067] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0068] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0069] b. NoOverlapStrNum increases by 1; i increases by 1;

[0070] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0071] If |ySv|

[0072] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOver lapStrNum]=(0,ySv*i),

[0073] If xStartPos is not equal to 0 or xStartPos is not equal to width-1, perform the following steps:

[0074] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv);

[0075] RemainingStrLen decrements NoOverlapStrLen[1];

[0076] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]=min(|ySv|× width,RemainingStrLen)NoOverlapOffset[2]=(0,ySv); NoOverlapStrNum=2; i=1;

[0077] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0078] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0079] b. NoOverlapStrNum increases by 1; i increases by 1;

[0080] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0081] If |ySv|

[0082] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i),

[0083] In vertical scanning,

[0084] Let the string vector of the self-referential string be (xSv, 0), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), and the coordinates of the last element be (xEndPos, yEndPos); the width and height of the decoding block are width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string is NoOverlapOffset[n], and the string length of the non-self-referential string is NoOverlapStrLe n[n], where n is a positive integer.

[0085] If yStartPos == 0 or yStartPos == height-1, perform the following steps:

[0086] A. NoOverlapStrLen[1] = min((|xSv|-1)×height+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = yStartPos+1; otherwise firstLineLen = height-yStartPos; NoOverlapOffset[1] = (xSv, 0);

[0087] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0088] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0089] b. NoOverlapStrNum increases by 1; i increases by 1;

[0090] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0091] If |xSv|

[0092] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|xSv|×height*i, NoOverlapOffset[NoOve rlapStrNum]=(xSv*i,0),

[0093] If yStartPos is not equal to 0 or yStartPos is not equal to height-1, perform the following steps:

[0094] A. NoOverlapStrLen[1] = min((|xSv|-1)×height+firstLineLen,RemainingStrLen), wherein, if the starting element is in the reverse row, firstLineLen = yStartPos+1; otherwise, firstLineLen = height-yStartPos; NoOverlapOffset[1] = (xSv, 0);

[0095] RemainingStrLen decrements NoOverlapStrLen[1];

[0096] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]=min(|xSv|× height,RemainingStrLen)NoOverlapOffset[2]=(xSv,0); NoOverlapStrNum=2; i=1;

[0097] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0098] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0099] b. NoOverlapStrNum increases by 1; i increases by 1;

[0100] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0101] If |xSv|

[0102] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|xSv|×height*i, NoOverlapOffset[No OverlapStrNum]=(xSv*i,0).

[0103] Furthermore, the method of splitting the remaining self-referential strings into at least two non-self-referential strings having the same string vector is:

[0104] In horizontal scanning,

[0105] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen, RemainingStrLen), wherein if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos;

[0106] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0107] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0108] b. NoOverlapStrNum increases by 1; i increases by 1;

[0109] c. Get NoOverlapStrLen[NoOverlapStrNum]:

[0110] NoOverlapStrLen[NoOverlapStrNum]=min(|ySv|×width,RemainingStrLen);

[0111] Wherein, let the string vector of the self-referential string be (xSv, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], both are (xSv, ySv), the string length of the non-self-referential string is NoOverlapStrLen[n], n is a positive integer;

[0112] In vertical scanning,

[0113] A. NoOverlapStrLen[1] = min((|xSv|-1)×height+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = yStartPos+1; otherwise firstLineLen = height-yStartPos;

[0114] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0115] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0116] b. NoOverlapStrNum increases by 1; i increases by 1;

[0117] c. Get NoOverlapStrLen[NoOverlapStrNum]:

[0118] NoOverlapStrLen[NoOverlapStrNum]=min(|xSv|×height,RemainingStrLen);

[0119] Among them, let the string vector of the self-referential string be (xSv, xSy), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string is NoOverlapOffset[n], both are (xSv, ySv), the string length of the non-self-referential string is NoOverlapStrLen[n], n is a positive integer.

[0120] Compared with the prior art, the present invention has the following advantages and effects:

[0121] The present invention splits the self-referencing string directly above into at least two non-self-referencing strings with the same or different string vectors, and reduces the number of non-self-referencing strings obtained after the splitting while maintaining low complexity, thereby improving image coding efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0122] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

[0123] Figure 1 It is a schematic diagram of the encoding method or system of the present invention.

[0124] Figure 2 It is a schematic diagram of a decoding method or device of the present invention.

[0125] Figure 3 It is a schematic diagram of splitting the self-referencing string directly above into non-self-referencing strings of the present invention. DETAILED DESCRIPTION

[0126] In order to make the purpose, technical solution and advantages of the present invention more clearly understood, the present invention is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not used to limit the present invention.

[0127] Embodiment 1: A self-reference string encoding system includes a coding block splitting module and a data code stream generating module, wherein the coding block splitting module is used to split the self-reference string in the coding block into non-self-reference strings and calculate the number of non-self-reference strings; the data code stream generating module is used to write part or all of the information of the encoding parameters of the self-reference string before splitting into the data code stream. String prediction or string matching includes one of the following sub-modes or a combination thereof: a common string sub-mode or a non-common string sub-mode or an equivalent string and unit base vector string sub-mode or an inter-frame string prediction sub-mode (the reference frame is a non-current frame image) or other string prediction sub-modes.

[0128] A method for encoding a self-referencing string comprises the following steps:

[0129] Step 1, input a coding block encoded using string prediction or string matching, split the self-referenced string directly above the coding block into two or more non-self-referenced strings with the same or different string vectors, and calculate the number of non-self-referenced strings. For example, in the horizontal scanning mode, for a self-referenced string with a string vector of (0, OffsetY) and a string length of Length, split it into N (N greater than or equal to 2) non-self-referenced strings according to a preset splitting method, wherein the string vectors (0, OffsetYn) of the N non-self-referenced strings are the same or different, and the sum of the lengths Lengthn of all non-self-referenced strings is equal to the length of the self-referenced string. Where n ranges from 1 to N. In the vertical scanning mode, for a self-referenced string with a string vector of (OffsetX, 0) and a string length of Length, split it into N (N greater than or equal to 2) non-self-referenced strings according to a preset splitting method, wherein the string vectors (OffsetXn, 0) of the N non-self-referenced strings are the same or different, and the sum of the lengths Lengthn of all non-self-referenced strings is equal to the length of the self-referenced string. Where n ranges from 1 to N.

[0130] Step 2: write part or all of the information of the encoding parameters of the self-reference string before splitting into the data code stream.

[0131] Embodiment 2:

[0132] A self-referenced string decoding system includes a self-referenced string decoding method or a self-referenced string decoding device, wherein the string prediction or string matching includes: a common string sub-mode; or a non-common string sub-mode; or an equivalent string and unit base vector string sub-mode; or an inter-frame string prediction sub-mode; or any combination of the above four modes.

[0133] A decoding device for a self-referencing string comprises a data code stream parsing module and a decoding block splitting module. The data code stream parsing module is used to parse a decoding block to obtain part or all of the information of the encoding parameters representing the string; the decoding block splitting module is used to split the self-referencing string in the decoding block into at least two non-self-referencing strings.

[0134] A method for decoding a self-referencing string comprises the following steps:

[0135] Step 1, input a decoding block decoded by using string prediction or string matching, parse the decoding block, and obtain partial or complete information representing encoding parameters of the string;

[0136] Step 2: Split the self-referencing string directly above the decoded block into two or more non-self-referencing strings with the same or different string vectors based on the information obtained in step 1:

[0137] For example, in the horizontal scanning mode, for a self-referencing string with a string vector of (0, OffsetY) and a string length of Length, a self-referencing string with a string vector of (0, OffsetY) is split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string in sequence, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, and the string vectors (0, OffsetYn) in all or part of the self-referencing strings are the same or different; wherein, the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row |OffsetY|*(i+1), and the string vector is (0, OffsetY* (i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string, and the length of K non-self-referencing strings, and the string vector is (0, OffsetY*K). K is a positive integer, 1≤i≤K.

[0138] In vertical scanning mode, for a self-referencing string with a string vector of (OffsetX, 0) and a string length of Length, a self-referencing string with a string vector of (OffsetX, 0) is split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string in order, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, and the string vectors (OffsetXn, 0) in all or part of the self-referencing strings are the same or different; wherein, the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column |OffsetX|-1 The length of the second non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string, and the length of the K non-self-referencing strings; the string vector is (OffsetX*K, 0). K is a positive integer, 1≤i≤K.

[0139] For another example, in the horizontal scanning mode, for a self-referencing string whose string vector is (0, OffsetY) and whose string length is Length, if the starting position of the current string is at the leftmost or rightmost position of the decoding block, the self-referencing string whose string vector is (0, OffsetY) is sequentially split into the first non-self-referencing string, K non-self-referencing strings, and the last non-self-referencing string, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, and the string vectors (0, OffsetYn) in all or part of the self-referencing strings are the same or different; wherein, the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row of |OffsetY|* (i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the lengths of the K non-self-referencing strings, and the string vector is (0, If the starting position of the current string is not at the leftmost or rightmost position of the decoded block, a string vector (0, The self-referencing string of the first non-self-referencing string (OffsetY) is sequentially split into a first non-self-referencing string, a second non-self-referencing string, K non-self-referencing strings and a last non-self-referencing string, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, and the string vectors (0, OffsetYn) in all or part of the self-referencing strings are the same or different; wherein the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th (1-K) string of the middle K non-self-referencing strings is the length of the entire row |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string and the middle K non-self-referencing strings, and the string vector is (0, OffsetY*K). Wherein, K is a positive integer, 1≤i≤K.

[0140] In vertical scanning, if the starting position of the current string is at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, and the string vectors (OffsetXn, 0) in all or part of the self-referencing strings are the same or different; wherein, the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the lengths of the K non-self-referencing strings, and the string vector is (OffsetX*K, 0);

[0141] If the starting position of the current string is not at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, the middle K non-self-referencing strings and the last non-self-referencing string (N=K+3), the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, and the string vectors (OffsetXn, 0) in all or part of the self-referencing strings are the same or different; wherein the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th (1~K)th string of the middle K non-self-referencing strings is |OffsetX|* (i+1) The length of the entire column, the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string, the second non-self-referencing string and the middle K non-self-referencing strings; the string vector is (OffsetX*K, 0).

[0142] Embodiment 3: A self-referenced string decoding system, comprising a self-referenced string decoding method or a self-referenced string decoding device, wherein the string prediction or string matching comprises: a common string sub-pattern; or a non-common string sub-pattern; or an equivalent string and unit basis vector string sub-pattern; or an inter-frame string prediction sub-pattern; or any combination of the above four patterns.

[0143] A decoding device for a self-referencing string comprises a data code stream parsing module and a decoding block splitting module. The data code stream parsing module is used to parse a decoding block to obtain part or all of the information of the encoding parameters representing the string; the decoding block splitting module is used to split the self-referencing string in the decoding block into at least two non-self-referencing strings.

[0144] A method for decoding a self-referencing string comprises the following steps:

[0145] Step 1, input a decoding block decoded by using string prediction or string matching, parse the decoding block, and obtain partial or complete information representing encoding parameters of the string;

[0146] Step 2: Split the self-referencing string directly above the decoded block into two or more non-self-referencing strings with the same or different string vectors based on the information obtained in step 1:

[0147] For example, in horizontal scanning mode, for a self-referencing string with a string vector of (0, OffsetY) and a string length of Length, a self-referencing string with a string vector of (0, OffsetY) is split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, the string vectors (0, OffsetYn) in all or part of the self-referencing strings are the same or different, except for the last string, the absolute values ​​of the Y components of the other string vectors are monotonically increasing; wherein, the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string, and the length of the K non-self-referencing strings, and the string vector is (0, OffsetY*K). wherein K is a positive integer, 1≤i≤K.

[0148] In vertical scanning mode, for a self-referencing string with a string vector of (OffsetX, 0) and a string length of Length, a self-referencing string with a string vector of (OffsetX, 0) is split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string in order, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, the string vectors (OffsetXn, 0) in all or part of the self-referencing strings are the same or different, and except for the last string, the absolute values ​​of the X components of the other string vectors are monotonically increasing; wherein, the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus |O The length of the first column of the self-referencing string is the length of the first column of the self-referencing string plus the length of the column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string, and the length of the K non-self-referencing strings; the string vector is (OffsetX*K, 0). K is a positive integer, 1≤i≤K.

[0149] For another example, in the horizontal scanning mode, for a self-referencing string whose string vector is (0, OffsetY) and whose string length is Length, if the starting position of the current string is at the leftmost or rightmost position of the decoding block, the self-referencing string whose string vector is (0, OffsetY) is sequentially split into the first non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string, the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, the string vectors (0, OffsetYn) in all or part of the self-referencing strings are the same or different, and except for the last string, the absolute values ​​of the Y components of the other string vectors are monotonically increasing; wherein, the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row |OffsetY|*(i+1), and the string vector is (0,OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (0,OffsetY*K). If the starting position of the current string is not at the leftmost or rightmost position of the decoding block, a self-referencing string with a string vector of (0, OffsetY) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string. The sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string. The string vectors (0, OffsetYn) in all or part of the self-referencing strings are the same or different. Except for the last string, the absolute values ​​of the Y components of the other string vectors are monotonically increasing. The length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th (1~K)th string of the middle K non-self-referencing strings is |OffsetY|*(i+1) The length of the entire row, the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string and the middle K non-self-referencing strings, the string vector is (0, OffsetY*K). K is a positive integer, 1≤i≤K.

[0150] In vertical scanning, if the starting position of the current string is at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string. The sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string. The string vectors (OffsetXn, 0) in all or part of the self-referencing strings are the same or different. Except for the last string, the absolute values ​​of the X components of the other string vectors are monotonically increasing. Among them, the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is |OffsetX|*(i+1) The length of the entire column, the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the lengths of K non-self-referencing strings, the string vector is (OffsetX*K, 0); if the starting position of the current string is not at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, the middle K non-self-referencing strings and the last non-self-referencing string (N=K+3), the sum of the lengths Lengthn of all non-self-referencing strings is equal to the length of the self-referencing string, the string vectors (OffsetXn, 0) in all or part of the self-referencing strings are the same or different, and except for the last string, the absolute values ​​of the X components of the other string vectors are monotonically increasing; wherein, the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus | The length of the whole column of |OffsetX|-1 is obtained, and the string vector is (OffsetX, 0); the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the whole column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th (1 to K)-th string of the middle K non-self-referencing strings is the length of the whole column of |OffsetX|*(i+1), and the string vector is (OffsetX* (i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string, the second non-self-referencing string and the middle K non-self-referencing strings; the string vector is (OffsetX*K, 0).

[0151] Embodiment 4: A self-referenced string decoding system, comprising a self-referenced string decoding method or a self-referenced string decoding device, wherein the string prediction or string matching comprises: a common string sub-pattern; or a non-common string sub-pattern; or an equivalent string and unit basis vector string sub-pattern; or an inter-frame string prediction sub-pattern; or any combination of the above four patterns.

[0152] A decoding device for a self-referencing string comprises a data code stream parsing module and a decoding block splitting module. The data code stream parsing module is used to parse a decoding block to obtain part or all of the information of the encoding parameters representing the string; the decoding block splitting module is used to split the self-referencing string in the decoding block into at least two non-self-referencing strings.

[0153] A method for decoding a self-referencing string comprises the following steps:

[0154] Step 1, input a decoding block decoded by using string prediction or string matching, parse the decoding block, and obtain partial or complete information representing encoding parameters of the string;

[0155] Step 2: Split the self-referencing string directly above the decoded block into two or more non-self-referencing strings with the same or different string vectors based on the information obtained in step 1:

[0156] For example, in a horizontal scan, the calculation is as follows:

[0157] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen, RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv); RemainingStrLen decrements NoOverlapStrLen[1];

[0158] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]=min(|ySv|× width,RemainingStrLen)NoOverlapOffset[2]=(0,ySv); NoOverlapStrNum=2; i=1;

[0159] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0160] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0161] b. NoOverlapStrNum increases by 1; i increases by 1;

[0162] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0163] If, |ySv|

[0164] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i),

[0165] Wherein, let the string vector of the self-referential string be (0, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string be NoOverlapStrLen[n], and n is a positive integer;

[0166] In vertical scanning, the calculation is performed as follows:

[0167] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen, RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv); RemainingStrLen decrements NoOverlapStrLen[1];

[0168] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]= min(|ySv|×width,RemainingStrLen)NoOverlapOffset[2]=(0,ySv); NoOverlapStrNum=2; i=1;

[0169] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0170] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0171] b. NoOverlapStrNum increases by 1; i increases by 1;

[0172] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0173] If |ySv|

[0174] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOver lapStrNum]=(0,ySv*i),

[0175] In which, let the string vector of the self-referential string be (xSv, 0), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string is NoOverlapStrLen[n], and n is a positive integer.

[0176] For example,

[0177] In horizontal scanning,

[0178] Let the string vector of the self-referential string be (0, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string be NoOverlapStrLen[n], n is a positive integer,

[0179] If xStartPos == 0 or xStartPos == width - 1, perform the following steps:

[0180] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv);

[0181] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0182] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0183] b. NoOverlapStrNum increases by 1; i increases by 1;

[0184] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0185] If |ySv|

[0186] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOver lapStrNum]=(0,ySv*i),

[0187] If xStartPos is not equal to 0 or xStartPos is not equal to width-1, perform the following steps:

[0188] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen, RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise, firstLineLen = width-xStartPos; NoOverlapOffset[1] = (0, ySv); RemainingStrLen decrements NoOverlapStrLen[1];

[0189] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]=min(|ySv|× width,RemainingStrLen)NoOverlapOffset[2]=(0,ySv); NoOverlapStrNum=2; i=1;

[0190] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0191] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0192] b. NoOverlapStrNum increases by 1; i increases by 1;

[0193] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0194] If |ySv|

[0195] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i),

[0196] In vertical scanning,

[0197] Let the string vector of the self-referential string be (xSv, 0), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), and the coordinates of the last element be (xEndPos, yEndPos); the width and height of the decoding block are width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string is NoOverlapOffset[n], and the string length of the non-self-referential string is NoOverlapStrLe n[n], where n is a positive integer.

[0198] If yStartPos == 0 or yStartPos == height-1, perform the following steps:

[0199] A. NoOverlapStrLen[1] = min((|xSv|-1)×height+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = yStartPos+1; otherwise firstLineLen = height-yStartPos; NoOverlapOffset[1] = (xSv, 0);

[0200] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0201] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0202] b. NoOverlapStrNum increases by 1; i increases by 1;

[0203] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0204] If |xSv|

[0205] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|xSv|×height*i, NoOverlapOffset[NoOve rlapStrNum]=(xSv*i,0),

[0206] If yStartPos is not equal to 0 or yStartPos is not equal to height-1, perform the following steps:

[0207] A. NoOverlapStrLen[1] = min((|xSv|-1)×height+firstLineLen,RemainingStrLen), wherein, if the starting element is in the reverse row, firstLineLen = yStartPos+1; otherwise, firstLineLen = height-yStartPos; NoOverlapOffset[1] = (xSv, 0);

[0208] RemainingStrLen decrements NoOverlapStrLen[1];

[0209] B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]=min(|xSv|× height,RemainingStrLen)NoOverlapOffset[2]=(xSv,0); NoOverlapStrNum=2; i=1;

[0210] C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0211] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0212] b. NoOverlapStrNum increases by 1; i increases by 1;

[0213] c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]:

[0214] If |xSv|

[0215] Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|xSv|×height*i, NoOverlapOffset[NoOverlapStrNum]=(xSv*i,0).

[0216] For example,

[0217] In horizontal scanning,

[0218] A. NoOverlapStrLen[1] = min((|ySv|-1)×width+firstLineLen, RemainingStrLen), wherein if the starting element is in the reverse row, firstLineLen = xStartPos+1; otherwise firstLineLen = width-xStartPos;

[0219] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0220] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0221] b. NoOverlapStrNum increases by 1; i increases by 1;

[0222] c. Get NoOverlapStrLen[NoOverlapStrNum]:

[0223] NoOverlapStrLen[NoOverlapStrNum]=min(|ySv|×width,RemainingStrLen);

[0224] Wherein, let the string vector of the self-referential string be (xSv, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], both are (xSv, ySv), the string length of the non-self-referential string is NoOverlapStrLen[n], n is a positive integer;

[0225] In vertical scanning,

[0226] A. NoOverlapStrLen[1] = min((|xSv|-1)×height+firstLineLen,RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = yStartPos+1; otherwise firstLineLen = height-yStartPos;

[0227] B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps:

[0228] a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum];

[0229] b. NoOverlapStrNum increases by 1; i increases by 1;

[0230] c. Get NoOverlapStrLen[NoOverlapStrNum]:

[0231] NoOverlapStrLen[NoOverlapStrNum]=min(|xSv|×height,RemainingStrLen);

[0232] Among them, let the string vector of the self-referential string be (xSv, xSy), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string is NoOverlapOffset[n], both are (xSv, ySv), the string length of the non-self-referential string is NoOverlapStrLen[n], n is a positive integer.

[0233] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A method for decoding a self-referencing string, characterized in that: The following steps are involved: Step 1, input a decoding block decoded by using string prediction or string matching, parse the decoding block, and obtain partial or complete information representing encoding parameters of the string; Step 2: split the self-referencing string directly above the decoding block into two or more non-self-referencing strings having the same or different string vectors according to the information obtained in step 1, and split the remaining self-referencing strings into at least two non-self-referencing strings having the same string vector; the scanning mode of the decoding block includes horizontal scanning and vertical scanning, and the method of splitting the self-referencing string into the non-self-referencing strings is any one of the following two methods: The first one: In horizontal scanning, for a self-referencing string whose string vector is (0, OffsetY) and whose string length is Length, split it into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are the same or different, and the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string; in vertical scanning, for a self-referencing string whose string vector is (OffsetX, 0) and whose string length is Length, split it into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are the same or different, and the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string; Second type: In horizontal scanning, for a self-referencing string whose string vector is (0, OffsetY) and whose string length is Length, it is split into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are different, the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string, and except for the last string, the absolute values ​​of the Y components of the other string vectors are monotonically increasing; in vertical scanning, for a self-referencing string whose string vector is (OffsetX, 0) and whose string length is Length, it is split into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are different, the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string, and except for the last string, the absolute values ​​of the X components of the other string vectors are monotonically increasing; The preset method is any one of the following two: The first one: In horizontal scanning, a self-referential string with a string vector of (0, OffsetY) is split into the first non-self-referential string, the second non-self-referential string, K non-self-referential strings and the last non-self-referential string in order; the length of the first non-self-referential string is the length of the first row of the self-referential string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referential string is the length of the entire row of the self-referential string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referential strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referential string is the total length of the self-referential string minus the length of the first non-self-referential string, the length of the second non-self-referential string and the length of the K non-self-referential strings, and the string vector is (0, OffsetY*K); In vertical scanning, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string; the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the second non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string and the length of the K non-self-referencing strings; the string vector is (OffsetX*K, 0); Wherein, K is a positive integer, 1≤i≤K; Second type: In horizontal scanning, if the starting position of the current string is at the leftmost or rightmost of the decoding block, a self-referencing string with a string vector of (0, OffsetY) is split into the first non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string in order; the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (0, OffsetY*K); If the starting position of the current string is not at the leftmost or rightmost position of the decoding block, a self-referencing string with a string vector of (0, OffsetY) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string; wherein the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); among the K non-self-referencing strings, the length of the i-th (1~K) string is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string and the K non-self-referencing strings, and the string vector is (0, OffsetY*K); In vertical scanning, if the starting position of the current string is at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, K non-self-referencing strings, and the last non-self-referencing string; wherein the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1),0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (OffsetX*K, 0); If the starting position of the current string is not at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string (N=K+3) in sequence; wherein the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); among the K non-self-referencing strings, the length of the i-th (1~K) string is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string, the second non-self-referencing string and the K non-self-referencing strings; the string vector is (OffsetX*K, 0).

2. A self-referential string decoding device, used to implement the self-referential string decoding method according to claim 1, characterized in that: include Data code stream parsing module: used to parse the decoded block to obtain part or all of the information of the encoding parameters representing the string; Decoding block splitting module: used to split the self-referencing string in the decoding block into at least two or more non-self-referencing strings with the same or different string vectors.

3. A self-referential string decoding system, comprising any one of the self-referential string decoding method according to claim 1 or the self-referential string decoding device according to claim 2, characterized in that: The string prediction or string matching includes: a common string sub-mode; or a non-common string sub-mode; or an equivalent string and unit base vector string sub-mode; or an inter-frame string prediction sub-mode; or any combination of the above four modes.

4. The self-referencing string decoding system according to claim 3, characterized in that: The scanning mode of the decoding block includes horizontal scanning and vertical scanning, and the method of splitting the self-reference string into non-self-reference strings is any one of the following two methods: The first one: In horizontal scanning, for a self-referencing string whose string vector is (0, OffsetY) and whose string length is Length, split it into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are the same or different, and the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string; in vertical scanning, for a self-referencing string whose string vector is (OffsetX, 0) and whose string length is Length, split it into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are the same or different, and the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string; Second type: In horizontal scanning, for a self-referencing string whose string vector is (0, OffsetY) and whose string length is Length, it is split into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are different, the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string, and except for the last string, the absolute values ​​of the Y components of the other string vectors are monotonically increasing; in vertical scanning, for a self-referencing string whose string vector is (OffsetX, 0) and whose string length is Length, it is split into at least two non-self-referencing strings according to a preset splitting method, the string vectors of the non-self-referencing strings are different, the sum of the lengths of all non-self-referencing strings is equal to the length of the self-referencing string, and except for the last string, the absolute values ​​of the X components of the other string vectors are monotonically increasing.

5. The self-referencing string decoding system according to claim 3, characterized in that: In step 2, the self-referential string directly above is split into at least two non-self-referential strings having the same or different string vectors, and the remaining self-referential strings are split into at least two non-self-referential strings having the same string vector.

6. The self-referencing string decoding system according to claim 4, characterized in that: The preset method is any one of the following two: The first one: In horizontal scanning, a self-referential string with a string vector of (0, OffsetY) is split into the first non-self-referential string, the second non-self-referential string, K non-self-referential strings and the last non-self-referential string in order; the length of the first non-self-referential string is the length of the first row of the self-referential string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referential string is the length of the entire row of the self-referential string |OffsetY|, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referential strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referential string is the total length of the self-referential string minus the length of the first non-self-referential string, the length of the second non-self-referential string and the length of the K non-self-referential strings, and the string vector is (0, OffsetY*K); In vertical scanning, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string; the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the second non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string, the length of the second non-self-referencing string and the length of the K non-self-referencing strings; the string vector is (OffsetX*K, 0); Wherein, K is a positive integer, 1≤i≤K; Second type: In horizontal scanning, if the starting position of the current string is at the leftmost or rightmost of the decoding block, a self-referencing string with a string vector of (0, OffsetY) is split into the first non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string in order; the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the i-th string among the K non-self-referencing strings is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (0, OffsetY*K); If the starting position of the current string is not at the leftmost or rightmost position of the decoding block, a self-referencing string with a string vector of (0, OffsetY) is sequentially split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string; wherein the length of the first non-self-referencing string is the length of the first row of the self-referencing string plus the length of the entire row of |OffsetY|-1, and the string vector is (0, OffsetY); the length of the second non-self-referencing string is the length of the entire row of the self-referencing string |OffsetY|, and the string vector is (0, OffsetY); among the K non-self-referencing strings, the length of the i-th (1~K) string is the length of the entire row of |OffsetY|*(i+1), and the string vector is (0, OffsetY*(i+1)); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string and the K non-self-referencing strings, and the string vector is (0, OffsetY*K); In vertical scanning, if the starting position of the current string is at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is sequentially split into the first non-self-referencing string, K non-self-referencing strings, and the last non-self-referencing string; wherein the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the i-th string among the K non-self-referencing strings is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1),0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the length of the first non-self-referencing string and the length of the K non-self-referencing strings, and the string vector is (OffsetX*K, 0); If the starting position of the current string is not at the top or bottom of the decoding block, a self-referencing string with a string vector of (OffsetX, 0) is split into the first non-self-referencing string, the second non-self-referencing string, K non-self-referencing strings and the last non-self-referencing string (N=K+3) in sequence; wherein the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); the length of the first non-self-referencing string is the length of the first column of the self-referencing string plus the length of the entire column of |OffsetX|-1, and the string vector is (OffsetX, 0); among the K non-self-referencing strings, the length of the i-th (1~K) string is the length of the entire column of |OffsetX|*(i+1), and the string vector is (OffsetX*(i+1), 0); the length of the last non-self-referencing string is the total length of the self-referencing string minus the sum of the lengths of the first non-self-referencing string, the second non-self-referencing string and the K non-self-referencing strings; the string vector is (OffsetX*K, 0).

7. The self-referencing string decoding system according to claim 4, characterized in that: The string vector of the non-self-referencing string and the length of the non-self-referencing string are calculated by any of the following two methods: The first one: In horizontal scanning, let the string vector of the self-referential string be (0, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string be NoOverlapStrLen[n], n is a positive integer, and calculate according to the following steps: A. NoOverlapStrLen[1] = min((|ySv| - 1) × width + firstLineLen, RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos + 1; otherwise firstLineLen = width - xStartPos; NoOverlapOffset[1] = (0, ySv); RemainingStrLen decrements NoOverlapStrLen[1]; B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2] = min(|ySv|× width, RemainingStrLen) NoOverlapOffset [2] = (0, ySv); NoOverlapStrNum=2;i=1; C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]: If, |ySv| Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i); In vertical scanning, let the string vector of the self-referential string be (xSv, 0), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string be NoOverlapStrLen[n], n is a positive integer, and calculate according to the following steps: A. NoOverlapStrLen[1] = min((|ySv| - 1) × width + firstLineLen, RemainingStrLen), where if the starting element is in the reverse row, firstLineLen = xStartPos + 1; otherwise firstLineLen = width - xStartPos; NoOverlapOffset[1] = (0, ySv); RemainingStrLen decrements NoOverlapStrLen[1]; B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2]= min(|ySv|×width,RemainingStrLen)NoOverlapOffset[2]=(0,ySv); NoOverlapStrNum=2;i=1; C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]: If |ySv| Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i); Second type: In horizontal scanning, Let the string vector of the self-referential string be (0, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string be NoOverlapOffset[n], the string length of the non-self-referential string be NoOverlapStrLen[n], n is a positive integer, If xStartPos==0 or xStartPos==width-1, then perform the following steps: A. NoOverlapStrLen[1] = min((|ySv| - 1) × width + firstLineLen, RemainingStrLen) , where if the starting element is in the reverse row, firstLineLen = xStartPos + 1; otherwise firstLineLen = width - xStartPos; NoOverlapOffset[1] = (0, ySv); B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]: If |ySv| Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv|×width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i), If xStartPos is not equal to 0 or xStartPos is not equal to width-1, perform the following steps: A. NoOverlapStrLen[1] = min((|ySv| - 1) × width + firstLineLen, RemainingStrLen) , where if the starting element is in the reverse row, firstLineLen = xStartPos + 1; otherwise firstLineLen = width - xStartPos; NoOverlapOffset[1] = (0, ySv); RemainingStrLen decrements NoOverlapStrLen[1]; B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2] = min(|ySv|× width, RemainingStrLen) NoOverlapOffset [2] = (0, ySv); NoOverlapStrNum=2;i=1; C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]: If |ySv| Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|ySv| × width*i, NoOverlapOffset[NoOverlapStrNum]=(0,ySv*i), In vertical scanning, Let the string vector of the self-referential string be (xSv, 0), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), and the coordinates of the last element be (xEndPos, yEndPos); the width and height of the decoding block are width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string is NoOverlapOffset[n], the string length of the non-self-referential string is NoOverlapStrLen[n], n is a positive integer, If yStartPos==0 or yStartPos==height-1, then perform the following steps: A. NoOverlapStrLen[1] = min((|xSv| - 1) × height + firstLineLen, RemainingStrLen) , where if the starting element is in the reverse row, firstLineLen = yStartPos + 1; otherwise, firstLineLen = height - yStartPos; NoOverlapOffset[1] = (xSv, 0); B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]: If |xSv| Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|xSv|×height*i, NoOverlapOffset[NoOverlapStrNum]=(xSv*i,0), If yStartPos is not equal to 0 or yStartPos is not equal to height-1, perform the following steps: A. NoOverlapStrLen[1] = min((|xSv|-1)×height+firstLineLen,RemainingStrLen) , where if the starting element is in the reverse row, firstLineLen=yStartPos+1; otherwise firstLineLen=height-yStartPos; NoOverlapOffset[1] = (xSv, 0); RemainingStrLen decrements NoOverlapStrLen[1]; B. When RemainingStrLen>NoOverlapStrLen[1], NoOverlapStrLen[2] = min(|xSv |× height, RemainingStrLen) NoOverlapOffset [2] = (xSv, 0); NoOverlapStrNum=2;i=1; C. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Obtain NoOverlapStrLen[NoOverlapStrNum] and NoOverlapOffset[NoOverlapStrNum]: If |xSv| Otherwise, NoOverlapStrLen[NoOverlapStrNum]=|xSv|×height *i, NoOverlapOffset[NoOverlapStrNum]=(xSv *i,0).

8. The self-referencing string decoding system according to claim 5, characterized in that: The method for splitting the remaining self-referential strings into at least two non-self-referential strings having the same string vector is: In horizontal scanning, let the string vector of the self-referential string be (xSv, ySv), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string is NoOverlapOffset[n], both are (xSv, ySv), the string length of the non-self-referential string is NoOverlapStrLen[n], n is a positive integer; A. NoOverlapStrLen[1]=min((|ySv|-1)×width+firstLineLen,RemainingStrLen), where if the starting element is in the reverse line, firstLineLen=xStartPos+1; otherwise firstLineLen=width-xStartPos; B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Get NoOverlapStrLen[NoOverlapStrNum]: NoOverlapStrLen[NoOverlapStrNum]=min(|ySv|×width,RemainingStrLen); In vertical scanning, let the string vector of the self-referential string be (xSv, xSy), the string length be StrLen, the coordinates of the starting element of the current string be (xStartPos, yStartPos), the coordinates of the last element be (xEndPos, yEndPos), the width and height of the decoding block be width and height respectively, initialize NoOverlapStrNum to 1, RemainingStrLen to StrLen, N equals NoOverlapStrNum, the string vector of the non-self-referential string is NoOverlapOffset[n], both are (xSv, ySv), the string length of the non-self-referential string is NoOverlapStrLen[n], n is a positive integer; A. NoOverlapStrLen[1] = min((|xSv| - 1)× height + firstLineLen, RemainingStrLen) , where if the starting element is in the reverse row, firstLineLen = yStartPos + 1; otherwise, firstLineLen = height - yStartPos; B. When RemainingStrLen>NoOverlapStrLen[NoOverlapStrNum], repeat the following steps: a. Update RemainingStrLen: RemainingStrLen decreases NoOverlapStrLen[NoOverlapStrNum]; b. NoOverlapStrNum increases by 1; i increases by 1; c. Get NoOverlapStrLen[NoOverlapStrNum]: NoOverlapStrLen[NoOverlapStrNum]=min(|xSv|×height, RemainingStrLen).

Images