Alfred
/
fm-rds-tx
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 6 Vikivietne Aktivitāte
Go-based FM stereo transmitter with RDS, Windows-first and cross-platform
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
181 Revīzija
1 Atzars
37MB
Koks: 0b76c7cdc2
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '0b76c7cdc2'
${ noResults }
fm-rds-tx/internal/watermark/watermark.go

589 rindas
26KB
Neapstrādāts Vainot Vēsture 

  1. // Package watermark implements spread-spectrum audio watermarking for fm-rds-tx.

  2. //

  3. // # Design

  4. //

  5. // The watermark is injected into the audio L/R signal after all audio

  6. // processing (LPF, clip, limiter) but before stereo encoding, so it

  7. // survives FM broadcast, receiver demodulation, de-emphasis, and moderate

  8. // EQ intact. The PN chip rate is limited to 12 kHz so all watermark energy

  9. // sits within 0–6 kHz — the band that survives every stage of the FM chain:

  10. //

  11. //   Embedder → Stereo Encode → Composite Clip → Pilot/RDS → FM Mod

  12. //   → FM Demod → De-emphasis → Stereo Decode → Audio Out → Recording

  13. //

  14. // The payload is Reed-Solomon encoded for robust recovery even when

  15. // individual bits have high error rates due to noise and audio masking.

  16. //

  17. // # Parameters

  18. //

  19. //   - PN sequence: 2048-chip LFSR-13 (seed 0x1ACE)

  20. //   - Payload: 8 bytes (SHA-256[:8] of key) → RS(16,8) → 16 bytes → 128 bits

  21. //   - Chip clock: 12 kHz → PN bandwidth 0–6 kHz (survives de-emphasis)

  22. //   - Frame period: ~21.8 s at 228 kHz composite (repeats ~2.7×/min)

  23. //   - Injection: -48 dBFS on audio L+R after all processing, before stereo encode

  24. //   - Spreading gain: 33 dB. RS erasure corrects up to 8 of 16 byte symbols.

  25. //

  26. // # Recovery (cmd/wmdecode)

  27. //

  28. //  1. Record FM receiver audio output as mono WAV (any sample rate ≥ 12 kHz).

  29. //  2. Phase search: energy-based coarse/fine search for chip alignment.

  30. //  3. Extract 128 bit correlations at found phase, averaged over all frames.

  31. //  4. Frame sync: try all 128 cyclic rotations of the bit sequence,

  32. //     RS-decode each; the rotation that succeeds gives the frame alignment.

  33. //  5. Byte-level erasure + soft-decision bit-flipping for error correction.

  34. //  6. RS erasure-decode → 8 payload bytes → compare against known keys.

  35. package watermark

  36. 

  37. import (

  38. 	"crypto/sha256"

  39. )

  40. 

  41. const (

  42. 	// pnChips is the spreading factor — PN chips per data bit.

  43. 	// Spreading gain = 10·log10(2048) = 33.1 dB.

  44. 	pnChips = 2048

  45. 

  46. 	// rsDataBytes is the number of payload bytes before RS encoding.

  47. 	rsDataBytes = 8

  48. 

  49. 	// rsCheckBytes is the number of RS parity bytes. With 8 check bytes the

  50. 	// code corrects up to 4 errors or up to 8 erasures per 16-byte codeword.

  51. 	rsCheckBytes = 8

  52. 

  53. 	// rsTotalBytes is the full RS codeword length.

  54. 	rsTotalBytes = rsDataBytes + rsCheckBytes // 16

  55. 

  56. 	// payloadBits is the total number of BPSK bits per watermark frame.

  57. 	payloadBits = rsTotalBytes * 8 // 128

  58. 

  59. 	// Level is the audio injection amplitude per channel (-48 dBFS).

  60. 	// At typical audio levels this is completely inaudible.

  61. 	Level = 0.040

  62. 

  63. 	// CompositeRate is the sample rate at which the watermark is embedded.

  64. 	CompositeRate = 228000

  65. )

  66. 

  67. // ChipRate is the effective PN chip clock rate (Hz). Determines the spectral

  68. // bandwidth of the watermark: Nyquist = ChipRate/2 = 6 kHz. This ensures

  69. // all PN energy is within the audio band that survives de-emphasis (50/75 µs),

  70. // receiver LPFs, audio codecs, speaker EQ, and even acoustic recording.

  71. //

  72. // At CompositeRate (228 kHz), each chip spans 228000/12000 = 19 samples.

  73. // At any recording rate R, each chip spans R/12000 samples.

  74. const ChipRate = 12000

  75. 

  76. // RecordingRate is the canonical recording rate for test WAV output (wmtest).

  77. // Not used for chip stepping — ChipRate controls that.

  78. const RecordingRate = 48000

  79. 

  80. // Embedder continuously embeds a watermark into audio L/R samples.

  81. // Not thread-safe: call NextSample from the single DSP goroutine only.

  82. type Embedder struct {

  83. 	codeword [rsTotalBytes]byte // RS-encoded payload, 16 bytes

  84. 	chipIdx  int               // chip position within current bit (0..pnChips-1)

  85. 	bitIdx   int               // current bit in codeword (0..127)

  86. 	symbol   int8              // BPSK symbol for current bit: +1 or -1

  87. 	accum    int               // Bresenham accumulator for chip-rate stepping

  88. 

  89. 	// Audio-level gate: mutes watermark during silence to prevent audibility.

  90. 	gateGain      float64 // smooth ramp 0.0 (muted) → 1.0 (open)

  91. 	gateThreshold float64 // audio level below which gate closes

  92. 	gateRampUp    float64 // per-sample increment when opening (~5ms)

  93. 	gateRampDown  float64 // per-sample decrement when closing (~5ms)

  94. 	gateEnabled   bool

  95. }

  96. 

  97. // NewEmbedder creates an Embedder for the given license key.

  98. // The key's SHA-256 hash (first 8 bytes) is RS-encoded and embedded.

  99. // An empty key embeds a null payload (still watermarks, just anonymous).

  100. func NewEmbedder(key string) *Embedder {

  101. 	var data [rsDataBytes]byte

  102. 	if key != "" {

  103. 		h := sha256.Sum256([]byte(key))

  104. 		copy(data[:], h[:rsDataBytes])

  105. 	}

  106. 	e := &Embedder{gateGain: 1.0}

  107. 	e.codeword = rsEncode(data)

  108. 	e.loadSymbol()

  109. 	return e

  110. }

  111. 

  112. // NextSample returns the watermark amplitude for one composite sample.

  113. // Add this value to both audio.Frame.L and audio.Frame.R before stereo encoding.

  114. //

  115. // The chip index advances using Bresenham stepping at ChipRate/CompositeRate,

  116. // so each chip occupies exactly CompositeRate/ChipRate composite samples on

  117. // average (~19 samples at 228 kHz). The PN signal bandwidth is 0–6 kHz.

  118. func (e *Embedder) NextSample() float64 {

  119. 	chip := float64(pnSequence[e.chipIdx])

  120. 	sample := Level * float64(e.symbol) * chip * e.gateGain

  121. 

  122. 	// Bresenham: advance chip once per ChipRate/CompositeRate composite samples.

  123. 	e.accum += ChipRate

  124. 	if e.accum >= CompositeRate {

  125. 		e.accum -= CompositeRate

  126. 		e.chipIdx++

  127. 		if e.chipIdx >= pnChips {

  128. 			e.chipIdx = 0

  129. 			e.bitIdx = (e.bitIdx + 1) % payloadBits

  130. 			e.loadSymbol()

  131. 		}

  132. 	}

  133. 	return sample

  134. }

  135. 

  136. // loadSymbol sets e.symbol from the current bit in the codeword (MSB first).

  137. func (e *Embedder) loadSymbol() {

  138. 	byteIdx := e.bitIdx / 8

  139. 	bitPos := uint(7 - (e.bitIdx % 8))

  140. 	if (e.codeword[byteIdx]>>bitPos)&1 == 0 {

  141. 		e.symbol = 1

  142. 	} else {

  143. 		e.symbol = -1

  144. 	}

  145. }

  146. 

  147. // PayloadHex returns the RS-encoded codeword as hex for logging.

  148. func (e *Embedder) PayloadHex() string {

  149. 	const hx = "0123456789abcdef"

  150. 	out := make([]byte, rsTotalBytes*2)

  151. 	for i, b := range e.codeword {

  152. 		out[i*2] = hx[b>>4]

  153. 		out[i*2+1] = hx[b&0xf]

  154. 	}

  155. 	return string(out)

  156. }

  157. 

  158. // EnableGate activates audio-level gating with asymmetric ramp times.

  159. // threshold is the linear audio amplitude below which the watermark is muted

  160. // (e.g. 0.01 ≈ -40 dBFS). compositeRate is needed to compute ramp speed.

  161. // Attack (open) is fast (5ms) so the watermark starts immediately with audio.

  162. // Release (close) is slow (200ms) to keep the watermark running through normal

  163. // inter-word and inter-phrase gaps — only extended silence mutes.

  164. func (e *Embedder) EnableGate(threshold, compositeRate float64) {

  165. 	attackSamples := compositeRate * 0.005  // 5ms open

  166. 	releaseSamples := compositeRate * 0.200 // 200ms close

  167. 	if attackSamples < 1 {

  168. 		attackSamples = 1

  169. 	}

  170. 	if releaseSamples < 1 {

  171. 		releaseSamples = 1

  172. 	}

  173. 	e.gateThreshold = threshold

  174. 	e.gateRampUp = 1.0 / attackSamples

  175. 	e.gateRampDown = 1.0 / releaseSamples

  176. 	e.gateEnabled = true

  177. }

  178. 

  179. // SetAudioLevel updates the gate state based on the current audio amplitude.

  180. // Call once per sample before NextSample. absLevel should be the absolute

  181. // mono audio level (pre- or post-pre-emphasis, either works).

  182. func (e *Embedder) SetAudioLevel(absLevel float64) {

  183. 	if !e.gateEnabled {

  184. 		return

  185. 	}

  186. 	if absLevel > e.gateThreshold {

  187. 		e.gateGain += e.gateRampUp

  188. 		if e.gateGain > 1.0 {

  189. 			e.gateGain = 1.0

  190. 		}

  191. 	} else {

  192. 		e.gateGain -= e.gateRampDown

  193. 		if e.gateGain < 0.0 {

  194. 			e.gateGain = 0.0

  195. 		}

  196. 	}

  197. }

  198. 

  199. // DiagnosticState returns internal state for debugging.

  200. type DiagnosticInfo struct {

  201. 	GateGain    float64

  202. 	GateEnabled bool

  203. 	ChipIdx     int

  204. 	BitIdx      int

  205. 	Symbol      int8

  206. }

  207. 

  208. // DiagnosticState returns a snapshot of the embedder's internal state.

  209. func (e *Embedder) DiagnosticState() DiagnosticInfo {

  210. 	return DiagnosticInfo{

  211. 		GateGain:    e.gateGain,

  212. 		GateEnabled: e.gateEnabled,

  213. 		ChipIdx:     e.chipIdx,

  214. 		BitIdx:      e.bitIdx,

  215. 		Symbol:      e.symbol,

  216. 	}

  217. }

  218. 

  219. // --- RS(16,8) over GF(2^8) — GF poly 0x11d, fcr=0, generator=2 ---

  220. // These routines are used by the embedder (encode) and the recovery tool (decode).

  221. 

  222. func gfMul(a, b byte) byte {

  223. 	if a == 0 || b == 0 {

  224. 		return 0

  225. 	}

  226. 	return gfExp[(int(gfLog[a])+int(gfLog[b]))%255]

  227. }

  228. 

  229. func gfInv(a byte) byte {

  230. 	if a == 0 {

  231. 		return 0

  232. 	}

  233. 	return gfExp[255-int(gfLog[a])]

  234. }

  235. 

  236. func gfPow(a byte, n int) byte {

  237. 	if a == 0 {

  238. 		return 0

  239. 	}

  240. 	return gfExp[(int(gfLog[a])*n)%255]

  241. }

  242. 

  243. // rsEncode encodes 8 data bytes into a 16-byte RS codeword.

  244. func rsEncode(data [rsDataBytes]byte) [rsTotalBytes]byte {

  245. 	var work [rsTotalBytes]byte

  246. 	copy(work[:rsDataBytes], data[:])

  247. 	// Polynomial long division by the generator polynomial.

  248. 	for i := 0; i < rsDataBytes; i++ {

  249. 		fb := work[i]

  250. 		if fb != 0 {

  251. 			for j := 1; j <= rsCheckBytes; j++ {

  252. 				work[i+j] ^= gfMul(rsGen[j], fb)

  253. 			}

  254. 		}

  255. 	}

  256. 	var cw [rsTotalBytes]byte

  257. 	copy(cw[:rsDataBytes], data[:])

  258. 	copy(cw[rsDataBytes:], work[rsDataBytes:])

  259. 	return cw

  260. }

  261. 

  262. // RSDecode recovers 8 data bytes from a (possibly corrupted) 16-byte codeword.

  263. // erasurePositions lists the byte indices (0..15) of symbols with low confidence

  264. // that should be treated as erasures. Up to 8 erasures can be corrected.

  265. // Returns (data, true) on success, (zero, false) on decoding failure.

  266. func RSDecode(recv [rsTotalBytes]byte, erasurePositions []int) ([rsDataBytes]byte, bool) {

  267. 	// Step 1: compute syndromes S[i] = C(α^i) via Horner's method.

  268. 	// The polynomial convention is C(x) = c[0]x^15 + c[1]x^14 + … + c[15],

  269. 	// so byte position j contributes c[j]·(α^i)^(15-j) to S[i].

  270. 	var S [rsCheckBytes]byte

  271. 	for i := 0; i < rsCheckBytes; i++ {

  272. 		var acc byte

  273. 		for _, c := range recv {

  274. 			acc = gfMul(acc, gfPow(2, i)) ^ c

  275. 		}

  276. 		S[i] = acc

  277. 	}

  278. 

  279. 	// Step 2: all syndromes zero → valid codeword.

  280. 	hasErr := false

  281. 	for _, s := range S {

  282. 		if s != 0 {

  283. 			hasErr = true

  284. 			break

  285. 		}

  286. 	}

  287. 	if !hasErr {

  288. 		var out [rsDataBytes]byte

  289. 		copy(out[:], recv[:rsDataBytes])

  290. 		return out, true

  291. 	}

  292. 	ne := len(erasurePositions)

  293. 	if ne == 0 || ne > rsCheckBytes {

  294. 		return [rsDataBytes]byte{}, false

  295. 	}

  296. 

  297. 	// Step 3: Solve for error magnitudes via Vandermonde system.

  298. 	//

  299. 	// Because C(x) = c[0]x^15 + … + c[15], byte position j maps to

  300. 	// polynomial power (15-j). The "locator" for position j is

  301. 	// X_j = α^(15-j). The syndrome equation becomes:

  302. 	//

  303. 	//   S[i] = Σ_k  e_k · X_k^i

  304. 	//

  305. 	// This is a linear system (Vandermonde) in the unknowns e_k.

  306. 	// Solve by Gaussian elimination in GF(2^8).

  307. 

  308. 	// Build locators

  309. 	X := make([]byte, ne)

  310. 	for k, pos := range erasurePositions {

  311. 		X[k] = gfPow(2, rsTotalBytes-1-pos)

  312. 	}

  313. 

  314. 	// Augmented matrix [V | S], ne × (ne+1)

  315. 	mat := make([][]byte, ne)

  316. 	for i := range mat {

  317. 		mat[i] = make([]byte, ne+1)

  318. 		for k := 0; k < ne; k++ {

  319. 			mat[i][k] = gfPow(X[k], i)

  320. 		}

  321. 		mat[i][ne] = S[i]

  322. 	}

  323. 

  324. 	// Gaussian elimination with partial pivoting

  325. 	for col := 0; col < ne; col++ {

  326. 		pivot := -1

  327. 		for row := col; row < ne; row++ {

  328. 			if mat[row][col] != 0 {

  329. 				pivot = row

  330. 				break

  331. 			}

  332. 		}

  333. 		if pivot < 0 {

  334. 			return [rsDataBytes]byte{}, false // singular

  335. 		}

  336. 		mat[col], mat[pivot] = mat[pivot], mat[col]

  337. 		inv := gfInv(mat[col][col])

  338. 		for j := 0; j <= ne; j++ {

  339. 			mat[col][j] = gfMul(mat[col][j], inv)

  340. 		}

  341. 		for row := 0; row < ne; row++ {

  342. 			if row == col {

  343. 				continue

  344. 			}

  345. 			f := mat[row][col]

  346. 			if f == 0 {

  347. 				continue

  348. 			}

  349. 			for j := 0; j <= ne; j++ {

  350. 				mat[row][j] ^= gfMul(f, mat[col][j])

  351. 			}

  352. 		}

  353. 	}

  354. 

  355. 	// Apply corrections

  356. 	result := recv

  357. 	for k := 0; k < ne; k++ {

  358. 		result[erasurePositions[k]] ^= mat[k][ne]

  359. 	}

  360. 

  361. 	// Verify syndromes after correction

  362. 	for i := 0; i < rsCheckBytes; i++ {

  363. 		var acc byte

  364. 		for _, c := range result {

  365. 			acc = gfMul(acc, gfPow(2, i)) ^ c

  366. 		}

  367. 		if acc != 0 {

  368. 			return [rsDataBytes]byte{}, false

  369. 		}

  370. 	}

  371. 

  372. 	var out [rsDataBytes]byte

  373. 	copy(out[:], result[:rsDataBytes])

  374. 	return out, true

  375. }

  376. 

  377. // KeyMatchesPayload returns true if SHA-256(key)[:8] matches payload.

  378. func KeyMatchesPayload(key string, payload [rsDataBytes]byte) bool {

  379. 	h := sha256.Sum256([]byte(key))

  380. 	var expected [rsDataBytes]byte

  381. 	copy(expected[:], h[:rsDataBytes])

  382. 	return expected == payload

  383. }

  384. 

  385. // KeyToPayload returns SHA-256(key)[:8].

  386. func KeyToPayload(key string) [rsDataBytes]byte {

  387. 	var data [rsDataBytes]byte

  388. 	h := sha256.Sum256([]byte(key))

  389. 	copy(data[:], h[:rsDataBytes])

  390. 	return data

  391. }

  392. 

  393. // RSEncode encodes 8 data bytes into a 16-byte RS codeword.

  394. func RSEncode(data [rsDataBytes]byte) [rsTotalBytes]byte {

  395. 	return rsEncode(data)

  396. }

  397. 

  398. // PNChipAt returns the PN chip value at group g, bin b.

  399. func (d *STFTDetector) PNChipAt(g, b int) int8 {

  400. 	return d.pnChips[g][b]

  401. }

  402. 

  403. // GroupBit returns the data bit index for group g.

  404. func (d *STFTDetector) GroupBit(g int) int {

  405. 	return d.groupToBit[g]

  406. }

  407. 

  408. // Constants exported for the recovery tool and legacy tools.

  409. const (

  410. 	PnChips       = pnChips

  411. 	PayloadBits   = payloadBits

  412. 	RsDataBytes   = rsDataBytes

  413. 	RsTotalBytes  = rsTotalBytes

  414. 	RsCheckBytes  = rsCheckBytes

  415. )

  416. 

  417. // PnSequenceAt returns the PN chip value (+1.0 or -1.0) at the given index.

  418. // Used by the decoder for rate-compensated correlation.

  419. func PnSequenceAt(chipIdx int) float64 {

  420. 	return float64(pnSequence[chipIdx%pnChips])

  421. }

  422. 

  423. // PNSequence exposes the raw PN chip values for the chip-rate decoder.

  424. var PNSequence = &pnSequence

  425. 

  426. // CorrelateAt returns the correlation of received samples at the given bit

  427. // position. recRate is the WAV sample rate.

  428. //

  429. // At any recording rate, chips are mapped via ChipRate: each chip spans

  430. // recRate/ChipRate samples. At 48 kHz: 4 samples/chip, 8192 samples/bit.

  431. // At 192 kHz: 16 samples/chip, 32768 samples/bit.

  432. func CorrelateAt(samples []float64, bitStart int, recRate float64) float64 {

  433. 	samplesPerBit := int(float64(pnChips) * recRate / float64(ChipRate))

  434. 	if samplesPerBit < 1 {

  435. 		samplesPerBit = 1

  436. 	}

  437. 	n := samplesPerBit

  438. 	if bitStart+n > len(samples) {

  439. 		n = len(samples) - bitStart

  440. 	}

  441. 	var acc float64

  442. 	for i := 0; i < n; i++ {

  443. 		chipIdx := int(float64(i)*float64(ChipRate)/recRate) % pnChips

  444. 		acc += samples[bitStart+i] * float64(pnSequence[chipIdx])

  445. 	}

  446. 	return acc

  447. }

  448. 

  449. 

  450. // pnSequence is the 2048-chip LFSR-13 spreading code (seed 0x1ACE).

  451. var pnSequence = [pnChips]int8{

  452. 		 1, -1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1, -1, -1,

  453. 		-1, -1, -1,  1, -1,  1,  1, -1,  1,  1, -1,  1,  1,  1, -1,  1,

  454. 		-1, -1,  1,  1,  1,  1,  1, -1, -1,  1,  1,  1,  1, -1,  1, -1,

  455. 		 1, -1,  1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,  1, -1, -1,

  456. 		-1,  1, -1, -1, -1,  1, -1,  1, -1,  1, -1, -1, -1,  1,  1,  1,

  457. 		-1,  1, -1, -1,  1, -1,  1,  1,  1, -1, -1,  1,  1,  1,  1, -1,

  458. 		 1, -1, -1,  1,  1, -1,  1,  1, -1, -1,  1,  1,  1,  1, -1,  1,

  459. 		-1,  1,  1, -1, -1, -1,  1,  1, -1, -1,  1, -1,  1,  1, -1, -1,

  460. 		-1,  1, -1,  1, -1, -1, -1, -1,  1,  1, -1,  1,  1,  1,  1, -1,

  461. 		-1, -1,  1, -1, -1,  1,  1,  1,  1,  1,  1,  1, -1,  1,  1, -1,

  462. 		 1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1,  1,  1,

  463. 		-1, -1,  1, -1, -1,  1, -1,  1,  1,  1,  1,  1,  1, -1,  1, -1,

  464. 		-1, -1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1, -1,  1, -1,

  465. 		 1, -1, -1, -1, -1, -1,  1,  1,  1, -1,  1, -1, -1,  1, -1, -1,

  466. 		-1,  1, -1,  1, -1,  1,  1, -1,  1,  1, -1,  1,  1,  1,  1, -1,

  467. 		-1, -1, -1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1,  1, -1,  1,

  468. 		 1, -1, -1, -1, -1,  1,  1,  1,  1,  1,  1, -1, -1,  1, -1, -1,

  469. 		-1,  1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1,  1,  1,  1,  1,

  470. 		-1,  1, -1,  1,  1, -1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,

  471. 		 1,  1, -1,  1,  1,  1, -1,  1,  1,  1,  1,  1,  1,  1,  1, -1,

  472. 		-1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, -1,  1, -1,  1,

  473. 		-1,  1, -1,  1, -1,  1, -1,  1, -1, -1,  1, -1,  1,  1, -1,  1,

  474. 		-1, -1,  1, -1,  1,  1,  1,  1, -1, -1,  1, -1,  1,  1,  1,  1,

  475. 		-1, -1,  1,  1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1,  1,  1,

  476. 		 1, -1, -1,  1, -1,  1,  1, -1,  1, -1,  1, -1,  1, -1, -1, -1,

  477. 		-1,  1,  1, -1,  1, -1, -1,  1, -1,  1,  1,  1, -1,  1, -1,  1,

  478. 		 1, -1,  1,  1, -1,  1, -1,  1, -1, -1,  1, -1,  1, -1, -1,  1,

  479. 		 1,  1,  1, -1, -1, -1,  1,  1,  1,  1, -1,  1, -1,  1, -1,  1,

  480. 		 1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1,  1, -1,  1,  1,

  481. 		 1,  1,  1, -1, -1, -1,  1,  1,  1,  1, -1, -1,  1,  1, -1, -1,

  482. 		-1,  1, -1,  1, -1,  1, -1, -1, -1, -1, -1,  1, -1, -1,  1, -1,

  483. 		 1,  1, -1,  1,  1,  1, -1,  1, -1, -1, -1, -1,  1,  1, -1,  1,

  484. 		-1,  1, -1, -1,  1, -1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1,

  485. 		-1,  1, -1, -1, -1, -1, -1,  1,  1,  1, -1, -1, -1,  1,  1,  1,

  486. 		-1,  1,  1,  1,  1,  1,  1, -1,  1,  1, -1, -1,  1, -1,  1, -1,

  487. 		 1, -1,  1, -1, -1,  1,  1,  1, -1, -1, -1, -1,  1,  1,  1,  1,

  488. 		-1,  1, -1,  1, -1, -1, -1,  1, -1,  1, -1,  1, -1, -1,  1, -1,

  489. 		 1,  1,  1, -1, -1, -1, -1,  1,  1,  1, -1, -1, -1, -1, -1, -1,

  490. 		 1, -1, -1, -1, -1, -1, -1,  1, -1, -1, -1,  1, -1,  1,  1,  1,

  491. 		-1,  1,  1,  1,  1, -1,  1,  1, -1,  1, -1,  1, -1, -1,  1,  1,

  492. 		-1, -1, -1, -1, -1,  1,  1,  1,  1, -1,  1, -1,  1,  1,  1, -1,

  493. 		 1,  1, -1, -1,  1,  1,  1,  1, -1, -1,  1,  1,  1,  1,  1, -1,

  494. 		 1, -1,  1, -1,  1,  1,  1,  1,  1,  1,  1,  1, -1, -1, -1, -1,

  495. 		 1,  1, -1, -1,  1,  1, -1, -1,  1, -1, -1, -1,  1,  1, -1,  1,

  496. 		 1, -1, -1, -1,  1,  1,  1, -1,  1, -1,  1,  1, -1, -1, -1,  1,

  497. 		-1,  1, -1,  1,  1, -1,  1, -1,  1,  1,  1, -1, -1, -1, -1,  1,

  498. 		 1, -1,  1, -1, -1,  1,  1, -1,  1,  1,  1, -1, -1,  1, -1,  1,

  499. 		 1,  1,  1,  1, -1, -1,  1,  1,  1, -1, -1, -1, -1, -1, -1, -1,

  500. 		-1,  1, -1,  1, -1,  1,  1,  1, -1,  1,  1,  1, -1,  1, -1, -1,

  501. 		 1, -1,  1, -1,  1,  1, -1, -1,  1, -1,  1,  1,  1,  1, -1, -1,

  502. 		-1, -1, -1,  1, -1,  1,  1, -1, -1,  1,  1,  1, -1,  1,  1,  1,

  503. 		 1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1,  1,

  504. 		 1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1, -1, -1,

  505. 		 1,  1, -1,  1, -1, -1, -1, -1, -1,  1, -1, -1, -1, -1, -1,  1,

  506. 		 1,  1, -1,  1,  1,  1,  1, -1,  1,  1,  1, -1, -1,  1,  1,  1,

  507. 		 1,  1,  1,  1, -1, -1,  1,  1,  1, -1, -1,  1,  1, -1, -1,  1,

  508. 		 1,  1, -1, -1,  1,  1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,

  509. 		 1, -1, -1,  1, -1, -1,  1, -1, -1,  1,  1,  1,  1,  1, -1,  1,

  510. 		-1, -1, -1, -1,  1, -1,  1, -1,  1, -1,  1,  1, -1,  1,  1,  1,

  511. 		-1, -1, -1, -1,  1,  1,  1,  1,  1, -1, -1,  1,  1,  1, -1,  1,

  512. 		 1, -1, -1,  1,  1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1, -1,

  513. 		-1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1, -1,  1, -1, -1,  1,

  514. 		 1,  1,  1,  1, -1, -1, -1,  1, -1,  1,  1,  1,  1,  1,  1,  1,

  515. 		 1, -1,  1,  1, -1,  1, -1,  1, -1,  1, -1,  1, -1,  1,  1, -1,

  516. 		-1, -1, -1,  1,  1,  1,  1, -1, -1, -1, -1, -1,  1, -1, -1, -1,

  517. 		-1, -1, -1, -1,  1, -1, -1, -1,  1,  1,  1, -1,  1,  1,  1, -1,

  518. 		 1, -1, -1, -1,  1,  1, -1, -1, -1, -1, -1, -1,  1,  1,  1, -1,

  519. 		 1, -1,  1,  1,  1, -1,  1,  1,  1,  1,  1,  1, -1, -1, -1, -1,

  520. 		-1, -1,  1,  1, -1, -1,  1,  1, -1,  1,  1,  1, -1,  1,  1, -1,

  521. 		-1, -1,  1,  1, -1,  1, -1,  1, -1, -1,  1,  1,  1, -1,  1, -1,

  522. 		 1,  1, -1,  1, -1, -1, -1, -1, -1, -1,  1,  1,  1,  1,  1, -1,

  523. 		-1, -1,  1, -1, -1, -1,  1,  1, -1, -1,  1,  1,  1, -1,  1, -1,

  524. 		-1, -1,  1,  1, -1,  1,  1, -1, -1,  1, -1,  1,  1,  1, -1, -1,

  525. 		 1, -1,  1, -1, -1, -1, -1,  1,  1, -1, -1, -1,  1,  1,  1,  1,

  526. 		-1,  1,  1,  1,  1,  1, -1,  1,  1, -1, -1,  1,  1,  1,  1,  1,

  527. 		 1,  1,  1, -1, -1,  1, -1, -1,  1,  1, -1, -1,  1,  1, -1, -1,

  528. 		-1,  1,  1,  1, -1, -1,  1, -1, -1,  1,  1,  1, -1,  1, -1,  1,

  529. 		-1, -1, -1, -1,  1, -1,  1, -1,  1,  1, -1,  1, -1, -1, -1,  1,

  530. 		-1,  1,  1, -1,  1, -1,  1,  1, -1,  1,  1,  1,  1, -1, -1,  1,

  531. 		-1,  1,  1, -1, -1, -1, -1, -1, -1, -1,  1, -1,  1,  1, -1, -1,

  532. 		-1,  1, -1, -1, -1,  1, -1,  1,  1, -1, -1, -1,  1, -1,  1,  1,

  533. 		 1, -1, -1, -1, -1, -1,  1, -1, -1,  1, -1,  1, -1,  1,  1,  1,

  534. 		-1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1,  1,

  535. 		 1, -1, -1, -1, -1,  1, -1,  1, -1, -1,  1, -1,  1, -1, -1, -1,

  536. 		 1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1, -1,  1,  1,  1,  1,

  537. 		 1, -1, -1,  1, -1,  1,  1,  1, -1, -1,  1,  1, -1, -1, -1,  1,

  538. 		 1,  1,  1,  1,  1, -1,  1, -1,  1,  1,  1, -1, -1,  1,  1, -1,

  539. 		-1,  1, -1,  1,  1, -1, -1,  1, -1, -1,  1,  1,  1, -1, -1, -1,

  540. 		-1, -1,  1, -1,  1,  1,  1,  1,  1,  1, -1,  1,  1,  1, -1, -1,

  541. 		-1, -1, -1, -1, -1, -1, -1,  1,  1, -1, -1, -1,  1, -1, -1, -1,

  542. 		 1, -1, -1, -1, -1, -1,  1, -1, -1,  1, -1, -1, -1, -1,  1, -1,

  543. 		-1, -1,  1,  1,  1, -1, -1, -1,  1, -1, -1,  1, -1, -1, -1, -1,

  544. 		-1, -1,  1, -1, -1,  1, -1, -1,  1, -1, -1, -1,  1, -1, -1,  1,

  545. 		-1, -1,  1, -1, -1,  1, -1, -1, -1, -1,  1, -1,  1,  1,  1,  1,

  546. 		-1,  1, -1, -1, -1,  1, -1,  1,  1, -1, -1,  1,  1,  1,  1, -1,

  547. 		 1,  1, -1,  1, -1,  1,  1,  1,  1,  1,  1,  1, -1, -1,  1, -1,

  548. 		 1,  1, -1, -1,  1,  1, -1, -1,  1, -1, -1,  1, -1,  1, -1, -1,

  549. 		-1, -1, -1,  1, -1,  1,  1,  1,  1, -1, -1, -1,  1, -1, -1, -1,

  550. 		-1,  1,  1, -1, -1,  1, -1, -1, -1, -1,  1, -1, -1, -1, -1, -1,

  551. 		 1, -1,  1,  1,  1, -1,  1, -1, -1, -1,  1, -1, -1,  1, -1,  1,

  552. 		-1,  1,  1, -1,  1,  1,  1,  1, -1,  1, -1, -1,  1, -1,  1, -1,

  553. 		-1,  1,  1, -1, -1, -1, -1,  1, -1,  1,  1, -1,  1,  1, -1, -1,

  554. 		-1,  1, -1, -1,  1, -1,  1, -1, -1,  1,  1,  1, -1,  1, -1, -1,

  555. 		-1, -1,  1,  1,  1, -1, -1,  1,  1,  1,  1, -1,  1,  1,  1,  1,

  556. 		 1,  1, -1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1, -1, -1,

  557. 		-1,  1,  1,  1,  1,  1, -1,  1, -1,  1,  1,  1, -1,  1, -1,  1,

  558. 		-1,  1, -1, -1,  1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1,

  559. 		-1,  1, -1,  1,  1, -1, -1, -1, -1,  1, -1,  1,  1,  1,  1, -1,

  560. 		-1,  1, -1, -1, -1,  1,  1,  1,  1,  1,  1,  1, -1,  1, -1, -1,

  561. 		-1,  1,  1, -1, -1,  1,  1, -1, -1, -1, -1,  1, -1, -1,  1,  1,

  562. 		 1, -1, -1,  1, -1, -1, -1,  1,  1,  1, -1, -1,  1,  1,  1, -1,

  563. 		-1, -1,  1, -1,  1, -1,  1,  1,  1,  1,  1,  1, -1,  1,  1, -1,

  564. 		 1, -1, -1,  1,  1, -1, -1,  1,  1,  1,  1,  1, -1, -1, -1,  1,

  565. 		 1, -1,  1,  1, -1, -1,  1,  1, -1,  1,  1,  1,  1,  1, -1, -1,

  566. 		 1, -1, -1,  1,  1,  1,  1,  1,  1,  1,  1, -1,  1, -1, -1, -1,

  567. 		-1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1, -1,  1,  1,  1, -1,

  568. 		 1,  1,  1, -1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1,  1, -1,

  569. 		-1,  1, -1,  1,  1,  1,  1,  1, -1, -1, -1, -1,  1, -1,  1,  1,

  570. 		-1, -1,  1,  1, -1,  1,  1,  1, -1, -1, -1, -1, -1,  1, -1,  1,

  571. 		-1, -1,  1,  1, -1,  1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,

  572. 		 1,  1,  1,  1,  1, -1, -1, -1,  1,  1,  1, -1, -1,  1,  1, -1,

  573. 		-1,  1, -1, -1, -1, -1, -1, -1,  1, -1,  1, -1, -1, -1, -1,  1,

  574. 		-1, -1, -1,  1, -1,  1,  1, -1,  1,  1,  1, -1, -1, -1,  1, -1,

  575. 		 1,  1, -1, -1, -1, -1, -1, -1,  1, -1, -1,  1, -1,  1, -1, -1,

  576. 		-1,  1, -1, -1, -1, -1,  1, -1,  1,  1, -1,  1,  1,  1,  1, -1,

  577. 		 1,  1,  1,  1, -1, -1,  1, -1,  1, -1,  1, -1, -1,  1,  1, -1,

  578. 		-1, -1,  1,  1,  1,  1, -1, -1, -1,  1,  1, -1,  1,  1,  1,  1,

  579. 		 1,  1,  1, -1,  1,  1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  580. }

  581. 

  582. // GF(2^8) tables with primitive polynomial 0x11d.

  583. var gfExp = [512]byte{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, 142, 1, 2}

  584. var gfLog = [256]byte{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}

  585. var rsGen = [9]byte{1, 255, 11, 81, 54, 239, 173, 200, 24}

  586. 

  587. 

  588. // rsGen is the RS(16,8) generator polynomial coefficients (fcr=0).