Decoder and nontransient memory

Abstract

A decoder and a non-transient memory are provided. The symbol sequence is entropy-encoded using a symbol occurrence table, and the symbol occurrence table is encoded using an integer value f. Decoding the symbol occurrence table adaptively using the integer value f includes: subdividing the decoding range of the symbol occurrence accumulation table consecutively at its respective intermediate indices; for each decoding range, calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range; and calculating f div (the entry at the last index – the entry at the first index + 1) to update f, decoding each entry of the symbol occurrence accumulation table; calculating the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table; and applying the decoded symbol occurrence table to entropy-decode the received encoded symbol sequence.

Description

[0001] (This application is a divisional application of the application filed on September 23, 2025, with application number 202511363424.9 and title "Decoding Method".) Technical Field

[0002] This technology relates to encoding and decoding, and specifically to systems, apparatus, circuits, methods, techniques, and storage devices for entropy encoding, and further includes encoding codebooks, parameters, and / or tables used in entropy encoding. The technology further relates to entropy encoding of an already compressed file, followed by encoding of a symbol occurrence table used in the entropy encoding. The technology also relates to entropy-based file segmentation in such a context. Background Technology

[0003] Movies, videos, digital music, video games, and other content can be streamed with reasonably low latency over limited bandwidth connections such as cellular phones and home Wi-Fi networks because the content is compressed before being streamed.

[0004] There are generally two types of compression: lossy and lossless. Lossy compression reduces the size of content by removing certain information. Typically, the removed information is imperceptible (e.g., high audio frequencies that only some people can hear, minute details in photos or images that will only be displayed at a lower resolution and therefore cannot be seen), etc.

[0005] With lossless compression, every bit of information in the source file or content is preserved after compression and is recovered when the file is decompressed. Lossless compression is useful for compressing computer executable files because losing any part of the computer's instructions can lead to execution errors (like trying to follow a drive instruction that deletes a line every two lines).

[0006] A common form of lossless compression is called "entropy coding." Entropy coding involves assigning codes to symbols so that the code length matches the probability of the symbol's occurrence. The most frequently occurring symbols are then encoded using the shortest possible code. Samuel F.B. Morse and his friend Alfred Vail used entropy coding when they designed Morse Code in the 1840s. Morse and Vail counted the number of letters in typesetting to estimate the frequency of letters in newsprint (since they were trying to devise a universal code that could be used for any message that might be sent by telegraph, they did not look at the actual frequency of symbols in any particular message). Here are their findings.

[0007] 12,000 E 2,500 F

[0008] 9,000 T 2,000 W, Y

[0009] 8,000 A, I, N, O, S 1,700 G, P

[0010] 6,400 H 1,600 B

[0011] 6,200 R 1,200 V

[0012] 4,400 D 800 K

[0013] 4,000 L 500 Q

[0014] 3,400 U 400 J, X

[0015] 3,000 C, M 200 Z

[0016] Because the letter "E" appeared most frequently, Morse and Vail assigned it a single dot (".") (the shortest code a telegraph operator could send). Similarly, Morse and Vail assigned the next shortest code (a single dash or "-") to the letter "T," as it appeared next most frequently. And so on. Morse and Vail assigned longer codes, consisting of combinations of four dots and / or dashes, to "Q," "J," "X," and "Z," because these letters appeared least frequently. There was no need to send a "codebook" with each message; Morse code was soon standardized, so most telegraph operators memorized it.

[0017] Entropy coding is currently widely used in various data compression methods, with Huffman and arithmetic coding perhaps being the most common. They often work by exploiting redundancy at the output of the quantizer. See Huffman, “A Method for the Construction of Minimum-Redundancy Codes” Proceedings of the IRE (September 1952). Arithmetic coding encodes the entire message into a single number (an arbitrary-precision decimal q, where 0.0 ≤ q < 1.0). It represents the current information as a range defined by two numbers. A more recent family of entropy encoders known as Asymmetric Numeral Systems (ANS) allows for faster implementations thanks to operations directly on a single natural number representing the current information. en.wikipedia.org / wiki / Arithmetic_coding; Duda et al, “The use of asymmetric numeral systems as an accurate replacement for Huffmancoding”, Picture Coding Symposium (2015).

[0018] A straightforward example method for compressing a sequence of symbols (e.g., computer data file 10) is to use, for example... Figure 1 The two-part encoding based on an ANS-type entropy encoder is shown. This involves first constructing a table F (item 16, the two-part encoding "codebook") containing the occurrence counts of each symbol in the sequence to be compressed (i.e., the "message"). Figure 1 Table F is shown as a histogram. The ANS encoder then uses table F (which allows estimation of the occurrence probability of each symbol) to iteratively encode each symbol of the sequence (which in the illustrated example is first compressed using LZ4 lossless compression to reduce redundancy) into a single large number (encoding). Note that in this example, table F16 is "tailor-made" for the specific sequence being compressed because it provides the most accurate estimate of the occurrence count of each symbol in the actual message to be encoded. Thus, in the example embodiment, each unique sequence to be encoded has its own corresponding symbol occurrence table F.

[0019] When table F remains the same throughout the entire sequence encoding process used to encode a particular sequence, the application is called "static encoding" (as opposed to "adaptive encoding," in which the table can change during each encoding iteration). Since the static ANS decoder will need table F 16 (codebook) to perform the inverse process of encoding, this table, along with code 14, is provided to the decoder in the form of a compressed sequence.

[0020] Compressed sequence = Encoding + Symbol occurrence table F

[0021] Since the symbol occurrence table F is also communicated to the decoder, it effectively becomes part of the compressed sequence's compression size. Therefore, it is desirable to compress table F efficiently to reduce the overall compressed sequence's size. Summary of the Invention

[0022] In one example embodiment, a decoding method, which can be performed using at least one processor and / or processing circuitry, includes: receiving an encoded symbol sequence entropy-encoded using a symbol occurrence table; receiving an integer value f encoded in the symbol occurrence table; and adaptively decoding the symbol occurrence table using the received integer value f, including: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective middle indices; and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding middle index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) calculating the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table; and applying the decoded symbol occurrence table to entropy decode the received encoded symbol sequence.

[0023] It should be clarified that the first reference to "symbol occurrence table" in the above example refers to Table F (not cumulative table C) in the example embodiment described in detail below. In fact, the "cumulative interpolation encoding / decoding" in the example embodiment includes the conversion between Table F and Table C as described above in (ii) (hence the "cumulative" wording in the title). Therefore, at the end of (i), the example embodiment has decoded Table C, and then at the end of (ii), the example embodiment has decoded Table F; therefore, (i) + (ii) decodes Table F. In other words:

[0024] The "Cumulative Interpolation Decoding" decodes table F through the following process:

[0025] i) Decode table C using "Interpolation Decoding".

[0026] ii) Calculate Table F based on Table C.

[0027] In one embodiment, the decoding may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0028] In one embodiment, the decoding may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0029] In an embodiment, the received second integer value m can be obtained from the header data of the encoded symbol sequence.

[0030] In an embodiment, the decoding may further include: decoding entries in the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree. The entries in the symbol occurrence accumulation table are decoded by traversing the tree of the subdivided decoding range in a depth-first pre-order manner and performing arithmetic division at each node in the tree.

[0031] In this embodiment, the received integer value f can be represented as a big number (bignum).

[0032] In an embodiment, the decoding may further include: renormalization to allow for faster and more storage-efficient decoding.

[0033] In an embodiment, the encoded symbol sequence may include an aggregation of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0034] In an embodiment, using the received integer value f may include: using only integer arithmetic, shifting, logical operations, loading, and storing to recover the entries in the symbol occurrence table.

[0035] In an embodiment, the application may include: applying asymmetric digital system (ANS) entropy decoding to decode the received coded symbol sequence.

[0036] In an embodiment, the decoding may further include: iterating or recursively subdividing the successive subdivisions and calculating for each decoding range.

[0037] In an embodiment, the decoding may further include: independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers.

[0038] In an embodiment, the decoding may further include: using at least one processor to execute instructions for lossless recovery by decoding the received entropy-encoded symbol sequence.

[0039] In an embodiment, the decoding may further include: using at least one graphics processing unit to generate at least a portion of an interactive graphics display based at least in part on graphics data that is losslessly recovered by decoding a received entropy-encoded symbol sequence.

[0040] In an embodiment, a decoder may include at least one processor and / or processing circuitry configured to operate including: accessing an integer value f encoded in a symbol occurrence table; and adaptively decoding the symbol occurrence table using the integer value f, including: (i) decoding each entry of a symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) calculating the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table.

[0041] In such an embodiment:

[0042] - The operation may further include: applying the calculated symbol occurrence table to entropy decode the encoded symbol sequence, and / or performing at least a portion of the entropy-decoded symbol sequence, and / or streaming at least a portion of the entropy-decoded symbol sequence.

[0043] - The operation may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0044] The operation may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0045] - The operation may further include: obtaining the received second integer value m from the header data of the encoded symbol sequence.

[0046] - The operation may further include: decoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree; and / or decoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range in a depth-first preorder order and performing arithmetic division at each node in the tree.

[0047] The received integer value f is represented as a big number (bignum).

[0048] - The operation may also include: renormalization to allow for faster and more storage-efficient decoding.

[0049] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0050] - Use may include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0051] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0052] - The operation may further include: iterating or recursively subdividing the successive subdivisions and the computation for each decoding range; and / or independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers; and / or using at least one processor to execute instructions for lossless recovery by decoding the entropy-encoded symbol sequence; and / or using at least one graphics processing unit to generate at least a portion of an interactive graphics display based at least in part on the graphics data losslessly recovered by decoding the entropy-encoded symbol sequence.

[0053] In an embodiment, a system for generating animated graphics may include: at least one storage device storing (i) at least one data block representing an encoded symbol sequence after entropy encoding using a symbol occurrence table, and (ii) an integer value f encoded by the symbol occurrence table; at least one processor and / or processing circuitry connected to the at least one storage device, the at least one processor and / or processing circuitry operating to: adaptively decode the symbol occurrence table using the integer value f, including: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) 1) to update f; (ii) to calculate the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table; and to apply the decoded symbol occurrence table to entropy decode the encoded symbol sequence represented by the at least one data block, at least a portion of the entropy-decoded symbol sequence representing graphic and / or graphic animation operations; and means for generating animated graphics based at least in part on the entropy-decoded symbol sequence.

[0054] In such an embodiment:

[0055] - The operation may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0056] The operation may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0057] - The received second integer value m can be obtained from the header metadata of the encoded symbol sequence.

[0058] - The operation may further include: decoding the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree.

[0059] - The operation may further include: decoding the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range in a depth-first preorder and calculating arithmetic division at each node of the tree.

[0060] - The received integer value f can be represented as a big number (bignum).

[0061] - The operation may also include: renormalization to allow for faster and more storage-efficient decoding.

[0062] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0063] - Use may include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0064] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0065] - The operation may further include: iterating or recursively subdividing the successive subdivisions and the computation for each decoding range; and / or independently decoding segments of the encoded symbol sequence generated from entropy-based binary segments of the symbol sequence and reconstructing the symbol sequence based on the segment headers; and / or executing instructions for lossless recovery by decoding the entropy-encoded symbol sequence; and / or decoding the entropy-encoded symbol sequence at least partially in a cloud environment.

[0066] - The apparatus may include at least one graphics processing unit configured to generate at least a portion of an interactive graphics display based at least in part on graphics data that is losslessly recovered by decoding an entropy-encoded sequence of symbols.

[0067] - The apparatus may include a simulator for generating the animated graphics based at least in part on the symbol sequence.

[0068] In an embodiment, an encoding method is performed using at least one processor and / or processing circuitry. The encoding method may include: generating a symbol occurrence table based on the occurrences of symbols in a symbol sequence to be entropy encoded; entropy encoding the symbol sequence using the symbol occurrence table; and adaptively encoding the symbol occurrence table using an integer value f, including: (i) calculating a symbol occurrence accumulation table based on the symbol occurrence table; (ii) encoding each entry of the symbol occurrence accumulation table by: successively subdividing the encoding range of the symbol occurrence accumulation table at respective intermediate indices; and for each encoding range, calculating f × (entry at the last index – entry at the first index + 1) + (entry at the corresponding intermediate index – entry at the first index) to encode the entry at the corresponding intermediate index of the encoding range and updating f; and forming at least one data block, the at least one data block representing (i) the entropy-encoded symbol sequence and (ii) the integer value f obtained for encoding the symbol occurrence table.

[0069] The above content corresponds to the following detailed example embodiments:

[0070] Cumulative interpolation encoding encodes table F through the following process:

[0071] Calculate Table C from Table F;

[0072] Use interpolation coding to encode table C.

[0073] In such an embodiment:

[0074] - The encoding may further include: generating a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the generated second integer value m as an upper bound of the symbol occurrence accumulation table.

[0075] - The encoding may further include: generating a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the generated second integer value m as the last entry in the symbol occurrence accumulation table.

[0076] - The operation may further include: including the second integer value m as metadata in the header associated with the encoded symbol sequence.

[0077] - The encoding may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range and calculating arithmetic multiplication at each node after the child nodes of each node.

[0078] - The encoding may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range in depth-first reverse post-order and calculating arithmetic multiplication at each node.

[0079] - The encoding may also include: representing the generated integer value f as a big number (bignum).

[0080] - The encoding may also include: renormalization to allow for faster and more storage-efficient encoding.

[0081] - The symbol sequence may include aggregations of different components, including the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0082] Using the integer value f may include encoding entries in the symbol occurrence table using only integer arithmetic, shifting, logical operations, loading, and storing.

[0083] - Applications may include: applying asymmetric digital system (ANS) entropy coding to encode the symbol sequence.

[0084] - The encoding may further include: iterating or recursively subdividing the successive subdivisions and the computation for each encoding range; and / or independently encoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and specifying the order of the segments of the symbol sequence within the segment header.

[0085] - The symbol sequence may include lossless encoded executable instructions and / or bit sequences configured to control the graphics processing unit to generate at least a portion of an interactive graphics display.

[0086] - The encoding may further include: segmenting the symbol sequence before encoding using entropy-based binary segmentation, wherein the entropy-based binary segmentation reduces or minimizes the sum of the entropy of all obtained segments and the size of the symbol occurrence table at each segmentation step.

[0087] In an embodiment, a system (or an encoder) for generating animated graphics may include: at least one storage device; and at least one processor and / or processing circuitry connected to the at least one storage device, the at least one processor and / or processing circuitry operating to include: generating a symbol occurrence table based on the occurrence of symbols in a symbol sequence to be entropy encoded, the symbol sequence at least partially contributing to the generation of animated graphics; entropy encoding the symbol sequence using the symbol occurrence table; and adaptively encoding the symbol occurrence table using an integer value f, including: (i) calculating a symbol occurrence accumulation table based on the symbol occurrence table, and (ii) encoding each entry of the symbol occurrence accumulation table by: successively subdividing the encoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each encoding range, calculating f × (entry at the last index – entry at the first index + 1) + (entry at the corresponding intermediate index – The entry at the first index is used to encode the entry at the corresponding intermediate index of the encoding range and update f; forming at least one data block, the at least one data block representing (i) an entropy-encoded symbol sequence and (ii) an integer value f representing an encoded symbol occurrence table; and storing the at least one data block in the storage device.

[0088] In such an embodiment:

[0089] - The operation may further include: generating a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the generated second integer value m as an upper bound of the symbol occurrence accumulation table.

[0090] The operation may further include: generating a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the generated second integer value m as the last entry in the symbol occurrence accumulation table.

[0091] - The operation may further include: including the second integer value m as metadata in the header associated with the encoded symbol sequence.

[0092] - The operation may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range and calculating arithmetic multiplication at each node after the child nodes of each node.

[0093] - The operation may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range in depth-first reverse order and calculating arithmetic multiplication at each node; and / or representing the received integer value f as a bignum; and / or renormalizing to allow for faster and more storage-efficient encoding.

[0094] - The symbol sequence may include aggregations of different components, including the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0095] - Using f can include: encoding entries in the symbol occurrence table using only integer arithmetic, shifting, logical operations, loading, and storing.

[0096] - Applications may include: applying asymmetric digital system (ANS) entropy coding to encode the symbol sequence.

[0097] - The operation may further include: iterating or recursively subdividing the successive subdivisions and the computation for each encoding range; and / or independently encoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and specifying the order of the segments of the symbol sequence within the segment header.

[0098] - The symbol sequence may include lossless encoded executable instructions.

[0099] - The symbol sequence may include a bit sequence configured to control at least one graphics processing unit to generate at least a portion of an interactive graphics display.

[0100] - The operation may further include: segmenting the unencoded symbol sequence using entropy-based binary segmentation, wherein the entropy-based binary segmentation reduces or minimizes the sum of the entropy of all obtained segments and the size of the symbol occurrence table at each segmentation step.

[0101] In an embodiment, a non-transitory memory may be configured to store instructions that cause at least one processor and / or processing circuitry to operate, the operation including: accessing an integer value f encoded in a symbol occurrence table; and adaptively decoding the symbol occurrence table using the integer value f, including: (i) decoding each entry of a symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) calculating the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table.

[0102] In such an embodiment, the operation may further include:

[0103] - Apply the calculated symbol occurrence table to entropy decode the encoded symbol sequence; and / or use at least a portion of the entropy-decoded symbol sequence to stream data representing at least a portion of a graphical user interaction; and / or perform at least a portion of the entropy-decoded symbol sequence; and / or stream at least a portion of the entropy-decoded symbol sequence.

[0104] - Receive a second integer value m, using zero as the lower bound of the symbol occurrence accumulation table, and using the received second integer value m as the upper bound of the symbol occurrence accumulation table;

[0105] - Receive the second integer value m, insert a zero value as the first entry in the symbol occurrence accumulation table, and insert the received second integer value m as the last entry in the symbol occurrence accumulation table;

[0106] - Obtain the received second integer value m from the header data of the encoded symbol sequence;

[0107] - Decode the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree; and / or by traversing the tree of the subdivided decoding range in a depth-first preorder order and performing arithmetic division at each node in the tree.

[0108] In such an embodiment:

[0109] - The received integer value f can be represented as a big number (bignum).

[0110] - The operation may also include: renormalization to allow for faster and more storage-efficient decoding.

[0111] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0112] - Using f can include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0113] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0114] - The operation may further include: iterating the successive subdivisions and the calculations for each decoding range; and / or recursively performing the successive subdivisions and the calculations for each decoding range.

[0115] - The operation may further include: independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers.

[0116] In an embodiment, a method for operating a cloud-based device may include: sending command and / or control signals to a decoder processor and / or decoder processing circuit located at a remote location via at least one network and / or communication link, the command and / or control signals causing the decoder processor and / or decoder processing circuit located at the remote location to operate, the operation including: accessing an integer value f encoded in a symbol occurrence table; and adaptively decoding the symbol occurrence table using the integer value f, including: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1). 1) to update f; (ii) to calculate the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table; and to apply the calculated symbol occurrence table to entropy decode the encoded symbol sequence; and to receive visual and / or audio information generated or produced using at least part of the entropy-decoded symbol sequence via the at least one network and / or communication link.

[0117] In such an embodiment:

[0118] Receiving may include receiving data representing at least a portion of at least one graphical representation based at least partially on a sequence of symbols that has been entropy-decoded.

[0119] - The method may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0120] The method may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0121] - The received second integer value m can be obtained from the header metadata of the encoded symbol sequence.

[0122] The method may further include decoding entries in the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree. The entries in the symbol occurrence accumulation table can be decoded by traversing the tree of the subdivided decoding range in a depth-first preorder order and performing arithmetic division at each node in the tree.

[0123] - The received integer value f can be represented as a big number (bignum).

[0124] - The method may also include: renormalization to allow for faster and more storage-efficient decoding.

[0125] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0126] - Using f can include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0127] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0128] - The method may further include: iterating or recursively subdividing the successive subdivisions and the computation for each decoding range; and / or independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers; and / or using at least one processor to execute instructions for lossless recovery by decoding the entropy-encoded symbol sequence; and / or using at least one graphics processing unit to generate at least a portion of an interactive graphics display based at least in part on the graphics data losslessly recovered by decoding the entropy-encoded symbol sequence.

[0129] Any of the features briefly described above may be used in combination with any other feature or combination of features. Attached Figure Description

[0130] Figure 1 This illustrates the existing LZ4 / ANS encoding process.

[0131] Figure 2A , Figure 2B An example encoding and decoding system is shown.

[0132] Figure 3 This illustrates an example of a new LZ4 compression / ANS entropy encoding process.

[0133] Figure 4 This illustration shows an example of encoding and decoding a symbol occurrence table of size 4. The entire table is encoded as f=147.

[0134] Figure 5A An example sequence of encoding steps is shown.

[0135] Figure 5B An example sequence of decoding steps is shown.

[0136] Figure 5C Example encoding and decoding steps are shown.

[0137] Figure 6 An example forward pass is shown to estimate the compressed size of the left sub-segment.

[0138] Figure 7 An example backpass is shown to estimate the compressed size of the right sub-segment.

[0139] Figure 8 Example sums of estimated compressed sizes for two segments are shown. The index of the minimum value of the sum represents the optimal potential cut point.

[0140] Figure 9 The illustration shows an example of segmentation, where each rectangle represents a segment of the sequence. S(n) is the estimated compressed size of the segment at index n, calculated as the sum of its 0th-order entropy and the size of its compressed byte occurrence table.

[0141] Figure 10A , Figure 10B This illustrates an example of the existing LZ4 block sequence format.

[0142] Figure 11 This schematically illustrates an example overview of the new encoding for the LZ4 block.

[0143] Figures 12A to 12B The above is a schematic diagram of an example compressed file format.

[0144] Figure 12C The example file header format is shown.

[0145] Figure 12D Example block header format is shown.

[0146] Figure 12E An example stream header format is shown.

[0147] Figure 12F The example paragraph header format is shown.

[0148] Figures 13A to 13H Example use cases are shown.

[0149] Figure 14A It is by Figure 13H The flowchart shows an example operation performed by the application server.

[0150] Figure 14B It is by Figure 13H The flowchart shows an example operation performed by the presentation system. Detailed Implementation

[0151] (One or more) example encoding / decoding systems

[0152] Figure 2A , Figure 2B An example encoding and decoding system is illustrated. An input file 50 containing a sequence of symbols (which may be stored on a storage medium) is encoded by an encoding device 56 to produce a compressed data stream or data file 54. The compressed data stream or data file 54 is communicated from the encoding device 56 to one or more decoding devices 58. The decoding devices 58 may be located remotely from the encoding device 56 or in the same location as the encoding device. The communication medium used to communicate the compressed data stream from the encoding device 56 to the decoding device 58 may include a memory storage device and / or a network and / or a wireless link and / or a cable and / or a signal path and / or any other arrangement for communicating digital data from one component to one or more other components.

[0153] Each decoding device 58 decodes the compressed data stream or data file 54 to recover the input file 52. Since the compression is lossless in the example embodiment, the recovered input file perfectly matches the original input file. In the illustrated example non-limiting embodiment, one or more decoding devices 58 may recover one or more input files 52 for use in generating real-time or other graphical presentations such as interactive video games.

[0154] Figure 2BAn encoding device 56 and a decoding device 58 are illustrated, each comprising a processing arrangement including one or more central processing units (CPUs) and / or one or more graphics processing units (GPUs) and / or one or more processing circuits. In some use cases, it is advantageous for the decoding device 58 to include custom-designed hardware, such as one or more application-specific integrated circuits (ASICs); and for the encoding device 56 to include one or more CPUs and / or GPUs, and one or more non-transitory memory devices storing encoded instructions executed by one or more CPUs and / or GPUs. However, this implementation is not limiting. In some use cases, the encoding device 56 and the decoding device 58 may each include software stored in non-transitory memory and executed on (one or more) processors. In other use cases, both the encoding device 56 and the decoding device 58 may include hardware circuitry, such as that provided by one or more ASICs (e.g., including transistor-based logic gates, computation units, and registers), or other hardware implementations.

[0155] In some embodiments, the encoding device 56 and the decoding device 58 are the same device (or in a common package) capable of operating in both encoding and decoding modes. Such a device, which can both encode and decode, is typically referred to as a "codec". In other embodiments, the encoding device 56 is structured differently from the decoding device 58, so that the encoding device 56 only encodes and does not decode, and the decoding device 58 only decodes and does not encode.

[0156] like Figure 3 As shown, encoding device 56 uses both LZ4 compression and ANS entropy encoding to losslessly encode the input file 10 into a compressed entropy-encoded file 14. That is, in the example embodiment, the encoding device can receive an input file that has already been compressed using LZ4, or can compress the file using LZ4 compression. Then, encoding device 56 entropy-encodes the already compressed input file, consisting of a sequence of symbols, into a corresponding entropy code. Similarly, decoding device 58 uses entropy decoding to decode the entropy-encoded file 14 to recover the compressed input file, which can then be decompressed using LZ4 to recover the original uncompressed input file.

[0157] In an example embodiment, cumulative interpolation coding techniques (which may be based on "binary interpolation coding" or "BIC") are used to encode / compress the codebook or table F16 itself used by the encoding device 56 to entropy-encode the compressed file and recover the entropy-encoded file. Thus, the encoding device 56 losslessly encodes the codebook or table F16 to produce a compact code for communication to the decoding device 58. The decoding device 58 decodes this code to recover the codebook or table F, which is then used to decode the entropy-encoded file F14 to recover the original file F10.

[0158] Compress the entropy table

[0159] Entropy coding can involve developing a symbol occurrence table F (sometimes called a "codebook"). To compress the symbol occurrence table F, the following method (Algorithm 1) can be used.

[0160] • Table C for calculating the cumulative value of F ( Figure 3 Item 18)

[0161] • Use cumulative interpolation encoding, such as binary interpolation encoding (“BIC”), to recursively encode the values ​​of the C table to produce an encoding (i.e., the stored integer value f).

[0162] More information related to BIC can be found in the following literature: Moffat et al, Binary Interpolative Coding for Effective Index Compression. Information Retrieval 3, 25–47 (2000). doi.org / 10.1023 / A:1013002601898, link.springer.com / article / 10.1023 / A:1013002601898; Turpin et al, Housekeeping for prefix coding, IEEE Transactions on Communications 48(4):622 - 628, 48(4):622 - 628 (May 2000DOI:10.1109 / 26.843129); Moffat et al, Large-Alphabet Semi-Static Entropy Coding Via Asymmetric Numeral Systems, ACM Transactions on Information Systems 38(4) May 2020 DOI:10.1145 / 3397175; Trotman, “Compressing InvertedFiles”, Information Retrieval 6, 5-19 (2003).

[0163] exist Figure 3In the example implementation shown, the encoding of table C (and therefore table F) is represented by an integer f (20). Thus, the integer value f constitutes the encoding of the symbolic appearance of table F. This integer f can become very large because, in general, we do not know its size beforehand, nor do we know the amount of storage required to store it. To overcome this problem, in one embodiment, we can use the “bignum” structure ( / / en.wikipedia.org / wiki / Arbitrary-precision_arithmetic) which can represent integers of arbitrary precision (other embodiments may use other alternative representations). At each decoding step, dividing bignum actually means multiple divisions. For example, if bignum is represented by n 32-bit values ​​at some point, we must perform n divisions. To allow for faster and more storage-efficient decoding, we can add a “renormalization” step to each encoding and decoding step. Renormalization keeps the encoded values ​​within a small, manageable range throughout all encoding / decoding processes to avoid arithmetic operations on extremely large integers. To keep the integer value within a small range, the idea is to write the least significant bit of the integer value to a buffer whenever the integer value exceeds a threshold during encoding. Then, at each decoding step, we only need to compute a single division on relatively small integers (and potentially read bits from the buffer), instead of computing divisions on very large integers or multiple divisions on small integers when using a bignum structure. Sending bits ahead of time like this might slightly infringe on compression ratio, but this is generally negligible compared to its speed and storage efficiency. Renormalization is frequently used to improve ANS encoding (graphallthethings.com / posts / streaming-ans-explained / #:~:text=Streaming%20and%20normalization). For some implementations, using such renormalization makes computation more efficient, but alternatively, other implementations can use repeated divisions at each step (e.g., if speed is not an issue or in a fast hardware implementation).

[0164] Furthermore, in this example unrestricted implementation, we make some assumptions:

[0165] • The symbols of the sequence are encoded as 8-bit symbols, so table F(16) contains 256 elements. The proposed implementation can be easily generalized to have 2 k A table of (k>0) elements (where k is the sign size in bits), or generalized to tables of arbitrary size by slight modifications or by padding the beginning with zeros to return the power of 2.

[0166] • The number of symbols m in the sequence (i.e., the total number of occurrences in table F (16) and the last value in table C (18)) is known at the time of decoding and is provided to the decoder, so it does not need to be encoded. This is a fair assumption for most practical use cases where the data file or message being encoded is predetermined and not randomly generated in real time as it is being encoded, especially since entropy encoders such as ANS already require this value to initialize decoding. More precisely, since the number of symbols m is necessary for decompressing the compressed file, the number of symbols m is stored in the compressed file. Therefore, both the ANS decoder and the interpolation decoder retrieve this value when they receive a compressed file containing it. This value can then be used by the interpolation decoder as the last value in table C. In a non-restrictive implementation, this value is stored in the header metadata preceding the encoding f of the table symbol occurrences. For example, in Figures 12A to 12B In this example file format, each "segment data" (616, 618) consists of an entropy code s for the symbol sequence and an interpolation code f for the corresponding symbol occurrence table used by the entropy code, preceded by a segment header (608) containing metadata required for decoding the segment data. In this example file format, the number of symbols m (which is used as an input integer value m in the interpolator decoder) is stored as the "[u8]raw data size" in the segment header (608). In another implementation, this number may be sent to the interpolator decoder in a different manner (such as along with the encoding of the symbol occurrence table).

[0167] The following algorithm can be described using Python pseudocode. Specifically, when a function is defined inside another function, as we did in Algorithms 1 and 2, the inner function can access variables of the outer function as if those variables were "global". We want to increment the same code for all calls to the recursive function, as if that same code were "shared" by all those calls. The implementation may vary depending on the programming language. For example, in C or C++, the algorithm could be implemented using two separate functions and pointers to a table C and a code f.

[0168] Algorithm 1. Cumulative Interpolation Encoding (Recursive Example)

[0169] function InterpolativeEncode

[0170] input:

[0171] - : 256 integer values ​​containing the symbol. array

[0172]

[0173] : zero value array

[0174]

[0175] for

[0176]

[0177] function InterpolativeEncodeRec

[0178] input:

[0179] - The first index of the range

[0180] - The last index of the range

[0181] if

[0182]

[0183] if

[0184] InterpolativeEncodeRec

[0185] InterpolativeEncodeRec

[0186]

[0187] InterpolativeEncodeRec

[0188] output:

[0189] Algorithm 2. Cumulative Interpolation Decoding (Recursive Example)

[0190] function InterpolativeDecode

[0191] input:

[0192] - Encoding of the symbol occurrence table calculated using Algorithm 1

[0193] - The : symbol appears in the last entry of the cumulative table.

[0194] 256 zero values array

[0195] 257 zero values array

[0196]

[0197] function InterpolativeDecodeRec

[0198] input:

[0199] - The first index of the range

[0200] - The last index of the range

[0201] if

[0202]

[0203]

[0204]

[0205] if

[0206] InterpolativeDecodeRec

[0207] InterpolativeDecodeRec

[0208] else

[0209] for

[0210]

[0211] InterpolativeDecodeRec

[0212] for

[0213]

[0214] output:

[0215] Note:

[0216] As can be seen from the above, at each encoding step, the example embodiment updates f from the entries in the cumulative table (which encodes intermediate entries). The example embodiment does not need to generate any entries; it only updates the integer f. Therefore, the encoding process of the example embodiment calculates f × (entry at the last index – entry at the first index + 1) + (entry at the intermediate index – entry at the first index) based on the symbol occurrence cumulative table for each encoding step, to encode the entries at the intermediate indices and update f.

[0217] This differs from decoding, in which the example embodiment performs a first operation and a second operation at each decoding step to generate entries and update f, namely: (1) calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the partially decoded symbol occurrence accumulation table to decode the entries at the middle indexes of the decoding range, and (2) calculating f div (the entry at the last index – the entry at the first index + 1) to update f.

[0218] Example

[0219] Figure 4 This shows an example encoding and decoding of table C calculated from an example table F of size 4 with m=10. Since it is assumed that the value 10 is known during decoding, we only need to encode the three values ​​less than 10. Naive encoding will... bit (of which) It is the ceiling function (see en.wikipedia.org / wiki / Floor_and_ceiling_functions) that encodes each of the three values, making the total encoding for table C to be... Position. But if Figure 1 As shown, the example method encodes the three values ​​progressively and sequentially (e.g., iteratively in one example embodiment) to obtain an intermediate representation sequence of the integer f=147, which means that table C is encoded in In position.

[0220] More in detail, Figure 4 This illustrates an example encoding process for encoding the input file table F, represented here as a histogram, to a value of 102. The arrays each contain integers appearing 3, 1, 2, 4, ...

[0221] As described above, define a C array 104 with 257 zero values, where , ,etc. Defined as the first index of the range and The last index defined in the range.

[0222] Since the value 10 is known during decoding, only the three values ​​less than 10 are encoded. See 106. Interpolation encoding techniques such as BIC are used in three iterations as operations on table C to encode the three values ​​into a single encoded integer 147.

[0223] 0 × (6+1) + 2 = 2 (Calculation step 110)

[0224] 2 × (4+1) + 3 = 13 (Calculation step 112)

[0225] 13 × (10+1) + 4 = 147 (Calculation step 114)

[0226] exist Figure 1 On the right side, the decoding process begins by knowing the value 10 (see array 116) and receiving the value 147. The decoding process then performs these decoding steps to reconstruct the intermediate tables C shown on the left.

[0227] 147 mod (10+1) = 4 (decoding step 116a) to produce array 118 that matches the definition portion of intermediate array 104.

[0228] 147 div (10+1) = 13 (Decoding step 118a)

[0229] 13 mod (4+1) = 3 (decoding step 118b) to produce array 120 that matches the definition portion of intermediate C array 106.

[0230] 13 div (4+1) = 2 (Decoding step 120a)

[0231] 2 mod (6+1) = 2 (decoding step 120b) to produce array 122 that matches the definition portion of intermediate C array 208.

[0232] 2 div (6+1) = 0 (decoding step 122a) to produce array 124 that perfectly matches the original F array 102 (i.e., the original frequency array is recovered without loss).

[0233] In the example above, the encoding is dynamic / adaptive because the following f calculation (note that this is one for the encoder) is variable for each calculation.

[0234]

[0235] For reference, you can see the changes shown in "6" -> "4" -> "10" (the reverse order of decoding). Figure 4 This is seen in [the text]. Therefore, the calculation (in the decoder) provides arithmetic division of the received integer value by the dynamically changing value to derive a series of remainders. This can also be described as changing the value based on the maximum and minimum values ​​within the target calculation range.

[0236] On the other hand, although the above algorithm is recursive and iteratively executed, such recursive program code is complex (compact and efficient), but can be alternatively implemented by encoding each computation one by one (i.e., "in sequence" or by "(multiple) sequential computations"), for example, using inline code instead of loops or recursion (i.e., calling a function itself). Meanwhile, the hardware implementation can pass data multiple times through the same circuitry, or provide a series of computational circuits or sequences of computational circuits, such as in a pipelined manner, or both.

[0237] Example: Compressing a sequence of symbols

[0238] To compress symbol sequences (e.g., files), these algorithms only need to be integrated into the ANS encoding / decoding described above.

[0239] Algorithm 3. Sequence Encoding

[0240] input:

[0241] - S: A sequence of symbols of arbitrary size

[0242] The calculation symbol appears in table F ( Figure 5A (Box 152)

[0243] The sequence code s is obtained by encoding S from F using an ANS encoder. Figure 5A (Box 154)

[0244] Algorithm 1 is used to encode F to obtain the table encoding f( Figure 5A (Box 156)

[0245] Concatenate s and f to obtain the coded segment S' ( Figure 5A (Box 158)

[0246] output: S'

[0247] Algorithm 4. Sequence Decoding

[0248] input:

[0249] - S': A sequence of arbitrary size encoded using Algorithm 5.

[0250] Split S' to obtain the sequence code s and the table code f ( Figure 5B (Box 162)

[0251] Algorithm 2 is used to decode f to obtain the symbol occurrence table F. Figure 5B (Box 164)

[0252] The decoder is used to decode s from F to obtain the decoded segment S. Figure 5B (Box 166)

[0253] output: S( Figure 5B (Box 168)

[0254] Figure 5C The overall example encoding and decoding steps are summarized, which can be performed by the same component operated by the same party, the same component operated by different parties, or different components operated by different parties. In this example, the Table F encoding and Table F decoding steps are characterized as a "cumulative interpolation algorithm," which in a particular embodiment may or may not be what a person skilled in the art would refer to as "binary interpolation encoding" or BIC.

[0255] Example binary segmentation

[0256] If the symbol distribution varies greatly within the sequence, splitting the sequence into several segments with homogeneous distributions and independently compressing these segments yields a better compression ratio. To do this, we slice the sequence where significant changes in the distribution are observed. Detecting such "changepoints" in the probability distribution of a stochastic process (a sequence of random variables) is a well-known problem known as changepoint detection. See, for example, en.wikipedia.org / wiki / Change_detection. Here, we propose a custom greedy algorithm using top-down binary segmentation.

[0257] If the sum of the estimated compressed sizes of the two segments is less than the estimated compressed size of the sequence, our segmentation algorithm seeks to split the sequence into two segments. To do this, we iterate through the sequence and, for each added symbol, compute the (0th-order) entropy of the base segment. For each symbol, if we decide to cut the sequence at that position, this gives the estimated compressed size of the first segment (the left sub-segment) of the two segments. In practice, we perform this evaluation every N symbols to reduce computation time.

[0258] To estimate the compressed size of the second segment (right sub-segment), we perform the same calculation by traversing the sequence in reverse. Regardless of the iteration direction, the entropy of the sequence calculated based on the occurrence of a symbol is the same. We then simply add the two estimates obtained at each symbol and select the cut point with the smallest sum.

[0259] Once the cut point is found, we compare the sum of the compressed sizes of the two resulting sub-segments with the compressed size of the parent segment using the proposed compression method. For this, we do not need to actually compress the segment. The (0th-order) entropy is almost an accurate estimate of the compressed size of the sequence using an ANS encoder with a frequency table encoded as two parts, but excluding the storage size of the ANS table itself. Therefore, we only need to compress the ANS table, which has already been calculated for entropy calculation, using a cumulative interpolation algorithm, and add its compressed size to the segment's entropy to obtain the segment's compressed size. Then, if the sum of the compressed sizes of the sub-segments is less than the compressed size of the parent segment, we segment; otherwise, we do not segment.

[0260] If segmentation occurs, the same algorithm is recursively applied to both subsegments, gradually building the segment tree. See, for example, en.wikipedia.org / wiki / Segment_tree. At the end of the algorithm, we simply take the leaf segments from the segment tree. Since we only cut node segments if they are beneficial, the leaf segments represent the best segments provided by the algorithm in the segment tree, such as... Figures 5A to 5C As shown, etc.

[0261] Figure 6 , Figure 7 , Figure 8 , Figure 9 This example illustrates finding cut points in a byte sequence. The sequence is generated by concatenating two sequences, each generated by randomly sampling bytes according to two different Gaussian distributions. The first sequence has a size of 12,000 bytes, and the second sequence has a size of 8,000 bytes. Therefore, the sequence has a size of 20,000 bytes, with a change in distribution around the 12,000th byte. As we can see below, the algorithm clearly identifies the cut point near the 12,000th byte.

[0262] When using this binary segmentation to segment the symbol sequence, the sequence compression and decompression algorithms therefore become as follows.

[0263] Algorithm 5. Using segmented sequence encoding

[0264] input:

[0265] - S: A sequence of symbols of arbitrary size

[0266] Use binary segmentation to obtain segment S.

[0267] For each segment S i :

[0268] Using Algorithm 3 to test S i Encode to obtain encoded S i '

[0269] Cascaded coded segments To obtain the encoded sequence S'

[0270] output: S'

[0271] Algorithm 6. Decoding using segmented sequences

[0272] input:

[0273] - S': Any value encoded using Algorithm 5 sequence

[0274] Split S' to obtain the coded segment

[0275] For each encoded segment S i ':

[0276] Using Algorithm 4 to pair S i 'Perform decoding to obtain decoded segment S'

[0277] Cascaded decoding segment To obtain the decoded sequence S

[0278] output: S

[0279] In Algorithm 5, the concatenation of coded segments involves storing one or more specific headers, which allows the coded sequence to be split into coded segments during decoding. This is an implementation detail and there are multiple implementations.

[0280] As mentioned above, most of the segmentation work is done on the encoder side. However, the decoder is also "aware" that it is operating on segments, at least because the decoder concatenates the decoded segments together in the appropriate order into a sequential file or stream.

[0281] LZ4 block compression

[0282] We propose applying the above compression method to LZ4 compression. This is as explained in the LZ4 documentation at github.com / lz4 / lz4 / blob / dev / doc / lz4_Block_format.md, and as in... Figure 10A , Figure 10BThe diagram illustrates that an LZ4 compressed block consists of "sequences," each of which is further composed of five streams, referred to as:

[0283] • Token

[0284] • Literal length,

[0285] •literal,

[0286] • Offset, and

[0287] • Match length.

[0288] These streams are explained in detail in the LZ4 documentation and the blog post "LZ4 Explained" (fastcompression.blogspot.com / 2011 / 05 / lz4-explained.html). Since an LZ4 block consists of many such sequences, we group the different streams of all block sequences into five groups. Then, for each group, we concatenate its streams into a single sequence that we compress using Algorithm 5 described above. Depending on the size of each group's streams, we can select to compress only a subset of these streams.

[0289] This method allows for a much better compression ratio than LZ4 alone (according to our experiments, 21.2% + / - 2.5% additional compression) while still allowing for fast decompression.

[0290] Figure 11 This is an overview of an example algorithm used to encode an LZ4 block. The figure also illustrates all the encoding algorithms described above. In this example, file X 502 is analyzed by the processor using a conventional LZ4 encoder 504 to produce an LZ4 block 506, which comprises multiple LZ4 sequences and generates multiple files 508A, 508B, 508C, 508D, and 508E. Algorithm 5 operates on each of these files 508, whereby Algorithm 5 segments the files as described above into segmented files 512. Thus, multiple files 512(S1) to 512(Sn) are generated for each of 508A, 508B, 508C, 508D, and 508E. Algorithm 3 operates on each of the segmented files 512(S1) to 512(Sn) using ANS entropy coding to produce an entropy code (integer s). i 514), and Algorithm 1 uses interpolation encoding as described above to operate on the symbol occurrence table F of the entropy-encoded segmented file to produce an integer f. i Algorithm 3 will also include the integer s. i and integer f i Cascade to produce file S' i Then, from file S'1 516 (S'1) to file S' nMultiple files of 516(S'n) are concatenated to file S' 520, and as... Figures 12A to 12B The format is shown. Files A' 522A to E' 522E correspond to file S' 520 (file S' 520 is used as file A' 522A when file A 508A is operated on using algorithm 5). The resulting files 522A to 522E are concatenated and stored in file X' 524, and as shown... Figures 12A to 12B The format shown is correct.

[0291] Figures 12A to 12B The file format of compressed file 610 is shown. Compressed file 610 is formatted to include a hierarchical structure, wherein:

[0292] • Compressed file 610 includes a file header 602 concatenated with file data 612 (see also...) Figure 12C );

[0293] • File data 612 includes one or more blocks, each of which includes a corresponding block header 604 concatenated with the corresponding block data 614 (see See File Data 614). Figure 12D );

[0294] • Each block of data 614 includes one or more streams 607, each of which includes a corresponding stream header 606 concatenated with the corresponding stream data 609 (see See Figure 12E );as well as

[0295] • Each stream of data 609 includes one or more segments, each of which includes a corresponding segment header 608 concatenated with the corresponding segment data 618 (see See...). Figure 12F ).

[0296] In the example shown, there are multiple blocks 614(0), ..., 614(z). Each block 614 includes multiple streams 607. For example, block 614(0) includes streams 607(0), ..., 607(4), and block 614(z) includes streams 607(5), ..., 607(n). Blocks 614 may have the same number of streams 607 or different numbers of streams.

[0297] In the example shown, each stream 607 includes multiple segments, each segment including a corresponding segment header 608 and corresponding segment data 618. For example, stream 609(0) includes segment header 608(0)(0) and associated segment data 618(0)(0), ..., segment header 608(0)(i) and associated segment data 618(0)(i). Meanwhile, stream 609(1) includes segment header 608(1)(0) and associated segment data 618(1)(0), ..., and segment header 608(1)(j) and associated segment data 618(1)(j). In the example shown, stream 609(n) includes segment header 608(n)(0) and associated segment data 618(n)(0), ..., and segment header 608(n)(t) and associated segment data 618(n)(t). Integer values ​​i, j, k, l, m, n, p, q, r, s, t can be the same or different values.

[0298] Figures 12A to 12B The various streams of data from file data 612 and Figure 11 The files in the stream correspond to each other, from file A' 522A to file E' 522E. The stream data within the stream may further include segments 616, each segment 616 being prefixed with a segment header 608. Figure 12A Each of the segment data 616a, 616b, 616c, 616d, and 616j (which are respectively) Figure 12B (618a, 618b, 618c, 618d, 618k) and Figure 11 The files S1' 516 (S'1) correspond to each other because all the first segments of data are present in their stream data. Files A' to E' actually correspond to each stream data.

[0299] In the example embodiment, Figure 12C , Figure 12D , Figure 12E and Figure 12F The following are examples of the importance of the "u" values ​​shown in the header.

[0300] u32: An unsigned integer that holds 32 bits of data.

[0301] u8: An unsigned integer that holds 8 bits of data.

[0302] u6: An unsigned integer that holds 6 bits of data.

[0303] u4: An unsigned integer that holds 4 bits of data.

[0304] u2: An unsigned integer that retains 2 bits of data.

[0305] [u8]: An array of u8 values.

[0306] exist Figure 12EIn the stream header 606 shown, there are fields “u2 Number of bytes for additional stream size” and “[u8] Number of bytes for additional stream size b6 ... bN (optional)”. Here, if the size of the “stream data” (in bytes) fits 6 bits (b0...b5) (i.e., the maximum size of 63 bytes), then “[u8] Number of bytes for additional stream size b6 ... bN (optional)” is empty, and “u2 Number of bytes for additional stream size” is 0. If the “stream data” contains more than 63 bytes (which is very likely), then more than 6 bits are used to encode its size. For example, if its size is 100KB, then 17 bits are used to encode that size (log2(100000) = 16.61), that is, 11 additional bits, and therefore 2 additional bytes (u8). In this case, "[u8] Additional stream size b6... bN" will contain 2 bytes (b6...b21, two u8 tables), and "u2 Number of bytes for additional stream size" will be equal to 2. This tells the decoder that it needs to read these 2 additional bytes after "u6 Stream size b0... b5" to obtain the complete stream size. Therefore, the decoder will concatenate the first 6 bits (b0...b5) with the next two bytes (b6...b21) to obtain the stream size (b0...b21 in binary representation, which will represent the integer 100000).

[0307] As Figure 12A / Figure 12B As an alternative to the data format shown, the compressed file can be easily "embedded" in another file without storing part or all of the header shown. For example, if we want to embed an encoded file into a game compressed file, we only need to store the stream, and do not need to store the file header 602, block header 604, stream header 606, or segment header 608.

[0308] In one embodiment, the formatted data shown can be stored in non-transitory memory and communicated from the encoder to the decoder. For example, see... Figure 13A ,Should Figure 13A The example encoding device communicates encoded data to the example decoding device via any kind of connection. See also... Figure 13B ,Should Figure 13B The example encoding device communicates encoded data to an example decoding device via a network connection. Decoding using a decoder is performed in reverse, and then the decoding device can use the decoded data, such as by storing the decoded data as computer code or instructions in at least one non-transitory memory device for execution by at least one processor. See also Figure 13C ,Should Figure 13CAn intermediate application server is shown that receives an encoded compressed data file from an encoding device and provides the encoded compressed data file to one or more application execution systems via a network. Each of the one or more application execution systems includes a decoder for decoding the encoded compressed data file and then using (e.g., executing) the decoded data to produce an output. Figure 13C This demonstrates that the intermediate application server does not need to decode the encoded compressed data file; instead, it can store the encoded compressed data file "as received" and provide it to the application execution server. Meanwhile, Figure 13D Another embodiment is shown, in which the application server can decode the encoded compressed data file and then re-encode the data to provide the encoded compressed data file to the application execution system.

[0309] Figure 13E Another example embodiment is shown, in which the application development system provides a data file to the application server via a network, and the application server encodes the data file and provides the encoded compressed data file to the application execution system, such as via a network. Figure 13F Another example embodiment is shown, in which the application development system provides a data file to the application server via a path other than through a network, and the application server encodes the data file and provides the encoded compressed data file to the application execution system, such as through a network.

[0310] Example I: Decoding Method

[0311] In one example embodiment, the decoding method may be performed using at least one processor and / or processing circuitry, the decoding method comprising: receiving an encoded symbol sequence entropy-encoded using a symbol occurrence table; receiving an integer value f encoded in the symbol occurrence table; and adaptively decoding the symbol occurrence table using the received integer value f, comprising: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective middle indices; and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding middle index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) calculating the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table; and applying the decoded symbol occurrence table to entropy decode the received encoded symbol sequence.

[0312] It should be clarified that the first reference to "symbol occurrence table" in the above example refers to Table F (not cumulative table C) in the example embodiment described in detail below. In fact, the "cumulative interpolation encoding / decoding" in the example embodiment includes the conversion between Table F and Table C as described above in (ii) (hence the "cumulative" wording in the title). Therefore, at the end of (i), the example embodiment has decoded Table C, and then at the end of (ii), the example embodiment has decoded Table F; therefore, (i) + (ii) decodes Table F. In other words:

[0313] The "Cumulative Interpolation Decoding" decodes table F through the following process:

[0314] i) Decode table C using "Interpolation Decoding".

[0315] ii) Calculate Table F based on Table C.

[0316] In one embodiment, the decoding may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0317] In one embodiment, the decoding may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0318] In an embodiment, the received second integer value m can be obtained from the header data of the encoded symbol sequence.

[0319] In an embodiment, the decoding may further include: decoding entries in the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree. The entries in the symbol occurrence accumulation table are decoded by traversing the tree of the subdivided decoding range in a depth-first pre-order manner and performing arithmetic division at each node in the tree.

[0320] In this embodiment, the received integer value f can be represented as a big number (bignum).

[0321] In an embodiment, the decoding may further include: renormalization to allow for faster and more storage-efficient decoding.

[0322] In an embodiment, the encoded symbol sequence may include an aggregation of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0323] In an embodiment, using the received integer value f may include: using only integer arithmetic, shifting, logical operations, loading, and storing to recover the entries in the symbol occurrence table.

[0324] In an embodiment, the application may include: applying asymmetric digital system (ANS) entropy decoding to decode the received coded symbol sequence.

[0325] In an embodiment, the decoding may further include: iterating or recursively subdividing the successive subdivisions and calculating for each decoding range.

[0326] In an embodiment, the decoding may further include: independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers.

[0327] In an embodiment, the decoding may further include: using at least one processor to execute instructions for lossless recovery by decoding the received entropy-encoded symbol sequence.

[0328] In an embodiment, the decoding may further include: using at least one graphics processing unit to generate at least a portion of an interactive graphics display based at least in part on graphics data that is losslessly recovered by decoding a received entropy-encoded symbol sequence.

[0329] Example II: Decoder

[0330] In an embodiment, the decoder may include at least one processor and / or processing circuitry configured to operate including: accessing an integer value f encoded in a symbol occurrence table; and adaptively decoding the symbol occurrence table using the integer value f, including: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) calculating the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table.

[0331] In such an embodiment:

[0332] - The operation may further include: applying the calculated symbol occurrence table to entropy decode the encoded symbol sequence, and / or performing at least a portion of the entropy-decoded symbol sequence, and / or streaming at least a portion of the entropy-decoded symbol sequence.

[0333] - The operation may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0334] The operation may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0335] - The operation may further include: obtaining the received second integer value m from the header data of the encoded symbol sequence.

[0336] - The operation may further include: decoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree; and / or decoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range in a depth-first preorder order and performing arithmetic division at each node in the tree.

[0337] The received integer value f is represented as a big number (bignum).

[0338] - The operation may also include: renormalization to allow for faster and more storage-efficient decoding.

[0339] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0340] - Use may include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0341] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0342] - The operation may further include: iterating or recursively subdividing the successive subdivisions and the computation for each decoding range; and / or independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers; and / or using at least one processor to execute instructions for lossless recovery by decoding the entropy-encoded symbol sequence; and / or using at least one graphics processing unit to generate at least a portion of an interactive graphics display based at least in part on the graphics data losslessly recovered by decoding the entropy-encoded symbol sequence.

[0343] Example III: Decoding System

[0344] An embodiment of a system for generating animated graphics may include: at least one storage device storing (i) at least one data block representing an encoded symbol sequence after entropy encoding using a symbol occurrence table, and (ii) an integer value f encoded by the symbol occurrence table; at least one processor and / or processing circuitry connected to the at least one storage device, the at least one processor and / or processing circuitry operating to: adaptively decode the symbol occurrence table using the integer value f, including: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) 1) to update f; (ii) to calculate the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table; and to apply the decoded symbol occurrence table to entropy decode the encoded symbol sequence represented by the at least one data block, at least a portion of the entropy-decoded symbol sequence representing graphic and / or graphic animation operations; and means for generating animated graphics based at least in part on the entropy-decoded symbol sequence.

[0345] In such an embodiment:

[0346] - The operation may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0347] The operation may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0348] - The received second integer value m can be obtained from the header metadata of the encoded symbol sequence.

[0349] - The operation may further include: decoding the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree.

[0350] - The operation may further include: decoding the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range in a depth-first preorder and calculating arithmetic division at each node of the tree.

[0351] - The received integer value f can be represented as a big number (bignum).

[0352] - The operation may also include: renormalization to allow for faster and more storage-efficient decoding.

[0353] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0354] - Use may include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0355] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0356] - The operation may further include: iterating or recursively subdividing the successive subdivisions and the computation for each decoding range; and / or independently decoding segments of the encoded symbol sequence generated from entropy-based binary segments of the symbol sequence and reconstructing the symbol sequence based on the segment headers; and / or executing instructions for lossless recovery by decoding the entropy-encoded symbol sequence; and / or decoding the entropy-encoded symbol sequence at least partially in a cloud environment.

[0357] - The apparatus may include at least one graphics processing unit configured to generate at least a portion of an interactive graphics display based at least in part on graphics data that is losslessly recovered by decoding an entropy-encoded sequence of symbols.

[0358] - The apparatus may include a simulator for generating the animated graphics based at least in part on the symbol sequence.

[0359] Example IV: Method for operating a server or computing device based on a decoding cloud

[0360] An embodiment of a method for operating a cloud-based device may include: sending command and / or control signals to a decoder processor and / or decoder processing circuit located at a remote location via at least one network and / or communication link, the command and / or control signals causing the decoder processor and / or decoder processing circuit located at the remote location to operate, the operation including: accessing an integer value f encoded in a symbol occurrence table; and adaptively decoding the symbol occurrence table using the integer value f, including: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table, to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1). (ii) update f by incrementing the entry at the first index by 1; (ii) calculate the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table; and apply the calculated symbol occurrence table to entropy decode the encoded symbol sequence; and receive visual and / or audio information generated or produced using at least part of the entropy-decoded symbol sequence via the at least one network and / or communication link.

[0361] like Figure 13HAs shown, one embodiment of an application server or other computing device includes a decoding system or decoder located in the "cloud" (i.e., at a cluster of servers or other remote location) and connected to communicate with other devices remotely to itself via one or more networks or other communication connections. The server or other computing device including the decoding system or decoder can receive or otherwise be provided with encoded (e.g., compressed) digital data files for decoding. In this context, the term "digital data" can include any kind of information, including image data, sound data, computer or processor instructions, computer programs, commands, constants, and any and all (one or more) other types of information. Therefore, the term "data file" is not limited to non-executable data but can include or encompass one or more computer programs that can be executed by one or more processors, as an example. Data files may or may not include a file header, and may be organized in one or more specific standardized types of "data file formats," such as those described at wikipedia.org / wiki / List_of_file_formats, or may not be organized in one or more specific standardized types of "data file formats."

[0362] Encoded compressed data files can be provided / generated by an encoding system or encoder of the type described above, which may or may not be part of the application development system, or may or may not be operatively coupled to or connected to the application development system. The application development system can, for example, create, generate, and / or produce data files with or without human involvement or intervention. In one embodiment, encoded compressed data files (e.g., computer instructions or programs, processor instructions, GPU instructions, image data such as texture data, etc.) can be provided by the encoding system or encoder to the decoding system or decoder in any number of ways (e.g., via (one or more) digital networks, via (one or more) communication links, via (one or more) physically portable tangible storage media such as flash drives, or in any other convenient manner, etc.). Servers or other computing devices may include one or more non-transitory storage devices configured to store or retain the encoded compressed data files once they are provided to the decoding system or decoder. In another embodiment, the application development server and the cloud-based application server can be co-located with each other (and may include, for example, a unified or coordinated cloud-based content licensing and distribution system, such as eShop).

[0363] A cloud-based decoding system or decoder may include one or more processors and / or processing circuitry and / or graphics processing units that execute instructions stored in one or more non-transitory storage devices. Such instruction execution causes one or more processors and / or processing circuitry and / or graphics processing units to access stored encoded compressed data files and decode the stored (one or more) encoded compressed data files into (one or more) decoded uncompressed data files in the manner detailed above. One or more processors and / or processing circuitry and / or graphics processing units may natively execute such stored decoding instructions, or they may interpret or otherwise transform the stored instructions to provide the decoding as described above, or they may emulate hardware and / or software decoders, or any combination of these techniques, to provide the decoder functionality as detailed above. Alternatively or additionally, the decoding process may be embedded in a hardware state machine or other hardware circuit decoder implementation. Alternatively, one or more parts of the decoding process may be implemented in instructions that can be executed by one or more processors, and another part of the decoding process may be implemented in one or more hardware circuits such as ASICs, state machines, etc.

[0364] like Figure 13H As shown, a decoding system or decoder can be triggered, initiated, or otherwise controlled, or caused to perform decoding, in response to one or more control signals received by a cloud-based server or other computing device from a device (e.g., a presentation system) located at a remote location via a network or other communication link. See also Figure 14A Boxes 702, 704, and 706. Therefore, in one embodiment, the presentation system can generate remote commands or remote control signals (see...). Figure 14B (Blocks 802 and 804) When the remote command or remote control signal is communicated to a cloud-based server or other computing device via a network or communication link, it causes the cloud-based decoding system or decoder to perform decoding. Figure 14A (See boxes 702, 704, and 706). The rendering system can automatically generate such commands or control signals, or it can generate such commands or control signals in response to human requests, such as requests to play a specific game or use a specific application. Figure 14BBoxes 802 and 804. In response to such a human request, the presentation system may send a command or control signal to the decoding system or decoder located in the cloud, which, in response to the human request, specifies a stored (one or more) encoded compressed data file or its association, and causes the decoding system or decoder to access the specific stored (one or more) encoded compressed data files, decode them, and store (one or more) decoded decompressed data files in non-transitory storage. Figure 14A (See boxes 702, 704, and 706). In this way, for example, a human user at the presentation system can initiate "on-demand" decoding of data files associated with a specific game the human user wants to play or a specific application the human user wants to use.

[0365] Once the cloud-based decoding system or decoder has decoded the stored encoded (compressed) data file to produce a corresponding decoded (uncompressed) data file (as detailed above), the cloud-based server or other computing device stores the decoded (uncompressed) data file in one or more non-transitory storage devices (such as one or more register files, NAND flash memory devices, magnetic storage devices, or semiconductor read / write memory (RAM), etc.). Figure 14A (See box 706). This stored, decoded, uncompressed data file is now available for processing and / or transmission by servers or other computing devices located in the cloud.

[0366] In one embodiment, a cloud-based server or other computing device can access, for example, decoded (uncompressed) data files stored in memory (or, in one embodiment, these files can be retrieved from another source, such as a remote source). Figure 14A (frame 708), and execute, process, and / or otherwise use computer instructions, computer programs, processor instructions, GPU instructions, image data, or any other information within the decoded, decompressed data file to automatically generate (one or more) visual and / or audio presentations. Figure 14A(See box 710). Visual and / or audio presentation may, for example, include a sequence of image frames and / or a sequence of sound frames that provide one or more graphical user interfaces. In one example, a cloud-based server processor and / or processor circuitry and / or graphics processing unit may natively execute or process (one or more) computer instructions, computer programs, processor instructions, GPU instructions, or other information from a decoded uncompressed data file to produce visual and / or audio presentation. In another example, a cloud-based server processor and / or processor circuitry and / or graphics processing unit may emulate other hardware and / or software to produce visual and / or audio presentation based at least in part on (one or more) computer instructions, computer programs, processor instructions, GPU instructions, or other information from a decoded uncompressed data file. For example, see: US 11911700; USP 10926174; USP 9662574; USP20230356078; Game Console GPUs pp 187–237 in Peddie, J., The History of the GPU – New Developments Springer, Cham. doi.org / 10.1007 / 978-3-031-14047-1_4(2022).

[0367] The cloud-based server processor and / or processing circuitry and / or graphics processing unit may be the same processor and / or processing circuitry and / or graphics processing unit used to perform the decoding process described above, or they may be different processors and / or processing circuitry and / or graphics processing units. In one embodiment, the cloud-based server processor and / or processing circuitry and / or graphics processing unit may be remotely controlled or caused to execute or otherwise process (one or more) computer instructions, computer programs, processor instructions, GPU instructions, or other information of a decoded uncompressed data file. For example, command or control signals may be used to initiate, control, or otherwise cause the cloud-based server processor and / or processing circuitry and / or graphics processing unit to execute (one or more) computer instructions, computer programs, processor instructions, GPU instructions, or other information of a decoded uncompressed data file. Such command or control signals may be provided, for example, by the rendering system and transmitted via a network or other communication link to the cloud-based server or other computing device (see [link]). Figure 14B(See boxes 802, 804). Command or control signals may, in one embodiment, specify a particular game or other application. In one embodiment, the same command or control signal may be used to cause a decoding system or decoder to decode one or more encoded compressed data files associated with the game, so that (one or more) decoded decompressed data files can be used to generate graphical, audio, and / or visual presentations corresponding to the game or other application (see...). Figure 14A ).

[0368] In one example embodiment, a cloud-based server or other computing device interacts with one, two, or more human users (and / or, in one embodiment, an automated "robot") via an associated presentation system to generate visual and / or audio presentations. For example, one or more presentation systems (which in one embodiment may include a game console, portable or mobile gaming device, smartphone, tablet, or any other computing device capable of providing human-readable output) may each have at least one corresponding human user, and one or more human users operate input devices such as joysticks, pointer-type devices, mouse-type devices, or numeric operation buttons. One or more presentation systems may generate input signals based on the human user's operation of the input devices and transmit these input signals (or information based on these input signals) from one or more presentation systems to the cloud-based server or other computing device in real time or near real time (i.e., with low latency) via one or more networks or other communication links. Different (one or more) presentation systems can be configured in different locations, and each presentation system can generate input signals concurrently but independently based on human user (and / or robot) operations at that presentation system, for that presentation system, or for physical and / or virtual input devices associated with that presentation system.

[0369] A cloud-based server or other computing device can use such input signals to at least partially control graphical, audio, and / or visual presentations corresponding to a game or other application, or information related to such graphical, audio, and / or visual presentations. For example, a cloud-based server or other computing device can use a first input signal provided by a first presentation system to control a first game character or second avatar and / or a first virtual camera / sound position viewpoint in a game, and can use a second input signal provided by a second presentation system to control a second game character or second avatar and / or a second virtual camera / sound position viewpoint in a game. The cloud-based server or other computing device can then, in response to the first and second input signals, generate data representing at least a portion of the same or different visual and / or audio display sequences, for example, to provide a multiplayer game or multiuser application in which different players or users experience the same or different (e.g., from different corresponding virtual camera / sound position viewpoints) visual and / or audio presentations. See also: Figure 14A Boxes 710, 712, and 714; Figure 14B Boxes 802 and 804. A cloud-based server or other computing device may update the visual and / or audio presentation, for example, every 1 / 30 or 1 / 60 second, or otherwise frequently, to provide the presentation system with information that can be used to provide animated motion pictures and sounds in response to a first input signal and a second input signal. In one example embodiment, the application server generates video and / or audio frames and streams these video and / or audio frames to the presentation system for presentation by a thin client presentation system. In another example embodiment, each presentation system performs a game process locally in response to locally provided (and in some cases remotely provided) user input, and the application server provides coordination functions between the presentation systems. In a further embodiment, the application server provides a download service to the presentation system by downloading encoded and / or decoded items such as executable code and / or control and coordination information for use by the presentation system to locally generate user presentation.

[0370] In one embodiment, a cloud-based server or other computing device may stream or otherwise transmit information related to such (one or more) visual and / or audio presentations to one or any number of presentation systems for presentation to a user. See also Figure 14A Box 710. As described above, such a cloud-based server or other computing device can natively access, use, or execute decoded instructions or data on a processor or other hardware, or translate or interpret decoded instructions or data for use, or execute an emulator configured to be compatible with the decoded instructions or data, etc. See also Figure 14A Boxes 708 and 710.

[0371] In one embodiment, the simulator generates animated graphics based at least in part on entropy-decoded symbol sequences.

[0372] In one embodiment, at least one processor and / or processing circuitry is configured to decode symbol sequences at least partially in a cloud environment.

[0373] In such an embodiment:

[0374] Receiving may include receiving data representing at least a portion of at least one graphical representation based at least partially on a sequence of symbols that has been entropy-decoded.

[0375] - The method may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0376] The method may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0377] - The received second integer value m can be obtained from the header metadata of the encoded symbol sequence.

[0378] The method may further include decoding entries in the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree. The entries in the symbol occurrence accumulation table can be decoded by traversing the tree of the subdivided decoding range in a depth-first preorder order and performing arithmetic division at each node in the tree.

[0379] - The received integer value f can be represented as a big number (bignum).

[0380] - The method may also include: renormalization to allow for faster and more storage-efficient decoding.

[0381] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0382] - Using f can include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0383] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0384] - The method may further include: iterating or recursively subdividing the successive subdivisions and the computation for each decoding range; and / or independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers; and / or using at least one processor to execute instructions for lossless recovery by decoding the entropy-encoded symbol sequence; and / or using at least one graphics processing unit to generate at least a portion of an interactive graphics display based at least in part on the graphics data losslessly recovered by decoding the entropy-encoded symbol sequence.

[0385] Example V: Encoding Method

[0386] An embodiment of the encoding method using at least one processor and / or processing circuitry may include: generating a symbol occurrence table based on the occurrence of symbols in a symbol sequence to be entropy encoded; entropy encoding the symbol sequence using the symbol occurrence table; and adaptively encoding the symbol occurrence table using an integer value f, including: (i) calculating a symbol occurrence accumulation table based on the symbol occurrence table; (ii) encoding each entry of the symbol occurrence accumulation table by: successively subdividing the encoding range of the symbol occurrence accumulation table at respective intermediate indices; and for each encoding range, calculating f × (entry at the last index – entry at the first index + 1) + (entry at the corresponding intermediate index – entry at the first index) to encode the entry at the corresponding intermediate index of the encoding range and updating f; and forming at least one data block, the at least one data block representing (i) the entropy-encoded symbol sequence and (ii) the integer value f obtained for encoding the symbol occurrence table.

[0387] The above content corresponds to the following detailed example embodiments:

[0388] Cumulative interpolation encoding encodes table F through the following process:

[0389] Calculate Table C from Table F;

[0390] Use interpolation coding to encode table C.

[0391] In such an embodiment:

[0392] - The encoding may further include: generating a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the generated second integer value m as an upper bound of the symbol occurrence accumulation table.

[0393] - The encoding may further include: generating a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the generated second integer value m as the last entry in the symbol occurrence accumulation table.

[0394] - The operation may further include: including the second integer value m as metadata in the header associated with the encoded symbol sequence.

[0395] - The encoding may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range and calculating arithmetic multiplication at each node after the child nodes of each node.

[0396] - The encoding may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range in depth-first reverse post-order and calculating arithmetic multiplication at each node.

[0397] - The encoding may also include: representing the generated integer value f as a big number (bignum).

[0398] - The encoding may also include: renormalization to allow for faster and more storage-efficient encoding.

[0399] - The symbol sequence may include aggregations of different components, including the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0400] Using the integer value f may include encoding entries in the symbol occurrence table using only integer arithmetic, shifting, logical operations, loading, and storing.

[0401] - Applications may include: applying asymmetric digital system (ANS) entropy coding to encode the symbol sequence.

[0402] - The encoding may further include: iterating or recursively subdividing the successive subdivisions and the computation for each encoding range; and / or independently encoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and specifying the order of the segments of the symbol sequence within the segment header.

[0403] - The symbol sequence may include lossless encoded executable instructions and / or bit sequences configured to control the graphics processing unit to generate at least a portion of an interactive graphics display.

[0404] - The encoding may further include: segmenting the symbol sequence before encoding using entropy-based binary segmentation, wherein the entropy-based binary segmentation reduces or minimizes the sum of the entropy of all obtained segments and the size of the symbol occurrence table at each segmentation step.

[0405] Example VI: Encoder

[0406] In another embodiment, the encoder includes at least one processor and / or processing circuitry for performing operations including: entropy encoding of a symbol sequence using a symbol occurrence table; generating an integer value f using interpolation encoding of the symbol occurrence table, including adaptively encoding a symbol occurrence accumulation table, including: repeatedly changing the encoding range of the symbol occurrence accumulation table based on the subdivision of (one or more) previous encoding ranges at intermediate indices, and for each encoding range: calculating f × (entry at the last index – entry at the first index + 1) + (entry at the intermediate index – entry at the first index) according to the symbol occurrence accumulation table to encode the entry at the intermediate index and update f; and forming at least one data block representing the encoded symbol sequence entropy encoded using the symbol occurrence table, and representing the integer value f of the encoded symbol occurrence table.

[0407] In such an embodiment:

[0408] - The operation may also include: generating a second integer value m, using zero as the lower bound of the sign occurrence accumulator, and using the generated second integer value m as the upper bound of the sign occurrence accumulator.

[0409] The operation may also include: generating a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the generated second integer value m as the last entry in the symbol occurrence accumulation table.

[0410] - The operation may also include: including the second integer value m as metadata in the header associated with the encoded symbol sequence.

[0411] - The operation may also include encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range and calculating arithmetic multiplication at each node after the child nodes of each node.

[0412] - The operation may also include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range in depth-first reverse order and calculating arithmetic multiplication at each node; and / or representing the generated integer value f as a bignum; and / or renormalizing to allow for faster and more storage-efficient encoding.

[0413] - The symbol sequence can include the aggregation of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0414] - Using f can include: encoding entries in the symbol occurrence table using only integer arithmetic, shifting, logical operations, loading, and storing.

[0415] - Applications may include: using asymmetric digital system (ANS) entropy coding to encode symbol sequences.

[0416] - The operation may also include: iterative or recursive subdivision and computation for each encoding range; and / or independently encoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and specifying the order of the segments of the symbol sequence in the segment header.

[0417] - The symbol sequence may include executable instructions that have been losslessly encoded.

[0418] - The symbol sequence may include a bit sequence configured to control at least one graphics processing unit to generate at least a portion of an interactive graphics display.

[0419] - The operation may also include: segmenting the symbol sequence prior to encoding using entropy-based binary segmentation, which at each segmentation step reduces or minimizes the sum of the entropy of all resulting segments and the size of the symbol occurrence table.

[0420] Example VII: Encoding System

[0421] An embodiment of a system for generating animated graphics may include: at least one storage device; and at least one processor and / or processing circuitry connected to the at least one storage device, the at least one processor and / or processing circuitry operating to include: generating a symbol occurrence table based on the occurrence of symbols in a symbol sequence to be entropy encoded, the symbol sequence at least partially contributing to the generation of animated graphics; entropy encoding the symbol sequence using the symbol occurrence table; and adaptively encoding the symbol occurrence table using an integer value f, including: (i) calculating a symbol occurrence accumulation table based on the symbol occurrence table, and (ii) encoding each entry of the symbol occurrence accumulation table by: successively subdividing the encoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each encoding range, calculating f × (entry at the last index – entry at the first index + 1) + (entry at the corresponding intermediate index – The entry at the first index is used to encode the entry at the corresponding intermediate index of the encoding range and update f; forming at least one data block, the at least one data block representing (i) an entropy-encoded symbol sequence and (ii) an integer value f representing an encoded symbol occurrence table; and storing the at least one data block in the storage device.

[0422] In such an embodiment:

[0423] - The operation may further include: generating a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the generated second integer value m as an upper bound of the symbol occurrence accumulation table.

[0424] The operation may further include: generating a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the generated second integer value m as the last entry in the symbol occurrence accumulation table.

[0425] - The operation may further include: including the second integer value m as metadata in the header associated with the encoded symbol sequence.

[0426] - The operation may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range and calculating arithmetic multiplication at each node after the child nodes of each node.

[0427] - The operation may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range in depth-first reverse order and calculating arithmetic multiplication at each node; and / or representing the received integer value f as a bignum; and / or renormalizing to allow for faster and more storage-efficient encoding.

[0428] - The symbol sequence may include aggregations of different components, including the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0429] - Using f can include: encoding entries in the symbol occurrence table using only integer arithmetic, shifting, logical operations, loading, and storing.

[0430] - Applications may include: applying asymmetric digital system (ANS) entropy coding to encode the symbol sequence.

[0431] - The operation may further include: iterating or recursively subdividing the successive subdivisions and the computation for each encoding range; and / or independently encoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and specifying the order of the segments of the symbol sequence within the segment header.

[0432] - The symbol sequence may include lossless encoded executable instructions.

[0433] - The symbol sequence may include a bit sequence configured to control at least one graphics processing unit to generate at least a portion of an interactive graphics display.

[0434] - The operation may further include: segmenting the unencoded symbol sequence using entropy-based binary segmentation, wherein the entropy-based binary segmentation reduces or minimizes the sum of the entropy of all obtained segments and the size of the symbol occurrence table at each segmentation step.

[0435] Example VIII: Non-transitory storage medium for decoding

[0436] An embodiment of the non-transitory memory can be configured to store instructions that cause at least one processor and / or processing circuitry to operate, the operation including: accessing an integer value f encoded in a symbol occurrence table; and adaptively decoding the symbol occurrence table using the integer value f, including: (i) decoding each entry of the symbol occurrence accumulation table by: successively subdividing the decoding range of the symbol occurrence accumulation table at respective intermediate indices, and for each decoding range: calculating the entry at the first index + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries of the symbol occurrence accumulation table to decode the entry at the corresponding intermediate index of the decoding range, and calculating f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) calculating the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table.

[0437] In such an embodiment, the operation may further include:

[0438] - Apply the calculated symbol occurrence table to entropy decode the encoded symbol sequence; and / or use at least a portion of the entropy-decoded symbol sequence to stream data representing at least a portion of a graphical user interaction; and / or perform at least a portion of the entropy-decoded symbol sequence; and / or stream at least a portion of the entropy-decoded symbol sequence.

[0439] - Receive a second integer value m, using zero as the lower bound of the symbol occurrence accumulation table, and using the received second integer value m as the upper bound of the symbol occurrence accumulation table;

[0440] - Receive the second integer value m, insert a zero value as the first entry in the symbol occurrence accumulation table, and insert the received second integer value m as the last entry in the symbol occurrence accumulation table;

[0441] - Obtain the received second integer value m from the header data of the encoded symbol sequence;

[0442] - Decode the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree; and / or by traversing the tree of the subdivided decoding range in a depth-first preorder order and performing arithmetic division at each node in the tree.

[0443] In such an embodiment:

[0444] - The received integer value f can be represented as a big number (bignum).

[0445] - The operation may also include: renormalization to allow for faster and more storage-efficient decoding.

[0446] - The encoded symbol sequence may include aggregations of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0447] - Using f can include: using only integer arithmetic, shifting, logical operations, loading, and storing to restore the entries in the symbol occurrence table.

[0448] - Applications may include: applying asymmetric digital system (ANS) entropy decoding to decode received coded symbol sequences.

[0449] - The operation may further include: iterating the successive subdivisions and the calculations for each decoding range; and / or recursively performing the successive subdivisions and the calculations for each decoding range.

[0450] - The operation may further include: independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers.

[0451] Example IX: Non-transitory storage medium used for encoding

[0452] An example embodiment stores instructions in a non-transient storage medium for causing at least one processor and / or processing circuitry to operate, the operation including: generating a symbol occurrence table based on the occurrence of symbols in a symbol sequence to be entropy encoded; entropy encoding the symbol sequence using the symbol occurrence table; and adaptively encoding the symbol occurrence table using an integer value f, including: (i) calculating a symbol occurrence accumulation table based on the symbol occurrence table; (ii) encoding each entry of the symbol occurrence accumulation table by: successively subdividing the encoding range of the symbol occurrence accumulation table at respective intermediate indices; and for each encoding range, calculating f × (entry at the last index – entry at the first index + 1) + (entry at the corresponding intermediate index – entry at the first index) to encode the entry at the corresponding intermediate index of the encoding range and updating f; and forming at least one data block, the at least one data block representing (i) the entropy-encoded symbol sequence and (ii) the integer value f obtained for encoding the symbol occurrence table.

[0453] In such an embodiment:

[0454] – The operation may further include: receiving a second integer value m, using zero as a lower bound of the symbol occurrence accumulation table, and using the received second integer value m as an upper bound of the symbol occurrence accumulation table.

[0455] – The operation may further include: receiving a second integer value m, inserting a zero value as the first entry in the symbol occurrence accumulation table, and inserting the received second integer value m as the last entry in the symbol occurrence accumulation table.

[0456] - The operation may further include: including the second integer value m as metadata in the header associated with the encoded symbol sequence.

[0457] - The operation may further include: encoding entries of the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range and calculating arithmetic multiplication at each node after the child nodes of each node.

[0458] - The operation may further include: encoding entries in the symbol occurrence accumulation table by traversing the tree of the subdivided encoding range in depth-first reverse order and calculating arithmetic multiplication at each node.

[0459] - The operation may also include: representing the received integer value f as a big number (bignum).

[0460] - The operation may also include: renormalization to allow for faster and more storage-efficient encoding.

[0461] - The symbol sequence may include aggregations of different components, including the token, literal length, literal, offset, and match length of the LZ4 block sequence.

[0462] - Using the integer value f includes: encoding the entries of the symbol occurrence table using only integer arithmetic, shifting, logical operations, loading, and storing.

[0463] - Applications may include: using asymmetric digital system (ANS) entropy coding to encode the symbol sequence.

[0464] - The operation may further include: iterating or recursively subdividing the successive subdivisions and the computation for each encoding range; and / or independently encoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and specifying the order of the segments of the symbol sequence within the segment header.

[0465] - The symbol sequence may include lossless encoded executable instructions and / or bit sequences configured to control the graphics processing unit to generate at least a portion of an interactive graphics display.

[0466] - The operation may further include: segmenting the unencoded symbol sequence using entropy-based binary segmentation, wherein the entropy-based binary segmentation reduces or minimizes the sum of the entropy of all obtained segments and the size of the symbol occurrence table at each segmentation step.

[0467] Example X: The encoding device and the decoding device can be the same device.

[0468] Example XI: Encoding and decoding methods can be combined into a common overall method.

[0469] Example XII:

[0470] Algorithm 1 / Algorithm 2 used to encode / decode the entropy table.

[0471] Example XIII:

[0472] The part of Algorithm 1 / Algorithm 2 used to encode / decode a portion of the cumulative table.

[0473] Example XIV:

[0474] Algorithm 3 / Algorithm 4 are used to encode / decode symbol sequences of arbitrary length.

[0475] Example XV:

[0476] Algorithm 5 / Algorithm 6 is used to encode / decode symbol sequences of arbitrary length using low-cost entropy-based binary segmentation to improve compression ratio.

[0477] Example XVI:

[0478] Algorithm 5 / Algorithm 6 is used to encode / decode LZ4 blocks by grouping the stream of block sequences by type and independently encoding all or part of these groups.

[0479] Some example related work

[0480] Binary interpolative coding

[0481] Binary interpolation encoding for Effective Index Compression: https: / / link.springer.com / article / 10.1023 / A:1013002601898

[0482] Maintenance operations for prefix coding: https: / / www.researchgate.net / publication / 3160122

[0483] Large-Alphabet Semi-Static Entropy Coding via Asymmetric Digital Systems: https: / / www.researchgate.net / publication / 342752784

[0484] Encoding of probability distributions for asymmetric number systems: https: / / www.researchgate.net / publication / 352373099

[0485] Binary segmentation:

[0486] A selective review of offline change point detection methods: https: / / arxiv.org / abs / 1801.00718

[0487] Ruptures: Change point detection in Python: https: / / arxiv.org / abs / 1801.00826

[0488] Change point detection using a Copula entropy-based two-sample test: https: / / arxiv.org / abs / 2403.07892

[0489] Detection of change points in conditional entropy using ordered patterns: https: / / arxiv.org / abs / 1510.01457

[0490] Optimal detection of points of change with linear computational cost: https: / / arxiv.org / abs / 1101.1438

[0491] Applying Adaptive Entropy-Based Thresholding to Change Point Detection Methods – An Application to Fault-Tolerant Fusion in Collaborative Mobile Robots: https: / / ieeexplore.ieee.org / document / 8820667

[0492] All patents and publications cited in this article are incorporated herein by reference as if explicitly stated.

[0493] Although the invention has been described in conjunction with embodiments that are now considered to be the most practical and preferred, it should be understood that the invention is not limited to the disclosed embodiments, but rather is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.

Claims

1. A decoder comprising at least one processor and / or processing circuitry, said at least one processor and / or processing circuitry being configured to operate, said operation comprising: Access the integer value f that encodes the symbol occurrence table; Adaptively decoding the symbol occurrence table using the integer value f includes: (i) Decode each entry in the symbol occurrence accumulation table using the following process: The decoding range of the accumulated table of symbol occurrences is subdivided consecutively at their respective intermediate indices, and For each decoding range: The entry at the first index is calculated as + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries in the symbol occurrence accumulation table, to decode the entries at the corresponding intermediate indices of the decoding range, and Calculate f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) Calculate the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table.

2. The decoder according to claim 1, wherein, The operation further includes: applying the calculated symbol occurrence table to entropy decode the encoded symbol sequence.

3. The decoder according to claim 2, wherein, The operation further includes: performing at least a portion of the entropy-decoded symbol sequence.

4. The decoder according to claim 2, wherein, The operation further includes streaming at least a portion of the entropy-decoded symbol sequence and / or information derived from at least a portion of the entropy-decoded symbol sequence.

5. The decoder according to claim 1, wherein, The operation also includes: Receive the second integer value m, Using zero as the lower bound of the cumulative table of sign occurrences, and The received second integer value m is used as the upper bound of the symbol occurrence accumulation table.

6. The decoder according to claim 5, wherein, The operation further includes obtaining the received second integer value m from the header data of the encoded symbol sequence.

7. The decoder according to claim 1, wherein, The operation also includes: Receive the second integer value m, Insert a zero value as the first entry in the cumulative table of the occurrences of the symbol, and The received second integer value m is inserted as the last entry in the cumulative table of the symbols.

8. The decoder according to claim 1, wherein, The operation further includes decoding the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree.

9. The decoder according to claim 8, wherein, The operation further includes decoding the entries in the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range in a depth-first preorder and calculating arithmetic division at each node of the tree.

10. The decoder according to claim 1, wherein, The received integer value f is represented as a large number, i.e., bignum.

11. The decoder according to claim 1, wherein, The operation also includes: renormalization to allow for faster and more storage-efficient decoding.

12. The decoder according to claim 1, wherein, The encoded symbol sequence comprises an aggregation of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

13. A non-transitory memory configured to store instructions that cause at least one processor and / or processing circuitry to operate, the operation comprising: Access the integer value f that encodes the symbol occurrence table; Adaptively decoding the symbol occurrence table using the integer value f includes: (i) Decode each entry in the symbol occurrence accumulation table using the following process: The decoding range of the accumulated table of symbol occurrences is subdivided consecutively at their respective intermediate indices, and For each decoding range: The entry at the first index is calculated as + f mod (the entry at the last index – the entry at the first index + 1) based on the decoded entries in the symbol occurrence accumulation table, to decode the entries at the corresponding intermediate indices of the decoding range, and Calculate f div (the entry at the last index – the entry at the first index + 1) to update f; (ii) Calculate the symbol occurrence table based on the decoded entries of the symbol occurrence accumulation table.

14. The non-transitory memory according to claim 13, wherein, The operation further includes: applying the calculated symbol occurrence table to entropy decode the encoded symbol sequence.

15. The non-transitory memory according to claim 14, wherein, The operation further includes: using at least a portion of the entropy-decoded symbol sequence to stream data representing at least a portion of the graphical user interaction.

16. The non-transitory memory according to claim 14, wherein, The operation further includes: performing at least a portion of the entropy-decoded symbol sequence.

17. The non-transitory memory according to claim 14, wherein, The operation further includes streaming information based on at least a portion of the entropy-decoded symbol sequence.

18. The non-transitory memory according to claim 14, wherein, The encoded symbol sequence comprises an aggregation of different components, which include the token, literal length, literal, offset, and match length of the LZ4 block sequence.

19. The non-transitory memory according to claim 14, wherein, Applications include: using Asymmetric Digital System Entropy Decoding (ANS) to decode received coded symbol sequences.

20. The non-transitory memory according to claim 13, wherein, The operation also includes iterating the successive subdivisions and the calculations for each decoding range.

21. The non-transitory memory according to claim 13, wherein, The operation also includes: recursively subdividing the consecutive subdivisions and performing the calculations for each decoding range.

22. The non-transitory memory according to claim 14, wherein, The operation further includes: independently decoding segments of the encoded symbol sequence generated from entropy-based binary segmentation of the symbol sequence, and reconstructing the symbol sequence based on the segment headers.

23. The non-transitory memory according to claim 13, wherein, The operation also includes: Receive the second integer value m, Using zero as the lower bound of the cumulative table of sign occurrences, and The received second integer value m is used as the upper bound of the symbol occurrence accumulation table.

24. The non-transitory memory according to claim 23, wherein, The operation further includes obtaining the received second integer value m from the header data of the encoded symbol sequence.

25. The non-transitory memory according to claim 13, wherein, The operation also includes: Receive the second integer value m, Insert a zero value as the first entry in the cumulative table of the occurrences of the symbol, and The received second integer value m is inserted as the last entry in the cumulative table of the symbols.

26. The non-transitory memory according to claim 13, wherein, The operation further includes decoding the entries of the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range and performing arithmetic division at each node before the child nodes of each node in the tree.

27. The non-transitory memory according to claim 26, wherein, The operation further includes decoding the entries in the symbol occurrence accumulation table by traversing the tree of the subdivided decoding range in a depth-first preorder and calculating arithmetic division at each node of the tree.

28. The non-transitory memory according to claim 13, wherein, The received integer value f is represented as a large number, i.e., bignum.

29. The non-transitory memory according to claim 13, wherein, The operation also includes: renormalization to allow for faster and more storage-efficient decoding.

30. The non-transitory memory according to claim 13, wherein, The operation also includes: using only integer arithmetic, shifting, logical operations, loading, and storing to recover the entries of the symbol occurrence table from the integer value f.

Images