KR20090100346A - Reverse concatenation for product codes - Google Patents

Abstract

A system, method and computer program product are provided to encode data for recording onto media whereby modulation and linear constraints from a concatenated code or product code are imposed. A first array of unencoded user data is generated. Each row is modulation encoded to enforce a first modulation constraint; the array is transformed into a second array which is transformed into a third array having predetermined empty locations in each column interleaved with the modulated data. A C2-parity byte is computed for at least some of the empty locations of the third array and a fourth array is generated. C1-parity symbols in each row are computed, generating a fifth array. A second modulation constraint is enforced on each C1-parity symbol in each row of the fifth array, generating a sixth array. The rows of the sixth array are assembled with header and sync fields for recording onto a recording media.

Description

REVERSE CONCATENATION FOR PRODUCT CODES} A reverse connection encoding system for write and write paths, and methods for encoding data for recording on media.

BACKGROUND OF THE INVENTION The present invention relates generally to encoding data to be recorded on a recording medium, and more particularly to reverse concatenation coding for product codes.

Data storage systems, such as tape drives and optical discs, that use removable media and typically write large amounts of data, rely on strong error correction codes (ECC). Tape drives and CD devices use powerful and complex ECCs that are based on the code concatenation of external C2 code and internal C1 code. The product code defined in the Linear Tape Open Third Generation (LTO-3) standard is a specific instance of the concatenated coding scheme, where the internal and external codes are RS based codes having lengths of 480 and 64, respectively, as provided in Table 1 .

The subdata set is a 64x480 byte array, i.e., the subdata set contains 30,720 bytes with 54x468 = 25,272 data bytes, producing a code rate of 0.8227. Each 480-byte row contains a codeword pair. In particular, the outer C2 code is the [N ₂ = 64, K ₂ = 54, d ₂ = 11] RS code through the Galois field GF 256, where N ₂ represents the length of the code, K ₂ Denotes the dimension of the cord and d ₂ denotes the minimum hamming distance of the cord. The internal C1 code is obtained by even / odd interleaving of the [240,234,7] Reed Solomon (RS) code through the GF 256.

In magnetic and optical recording, the modulation code is used to enable timing recovery from the reread signal without substantial loss of performance and to enable short path storage in the detector. Thus, in the write path prior to writing the ECC encoded data on the medium, the ECC encoded data is transferred through the modulation encoder. With reference to FIG. 1, user data is first encoded by ECC 102 and then passed through a modulation encoder 104 such as a 16/17 run length limited (RLL) encoder. FC) architecture 100 is known. To improve ECC performance, there is an interleaver 106 of elongated blocks in the LTO-3 write path, denoted by interleaving and track allocation blocks. This block 106 buffers a subdata set of 64 consecutive products, thereby accumulating a total of 64 × 64 = 4096 rows. These 4096 rows are assigned to sixteen tracks 108 of magnetic tape in a predefined order. For each track there is a rate 16/17 modulation encoder, which encodes the assigned row and guarantees a predetermined modulation limit, i.e., an interleaved I = 11 constraint.

Recently, the reverse connection (RC) architecture has increased its interest in the hard disk drive (HDD) industry. 2 is a block diagram of such an architecture 200. In RC architecture 200, the order of the ECC encoder and modulation encoder is reversed so that data is first passed through modulation encoder 202 and the modulated data is ECC encoded using systematic encoder 204 for error correction code. do. The ECC parity symbol is encoded using a second modulation encoder 206 as shown or it is inserted into the data symbol stream at the bit level or symbol level. Inserting an entire parity symbol into the data symbol stream is referred to as partial symbol interleaving. The parity insertion strategy results in a simple scheme with error-free delivery, but such a strategy can weaken the original modulation constraints. Nevertheless, there are three main advantages that make RC attractive:

a) There is no error propagation through the modulation decoder.

b) Since no error propagation occurs, the first modulation code is adopted very long to enable efficient and high rate modulation code in terms of capacity to obtain the code rate.

c) In the reread path, an ECC decoding block is placed immediately after the channel detection block, which allows soft information to be passed in bit order from the detector to the decoder. This creates an appropriate framework for using new ECC techniques, which are based on turbo and LDPC code, and keep the promise of significant performance improvements. Also, in this framework, parity post processing schemes can be easily implemented.

It would be desirable to provide the same advantages in the framework of tape recording. However, the ECC used for the HDD has a different structure from the ECC used for tape recording. In HDDs, ECC is mainly based on a single high-rate Reed Solomon (RS) code, but on tape, large, powerful product codes that require new RC structures are used. RC is proposed for one-dimensional ECC structures, but ECC typically consists of a single code such as Reed Solomon code or LDPC code. However, well-known RC schemes do not focus on specific problems arising from ECC based on connected code or product code. In the case of a connected code or a product code, the output of the internal C1 code must be mapped to a track / channel so that all rows must meet a predetermined modulation constraint. Thus, a large drawback is illustrated which is illustrated with respect to the LTO-3 product code. Referring to Table 1, if the modulation encoder is placed before the systematic ECC encoder, only the K ₂ rows except the C1 parity byte will satisfy the modulation constraint. The remaining N ₂ -K ₂ rows (rows 54-63) consisting of C2 parity bytes do not meet the modulation constraints. The C1 parity part poses a minor problem as it can be handled separately as in the case of one-dimensional ECC. However, no efficient solution has yet been proposed for the C2 parity portion. Thus, a significant amount of rows cannot meet the modulation constraints and will require further processing. According to the one-dimensional RC strategy, these rows need to be passed to a second modulation encoder or processed using a parity insertion strategy. All these techniques are not desirable below: (1) the second modulation code will cause error propagation so that soft information cannot be conveyed bit by bit from the channel detector to the ECC decoder, and (2) dead track In the case of a dead track, performance is degraded due to partial symbol interleaving, because the entire defect is split and spreads into different rows, causing multiple errors in multiple rows.

The aforementioned deficiencies will be avoided if the external C2 encoder is exchanged with the first modulation encoder, ie if the order of encoding does not matter. However, this is not the case and so far no reverse concatenation architecture has been proposed for product code.

A preferred embodiment of the present invention provides a reverse connection encoding system for a write write path. The reverse coupled encoding system includes means for generating a first data array of unencoded user data, and second data comprising data that is modulated by forcing a first modulation constraint for each row of the first data array. And a first modulation encoder for generating the array. The system further includes a formatter operable to process the second data array and create a third data array by inserting predetermined empty locations into each column where the modulation constrained data is interleaved. . The C2 encoder is operable to calculate a C2 parity byte for each of the plurality of empty positions in each column of the third data array and generate a fourth data array. The C1 encoder is operable to calculate a C1 parity symbol and generate a fifth array for each row of the fourth data array. The system further includes a second modulation encoder operable to impose a second modulation constraint on each C1 parity symbol of the fifth data array to produce a sixth data array. The system further includes means for recording the rows of the sixth data array on the track of the recording medium.

Another preferred embodiment of the present invention provides a method of encoding data for recording on a medium, the method comprising generating a first data array of unencoded user data, and comprising a modulation constrained data. Imparting a first modulation constraint for each row in the first data array to produce a second data array, and inserting a predetermined empty position into each column of the second data array where the modulation constrained data is interleaved. Thereby formatting the second data array and generating a third data array, calculating C2 parity bytes for each of the plurality of empty positions in each column of the third data array, and generating a fourth data array; Compute a C1 parity symbol for each row of the fourth data array and generate a fifth data array. Creating a sixth data array and imparting a second modulation constraint on each C1 parity symbol of the fifth data array, and recording a row of the sixth data array on a recording medium. do.

Another embodiment of the present invention provides a computer program product of a computer readable medium usable with a programmable computer, the computer program product embodying computer readable code embodied for encoding data for writing on the medium. The computer readable code includes instructions for generating a first data array of unencoded user data, and for each row in the first data array to produce a second data array comprising modulation constrained data. Instructions for formatting a second data array and inserting a predetermined empty position into each column of a second data array in which modulation-constrained data is interleaved, and instructions for formatting the second data array and generating a third data array; Each of the third data array Calculating a C2 parity byte for each of the plurality of empty positions in the column and generating a fourth data array; and calculating P C1 parity symbols in each row of the fourth data array and generating a fifth data array. An instruction to impose a second modulation constraint on each C1 parity symbol in each row of the fifth data array and to generate a sixth data array, and to record a row of the sixth data array on a track of the recording medium. Contains instructions.

1 is a block diagram of prior art data encoding using a forward connection.

2 is a block diagram of prior art data encoding using a reverse connection.

3 is a block diagram of a prior art LTO-3 write path.

4 is a high level block diagram of the reverse connection structure of the present invention.

5A is a block diagram of a write path that may include the reverse connection structure of the present invention.

5B is a block diagram of a portion of the write path of one embodiment of the present invention.

6 is a more detailed block diagram of the reverse connection structure of the present invention.

7 illustrates a data set provided with empty positions by the formatter of the present invention.

8 is a functional block diagram of a systematic second modulation encoder of the present invention.

9 illustrates the synthesis of codeword quads following data encoding in accordance with the present invention.

10 is a block diagram of an alternative embodiment where both unconstrained data bytes and parity bytes are inserted into empty positions provided by the formatter.

3 is a block diagram of a write path 300 in accordance with the LTO-3 standard. The host records are compressed 302 and the data set and DSIT generator 304 generate a sub data set from the stream of symbols. ECC encoder 306 provides ECC encoding and passes the encoded sub data set to codeword pair header and codeword quad generator 308. The final codeword quad is passed to the write formatter 310, where a 16-track bit stream is generated. The bit stream is processed at data randomizer 312 and then modulated and encoded 314. The RLL encoded bit stream is converted into the synchronized bit stream by inserting a sink and formatting the pattern in the synchronization generation block 316 and the synchronized bit stream is passed through a write equalizer 318 which provides the bit stream. Can be recorded on the medium.

As shown in the high level schematic of FIG. 4, the present invention 400 provides a reverse connection structure in which data is first passed through a serial / parallel block 401 to form an unencoded array. Each row of each array is modulated and encoded at the first modulation encoder 402 and then ECC is provided to the ECC encoder 404. Each row is processed through a second modulation encoder 406 or partially symbol interleaved to meet the required modulation constraints.

5A is a block diagram of a write path 500 that may include the reverse connection structure of the present invention. For the LTO-3 write path of FIG. 3, the host record in the write path 500 of the present invention is compressed 502 and the data set and DSIT generator 504 generate a sub data set from a stream of symbols. The sub data set is then randomized in a row-wise manner in the data randomizer 506 and the randomized data is passed to the first modulation encoder 508 (row-wise). The C2 and C1 ECC encoder 510 encodes the modulation encoded sub data set, which will be described in more detail. The second modulation encoder 512 provides additional modulation encoding for the encoded sub data set, which is then processed by the interleaving and track allocation block 520. The resulting multi-track stream of C1 codewords and codeword pairs is converted to a synchronized bit stream by inserting a sink and formatting the pattern at the synchronization generation block 514, where the synchronized bit stream is a write equalizer providing a write stream. 516 and then recorded on medium 518.

FIG. 5B is a block diagram of a portion of the write path of one embodiment of the present invention, and interleaving and track allocation block 520 processes the sub data sets in rows in a format for LTO-3 tape media. In this embodiment, the interleaving and track allocation block 520 includes a codeword pair header and a codeword quad generator 522, where the modulated data from the second modulation encoder 512 is interleaved with the codeword header. To form a codeword quad. Interleaving and track allocation block 520 further includes a write formatter 524 that maps codeword quads to logical tracks. The final 16-track bit stream is converted into a synchronized bit stream by inserting a sink and formatting the pattern in the synchronization generation block 514 and the synchronized bit stream is passed through a write equalizer 516 that provides the bit stream. Can be written on tape 530. It will be appreciated that the present invention is not limited to combining C1 code words and codeword headers in this manner, but may be combined in other ways.

6 is a more detailed block diagram of the RC structure 600 of the present invention. Structure 600 includes a set of high rate modulation encoders 602 and an external column-by-column C2 encoder 604, with one encoder for each of these N ₂ rows representing data from serial / parallel block 601. Receive This structure 600 also provides a format block 606 disposed between the modulation encoder 602 and the C2 encoder 604. As described in more detail, the format block 606 reconstructs the modulation encoded user data array so that the size is based on the length rather than the dimensions of the outer code. An internal C1 encoder 608 is placed for each row following the C2 encoder 604 to generate a parity byte at the end of each row. Processing of the encoded rows is completed by a set of systematic modulation encoders 610. The data from the C2 encoder 604 and the data from the set 610 of the second modulation encoder are multiplexed within the multiplexer 612 to form a complete sub data set.

User Data Reconstruction

In contrast to the conventional encoding of C2 codes of length N ₂ , wherein the user data consists of K ₂ rows (K ₂ is on the order of C ₂ ), the unencoded user data array of the present invention is represented by a serial / parallel block 601. It consists of N ₂ rows that are generated. Examples of such unencoded user data arrays are shown in Table 2, which is a variation of the sub data set array of the LTO-3 standard (Table 1).

In particular, the array contains more than 520 user bytes than conventional LTO-3 sub data sets. Each row of the unencoded user data array is passed through a first modulation encoder 602, which imposes a modulation constraint at the input end of the format block 606. At this point, the modulated user data array still contains N ₂ rows of modulation constraint data due to the first modulation encoder 602. In one embodiment, the first modulation encoder 602 may be derived from a rate-215 / 216 interleaved Pinabochy modulation code that meets the global G = 14 modulation constraint and the interleaved I = 7 constraint. Each row contains 8x403 = 3224 data bits, which is the length of the 15-bit sequence: 214, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215 , Grouped by 215.

A dummy zero bit is added to the beginning of the length-214 bit sequence, after which all sequences are encoded to generate a 15-bit sequence of length 216, which adds up to a total of 405 bytes per row. . The first modulation code converts the unencoded user data array of Table 2 into a modulation constrained user data array of Table 3.

More generally, one code is selected for the first modulation code, which supports partial interleaving of unconstrained symbols such that the predetermined global G constraint and interleaved I constraint are met after partial symbol interleaving.

Format block

Format block 606 converts the modulated user data array of Table 3 to an array with N ₂ -K ₂ empty components in each column. The N ₂ -K ₂ empty positions are the place holding positions where the parity symbols to be generated by the C2 encoder 604 are introduced. In the design phase of the format block, a parity pattern array is determined. If a parity pattern array is provided, format block 606 interleaves the empty cells in a row-by-row fashion into the modulated user data array of Table 3 to extend the length of each row by L bytes. This interleaving operation is similar to partial symbol interleaving and weakens the modulation constraints of the first modulation code. In the described embodiment, the insertion of 8-bit parity symbols into the array will weaken the global and interleaving constraints to G = 22 and I = 11.

In order to retrieve the parity pattern array, the order of the modulated user data array must satisfy the Diophantine equation, i.e., (M + L) × (N ₂ -K ₂ ) = N ₂ × L, where L is the number of C2 parity symbols per row, and M + L = K ₁ is the order of the C1 code based on the C2 symbol (ie, the order of the C1 code must be expressed in C2 symbol units, such as bytes). This diopantus equation may make it necessary to adjust the parameters of the C1 code. In the above example based on LTO-3, M + L = K ₁ = 480 satisfies an equation with a C2 parity byte position of L = 75 in each row. In addition, the parity bytes should be spaced apart by a predetermined minimum amount so as not to completely destroy the modulation constraints of the first modulation code. In an example, a space of at least two byte positions is sufficient to obtain a constraint of (G, I) = (22, 11). As there are 64 rows in each parity pattern array, there are total 64 × 75 = 4800 C2 parity byte positions for the parity pattern array. The insertion position is defined by the following ten linear equations (module 64), which are related to the column index x to the row index y as follows, i.e. y x + c _i (mod 64),

Here, c _i ∈ {0, 6, 13, 19, 26, 32, 38, 45, 51, 58} and 0 x <480 = k ₁ . The parity pattern is preferably selected such that each column contains N ₂ -K ₂ = 10 parity positions and the pattern is repeated in as many columns as possible. In an example, the parity pattern is repeated every 32th column. This particular parity pattern array is shown in FIG. 7 and the dotted lines represent ten empty parity insertion positions for each column.

Column-dependent C2 encoding

Since each column contains ten parity place holding positions, each column can be encoded with a codeword of rate-54 / 64 RS C2 code. Also, since the parity position varies from column to column, the C2 encoder is also preferably changed from column to column.

The C2 code may be a Reed Solomon code, but other codes may be used. Preferably, this code is a code that can be spaced apart at a maximum distance with the useful properties that all sets of K ₂ components form an information set. Thus, uniquely determine the N ₂ -K ₂ parity symbols in which all K ₂ components of the set remain. At the input of the C2 encoder 604, every column contains K ₂ modulation data bytes and N ₂ -K ₂ empty parity positions. In each column, the C2 encoder 604 determines N ₂ -K ₂ parity bytes from K ₂ modulation data bytes and inserts it into the empty parity position. The output of the C2 encoder 604 is a C2 encoded array of size N ₂ × K ₁ as shown in Table 4. The C2 encoded array meets a predetermined modulation constraint along each row.

More generally, the C2 encoder is an encoder for rate K ₂ / N ₂ Reed Solomon code through gallois field GF (2 ^m ), in particular the codeword component consisting of m-bit symbols.

C1 encoding

The rows of the C2 encoded array are passed through the C1 encoder 608 for the C1 code. The final C1 parity symbol may be processed by the second modulation encoder 610 as shown in FIG. 6 or partly interleaved bit by byte into the data stream of the C1 encoder 608. In the LTO-3 based example described above, the C1 code of order K ₁ = 480 and length N ₁ = 492 is obtained via GF 256 as an even / odd interleaved Reed Solomon code of order 240 and length 246. Such code generates 2 × 6 = 12 interleaved RS parity bytes per row, which is attached to the end of each row as shown in Table 5. Even and odd parity bytes in a row are indicated by * and dot, respectively.

More generally, the C1 encoder can be obtained from even / odd interleaved Reed Solomon codes of order K ₁ and length N ₁ via GF 2 ⁸ . The C1 encoder can be derived from the linear code via gallois field GF (2 ^r ) with ^r -bit symbols, and has order mK ₁ through GF (2). The C1 encoder can also be derived from the low density parity check code via gallois field GF (2 ^r ), and has order mK ₁ via GF (2).

Final modulation coding

Figure 8 illustrates a method of applying a (G, I) = (22, 11) constraint across the appended C1 parity bytes, where the twelve C1 parity bytes in each row are preferably systematic second modulation encoders. Passed over 610, the encoder adds a single modulation bit to each beginning of the C1 parity byte in each row. The modulation bit is preferably determined by inverting a second bit p ₁ that characterizes a systematic second encoder within each C1 parity byte and adding it to the parity byte. The simple second modulation encoder 610 may be an inverter with a simple inverse and allows soft information to be transferred bit by bit from the channel bit detector to the ECC detector when data is read. The second modulation encoder 610 also maintains G = 22 and I = 11 constraints. In addition, non-systematic modulation schemes can be used, for example, by applying the 16 / 17-code of LTO-3. However, conveying soft information cannot be performed bit by bit.

After the C1 / C2 encoded sub data set is generated, the codeword quads are combined by the multiplexer in a manner similar to the LTO-3 standard. As shown in FIG. 9, a series of rows 902A, 902B, such as the first row and the second row, of the C1 / C2 encoded subdata set are interleaved with the encoded headers 906A, 906B so that the first and second codeword pairs. 902A and 902B are formed, respectively. The two codeword pairs 902A, 902B include a codeword quad 900.

Features of the proposed RC structure for concatenated codes include (1) user data reconstruction into N ₂ rows, (2) a format block based on a predetermined C2 parity pattern, and (3) column dependent C2 encoding. As a result, benefits from the features of the reverse connection scheme discussed in the technical background, namely no error propagation in the demodulator, enable a novel soft decoding scheme based on an improved rate of modulation code and parity post-processor or turbo coding scheme. Can be obtained from this invention.

The RC structure of the present invention adds 16 + 12 = 28 bits to each row for modulation. Each row contains 403x8 = 3224 data bits. Thus, the rate of the RC modulation scheme is R _RC = 3224/3252 = 0.9914.

The typical forward connection structure is based on 16/17 code. Therefore, R _FC = 16/17 = 0.9412.

As a result, the RC structure of the present invention has a 5.34% higher rate than the standard LTO-3 format but keeps the I = 11 constraint the same but weakens the G constraint from 13 to 22. In addition, the RC structure of the present invention can be extended to 10-bit ECC and longer C1 codes despite weakening the modulation constraint to (G, I) = (24,12).

The performance of the C2 code can be improved primarily by selecting longer C2 codes of the same rate as the LTO-3 code. The present invention relates to a reverse connection (RC) scheme based on a Reed Solomon (RS) code with parameters [N ₂ = 96, K ₂ = 80, d ₂ = 17] via gallois field GF 256. Two embodiments are provided, where N ₂ represents a length, K ₂ represents an order, and d ₂ represents the minimum Hamming distance of the C2 code. Because the RS code has a length of 96, the corresponding RC scheme uses an unencoded user data array with N ₂ = 96 rows. An example of the aforementioned unencoded user data array of size N ₂ x U = 96 x 398 with U = 398 unencoded user bytes per row is shown in Table 6.

Each row of the unencoded user data array is passed through a first modulation encoder 602 and thus meets modulation constraints at the input of the format block 606. In a second embodiment, the first modulation encoder 602 is similar to that used in the previously described embodiment (having a length 64 C2 code), but with a global G = 14 and interleaved I = 7 constraint. It is derived from a 199/200 interleaved Pinabochi code. The 8x398 = 3184 data bits in each row are all grouped into a 16-bit sequence of length 199. Then all 16 bit sequences are modulated and encoded to produce a 16 bit sequence of length 200, which is added until M = 400 bytes per row. Thus, the first modulation code converts the unencoded user data array of Table 6 into the modulated user data array of Table 7 of size N ₂ x M = 96 x 400 size.

Format block 606 converts the modulated user data array into an array having an " empty " component of N ₂ -K ₂ = 16 in each column. The number of C2 parity symbols per row must be L = 80 to satisfy the Diopantus equation with M = 400 (M + L) × (N ₂ -K ₂ ) = N ₂ × L, which is based on the C2 symbols , K ₁ = L + M = 480 for the order of the C1 code in bytes. Note that the Diopantus equation is simplified to M = 5L for specific selection of parameters of the C2 code. Since there are 96 rows in each parity pattern array, there are total 96 × 80 = 7680 C2 parity bytes per parity pattern array. The insertion position for this C680 parity byte of 7680 is defined by the following 16 linear equations (modulo 96), which relates to column index x to row index y, ie y x + c _i (mod 96), where , c _i = 6i (i = 0, 1, 2, ....., 15) and 0 x <480 = K ₁ .

At the input of the C2 encoder 604, every column contains K ₂ = 80 modulation data bytes and N ₂ -K ₂ = 16 empty parity positions. In each column, the C2 encoder 604 determines N ₂ -K ₂ = 16 parity bytes from K ₂ = 80 modulated data bytes and inserts it into the empty parity position. The output of the C2 encoder 604 is a C2 encoded array of size N ₂ × K ₁ = 96 × 480 shown in Table 8, where the positions of the C2 parity bytes are indicated by 'x'.

The C1 code is selected as in the previously described embodiment, which has order K ₁ = 480 and length N ₁ = 492, and even / odd interleaving of Reed Solomon code of order 240 and length 246 via GF 256 Is obtained by. Twelve parity bytes in each row are passed through a simple systematic second modulation encoder 610, which adds a single bit to the beginning of each parity byte. The modulation bit is obtained by inverting the second bit in each parity byte and adding it to the parity byte, thereby generating G = 22 and I = 11 constraints across all rows.

In connection with the implementation, the second embodiment based on the C2 code of length 96 and order 80 has the following advantages over the first embodiment based on the C2 code of length 64 and order 54.

(1) The first modulation encoder 602 of the second embodiment is based on a rate-199 / 200 pinabochee code, the length of which equally divides the row length of the modulated user data array and thus for each row. In the second embodiment, the same Pinabochi encoder can be applied 16 times.

(2) Column dependent C2 encoding is simpler than for the second embodiment, since the parity pattern is repeated every sixth column, so at most six different C2 encoders 604 are required, but the first embodiment The proposed parity pattern is repeated only every 32 columns.

The present invention also provides a third embodiment of an RC structure based on partial interleaving of a predetermined number of unconstrained data bytes, illustrating the variety of empty locations generated by format block 606. In the first two embodiments, the C2 encoder inserts a parity byte into the parity position. However, empty positions may also be used in different ways, some may be filled with C2 parity bytes and some may be filled with unconstrained data bytes. 10 shows a block diagram of an RC structure 1000 for a product code, where unconstrained data bytes are inserted at some of the free locations provided by the formatter 606, and parity bytes are inserted into the remaining free locations. Insertion of unconstrained data bytes occurs prior to the C2 encoder because the C2 encoder needs bytes to calculate the parity byte. Unconstrained data bytes are generated by demultiplexer 1002. Demultiplexer 1002 processes user data by one portion processed by a first set of modulation encoders 602 and by insertion block 1004 prior to C2 encoder 604 and by a first set of modulation encoders 602. Separate into 2 parts bypassing.

The RC structure of the third embodiment uses an RS code with parameters [N ₂ = 96, K ₂ = 81, d ₂ = 16] as C2 code via GF 256, where N ₂ represents length and K ₂ represents the order, d ₂ represents the minimum Hamming distance of the C2 code. For each sub data set, there are N ₂ × (U + D) = 96 × 399 = 38,304 bytes of user data, these bytes being N ₂ × U = 96 encoded by the first modulation encoder 602. × 394 = 37,824 bytes, and the C2 encoder 604 is divided into _{N 2 × D = 96 × 5} = 480 bytes to be processed by the previous insertion block 1004. Thus, an unencoded user data array has a size of N ₂ × U = 96 × 394. Each row of such an array is encoded by a rate-197 / 200 interleaving Pinabochi code with a global G = 10 constraint and an I = 5 constraint. -197/200 rate modulation encoder 16 times per line applied by 8 × 394 = each line of the non-encoded sub-set of data having 3152 bits, N ₂ × M = 96 lines of the modulated user data array of the size of 400 × Is mapped to

Format block 606 converts the modulated user data array into an array having N ₂ -K ₂ + T 'empty' positions in each column, where T is unconstrained per column inserted by insert block 1004. The number of data bytes. It will be appreciated that for T = 1 there are 16 empty positions in each column, but T may be equal to some other number. One of these 16 free locations will be filled by unconstrained data bytes and the remaining N ₂ -K ₂ free locations will be filled with C2 parity bytes. The number of empty positions per row must be L = 80 to satisfy the Diopantus equation with M = 400 and T = 1 (M + L) × (N ₂ -K ₂ + T) = N ₂ × L Generate K ₁ = L + M = 480 based on the C2 symbol, ie for the order of the C1 code in bytes. Since there are 96 rows in each parity pattern array, there are total 96 × 80 = 7680 empty positions per parity pattern array. The insertion position of this 7680 is defined by the following 16 linear equations (modulo 96), which is related to column index x to row index y, ie y x + c _i (mod 96), where c _i = 6i It is (i = 0, 1, 2 , ....., 15) , and 0 x <480 = K _1.

Unconstrained N ₂ × D = 96 × 5 = 480 = (M + L) × T The data byte is within all 480 empty positions in the first six rows of the array, i.e., additional condition 0 y <6 is satisfied on the row indicator It is inserted at the position defined by the above equation. In each column, exactly unconstrained data bytes of T = 1 are inserted so that the remaining N ₂ -K ₂ = 15 empty positions are filled with C2 parity bytes.

At the input of the C2 encoder 604, every column contains K ₂ = 81 modulated or unconstrained data bytes and an empty parity position of N ₂ -K ₂ = 15. In each column, C2 encoder 604 determines a parity byte of N ₂ -K ₂ = 15 from K ₂ = 81 bytes and inserts it into the empty parity position. The output of the C2 encoder 604 is a C2 encoded array of size N ₂ × K ₁ = 96 × 480, as shown in Table 9, where the positions of the C2 parity bytes are denoted by 'p' and the previously inserted unconstrained. The data byte is represented by 'd'. Note that at most only six different column dependent C2 encoders 604 are needed, because the parity pattern is repeated every six columns. Insertion of parity and unconstrained bytes weakens the I = 5 and G = 10 modulation constraints of the first modulation code along each row after C2 encoding to I = 9 and G = 18.

The C1 code is selected in the same manner as selected for the first and second embodiments described previously. The C1 code has order K ₁ = 480 and length N ₁ = 492 and is obtained by even / odd interleaving of Reed Solomon codes of order 240 and length 246 via GF 256. Twelve parity bytes in each row are passed through a simple systematic second modulation encoder 610, which adds a single bit to the beginning of each parity byte. The modulation bit is obtained by inverting the second bit in each parity byte and adding it to the parity byte, thereby generating G = 18 and I = 9 constraints across all rows.

It is important to note that while the present invention has been described in the context of operating a data processing system, those skilled in the art will appreciate that the process of the present invention may be distributed in the form of a variety of media of computer readable instructions and that the invention is used in practice to perform such distribution. It should be noted that it is recognized that it applies regardless of the specific type of signal bearing medium. Examples of computer readable media include recordable type media such as floppy disks, hard disk drives, RAM, CD-ROMs and transport type media such as digital and analog communication links.

The description of the invention is presented for purposes of illustration and description, but is not limited to the invention in the form disclosed. It will be apparent to those skilled in the art that many modifications and variations can be made. The embodiments have been selected and described in order to best explain the principles of the invention and to enable those skilled in the art to understand the invention of various embodiments with various modifications adapted for a particular use. In addition, although the present invention has been described above in connection with systems and methods, a need in the art may be satisfied with a computer program product including instructions for encoding data to be recorded on a medium.

Claims (10)

A reverse connection encoding system for write and write paths, A user data array generator operative to process input user data to produce a first data array; A first modulation encoder for generating a second data array including modulation-constrained data by imparting a first modulation constraint on each row of the first data array; A formatter operative to process the second data array to create a third data array by inserting predetermined empty locations into each column of the second data array where the modulation constrained data is interleaved. , A C2 encoder operative to calculate a C2 parity byte for each of the plurality of empty positions in each column of the third data array to produce a fourth data array; A C1 encoder operative to calculate a C1 parity symbol for each row of the fourth data array to produce a fifth array; A second modulation encoder operative to impose a second modulation constraint on each C1 parity symbol of the fifth data array to produce a sixth data array; Means for recording the rows of the sixth data array on a track of the recording medium; Reverse connection encoding system. The method of claim 1, A demultiplexer operative to generate a number of unconstrained data bytes, Insert the unconstrained data byte into at least one of the empty positions in each column of the third data array, and insert the calculated C2 parity byte into the remaining empty positions in each column of the third data array. Further comprising an insertion block operative to Reverse connection encoding system. The method of claim 2, The formatter is the third data array _{M + L = K 1 = 480} , L = 80 and N ₂ -K ₂ diophantine equation (M + L) is satisfied by a _{= 15 × (N 2 - K} 2 + 1) = determine the empty positions to satisfy N ₂ × L, The empty positions are spaced at least a predetermined minimum amount of two, The empty positions are identified by y x + c _i (mod 96), where x and y are the column and row indicators of the third data array, respectively, and c _i = 6i (i = 0, 1, 2, ....., 15) and 0 x <480 = K ₁ Reverse connection encoding system. The method of claim 1, The formatter is further configured to ensure that the empty positions in the third data array are spaced apart by a predetermined number of bytes and that each order of the second data array and the third data array satisfies a Diophantine equation. Operable to process the second data array Reverse connection encoding system. The method of claim 4, wherein The Diopanthus equation is (M + L) × (N ₂ -K ₂ ) = N ₂ × L, Where M + L = K ₁ , M is the number of columns in the second data array, and L is the size by which the number of rows in the second data array is expanded by the formatter while processing the second data array. K ₁ is the number of columns in the third data array, N ₂ -K ₂ is the predetermined number of bytes separating the empty positions in the third data array, N ₂ is the number of rows in the second data array, and K ₂ is the C2 code of the C2 encoder Order of Reverse connection encoding system. The method of claim 5, wherein The Diopanthus equation is satisfied by M + L = K ₁ = 480, L = 75, N ₂ = 64, N ₂ -K ₂ = 10, The predetermined number of bytes at which the empty positions of the third data array are spaced apart is at least two, The empty positions of the third data array are identified by y x + c _i (mod 64), where x and y are the column and row indicators of the third data array, respectively, and c _i ∈ {0, 6, 13 , 19, 26, 32, 38, 45, 51, 58} and 0 x <480 = k ₁ Reverse connection encoding system. The method of claim 1, A codeword pair header and a codeword quad generator operative to interleave rows of a sixth data array with codeword headers to generate codeword quads; And a write formatter operative to map the codeword quad to a logical track of the recording medium. Reverse connection encoding system. A method of encoding data for recording on a medium, Creating a first data array of unencoded user data; Imparting a first modulation constraint for each row in the first data array to produce a second data array comprising modulation-constrained data; Formatting the second data array by inserting a predetermined empty position into each column of the second data array where modulation constrained data is interleaved to produce a third data array; Calculating a C2 parity byte for each of the plurality of empty positions in each column of the third data array to produce a fourth data array; Calculating a C1 parity symbol for each row of the fourth data array to generate a fifth data array; Generating a sixth data array by imparting a second modulation constraint on each C1 parity symbol of the fifth data array; Recording a row of the sixth data array on a track of a recording medium. Data encoding method. The method of claim 8, Generating a plurality of unconstrained data bytes, Inserting the unconstrained data byte into at least one of the empty positions in each column of the third data array and inserting the calculated C2 parity byte into the remaining empty positions in each column of the third data array. Including more steps Data encoding method. A computer program product on a computer readable medium usable with a programmable computer, the computer program product comprising: The computer program product has computer readable code implemented for encoding data for recording on the medium, The computer readable code is Instructions for creating a first data array of unencoded user data; Instructions for imparting a first modulation constraint for each row in the first data array to produce a second data array that includes modulation-constrained data; Instructions for formatting the second data array and generating a third data array by inserting a predetermined empty position into each column of the second data array with the modulation constrained data interleaved; Instructions for calculating a C2 parity byte for each of a plurality of empty positions in each column of the third data array and generating a fourth data array; Instructions for calculating P C1 parity symbols in each row and generating a fifth data array; Instructions for imparting a second modulation constraint and generating a sixth data array for each C1 parity symbol in each row; Instructions for recording the row of the sixth data array on a track of a recording medium; Computer program products.

Images