Selection of pivot positions for linear network codes

Abstract

A method for encoding data includes: selecting a sequence of pivot candidate positions from a sequence of g encoded vectors to encode blocks of g data symbols in a round of encoding by the following steps: providing a set of g pivot candidate positions; selecting pivot candidate positions for the sequence from the set of pivot candidate positions; removing the selected pivot candidate positions from the set of pivot candidate positions; and repeating until the set of pivot candidate positions is empty and the sequence of selected pivot candidate positions in the round is non-linear. A set of encoded vectors is generated based on the sequence of selected pivot candidate positions, each encoded vector including zero-valued coefficients at positions within the encoded vector preceding the pivot candidate positions and non-zero-valued coefficients at least at the pivot candidate positions.

Description

Technical Field

[0001] This invention relates to a method for encoding data. Background Technology

[0002] Erasure correction code (ECC) is a useful tool when building efficient and scalable air communication systems. The basic principle is to (1) generate a stream of decoded packets from the source data block at the encoder, and (2) collect the decoded packets at the decoder to reconstruct the origin block of the source data.

[0003] Figure 1 illustrates the basic architecture of an ECC-based system. A common scenario is for a single encoder 10 to send decoded packets to a single decoder 20. However, in many practical applications (e.g., multicast), a single encoder 10 can also simultaneously send packets to many decoders 20-1, 20-2…20-m via the same or different communication channels (wired, wireless, etc.) 30-1, 30-2, 30-p. Alternatively, several encoders 10-1, 10-2, 10-n can be used, as long as they operate on the same source data block.

[0004] In practice, a file or stream can be divided into multiple blocks. A block consists of g source symbols, each m bytes in size, where g is called the block size, and the block contains g·m bytes. If multiple blocks are used, they can have different sizes. Additionally, source symbols of unequal sizes can be used within a block; in this case, zero-padding or similar techniques can be used during encoding and decoding.

[0005] The challenge in ECC-based systems is that when the source data blocks become large (e.g., 1000s of source symbols), it leads to high computational complexity in the encoder and decoder.

[0006] This problem is typically handled in one of two ways:

[0007] 1. Split the source data block into multiple smaller and more manageable blocks. However, this solution often introduces inefficiencies into the system when many receivers are involved. Each receiver may lose a different subset of the block, and therefore each transmission from the sender may only benefit a subset of the receivers.

[0008] 2. Use single or large blocks, but construct codes to reduce decoding complexity. A popular approach is to use sparse codes, where the symbols for a single decoding are linear combinations of only a very finite set of source symbols; that is, most of the code vector coefficients for any given decoded block will be zero. g source symbols are sent in g encoded blocks in a round, with code vectors that vary for each block decoded in that round.

[0009] Option (2) typically provides the most efficient use of the communication channel if a well-designed sparse ECC is used. Furthermore, using large blocks simplifies the overall system design.

[0010] Referring to Figure 2, in order to perform the encoding of a data block, the g source symbols of the block are typically arranged into a matrix M = [m0, m1, ..., m g-1 ], where each m i It is a column vector.

[0011] To generate a given decoded symbol x, M is multiplied over a finite field GF by a coding vector v containing g decoding coefficients. The practical interpretation is that each decoded symbol is a mixture of one or more source symbols and their corresponding decoding coefficients, where many coefficients are zero in sparse schemes.

[0012] The process of generating the code vector is crucial to the performance of network decoding. Some strategies include a system phase in which all g source symbols are transmitted as is. Other strategies use a feedback-based deterministic approach, while still others use probabilistic methods to generate random decoding coefficients.

[0013] The information about the symbols and the encoded vectors used to represent each decoded symbol is included in the decoded block. Note that in the decoded block, the encoded vector can be represented by the actual decoded coefficients or any other representation that allows the decoder to reconstruct the encoded vector. A common implementation is to use a seed from a random number generator.

[0014] The purpose of the decoder is to undo the mixing of source symbols performed by the encoder in order to recover g source symbols. Typically, decoding can be completed after adding g linearly independent decoded blocks to the decoder. We say that a decoded block is linearly independent if and only if the encoded vectors recovered from the decoded block are linearly independent with respect to any previously recovered encoded vectors of a particular block. If the decoded block is determined to be linearly dependent, it does not contribute useful information to decoding and can be discarded.

[0015] In practice, decoding a block of code in one round is typically performed by arranging the received coded vectors as rows in matrix X and the decoded symbols as rows in matrix G. Initially, before any decoded blocks are received, both matrices X and G will contain only zeros. For each arriving decoded block, the decoder performs Gauss-Jordan elimination on the arriving coded vector and the non-zero rows of X. All row operations performed on the coded vectors are also performed on the decoded symbols with rows from matrix G. If the arriving coded vector is reduced to all zeros, the decoded block is linearly dependent and will be discarded. Conversely, if the coded vector contains non-zero coefficients, the decoded blocks are linearly independent, and the coded vector and decoded symbols can be inserted into X and G respectively.

[0016] When inserting encoded vectors and decoded symbols at the decoder, if matrix X contains linearly independent non-zero rows where the leftmost non-zero coefficient is at index j, then we say that the decoder has a pivot at index j. Therefore, a pivot is the leftmost non-zero coefficient of the linearly independent decoded vector. The number of pivots in matrix X is called the rank of the decoder, and decoding is complete once g pivots are found.

[0017] If no computation is required to determine whether the decoded blocks are linearly independent, then the decoded blocks are directly insertable. This is true if and only if the leftmost non-zero coefficient of the coded vector represented in the decoded block does not have the same index as the principal element in the decoder. In the following text, we will refer to the leftmost non-zero coefficient of the coded vector represented in the decoded block before any computation as a principal element candidate, as shown in Figure 3.

[0018] Directly insertable blocks reduce decoding overhead and minimize the computational work required to decode symbols.

[0019] Currently, most sparse stochastic linear network decoding (RLNC) solutions generate coded vectors according to some random distribution. This makes the decoding overhead independent of the underlying communication channel; that is, the solution will perform the same operation on channels with or without bursts of, for example, 0%, 10%, or 50% packet loss. An example of this process is explained in more detail in "Perpettual Codes for Network Coding" by Janus Heide et al., September 15, 2015 (https: / / arxiv.org / pdf / 1509.04492.pdf). While this provides predictable computational complexity and decoding overhead, unfortunately, even when packet loss is low, the ratio of directly inserted decoded packets is low.

[0020] Janus Heide et al.'s "On Code Parameters and Coding Vector Representation for Practical RLNC," Proc. 2011 IEEE International Conference on Communications, June 5-9, 2011, Kyoto, Japan, pp. 1-5, discusses the drawbacks associated with RLNC, including decoding complexity and overhead generated by the coding vector. Increasing the field size and generation size presents a fundamental trade-off between packet-based throughput and operational overhead. On the one hand, reducing the probability of sending redundant packets is beneficial for throughput and thus reduces transmission energy. On the other hand, the amount of decoding complexity and header overhead increases with field size and generation length, leading to higher energy consumption.

[0021] Qureshi Jalaluddin et al.'s "Erasure Coding for Ultra-Low Power Wireless Networks," IEEE Transactions on Green Communications and Networking, IEEE, Vol.3, no.4, December 1, 2019, pp. 866-875, discloses a sparse parallel concatenated decoding (SPCC) scheme in which the sparsity and ratio of the decoded blocks are optimized for different k values ​​on GF(2) (i.e., a Galois field of size 2) and larger field sizes (such as GF(32)) to minimize the total energy cost of the network.

[0022] Checking whether the pivot at the same position in a round (i.e., the pivot with the same index that has a pivot candidate) no longer exists is sufficient for the decoder to determine whether the pivot candidate can be directly inserted. Below, we evaluate the fraction of pivot candidates that can be directly inserted using existing techniques.

[0023] As a baseline, let's consider the case where principal component candidate indices (i.e., principal component candidate positions within the encoding vector) are generated randomly and uniformly from all available candidates at the encoder. This is typical of most sparse ECC methods, such as those mentioned above.

[0024] We first examine how many master bits we lost at the decoder after receiving g decoded packets.

[0025] 1. The probability that a principal candidate is not selected is equal to the probability that different principal candidates are selected: 1 - (1 / g)

[0026] 2. Then, the probability of not selecting a pivot candidate after g attempts is (1-(1 / g)). g

[0027] 3. Then, the probability of having already selected a principal candidate is 1 - (1 - (1 / g)). g It tends to be about 63% as g increases.

[0028] This means that, on average, we will use a random uniform strategy to directly insert approximately 63% of the principal candidate as the principal.

[0029] Another way to increase the proportion of decoded blocks that can be directly inserted into the decoder is to use a systematic approach such as linear sequences. In a linear sequence, the encoder generates principal candidate indices in order from 0, 1, 2 up to g-1 (then the encoder restarts generating the index sequence from 0).

[0030] The resulting g-1 indexes are used to generate each encoded vector for one round. In each case, the encoded vector consists of non-zero coefficients from a finite field at the pivot candidate index position. The coefficients at index positions preceding the pivot candidate position are zero; while the coefficients at index positions following the pivot candidate position are determined according to the decoding scheme, but typically these coefficients consist of a finite number of non-zero coefficients whose values ​​and positions are implicitly or explicitly known by the encoder and decoder.

[0031] As an example, if g=10, the sequence of principal candidate positions will look like the rounds shown in Figure 4.

[0032] If we consider the case where there is no loss, all receivers only need a single round of coded packets to decode the data, and each principal candidate will be directly inserted, with zero decoding overhead. Furthermore, for uniform random loss experienced in each round, as shown in Figure 4, the method works well, and as the loss level increases, we approach the performance of the aforementioned random uniform candidate generation.

[0033] To analyze the performance of the linear sequence method, we examine how many principal elements are lost at the decoder after receiving the decoded packets.

[0034] 1. First, we look at how many rounds we need to receive g symbols, that is, how many times we will repeat the sequence. Considering packet loss, we need 1 / (1-p) rounds.

[0035] 2. The probability of receiving a principal candidate in one round is the probability that it has not been lost in all rounds, which is 1-p. rounds .

[0036] Unfortunately, this doesn't work well if the packet loss is sudden or periodic. The fundamental problem is that, since the principal component candidate positions are selected linearly, we have a high probability of overlap. If we have overlap at index i, it's very likely that we'll also overlap at i+1, and so on.

[0037] Figure 5 The model can be used to simulate burst / periodic losses. The model has good and bad states. In the good state, burst-length packets are received, followed by a random transition to either a good or bad state. In the bad state, burst-length packets are discarded, followed by a random transition to either a good or bad state.

[0038] refer to Figure 6 As can be seen, the performance of using linear sequences fluctuates greatly, especially when the loss is very abrupt from one round to another. In this case, we observe that the suboptimal worst-case behavior and the random uniform principal component candidate position selection strategy outperform the linear sequence strategy.

[0039] In summary, both current strategies, "random uniform principal candidate position selection" and "linear sequence principal candidate position selection," have significant drawbacks. When using the random uniform strategy, performance remains independent of the underlying channel (burst, non-burst, packet loss amount); however, it consistently only allows direct insertion of approximately 63% of symbols. The linear sequence strategy performs much better when packet loss is low and uniform. However, if the loss is bursty, it exhibits fluctuating and poor worst-case behavior. Summary of the Invention

[0040] According to the present invention, a method for encoding data according to claim 1 is provided.

[0041] In a second aspect, a resulting computer program is provided, comprising computer-readable code stored in a computer-readable medium, and including instructions configured to perform the steps of claim 1 when executed in an encoder.

[0042] In a third aspect, an encoder is provided, configured to receive data blocks to be sent to one or more receivers, and includes a processor configured to perform the steps of claim 1.

[0043] The implementation improves the performance of sparse ECC by increasing the number of blocks containing encoded vectors that can be directly inserted into the decoder.

[0044] The implementation reduces decoding overhead and minimizes the computational work that must be done when decoding the decoded symbols. This is particularly useful for bulk codes (i.e., codes generated from bulk symbols).

[0045] In some cases, when implementing network decoding, such as random linear network decoding (RLNC), the number of directly inserted symbols is maximized. The proposed method is implemented at the encoder, makes no assumptions about the communication channel, and does not require feedback from the decoder to the encoder.

[0046] The implementation ensures that the selection of principal candidate positions at the encoder is random compared to any previous round. Attached Figure Description

[0047] Embodiments of the invention will now be described by way of example with reference to the accompanying drawings, wherein:

[0048] Figure 1 shows a traditional encoder-decoder structure;

[0049] Figure 2 shows a traditional encoding matrix;

[0050] Figure 3 shows the principal candidate in the encoding vector;

[0051] Figure 4 illustrates an exemplary generation of principal component candidate positions for a conventional linear sequence, where g = 10 and grouping loss is 50%.

[0052] Figure 5 An algorithm for simulating burst loss used in the embodiments for evaluating the present invention is shown;

[0053] Figure 6 The results of conventional methods for selecting principal component candidates for encoding vectors were compared;

[0054] Figure 7 The selection of principal candidate positions for an encoding vector according to a first embodiment of the present invention is shown, where g = 10;

[0055] Figure 8 Showing more details Figure 7 The successive permutation of the principal candidate positions;

[0056] Figure 9 The performance of the first embodiment of the invention is shown, despite the presence of sudden loss;

[0057] Figure 10 The results of a first embodiment of the present invention are shown compared to conventional methods for selecting principal candidate vectors.

[0058] Figure 11 This illustrates five rounds of principal component candidate positions selected according to an embodiment of the first embodiment of the present invention; and

[0059] Figure 12 and Figure 13The time usage and the number of invalid principal component candidates for the implementation of the first embodiment of the present invention are shown respectively. Detailed Implementation

[0060] In a first embodiment, to provide stable and high-scoring directly insertable principal elements at the decoder, a method is provided for selecting principal element candidate positions in the encoder for combining a matrix of g data symbols in a block of data in a round of decoding. Once the coded vector is determined and used to generate symbols for a round of decoding, the decoded blocks, including information representing the coded vector and the decoded symbols, can be transmitted and decoded in a conventional but computationally more efficient manner.

[0061] One implementation of the first embodiment includes:

[0062] 1. Given a source data block containing g symbols.

[0063] 2. To generate principal candidate positions 0 to g-1 for each encoded vector in a given round i:

[0064] a. In the case that there is no repetition in the i-th round, randomly select a pivot candidate position from the set of pivot candidate positions 0 to g-1.

[0065] b. Repeat step 2a until all principal component candidate positions have been selected.

[0066] c. Repeat step 2 for each subsequent round.

[0067] Therefore, each round will result in a "random sequence" of permutations of the available principal component candidate positions. Unbiased random algorithms can be used to provide each permutation; however, other random distributions are also possible.

[0068] As indicated, pivot candidate positions are selected randomly but without repetition in each round, so for example, if g = 10, the sequence of pivot candidate positions for 0 in the first round can look like this: Figure 7 As shown.

[0069] Therefore, assuming the decoded packets are sent sequentially, in this case, the first packet will include a pivot candidate at index position 8. All decoded coefficients before this position will be zero, and the value of any decoded coefficient after this position will be determined by the decoding scheme. The next packet will have a pivot candidate at index position 6, where all decoded coefficients before this position are zero, and the value of any decoded coefficient after this position will be determined by the decoding scheme, and so on for the remainder of this round.

[0070] To ensure that the impact of sudden loss affecting multiple rounds of transmission is minimized, in another implementation of the above embodiments, instead of repeating step 2 for multiple rounds, the random sequence determined in the first round can be shifted round by round. Figure 8 This illustrates how to replace the sequence of round 0 with the sequence by shifting it round by round, and similarly shifting it by one for consecutive rounds, to produce the sequence of round 1. Note that in variations of this implementation, different shift values ​​can be used.

[0071] The analysis for this method is the same as for linear sequences, because whether a pivot candidate can be directly inserted during a given round depends on whether a pivot exists at that position. Therefore, we achieve the same performance as linear sequences because, if no group loss occurs, we directly insert all pivot candidates with zero overhead.

[0072] However, if the channel experiences periodic packet loss or bursts across rounds, the "random sequence" method in this embodiment reduces the probability of overlap compared to a repeating linear sequence, thus providing more stable performance under these conditions. This is for Figure 9 The implementation shown in the example states that the permutation of one round is offset by 1 for each subsequent round, but this also applies if the permutation of each round is selected as defined in step 2 above.

[0073] We can directly compare existing linear sequence and random uniform sequence methods with, for example... Figure 10 The fraction of directly insertable principal components between the "random sequence" methods of the illustrated embodiment.

[0074] It can be seen that the "random sequence" strategy in the first embodiment improves the worst-case behavior of the "linear sequence" and performs better than "random uniform" consistently under both periodic loss and uniform loss models.

[0075] One implementation of this random sequence method is, for example, to use Fisher-Yates shuffling to generate a lookup table of pre-computed random permutations of the sequence with pivot candidate positions, and then to randomly offset the sequence at each iteration. Note that in the implementation of the first embodiment, pivot candidates with the same position are not repeated within a single round to maintain the zero-overhead property when no loss is observed.

[0076] In practice, lookup table implementations work well for small block sizes. However, this can be impractical as block sizes increase. For example, a 700MB block size and a 1400-byte symbol size would require a 2MB lookup table. For some embedded devices, the amount of available storage is limited, and therefore alternative, less storage-intensive solutions are desired.

[0077] An alternative implementation with significantly lower storage consumption utilizes the property of finite fields, namely that the primitive elements of a finite field GF(p) are generators of the field. In other words, if a is a primitive element of some field GF(p), then for some integer i, any non-zero element of that field can be written as a. i This means that if the number of elements in the field is p, we can generate all non-zero elements of the field by looping from i = 0 to i = p - 1.

[0078] Let’s look at an example GF(11). This is a finite field with 11 elements (10 non-zero elements), of which 2 elements are prime elements.

[0079] The following Python program generates a pseudo-random sequence:

[0080]

[0081]

[0082] The output of this method is as follows Figure 11 As shown.

[0083] From this example, we can derive the components of a general process as follows:

[0084] 1. Given a block size g, find a prime number p that satisfies p ≥ g.

[0085] 2. For the prime number p that is found, find the prime element e.

[0086] 3. Use prime elements to generate a sequence of candidate positions for pivot elements.

[0087] 4. For each iteration, add a round offset to scramble the sequence compared to the previous round.

[0088] 5. Once a prime element is reached, the sequence has completed one full iteration, the incrementing wheel shifts and continues.

[0089] We can estimate the memory requirements of this method. In the pseudocode above, we stored 5 integer values. These can be 8, 16, 32, or 64 bits. This results in a maximum memory requirement of 5.64 bits = 5.8 bytes = 40 bytes, significantly lower than the table-based method.

[0090] To generate the sequence, we first need to find a suitable finite field. For this, we can use a prime number search algorithm. The number of elements in the finite field must be equal to or greater than the number of possible pivot candidate positions. When generating the field, we can choose a pivot candidate position that is outside the valid range. In this case, we simply skip this one and move on to the next. Furthermore, once a prime number is selected, the prime elements that generate the sequence must be found. Currently, there is no deterministic algorithm to solve this problem, but several heuristic-based algorithms have been proposed in the literature.

[0091] To simplify the search, we only search for primes where 2 is a prime element. Using 2 as a prime element produces a faster implementation because bit shifts can be used to calculate its powers.

[0092] Figure 12 The time spent searching for primes with prime element 2 to generate pivot candidate positions for a given number of source symbols is shown. Note that this operation occurs only once.

[0093] The difference between the size of the finite field and the actual block size (the number of source symbols) represents the amount of pivot candidate positions that need to be skipped when generating the sequence. Figure 13 .

[0094] It should be noted that for each source data block, the overhead associated with finding prime numbers and prime elements only needs to be computed once. Furthermore, only the encoder needs prime numbers and prime elements. The decoder only uses the actual principal candidate numbers to insert into the decoded blocks.

[0095] Finally, we can note that, if advantageous, a lookup table for prime numbers and prime elements can be constructed, thereby avoiding the need to search for these prime numbers and prime elements at runtime.

[0096] Other implementations of the above-described embodiments are also possible, as long as they allow random permutations of the sequence of generating principal candidate positions.

[0097] In the second embodiment, it may be beneficial to repeat or omit principal candidate elements at a given position within a single round. For example:

[0098] If it is known that the principal element with a given position has already been determined by all receivers, then we can omit that given position from the set of principal element candidate positions in the next round.

[0099] Encoders using UEP (Inequality Error Protection) can decide to include specific symbols more frequently than others (i.e., increase the likelihood of selecting principal candidate positions at specific locations), thereby increasing the probability of decoding a subset of specific symbols. Therefore, the set of principal candidate positions can include one or more copies. This is beneficial if certain parts of the content / file are more important than others.

[0100] Therefore, we can extend the first embodiment to cover the following cases where a deterministic algorithm is used to allow the repetition or omission of principal candidate positions within the same round:

[0101] 1. Given a source data block containing g symbols.

[0102] 2. To generate the principal candidate positions from 0 to g-1 for a given round i:

[0103] a. The set of principal candidate positions to be determined includes principal candidate positions that may omit symbols known to have been received by all receivers in previous rounds; principal candidate positions that copy symbols that are more important than other symbols; or principal candidate positions that reintroduce principal candidates known to have been lost at all receivers in that round.

[0104] b. Select a pivot candidate position from the set of pivot candidate positions.

[0105] c. Remove the selected pivot candidate position from the set of pivot candidate positions.

[0106] d. Repeat step 2a until the set of principal candidate positions is empty.

[0107] 3. Repeat step 2 for each subsequent round.

[0108] Similarly, in step 2b, the positions of the principal candidate positions are selected such that the sequence of principal candidate positions in this round is non-linear with respect to each other, and the repetition of the principal candidate positions in this round is only used for intentionally retransmitting information that is known to be critical in the prior art to prevent delays in retransmission in the event of loss; or if it is known that all receivers have been lost in a round, the decoded packets are retransmitted in a round.

[0109] The set of principal candidate positions can also change dynamically within a given round. Therefore, if feedback from the receiver to the transmitter is available before a round is completed, we can reintroduce principal candidates at the same positions where they are known to have been lost at all receivers in a round, and retransmit the encoded packets based on the principal candidates encoded in that round.

[0110] Nevertheless, it should be understood that the implementation of this application finds particular utility in distributing information (e.g., software or media updates) to a large number of receivers (particularly receivers with limited computing resources where no feedback is available).

Claims

1. A method for encoding data, comprising: a) selecting a sequence of leading candidate positions for a sequence of g encoding vectors to encode a block of g data symbols in a round of g encoded packets by: i) providing a set of g leading candidate positions; ii) selecting a leading candidate position from the set of leading candidate positions for a sequence; iii) removing the selected leading candidate position from the set of leading candidate positions; and iv) repeating from step ii) until the set of leading candidate positions is empty and the sequence of selected leading candidate positions for the round is non-linear; b) generating a sequence of g encoding vectors based on the sequence of selected leading candidate positions, each encoding vector comprising zero-valued coefficients for positions within the encoding vector before the leading candidate position of the encoding vector and non-zero-valued coefficients for at least the leading candidate position; c) generating a set of encoded data symbols by encoding the block of data symbols with the corresponding generated encoding vectors; d) generating encoded packets, each encoded packet comprising a corresponding encoded data symbol and information representing the encoding vector used to encode the data symbol; e) transmitting the encoded packets; and f) for at least one subsequent round, permuting the sequence of selected leading candidate positions so that the sequence of selected leading candidate positions changes from round to round, then repeating steps b) to e). The permutation ensures that a unique leading candidate position of a round does not appear in the same position in the sequence of selected leading candidate positions of consecutive rounds.

2. The method of claim 1, wherein, The permutation step comprises shifting the sequence of selected leading candidate positions from a previous round to generate the sequence of leading candidate positions for the next round.

3. The method of claim 1, wherein, Step ii) comprises randomly selecting a leading candidate position from the set of leading candidate positions.

4. The method of claim 1, wherein, The encoding scheme is sparse and only a subset of coefficients in subsequent positions of the encoding vector after the leading candidate position are non-zero-valued.

5. The method of claim 1, wherein, 6. The method of claim 1, wherein if a given data symbol of the block of data symbols is more critical than other data symbols, the method comprises including a leading candidate position corresponding to the position of the data symbol in the block of data symbols more than once in the set of leading candidate positions.

7. The method of claim 1, comprising reducing g for subsequent rounds in response to receiving information that all receivers have received one or more data symbols.

8. The method of claim 1, wherein the set of g leading candidate positions comprises elements of a finite field having p > g elements, and wherein the steps of selecting a leading candidate position and removing the selected leading candidate position are performed by traversing the finite field based on increasing powers of generating prime elements of the finite field.

9. The method of claim 1, further comprising storing the sequence of selected leading candidate positions in a table. ​ 10. A computer program product comprising computer readable code, said computer readable code stored in a computer readable medium and comprising instructions which, when executed in an encoder, are configured to cause the encoder to perform the method according to any one of claims 1-9.

11. An encoder configured to receive a data block to be transmitted to one or more receivers and comprising a processor configured to perform the method according to any one of claims 1-9.

Images