Alfred
/
fm-rds-tx
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 6 Wiki Aktivita
Go-based FM stereo transmitter with RDS, Windows-first and cross-platform
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
176 Revize
1 Větev
37MB
Strom: e1329a864c
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „e1329a864c“
${ noResults }
fm-rds-tx/internal/watermark/watermark.go

524 řádky
24KB
Surový Blame Historie 

  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 (Fix B) before stereo

  6. // encoding, so it survives FM broadcast and receiver demodulation intact.

  7. // The payload is Reed-Solomon encoded (Fix C) for robust recovery even when

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

  9. //

  10. // # Parameters

  11. //

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

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

  14. //   - Frame period: ~5.5 s at 228 kHz composite (repeats ~11×/min)

  15. //   - Injection: -48 dBFS on audio L+R before stereo encode (gated on audio level)

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

  17. //

  18. // # Recovery (cmd/wmdecode)

  19. //

  20. //  1. Record FM receiver audio output as mono WAV (48 kHz preferred).

  21. //  2. Phase search: slide a single-bit PN template across [0, samplesPerBit)

  22. //     to find chip-aligned sample offset (coarse-fine search).

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

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

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

  26. //  5. Sort bits by |correlation| (confidence). Mark weakest as erasures.

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

  28. package watermark

  29. 

  30. import (

  31. 	"crypto/sha256"

  32. )

  33. 

  34. const (

  35. 	// pnChips is the spreading factor — PN chips per data bit at composite rate.

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

  37. 	pnChips = 2048

  38. 

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

  40. 	rsDataBytes = 8

  41. 

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

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

  44. 	rsCheckBytes = 8

  45. 

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

  47. 	rsTotalBytes = rsDataBytes + rsCheckBytes // 16

  48. 

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

  50. 	payloadBits = rsTotalBytes * 8 // 128

  51. 

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

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

  54. 	Level = 0.004

  55. 

  56. 	// CompositeRate is the sample rate at which the watermark was embedded.

  57. 	// The recovery tool uses this to compute fractional chip indices.

  58. 	CompositeRate = 228000

  59. )

  60. 

  61. // RecordingRate is the canonical recording rate used for chip-rate Bresenham stepping.

  62. // The embedder advances chips at this rate, so the decoder at this rate sees

  63. // exactly pnChips samples per bit with no fractional-stepping errors.

  64. const RecordingRate = 48000

  65. 

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

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

  68. type Embedder struct {

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

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

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

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

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

  74. 

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

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

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

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

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

  80. 	gateEnabled   bool

  81. }

  82. 

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

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

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

  86. func NewEmbedder(key string) *Embedder {

  87. 	var data [rsDataBytes]byte

  88. 	if key != "" {

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

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

  91. 	}

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

  93. 	e.codeword = rsEncode(data)

  94. 	e.loadSymbol()

  95. 	return e

  96. }

  97. 

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

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

  100. //

  101. // The chip index advances using Bresenham stepping at RecordingRate/CompositeRate,

  102. // so each chip occupies exactly CompositeRate/RecordingRate composite samples on

  103. // average. A decoder recording at RecordingRate (48 kHz) sees exactly pnChips

  104. // samples per data bit, enabling simple integer-stride correlation.

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

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

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

  108. 

  109. 	// Bresenham: advance chip once per RecordingRate/CompositeRate composite samples.

  110. 	e.accum += RecordingRate

  111. 	if e.accum >= CompositeRate {

  112. 		e.accum -= CompositeRate

  113. 		e.chipIdx++

  114. 		if e.chipIdx >= pnChips {

  115. 			e.chipIdx = 0

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

  117. 			e.loadSymbol()

  118. 		}

  119. 	}

  120. 	return sample

  121. }

  122. 

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

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

  125. 	byteIdx := e.bitIdx / 8

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

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

  128. 		e.symbol = 1

  129. 	} else {

  130. 		e.symbol = -1

  131. 	}

  132. }

  133. 

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

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

  136. 	const hx = "0123456789abcdef"

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

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

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

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

  141. 	}

  142. 	return string(out)

  143. }

  144. 

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

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

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

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

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

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

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

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

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

  154. 	if attackSamples < 1 {

  155. 		attackSamples = 1

  156. 	}

  157. 	if releaseSamples < 1 {

  158. 		releaseSamples = 1

  159. 	}

  160. 	e.gateThreshold = threshold

  161. 	e.gateRampUp = 1.0 / attackSamples

  162. 	e.gateRampDown = 1.0 / releaseSamples

  163. 	e.gateEnabled = true

  164. }

  165. 

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

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

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

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

  170. 	if !e.gateEnabled {

  171. 		return

  172. 	}

  173. 	if absLevel > e.gateThreshold {

  174. 		e.gateGain += e.gateRampUp

  175. 		if e.gateGain > 1.0 {

  176. 			e.gateGain = 1.0

  177. 		}

  178. 	} else {

  179. 		e.gateGain -= e.gateRampDown

  180. 		if e.gateGain < 0.0 {

  181. 			e.gateGain = 0.0

  182. 		}

  183. 	}

  184. }

  185. 

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

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

  188. 

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

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

  191. 		return 0

  192. 	}

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

  194. }

  195. 

  196. func gfInv(a byte) byte {

  197. 	if a == 0 {

  198. 		return 0

  199. 	}

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

  201. }

  202. 

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

  204. 	if a == 0 {

  205. 		return 0

  206. 	}

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

  208. }

  209. 

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

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

  212. 	var work [rsTotalBytes]byte

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

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

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

  216. 		fb := work[i]

  217. 		if fb != 0 {

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

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

  220. 			}

  221. 		}

  222. 	}

  223. 	var cw [rsTotalBytes]byte

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

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

  226. 	return cw

  227. }

  228. 

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

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

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

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

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

  234. 	// Step 1: compute syndromes.

  235. 	var S [rsCheckBytes]byte

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

  237. 		var acc byte

  238. 		for _, c := range recv {

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

  240. 		}

  241. 		S[i] = acc

  242. 	}

  243. 

  244. 	// Step 2: if no erasures and all syndromes zero, no errors.

  245. 	hasErr := false

  246. 	for _, s := range S {

  247. 		if s != 0 {

  248. 			hasErr = true

  249. 			break

  250. 		}

  251. 	}

  252. 	if !hasErr && len(erasurePositions) == 0 {

  253. 		// Valid codeword, no errors, no erasures.

  254. 		var out [rsDataBytes]byte

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

  256. 		return out, true

  257. 	}

  258. 	if hasErr && len(erasurePositions) == 0 {

  259. 		// Errors present but no erasure positions supplied — cannot correct.

  260. 		// BUG FIX: previously fell through to ne==0 check and returned wrong

  261. 		// data as correct. Now correctly signals failure so the caller can

  262. 		// retry with erasure positions.

  263. 		return [rsDataBytes]byte{}, false

  264. 	}

  265. 

  266. 	// Step 3: erasure locator polynomial Γ(x) = ∏(1 - α^(e_j)·x).

  267. 	gamma := []byte{1}

  268. 	for _, pos := range erasurePositions {

  269. 		// multiply gamma by (1 + α^pos · x)

  270. 		alpha := gfPow(2, pos)

  271. 		next := make([]byte, len(gamma)+1)

  272. 		for j, g := range gamma {

  273. 			next[j] ^= g

  274. 			next[j+1] ^= gfMul(g, alpha)

  275. 		}

  276. 		gamma = next

  277. 	}

  278. 

  279. 	// Step 4: modified syndrome T(x) = S(x)·Γ(x).

  280. 	t := make([]byte, rsCheckBytes)

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

  282. 		var acc byte

  283. 		for j := 0; j < len(gamma) && j <= i; j++ {

  284. 			if i-j < rsCheckBytes {

  285. 				acc ^= gfMul(gamma[j], S[i-j])

  286. 			}

  287. 		}

  288. 		t[i] = acc

  289. 	}

  290. 

  291. 	// Step 5: compute error magnitudes using Forney's formula.

  292. 	// For erasure-only decoding (no additional errors), the error locator

  293. 	// is Γ itself. Evaluate omega = T mod x^(ne) where ne = len(erasures).

  294. 	ne := len(erasurePositions)

  295. 	if ne == 0 {

  296. 		// Should not be reachable: handled above. Fail safely.

  297. 		return [rsDataBytes]byte{}, false

  298. 	}

  299. 	if ne > rsCheckBytes {

  300. 		return [rsDataBytes]byte{}, false

  301. 	}

  302. 

  303. 	result := recv

  304. 	for _, pos := range erasurePositions {

  305. 		xi := gfPow(2, pos)

  306. 		// Evaluate omega at xi^-1.

  307. 		xiInv := gfInv(xi)

  308. 		var omega byte

  309. 		for j := 0; j < ne && j < rsCheckBytes; j++ {

  310. 			omega ^= gfMul(t[j], gfPow(xiInv, j))

  311. 		}

  312. 		// Formal derivative of gamma at xi^-1 (only odd-degree terms survive in GF(2)).

  313. 		var gammaPrime byte

  314. 		for j := 1; j < len(gamma); j += 2 {

  315. 			gammaPrime ^= gfMul(gamma[j], gfPow(xiInv, j-1))

  316. 		}

  317. 		if gammaPrime == 0 {

  318. 			return [rsDataBytes]byte{}, false

  319. 		}

  320. 		magnitude := gfMul(omega, gfInv(gammaPrime))

  321. 		result[pos] ^= magnitude

  322. 	}

  323. 

  324. 	// Verify syndromes after correction.

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

  326. 		var acc byte

  327. 		for _, c := range result {

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

  329. 		}

  330. 		if acc != 0 {

  331. 			return [rsDataBytes]byte{}, false

  332. 		}

  333. 	}

  334. 

  335. 	var out [rsDataBytes]byte

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

  337. 	return out, true

  338. }

  339. 

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

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

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

  343. 	var expected [rsDataBytes]byte

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

  345. 	return expected == payload

  346. }

  347. 

  348. // Constants exported for the recovery tool.

  349. const (

  350. 	PnChips       = pnChips

  351. 	PayloadBits   = payloadBits

  352. 	RsDataBytes   = rsDataBytes

  353. 	RsTotalBytes  = rsTotalBytes

  354. 	RsCheckBytes  = rsCheckBytes

  355. )

  356. 

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

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

  359. //

  360. // At recRate = RecordingRate (48000 Hz) the chip stride is exactly 1 — the

  361. // embedder was designed for this rate. At other rates the chip index is

  362. // scaled proportionally (still works with enough frame averaging).

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

  364. 	// Samples per bit at the canonical recording rate.

  365. 	// At RecordingRate: samplesPerBit = pnChips (integer, perfect).

  366. 	// At other rates: scale proportionally.

  367. 	samplesPerBit := int(float64(pnChips) * recRate / float64(RecordingRate))

  368. 	if samplesPerBit < 1 {

  369. 		samplesPerBit = 1

  370. 	}

  371. 	n := samplesPerBit

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

  373. 		n = len(samples) - bitStart

  374. 	}

  375. 	var acc float64

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

  377. 		// Map recording-rate sample index to chip index.

  378. 		chipIdx := int(float64(i)*float64(RecordingRate)/recRate) % pnChips

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

  380. 	}

  381. 	return acc

  382. }

  383. 

  384. 

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

  386. var pnSequence = [pnChips]int8{

  387. 		 1, -1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1, -1, -1,

  388. 		-1, -1, -1,  1, -1,  1,  1, -1,  1,  1, -1,  1,  1,  1, -1,  1,

  389. 		-1, -1,  1,  1,  1,  1,  1, -1, -1,  1,  1,  1,  1, -1,  1, -1,

  390. 		 1, -1,  1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,  1, -1, -1,

  391. 		-1,  1, -1, -1, -1,  1, -1,  1, -1,  1, -1, -1, -1,  1,  1,  1,

  392. 		-1,  1, -1, -1,  1, -1,  1,  1,  1, -1, -1,  1,  1,  1,  1, -1,

  393. 		 1, -1, -1,  1,  1, -1,  1,  1, -1, -1,  1,  1,  1,  1, -1,  1,

  394. 		-1,  1,  1, -1, -1, -1,  1,  1, -1, -1,  1, -1,  1,  1, -1, -1,

  395. 		-1,  1, -1,  1, -1, -1, -1, -1,  1,  1, -1,  1,  1,  1,  1, -1,

  396. 		-1, -1,  1, -1, -1,  1,  1,  1,  1,  1,  1,  1, -1,  1,  1, -1,

  397. 		 1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1,  1,  1,

  398. 		-1, -1,  1, -1, -1,  1, -1,  1,  1,  1,  1,  1,  1, -1,  1, -1,

  399. 		-1, -1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1, -1,  1, -1,

  400. 		 1, -1, -1, -1, -1, -1,  1,  1,  1, -1,  1, -1, -1,  1, -1, -1,

  401. 		-1,  1, -1,  1, -1,  1,  1, -1,  1,  1, -1,  1,  1,  1,  1, -1,

  402. 		-1, -1, -1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1,  1, -1,  1,

  403. 		 1, -1, -1, -1, -1,  1,  1,  1,  1,  1,  1, -1, -1,  1, -1, -1,

  404. 		-1,  1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1,  1,  1,  1,  1,

  405. 		-1,  1, -1,  1,  1, -1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,

  406. 		 1,  1, -1,  1,  1,  1, -1,  1,  1,  1,  1,  1,  1,  1,  1, -1,

  407. 		-1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, -1,  1, -1,  1,

  408. 		-1,  1, -1,  1, -1,  1, -1,  1, -1, -1,  1, -1,  1,  1, -1,  1,

  409. 		-1, -1,  1, -1,  1,  1,  1,  1, -1, -1,  1, -1,  1,  1,  1,  1,

  410. 		-1, -1,  1,  1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1,  1,  1,

  411. 		 1, -1, -1,  1, -1,  1,  1, -1,  1, -1,  1, -1,  1, -1, -1, -1,

  412. 		-1,  1,  1, -1,  1, -1, -1,  1, -1,  1,  1,  1, -1,  1, -1,  1,

  413. 		 1, -1,  1,  1, -1,  1, -1,  1, -1, -1,  1, -1,  1, -1, -1,  1,

  414. 		 1,  1,  1, -1, -1, -1,  1,  1,  1,  1, -1,  1, -1,  1, -1,  1,

  415. 		 1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1,  1, -1,  1,  1,

  416. 		 1,  1,  1, -1, -1, -1,  1,  1,  1,  1, -1, -1,  1,  1, -1, -1,

  417. 		-1,  1, -1,  1, -1,  1, -1, -1, -1, -1, -1,  1, -1, -1,  1, -1,

  418. 		 1,  1, -1,  1,  1,  1, -1,  1, -1, -1, -1, -1,  1,  1, -1,  1,

  419. 		-1,  1, -1, -1,  1, -1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1,

  420. 		-1,  1, -1, -1, -1, -1, -1,  1,  1,  1, -1, -1, -1,  1,  1,  1,

  421. 		-1,  1,  1,  1,  1,  1,  1, -1,  1,  1, -1, -1,  1, -1,  1, -1,

  422. 		 1, -1,  1, -1, -1,  1,  1,  1, -1, -1, -1, -1,  1,  1,  1,  1,

  423. 		-1,  1, -1,  1, -1, -1, -1,  1, -1,  1, -1,  1, -1, -1,  1, -1,

  424. 		 1,  1,  1, -1, -1, -1, -1,  1,  1,  1, -1, -1, -1, -1, -1, -1,

  425. 		 1, -1, -1, -1, -1, -1, -1,  1, -1, -1, -1,  1, -1,  1,  1,  1,

  426. 		-1,  1,  1,  1,  1, -1,  1,  1, -1,  1, -1,  1, -1, -1,  1,  1,

  427. 		-1, -1, -1, -1, -1,  1,  1,  1,  1, -1,  1, -1,  1,  1,  1, -1,

  428. 		 1,  1, -1, -1,  1,  1,  1,  1, -1, -1,  1,  1,  1,  1,  1, -1,

  429. 		 1, -1,  1, -1,  1,  1,  1,  1,  1,  1,  1,  1, -1, -1, -1, -1,

  430. 		 1,  1, -1, -1,  1,  1, -1, -1,  1, -1, -1, -1,  1,  1, -1,  1,

  431. 		 1, -1, -1, -1,  1,  1,  1, -1,  1, -1,  1,  1, -1, -1, -1,  1,

  432. 		-1,  1, -1,  1,  1, -1,  1, -1,  1,  1,  1, -1, -1, -1, -1,  1,

  433. 		 1, -1,  1, -1, -1,  1,  1, -1,  1,  1,  1, -1, -1,  1, -1,  1,

  434. 		 1,  1,  1,  1, -1, -1,  1,  1,  1, -1, -1, -1, -1, -1, -1, -1,

  435. 		-1,  1, -1,  1, -1,  1,  1,  1, -1,  1,  1,  1, -1,  1, -1, -1,

  436. 		 1, -1,  1, -1,  1,  1, -1, -1,  1, -1,  1,  1,  1,  1, -1, -1,

  437. 		-1, -1, -1,  1, -1,  1,  1, -1, -1,  1,  1,  1, -1,  1,  1,  1,

  438. 		 1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1,  1,

  439. 		 1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1, -1, -1,

  440. 		 1,  1, -1,  1, -1, -1, -1, -1, -1,  1, -1, -1, -1, -1, -1,  1,

  441. 		 1,  1, -1,  1,  1,  1,  1, -1,  1,  1,  1, -1, -1,  1,  1,  1,

  442. 		 1,  1,  1,  1, -1, -1,  1,  1,  1, -1, -1,  1,  1, -1, -1,  1,

  443. 		 1,  1, -1, -1,  1,  1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,

  444. 		 1, -1, -1,  1, -1, -1,  1, -1, -1,  1,  1,  1,  1,  1, -1,  1,

  445. 		-1, -1, -1, -1,  1, -1,  1, -1,  1, -1,  1,  1, -1,  1,  1,  1,

  446. 		-1, -1, -1, -1,  1,  1,  1,  1,  1, -1, -1,  1,  1,  1, -1,  1,

  447. 		 1, -1, -1,  1,  1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1, -1,

  448. 		-1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1, -1,  1, -1, -1,  1,

  449. 		 1,  1,  1,  1, -1, -1, -1,  1, -1,  1,  1,  1,  1,  1,  1,  1,

  450. 		 1, -1,  1,  1, -1,  1, -1,  1, -1,  1, -1,  1, -1,  1,  1, -1,

  451. 		-1, -1, -1,  1,  1,  1,  1, -1, -1, -1, -1, -1,  1, -1, -1, -1,

  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. }

  516. 

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

  518. 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}

  519. 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}

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

  521. 

  522. 

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