legacy/libburn/trunk/libburn/ecma130ab.c

856 lines
32 KiB
C

/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif
/* ts A91016 : libburn/ecma130ab.c is the replacement for old libburn/lec.c
Copyright 2009, Thomas Schmitt <scdbackup@gmx.net>, libburnia-project.org
Provided under GPL version 2 or later.
This code module implements the production of RSPC parity bytes (P- and Q-
parity) and the scrambling of raw CD-ROM sectors as specified in ECMA-130:
http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-130.pdf
The following statements about Galois Fields have been learned mostly from
http://www.cs.utk.edu/~plank/plank/papers/CS-96-332.pdf
by James S. Plank after an e-mail exchange with Norbert Preining.
The output has been compared with the output of the old code of libburn
which was labeled "borrowed HEAVILY from cdrdao" and claimed by Joerg
Schilling to stem from code by Heiko Eissfeldt.
-------------------------------------------------------------------------
Note: In this text, "^" denotes exponentiation and not the binary exor
operation. Confusingly in the C code "^" is said exor.
Note: This is not C1, C2 which is rather mentioned in ECMA-130 Annex C and
always performed inside the drive.
-------------------------------------------------------------------------
RSPC , P- and Q-Parity
ECMA-130 Annex A prescribes to compute the parity bytes for P-columns and
Q-diagonals by RSPC based on a Galois Field GF(2^8) with enumerating
polynomials x^8+x^4+x^3+x^2+1 (i.e. 0x11d) and x^1 (i.e. 0x02).
Bytes 12 to 2075 of a audio-sized sector get ordered in two byte words
as 24 rows and 43 columns. Then this matrix is split into a LSB matrix
and a MSB matrix of the same layout. Parity bytes are to be computed
from these 8-bit values.
2 P-bytes cover each column of 24 bytes. They get appended to the matrix
as rows 24 and 25.
2 Q-bytes cover each the 26 diagonals of the extended matrix.
Both parity byte pairs have to be computed so that extended rows or
diagonals match this linear equation:
H x V = (0,0)
H is a 2-row matrix of size n matching the length of the V ectors
[ 1 1 ... 1 1 ]
[ x^(n-1) x^(n-2) x^1 1 ]
Vp represents a P-row. It is a byte vector consisting of row bytes at
position 0 to 23 and the two parity bytes which shall be determined
at position 24 and 25. So Hp has 26 columns.
Vq represents a Q-diagonal. It is a byte vector consisting of diagonal
bytes at position 0 to 42 and the two parity bytes at position 43 and 44.
So Hq has 45 columns. The Q-diagonals cover P-parity bytes.
By applying some high school algebra one gets the parity bytes b0, b1 of
vector V = (n_payload_bytes, b0 , b1) as
b0 = ( H[n] * SUM(n_payload_bytes) - H[0..(n-1)] x n_payload_bytes )
/ (H[n+1] - H[n])
b1 = - SUM(n_payload_bytes) - b0
H[i] is the i-the element of the second row of matrix H. E.g. H[0] = x^(n-1)
The result has to be computed by Galois field arithmetics. See below.
The P-parity bytes of each column get reunited as LSB and MSB of two words.
word1 gets written to positions 1032 to 1074, word0 to 1075 to 1117.
The Q-parity bytes of each diagonal get reunited too. word1 goes to 1118
to 1143, word0 to 1144 to 1169.
>>> I do not read this swap of word1 and word0 from ECMA-130 Annex A.
>>> But the new output matches the old output only if it is done that way.
>>> See correctness reservation below.
Algebra on Galois fields is the same as on Rational Numbers.
But arithmetics is defined by operations on polynomials rather than the
usual integer arithmetics on binary numbers.
Addition and subtraction are identical with the binary exor operator.
Multiplication and division would demand polynomial division, e.g. by the
euclidian algorithm. The computing path over logarithms and powers follows
algebra and reduces the arithmetic task to table lookups, additions
modulo 255, and exor operations. Note that the logarithms are natural
numbers, not polynomials. They get added or subtracted by the usual addition
(not by exor) and their polynomial power depends on their value modulo 255.
Needed are a logarithm table and a power table (or inverse logarithm table)
for Galois Field GF(2^8) which will serve to perform the peculiar
multiplication and division operation of Galois fields.
The power table is simply an enumeration of x^n accorting to
GF-multiplication. It also serves as second line of matrix H for the parity
equations:
Hp[i] = gfpow[25-i] , i out of {0,..,25}
Hq[i] = gfpow[44-i] , i out of {0,..,44}
The logarithm table is the inverse permutation of the power table.
Some simplifications apply to the implementation:
In the world of Galois fields there is no difference between - and +.
The term (H[n+1] - H[n]) is constant: 3.
-------------------------------------------------------------------------
Scrambling
ECMA-130 Annex B prescribes to exor the byte stream of an audio-sized sector
with a sequence of pseudo random bytes. It mentions polynomial x^15+x+1 and
a 15-bit register.
It shows a diagram of a Feedback Shift Register with 16 bit boxes, though.
Comparing this with explanations in
http://www.newwaveinstruments.com/resources/articles/m_sequence_linear_feedback_shift_register_lfsr.htm
one can recognize the diagram as a Fibonacci Implementation. But there seems
really to be one bit box too many.
The difference of both lengths is expressed in function next_bit() by
the constants 0x3fff,0x4000 for 15 bit versus 0x7fff,0x8000 for 16 bits.
Comparing the output of both alternatives with the old scrambler output
lets 15 bit win for now.
So the prescription is to start with 15 bit value 1, to use the lowest bit
as output, to shift the bits down by one, to exor the output bit with the
next lowest bit, and to put that exor result into bit 14 of the register.
-------------------------------------------------------------------------
Correctness Reservation
In both cases, parity and scrambling, the goal for now is to replicate the
output of the dismissed old lec.c by output which is based on published
specs and own implementation code. Whether they comply to ECMA-130 is a
different question which can only be answered by real test cases for
raw CD recording.
Of course this implementation will be corrected so that it really complies
to ECMA-130 as soon as evidence emerges that it does not yet.
*/
/* ------------------------------------------------------------------------- */
/* Power and logarithm tables for GF(2^8), parity matrices for ECMA-130.
Generated by burn_rspc_setup_tables() and burn_rspc_print_tables().
The highest possible sum of gflog[] values is is 508. So the table gfpow[]
with period 255 was manually unrolled to 509 elements to avoid one modulo
255 operation in burn_rspc_mult().
Proposed by D. Hugh Redelmeier.
*/
static unsigned char gfpow[509] = {
1, 2, 4, 8, 16, 32, 64, 128, 29, 58,
116, 232, 205, 135, 19, 38, 76, 152, 45, 90,
180, 117, 234, 201, 143, 3, 6, 12, 24, 48,
96, 192, 157, 39, 78, 156, 37, 74, 148, 53,
106, 212, 181, 119, 238, 193, 159, 35, 70, 140,
5, 10, 20, 40, 80, 160, 93, 186, 105, 210,
185, 111, 222, 161, 95, 190, 97, 194, 153, 47,
94, 188, 101, 202, 137, 15, 30, 60, 120, 240,
253, 231, 211, 187, 107, 214, 177, 127, 254, 225,
223, 163, 91, 182, 113, 226, 217, 175, 67, 134,
17, 34, 68, 136, 13, 26, 52, 104, 208, 189,
103, 206, 129, 31, 62, 124, 248, 237, 199, 147,
59, 118, 236, 197, 151, 51, 102, 204, 133, 23,
46, 92, 184, 109, 218, 169, 79, 158, 33, 66,
132, 21, 42, 84, 168, 77, 154, 41, 82, 164,
85, 170, 73, 146, 57, 114, 228, 213, 183, 115,
230, 209, 191, 99, 198, 145, 63, 126, 252, 229,
215, 179, 123, 246, 241, 255, 227, 219, 171, 75,
150, 49, 98, 196, 149, 55, 110, 220, 165, 87,
174, 65, 130, 25, 50, 100, 200, 141, 7, 14,
28, 56, 112, 224, 221, 167, 83, 166, 81, 162,
89, 178, 121, 242, 249, 239, 195, 155, 43, 86,
172, 69, 138, 9, 18, 36, 72, 144, 61, 122,
244, 245, 247, 243, 251, 235, 203, 139, 11, 22,
44, 88, 176, 125, 250, 233, 207, 131, 27, 54,
108, 216, 173, 71, 142,
1, 2, 4, 8, 16, 32, 64, 128, 29, 58,
116, 232, 205, 135, 19, 38, 76, 152, 45, 90,
180, 117, 234, 201, 143, 3, 6, 12, 24, 48,
96, 192, 157, 39, 78, 156, 37, 74, 148, 53,
106, 212, 181, 119, 238, 193, 159, 35, 70, 140,
5, 10, 20, 40, 80, 160, 93, 186, 105, 210,
185, 111, 222, 161, 95, 190, 97, 194, 153, 47,
94, 188, 101, 202, 137, 15, 30, 60, 120, 240,
253, 231, 211, 187, 107, 214, 177, 127, 254, 225,
223, 163, 91, 182, 113, 226, 217, 175, 67, 134,
17, 34, 68, 136, 13, 26, 52, 104, 208, 189,
103, 206, 129, 31, 62, 124, 248, 237, 199, 147,
59, 118, 236, 197, 151, 51, 102, 204, 133, 23,
46, 92, 184, 109, 218, 169, 79, 158, 33, 66,
132, 21, 42, 84, 168, 77, 154, 41, 82, 164,
85, 170, 73, 146, 57, 114, 228, 213, 183, 115,
230, 209, 191, 99, 198, 145, 63, 126, 252, 229,
215, 179, 123, 246, 241, 255, 227, 219, 171, 75,
150, 49, 98, 196, 149, 55, 110, 220, 165, 87,
174, 65, 130, 25, 50, 100, 200, 141, 7, 14,
28, 56, 112, 224, 221, 167, 83, 166, 81, 162,
89, 178, 121, 242, 249, 239, 195, 155, 43, 86,
172, 69, 138, 9, 18, 36, 72, 144, 61, 122,
244, 245, 247, 243, 251, 235, 203, 139, 11, 22,
44, 88, 176, 125, 250, 233, 207, 131, 27, 54,
108, 216, 173, 71,
};
static unsigned char gflog[256] = {
0, 0, 1, 25, 2, 50, 26, 198, 3, 223,
51, 238, 27, 104, 199, 75, 4, 100, 224, 14,
52, 141, 239, 129, 28, 193, 105, 248, 200, 8,
76, 113, 5, 138, 101, 47, 225, 36, 15, 33,
53, 147, 142, 218, 240, 18, 130, 69, 29, 181,
194, 125, 106, 39, 249, 185, 201, 154, 9, 120,
77, 228, 114, 166, 6, 191, 139, 98, 102, 221,
48, 253, 226, 152, 37, 179, 16, 145, 34, 136,
54, 208, 148, 206, 143, 150, 219, 189, 241, 210,
19, 92, 131, 56, 70, 64, 30, 66, 182, 163,
195, 72, 126, 110, 107, 58, 40, 84, 250, 133,
186, 61, 202, 94, 155, 159, 10, 21, 121, 43,
78, 212, 229, 172, 115, 243, 167, 87, 7, 112,
192, 247, 140, 128, 99, 13, 103, 74, 222, 237,
49, 197, 254, 24, 227, 165, 153, 119, 38, 184,
180, 124, 17, 68, 146, 217, 35, 32, 137, 46,
55, 63, 209, 91, 149, 188, 207, 205, 144, 135,
151, 178, 220, 252, 190, 97, 242, 86, 211, 171,
20, 42, 93, 158, 132, 60, 57, 83, 71, 109,
65, 162, 31, 45, 67, 216, 183, 123, 164, 118,
196, 23, 73, 236, 127, 12, 111, 246, 108, 161,
59, 82, 41, 157, 85, 170, 251, 96, 134, 177,
187, 204, 62, 90, 203, 89, 95, 176, 156, 169,
160, 81, 11, 245, 22, 235, 122, 117, 44, 215,
79, 174, 213, 233, 230, 231, 173, 232, 116, 214,
244, 234, 168, 80, 88, 175
};
#define Libburn_use_h_matriceS 1
#ifdef Libburn_use_h_matriceS
/* On my AMD 2x64 bit 3000 MHz processor h[i] costs about 7 % more time
than using gfpow[25-i] and gfpow[44-1]. I blame this on the more
condensed data representation which slightly increases the rate of cache
hits.
Nevertheless this effect is very likely depending on the exact cache
size and architecture. In general, using h[] saves more than 8000
subtractions per sector.
*/
/* Parity matrices H as prescribed by ECMA-130 Annex A.
Actually just reverted order start pieces of gfpow[].
*/
static unsigned char h26[26] = {
3, 143, 201, 234, 117, 180, 90, 45, 152, 76,
38, 19, 135, 205, 232, 116, 58, 29, 128, 64,
32, 16, 8, 4, 2, 1,
};
static unsigned char h45[45] = {
238, 119, 181, 212, 106, 53, 148, 74, 37, 156,
78, 39, 157, 192, 96, 48, 24, 12, 6, 3,
143, 201, 234, 117, 180, 90, 45, 152, 76, 38,
19, 135, 205, 232, 116, 58, 29, 128, 64, 32,
16, 8, 4, 2, 1,
};
#endif /* Libburn_use_h_matriceS */
/* Pseudo-random bytes which of course are exactly the same as with the
previously used code.
Generated by function print_ecma_130_scrambler().
*/
static unsigned char ecma_130_annex_b[2340] = {
1, 128, 0, 96, 0, 40, 0, 30, 128, 8,
96, 6, 168, 2, 254, 129, 128, 96, 96, 40,
40, 30, 158, 136, 104, 102, 174, 170, 252, 127,
1, 224, 0, 72, 0, 54, 128, 22, 224, 14,
200, 4, 86, 131, 126, 225, 224, 72, 72, 54,
182, 150, 246, 238, 198, 204, 82, 213, 253, 159,
1, 168, 0, 126, 128, 32, 96, 24, 40, 10,
158, 135, 40, 98, 158, 169, 168, 126, 254, 160,
64, 120, 48, 34, 148, 25, 175, 74, 252, 55,
1, 214, 128, 94, 224, 56, 72, 18, 182, 141,
182, 229, 182, 203, 54, 215, 86, 222, 190, 216,
112, 90, 164, 59, 59, 83, 83, 125, 253, 225,
129, 136, 96, 102, 168, 42, 254, 159, 0, 104,
0, 46, 128, 28, 96, 9, 232, 6, 206, 130,
212, 97, 159, 104, 104, 46, 174, 156, 124, 105,
225, 238, 200, 76, 86, 181, 254, 247, 0, 70,
128, 50, 224, 21, 136, 15, 38, 132, 26, 227,
75, 9, 247, 70, 198, 178, 210, 245, 157, 135,
41, 162, 158, 249, 168, 66, 254, 177, 128, 116,
96, 39, 104, 26, 174, 139, 60, 103, 81, 234,
188, 79, 49, 244, 20, 71, 79, 114, 180, 37,
183, 91, 54, 187, 86, 243, 126, 197, 224, 83,
8, 61, 198, 145, 146, 236, 109, 141, 237, 165,
141, 187, 37, 179, 91, 53, 251, 87, 3, 126,
129, 224, 96, 72, 40, 54, 158, 150, 232, 110,
206, 172, 84, 125, 255, 97, 128, 40, 96, 30,
168, 8, 126, 134, 160, 98, 248, 41, 130, 158,
225, 168, 72, 126, 182, 160, 118, 248, 38, 194,
154, 209, 171, 28, 127, 73, 224, 54, 200, 22,
214, 142, 222, 228, 88, 75, 122, 183, 99, 54,
169, 214, 254, 222, 192, 88, 80, 58, 188, 19,
49, 205, 212, 85, 159, 127, 40, 32, 30, 152,
8, 106, 134, 175, 34, 252, 25, 129, 202, 224,
87, 8, 62, 134, 144, 98, 236, 41, 141, 222,
229, 152, 75, 42, 183, 95, 54, 184, 22, 242,
142, 197, 164, 83, 59, 125, 211, 97, 157, 232,
105, 142, 174, 228, 124, 75, 97, 247, 104, 70,
174, 178, 252, 117, 129, 231, 32, 74, 152, 55,
42, 150, 159, 46, 232, 28, 78, 137, 244, 102,
199, 106, 210, 175, 29, 188, 9, 177, 198, 244,
82, 199, 125, 146, 161, 173, 184, 125, 178, 161,
181, 184, 119, 50, 166, 149, 186, 239, 51, 12,
21, 197, 207, 19, 20, 13, 207, 69, 148, 51,
47, 85, 220, 63, 25, 208, 10, 220, 7, 25,
194, 138, 209, 167, 28, 122, 137, 227, 38, 201,
218, 214, 219, 30, 219, 72, 91, 118, 187, 102,
243, 106, 197, 239, 19, 12, 13, 197, 197, 147,
19, 45, 205, 221, 149, 153, 175, 42, 252, 31,
1, 200, 0, 86, 128, 62, 224, 16, 72, 12,
54, 133, 214, 227, 30, 201, 200, 86, 214, 190,
222, 240, 88, 68, 58, 179, 83, 53, 253, 215,
1, 158, 128, 104, 96, 46, 168, 28, 126, 137,
224, 102, 200, 42, 214, 159, 30, 232, 8, 78,
134, 180, 98, 247, 105, 134, 174, 226, 252, 73,
129, 246, 224, 70, 200, 50, 214, 149, 158, 239,
40, 76, 30, 181, 200, 119, 22, 166, 142, 250,
228, 67, 11, 113, 199, 100, 82, 171, 125, 191,
97, 176, 40, 116, 30, 167, 72, 122, 182, 163,
54, 249, 214, 194, 222, 209, 152, 92, 106, 185,
239, 50, 204, 21, 149, 207, 47, 20, 28, 15,
73, 196, 54, 211, 86, 221, 254, 217, 128, 90,
224, 59, 8, 19, 70, 141, 242, 229, 133, 139,
35, 39, 89, 218, 186, 219, 51, 27, 85, 203,
127, 23, 96, 14, 168, 4, 126, 131, 96, 97,
232, 40, 78, 158, 180, 104, 119, 110, 166, 172,
122, 253, 227, 1, 137, 192, 102, 208, 42, 220,
31, 25, 200, 10, 214, 135, 30, 226, 136, 73,
166, 182, 250, 246, 195, 6, 209, 194, 220, 81,
153, 252, 106, 193, 239, 16, 76, 12, 53, 197,
215, 19, 30, 141, 200, 101, 150, 171, 46, 255,
92, 64, 57, 240, 18, 196, 13, 147, 69, 173,
243, 61, 133, 209, 163, 28, 121, 201, 226, 214,
201, 158, 214, 232, 94, 206, 184, 84, 114, 191,
101, 176, 43, 52, 31, 87, 72, 62, 182, 144,
118, 236, 38, 205, 218, 213, 155, 31, 43, 72,
31, 118, 136, 38, 230, 154, 202, 235, 23, 15,
78, 132, 52, 99, 87, 105, 254, 174, 192, 124,
80, 33, 252, 24, 65, 202, 176, 87, 52, 62,
151, 80, 110, 188, 44, 113, 221, 228, 89, 139,
122, 231, 99, 10, 169, 199, 62, 210, 144, 93,
172, 57, 189, 210, 241, 157, 132, 105, 163, 110,
249, 236, 66, 205, 241, 149, 132, 111, 35, 108,
25, 237, 202, 205, 151, 21, 174, 143, 60, 100,
17, 235, 76, 79, 117, 244, 39, 7, 90, 130,
187, 33, 179, 88, 117, 250, 167, 3, 58, 129,
211, 32, 93, 216, 57, 154, 146, 235, 45, 143,
93, 164, 57, 187, 82, 243, 125, 133, 225, 163,
8, 121, 198, 162, 210, 249, 157, 130, 233, 161,
142, 248, 100, 66, 171, 113, 191, 100, 112, 43,
100, 31, 107, 72, 47, 118, 156, 38, 233, 218,
206, 219, 20, 91, 79, 123, 116, 35, 103, 89,
234, 186, 207, 51, 20, 21, 207, 79, 20, 52,
15, 87, 68, 62, 179, 80, 117, 252, 39, 1,
218, 128, 91, 32, 59, 88, 19, 122, 141, 227,
37, 137, 219, 38, 219, 90, 219, 123, 27, 99,
75, 105, 247, 110, 198, 172, 82, 253, 253, 129,
129, 160, 96, 120, 40, 34, 158, 153, 168, 106,
254, 175, 0, 124, 0, 33, 192, 24, 80, 10,
188, 7, 49, 194, 148, 81, 175, 124, 124, 33,
225, 216, 72, 90, 182, 187, 54, 243, 86, 197,
254, 211, 0, 93, 192, 57, 144, 18, 236, 13,
141, 197, 165, 147, 59, 45, 211, 93, 157, 249,
169, 130, 254, 225, 128, 72, 96, 54, 168, 22,
254, 142, 192, 100, 80, 43, 124, 31, 97, 200,
40, 86, 158, 190, 232, 112, 78, 164, 52, 123,
87, 99, 126, 169, 224, 126, 200, 32, 86, 152,
62, 234, 144, 79, 44, 52, 29, 215, 73, 158,
182, 232, 118, 206, 166, 212, 122, 223, 99, 24,
41, 202, 158, 215, 40, 94, 158, 184, 104, 114,
174, 165, 188, 123, 49, 227, 84, 73, 255, 118,
192, 38, 208, 26, 220, 11, 25, 199, 74, 210,
183, 29, 182, 137, 182, 230, 246, 202, 198, 215,
18, 222, 141, 152, 101, 170, 171, 63, 63, 80,
16, 60, 12, 17, 197, 204, 83, 21, 253, 207,
1, 148, 0, 111, 64, 44, 48, 29, 212, 9,
159, 70, 232, 50, 206, 149, 148, 111, 47, 108,
28, 45, 201, 221, 150, 217, 174, 218, 252, 91,
1, 251, 64, 67, 112, 49, 228, 20, 75, 79,
119, 116, 38, 167, 90, 250, 187, 3, 51, 65,
213, 240, 95, 4, 56, 3, 82, 129, 253, 160,
65, 184, 48, 114, 148, 37, 175, 91, 60, 59,
81, 211, 124, 93, 225, 249, 136, 66, 230, 177,
138, 244, 103, 7, 106, 130, 175, 33, 188, 24,
113, 202, 164, 87, 59, 126, 147, 96, 109, 232,
45, 142, 157, 164, 105, 187, 110, 243, 108, 69,
237, 243, 13, 133, 197, 163, 19, 57, 205, 210,
213, 157, 159, 41, 168, 30, 254, 136, 64, 102,
176, 42, 244, 31, 7, 72, 2, 182, 129, 182,
224, 118, 200, 38, 214, 154, 222, 235, 24, 79,
74, 180, 55, 55, 86, 150, 190, 238, 240, 76,
68, 53, 243, 87, 5, 254, 131, 0, 97, 192,
40, 80, 30, 188, 8, 113, 198, 164, 82, 251,
125, 131, 97, 161, 232, 120, 78, 162, 180, 121,
183, 98, 246, 169, 134, 254, 226, 192, 73, 144,
54, 236, 22, 205, 206, 213, 148, 95, 47, 120,
28, 34, 137, 217, 166, 218, 250, 219, 3, 27,
65, 203, 112, 87, 100, 62, 171, 80, 127, 124,
32, 33, 216, 24, 90, 138, 187, 39, 51, 90,
149, 251, 47, 3, 92, 1, 249, 192, 66, 208,
49, 156, 20, 105, 207, 110, 212, 44, 95, 93,
248, 57, 130, 146, 225, 173, 136, 125, 166, 161,
186, 248, 115, 2, 165, 193, 187, 16, 115, 76,
37, 245, 219, 7, 27, 66, 139, 113, 167, 100,
122, 171, 99, 63, 105, 208, 46, 220, 28, 89,
201, 250, 214, 195, 30, 209, 200, 92, 86, 185,
254, 242, 192, 69, 144, 51, 44, 21, 221, 207,
25, 148, 10, 239, 71, 12, 50, 133, 213, 163,
31, 57, 200, 18, 214, 141, 158, 229, 168, 75,
62, 183, 80, 118, 188, 38, 241, 218, 196, 91,
19, 123, 77, 227, 117, 137, 231, 38, 202, 154,
215, 43, 30, 159, 72, 104, 54, 174, 150, 252,
110, 193, 236, 80, 77, 252, 53, 129, 215, 32,
94, 152, 56, 106, 146, 175, 45, 188, 29, 177,
201, 180, 86, 247, 126, 198, 160, 82, 248, 61,
130, 145, 161, 172, 120, 125, 226, 161, 137, 184,
102, 242, 170, 197, 191, 19, 48, 13, 212, 5,
159, 67, 40, 49, 222, 148, 88, 111, 122, 172,
35, 61, 217, 209, 154, 220, 107, 25, 239, 74,
204, 55, 21, 214, 143, 30, 228, 8, 75, 70,
183, 114, 246, 165, 134, 251, 34, 195, 89, 145,
250, 236, 67, 13, 241, 197, 132, 83, 35, 125,
217, 225, 154, 200, 107, 22, 175, 78, 252, 52,
65, 215, 112, 94, 164, 56, 123, 82, 163, 125,
185, 225, 178, 200, 117, 150, 167, 46, 250, 156,
67, 41, 241, 222, 196, 88, 83, 122, 189, 227,
49, 137, 212, 102, 223, 106, 216, 47, 26, 156,
11, 41, 199, 94, 210, 184, 93, 178, 185, 181,
178, 247, 53, 134, 151, 34, 238, 153, 140, 106,
229, 239, 11, 12, 7, 69, 194, 179, 17, 181,
204, 119, 21, 230, 143, 10, 228, 7, 11, 66,
135, 113, 162, 164, 121, 187, 98, 243, 105, 133,
238, 227, 12, 73, 197, 246, 211, 6, 221, 194,
217, 145, 154, 236, 107, 13, 239, 69, 140, 51,
37, 213, 219, 31, 27, 72, 11, 118, 135, 102,
226, 170, 201, 191, 22, 240, 14, 196, 4, 83,
67, 125, 241, 225, 132, 72, 99, 118, 169, 230,
254, 202, 192, 87, 16, 62, 140, 16, 101, 204,
43, 21, 223, 79, 24, 52, 10, 151, 71, 46,
178, 156, 117, 169, 231, 62, 202, 144, 87, 44,
62, 157, 208, 105, 156, 46, 233, 220, 78, 217,
244, 90, 199, 123, 18, 163, 77, 185, 245, 178,
199, 53, 146, 151, 45, 174, 157, 188, 105, 177,
238, 244, 76, 71, 117, 242, 167, 5, 186, 131,
51, 33, 213, 216, 95, 26, 184, 11, 50, 135,
85, 162, 191, 57, 176, 18, 244, 13, 135, 69,
162, 179, 57, 181, 210, 247, 29, 134, 137, 162,
230, 249, 138, 194, 231, 17, 138, 140, 103, 37,
234, 155, 15, 43, 68, 31, 115, 72, 37, 246,
155, 6, 235, 66, 207, 113, 148, 36, 111, 91,
108, 59, 109, 211, 109, 157, 237, 169, 141, 190,
229, 176, 75, 52, 55, 87, 86, 190, 190, 240,
112, 68, 36, 51, 91, 85, 251, 127, 3, 96,
1, 232, 0, 78, 128, 52, 96, 23, 104, 14,
174, 132, 124, 99, 97, 233, 232, 78, 206, 180,
84, 119, 127, 102, 160, 42, 248, 31, 2, 136,
1, 166, 128, 122, 224, 35, 8, 25, 198, 138,
210, 231, 29, 138, 137, 167, 38, 250, 154, 195,
43, 17, 223, 76, 88, 53, 250, 151, 3, 46,
129, 220, 96, 89, 232, 58, 206, 147, 20, 109,
207, 109, 148, 45, 175, 93, 188, 57, 177, 210,
244, 93, 135, 121, 162, 162, 249, 185, 130, 242,
225, 133, 136, 99, 38, 169, 218, 254, 219, 0,
91, 64, 59, 112, 19, 100, 13, 235, 69, 143,
115, 36, 37, 219, 91, 27, 123, 75, 99, 119,
105, 230, 174, 202, 252, 87, 1, 254, 128, 64,
96, 48, 40, 20, 30, 143, 72, 100, 54, 171,
86, 255, 126, 192, 32, 80, 24, 60, 10, 145,
199, 44, 82, 157, 253, 169, 129, 190, 224, 112,
72, 36, 54, 155, 86, 235, 126, 207, 96, 84,
40, 63, 94, 144, 56, 108, 18, 173, 205, 189,
149, 177, 175, 52, 124, 23, 97, 206, 168, 84,
126, 191, 96, 112, 40, 36, 30, 155, 72, 107,
118, 175, 102, 252, 42, 193, 223, 16, 88, 12,
58, 133, 211, 35, 29, 217, 201, 154, 214, 235,
30, 207, 72, 84, 54, 191, 86, 240, 62, 196,
16, 83, 76, 61, 245, 209, 135, 28, 98, 137,
233, 166, 206, 250, 212, 67, 31, 113, 200, 36,
86, 155, 126, 235, 96, 79, 104, 52, 46, 151,
92, 110, 185, 236, 114, 205, 229, 149, 139, 47,
39, 92, 26, 185, 203, 50, 215, 85, 158, 191,
40, 112, 30, 164, 8, 123, 70, 163, 114, 249,
229, 130, 203, 33, 151, 88, 110, 186, 172, 115,
61, 229, 209, 139, 28, 103, 73, 234, 182, 207,
54, 212, 22, 223, 78, 216, 52, 90, 151, 123,
46, 163, 92, 121, 249, 226, 194, 201, 145, 150,
236, 110, 205, 236, 85, 141, 255, 37, 128, 27,
32, 11, 88, 7, 122, 130, 163, 33, 185, 216,
114, 218, 165, 155, 59, 43, 83, 95, 125, 248,
33, 130, 152, 97, 170, 168, 127, 62, 160, 16,
120, 12, 34, 133, 217, 163, 26, 249, 203, 2,
215, 65, 158, 176, 104, 116, 46, 167, 92, 122,
185, 227, 50, 201, 213, 150, 223, 46, 216, 28,
90, 137, 251, 38, 195, 90, 209, 251, 28, 67,
73, 241, 246, 196, 70, 211, 114, 221, 229, 153
};
/* ------------------------------------------------------------------------- */
/* This is the new implementation of P- and Q-parity generation.
It needs about the same computing time as the old implementation (both
with gcc -O2 on AMD 64 bit). Measurements indicate that about 280 MIPS
are needed for 48x CD speed (7.1 MB/s).
*/
static unsigned char burn_rspc_mult(unsigned char a, unsigned char b)
{
if (a == 0 || b == 0)
return 0;
/* Optimization of (a == 0 || b == 0) by D. Hugh Redelmeier
if((((int)a - 1) | ((int)b - 1)) < 0)
return 0;
*/
return gfpow[gflog[a] + gflog[b]];
/* % 255 not necessary because gfpow is unrolled up to index 510 */
}
/* Divide by polynomial 0x03. Derived from burn_rspc_div() and using the
unrolled size of the gfpow[] array.
*/
static unsigned char burn_rspc_div_3(unsigned char a)
{
if (a == 0)
return 0;
return gfpow[230 + gflog[a]];
}
static void burn_rspc_p0p1(unsigned char *sector, int col,
unsigned char *p0_lsb, unsigned char *p0_msb,
unsigned char *p1_lsb, unsigned char *p1_msb)
{
unsigned char *start, b;
unsigned int i, sum_v_lsb = 0, sum_v_msb = 0;
unsigned int hxv_lsb = 0, hxv_msb = 0;
start = sector + 12 + 2 * col;
for(i = 0; i < 24; i++) {
b = *start;
sum_v_lsb ^= b;
#ifdef Libburn_use_h_matriceS
hxv_lsb ^= burn_rspc_mult(b, h26[i]);
#else
hxv_lsb ^= burn_rspc_mult(b, gfpow[25 - i]);
#endif
b = *(start + 1);
sum_v_msb ^= b;
#ifdef Libburn_use_h_matriceS
hxv_msb ^= burn_rspc_mult(b, h26[i]);
#else
hxv_msb ^= burn_rspc_mult(b, gfpow[25 - i]);
#endif
start += 86;
}
/* 3 = gfpow[1] ^ gfpow[0] , 2 = gfpow[1] */
*p0_lsb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_lsb) ^ hxv_lsb);
*p0_msb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_msb) ^ hxv_msb);
*p1_lsb = sum_v_lsb ^ *p0_lsb;
*p1_msb = sum_v_msb ^ *p0_msb;
}
void burn_rspc_parity_p(unsigned char *sector)
{
int i;
unsigned char p0_lsb, p0_msb, p1_lsb, p1_msb;
/* Loop over P columns */
for(i = 0; i < 43; i++) {
burn_rspc_p0p1(sector, i, &p0_lsb, &p0_msb, &p1_lsb, &p1_msb);
sector[2162 + 2 * i] = p0_lsb;
sector[2162 + 2 * i + 1] = p0_msb;
sector[2076 + 2 * i] = p1_lsb;
sector[2076 + 2 * i + 1] = p1_msb;
#ifdef Libburn_with_lec_generatoR
if(verbous) {
printf("p %2d : %2.2X %2.2X ", i,
(unsigned int) p0_lsb, (unsigned int) p0_msb);
printf("%2.2X %2.2X ",
(unsigned int) p1_lsb, (unsigned int) p1_msb);
printf("-> %d,%d\n", 2162 + 2 * i, 2076 + 2 * i);
}
#endif /* Libburn_with_lec_generatoR */
}
}
static void burn_rspc_q0q1(unsigned char *sector, int diag,
unsigned char *q0_lsb, unsigned char *q0_msb,
unsigned char *q1_lsb, unsigned char *q1_msb)
{
unsigned char *start, b;
unsigned int i, idx, sum_v_lsb = 0, sum_v_msb = 0;
unsigned int hxv_lsb = 0, hxv_msb = 0;
start = sector + 12;
idx = 2 * 43 * diag;
for(i = 0; i < 43; i++) {
if (idx >= 2236)
idx -= 2236;
b = start[idx];
sum_v_lsb ^= b;
#ifdef Libburn_use_h_matriceS
hxv_lsb ^= burn_rspc_mult(b, h45[i]);
#else
hxv_lsb ^= burn_rspc_mult(b, gfpow[44 - i]);
#endif
b = start[idx + 1];
sum_v_msb ^= b;
#ifdef Libburn_use_h_matriceS
hxv_msb ^= burn_rspc_mult(b, h45[i]);
#else
hxv_msb ^= burn_rspc_mult(b, gfpow[44 - i]);
#endif
idx += 88;
}
/* 3 = gfpow[1] ^ gfpow[0] , 2 = gfpow[1] */
*q0_lsb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_lsb) ^ hxv_lsb);
*q0_msb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_msb) ^ hxv_msb);
*q1_lsb = sum_v_lsb ^ *q0_lsb;
*q1_msb = sum_v_msb ^ *q0_msb;
}
void burn_rspc_parity_q(unsigned char *sector)
{
int i;
unsigned char q0_lsb, q0_msb, q1_lsb, q1_msb;
/* Loop over Q diagonals */
for(i = 0; i < 26; i++) {
burn_rspc_q0q1(sector, i, &q0_lsb, &q0_msb, &q1_lsb, &q1_msb);
sector[2300 + 2 * i] = q0_lsb;
sector[2300 + 2 * i + 1] = q0_msb;
sector[2248 + 2 * i] = q1_lsb;
sector[2248 + 2 * i + 1] = q1_msb;
#ifdef Libburn_with_lec_generatoR
if(verbous) {
printf("q %2d : %2.2X %2.2X ", i,
(unsigned int) q0_lsb, (unsigned int) q0_msb);
printf("%2.2X %2.2X ",
(unsigned int) q1_lsb, (unsigned int) q1_msb);
printf("-> %d,%d\n", 2300 + 2 * i, 2248 + 2 * i);
}
#endif /* Libburn_with_lec_generatoR */
}
}
/* ------------------------------------------------------------------------- */
/* The new implementation of the ECMA-130 Annex B scrambler.
It is totally unoptimized. One should make use of larger word operations.
Measurements indicate that about 50 MIPS are needed for 48x CD speed.
*/
void burn_ecma130_scramble(unsigned char *sector)
{
int i;
unsigned char *s;
s = sector + 12;
for (i = 0; i < 2340; i++)
s[i] ^= ecma_130_annex_b[i];
}
/* ------------------------------------------------------------------------- */
/* The following code is not needed for libburn but rather documents the
origin of the tables above. In libburn it will not be compiled.
*/
#ifdef Libburn_with_lec_generatoR
/* This function produced the content of gflog[] and gfpow[]
*/
static int burn_rspc_setup_tables(void)
{
unsigned int b, l;
memset(gflog, 0, sizeof(gflog));
memset(gfpow, 0, sizeof(gfpow));
b = 1;
for (l = 0; l < 255; l++) {
gfpow[l] = (unsigned char) b;
gflog[b] = (unsigned char) l;
b = b << 1;
if (b & 256)
b = b ^ 0x11d;
}
return 0;
}
/* This function printed the content of gflog[] and gfpow[] as C code
and compared the content with the tables of the old implementation.
h26[] and h45[] are reverted order copies of gfpow[]
*/
static int burn_rspc_print_tables(void)
{
int i;
printf("static unsigned char gfpow[255] = {");
printf("\n\t");
for(i= 0; i < 255; i++) {
printf("%3u, ", gfpow[i]);
#ifdef Libburn_with_old_lec_comparisoN
if(gfpow[i] != gf8_ilog[i])
fprintf(stderr, "*** ILOG %d : %d != %d ***\n", i, gfpow[i], gf8_ilog[i]);
#endif
if((i % 10) == 9)
printf("\n\t");
}
printf("\n};\n\n");
printf("static unsigned char gflog[256] = {");
printf("\n\t");
for(i= 0; i < 256; i++) {
printf(" %3u,", gflog[i]);
#ifdef Libburn_with_old_lec_comparisoN
if(gflog[i] != gf8_log[i])
fprintf(stderr, "*** LOG %d : %d != %d ***\n", i, gflog[i], gf8_log[i]);
#endif
if((i % 10) == 9)
printf("\n\t");
}
printf("\n};\n\n");
printf("static unsigned char h26[26] = {");
printf("\n\t");
for(i= 0; i < 26; i++) {
printf(" %3u,", gfpow[25 - i]);
if((i % 10) == 9)
printf("\n\t");
}
printf("\n};\n\n");
printf("static unsigned char h45[45] = {");
printf("\n\t");
for(i= 0; i < 45; i++) {
printf(" %3u,",gfpow[44 - i]);
if((i % 10) == 9)
printf("\n\t");
}
printf("\n};\n\n");
return 0;
}
/* This code was used to generate the content of array ecma_130_annex_b[].
*/
static unsigned short ecma_130_fsr = 1;
static int next_bit(void)
{
int ret;
ret = ecma_130_fsr & 1;
ecma_130_fsr = (ecma_130_fsr >> 1) & 0x3fff;
if (ret ^ (ecma_130_fsr & 1))
ecma_130_fsr |= 0x4000;
return ret;
}
static int print_ecma_130_scrambler(void)
{
int i, j, b;
ecma_130_fsr = 1;
printf("static unsigned char ecma_130_annex_b[2340] = {");
printf("\n\t");
for (i = 0; i < 2340; i++) {
b = 0;
for (j = 0; j < 8; j++)
b |= next_bit() << j;
printf("%3u, ", b);
if ((i % 10) == 9)
printf("\n\t");
}
printf("\n};\n");
return 1;
}
#ifdef Libburn_with_general_rspc_diV
/* This is a general polynomial division function.
burn_rspc_div_3() has been derived from this by setting b to constant 3.
*/
static unsigned char burn_rspc_div(unsigned char a, unsigned char b)
{
int d;
if (a == 0)
return 0;
if (b == 0)
return -1;
d = gflog[a] - gflog[b];
if (d < 0)
d += 255;
return gfpow[d];
}
#endif /* Libburn_with_general_rspc_diV */
#endif /* Libburn_with_lec_generatoR */