#)diPdZddlZddlZ eean#e$r ddlmZd5daYnwxYw en #e$reZYnwxYwGdde Z t dgd za t d a e d ad Zd6dZd7dZdZdZdZdZdZdZdZd8dZd9dZdZdZdZd Zd!Zd"Z d#Z!d$Z"d:d%Z#d:d&Z$d;d'Z%d;d(Z&d:d)Z'd:d*Z(dd0Z.d>d1Z/d:d2Z0Gd3d4e1Z2dS)?uW Reed Solomon ============ A pure-python `universal errors-and-erasures Reed-Solomon Codec `_ , based on the wonderful tutorial at `wikiversity `_, written by "Bobmath" and "LRQ3000". The code of wikiversity is here consolidated into a nice API with exceptions handling. The algorithm can correct up to 2*e+v <= nsym, where e is the number of errors, v the number of erasures and nsym = n-k = the number of ECC (error correction code) symbols. This means that you can either correct exactly floor(nsym/2) errors, or nsym erasures (errors where you know the position), and a combination of both errors and erasures. The code should work on pretty much any reasonable version of python (2.4-3.5), but I'm only testing on 2.7 - 3.4. .. note:: The codec is universal, meaning that it can decode any message encoded by another RS encoder as long as you provide the correct parameters. Note however that if you use higher fields (ie, bigger c_exp), the algorithms will be slower, first because we cannot then use the optimized bytearray() structure but only array.array('i', ...), and also because Reed-Solomon's complexity is quadratic (both in encoding and decoding), so this means that the longer your messages, the longer it will take to encode/decode (quadratically!). The algorithm itself can handle messages up to (2^c_exp)-1 symbols, including the ECC symbols, and each symbol can have a value of up to (2^c_exp)-1 (indeed, both the message length and the maximum value for one character is constrained by the same mathematical reason). By default, we use the field GF(2^8), which means that you are limited to values between 0 and 255 (perfect to represent a single hexadecimal symbol on computers, so you can encode any binary stream) and limited to messages+ecc of maximum length 255. However, you can "chunk" longer messages to fit them into the message length limit. The ``RSCodec`` class will automatically apply chunking, by splitting longer messages into chunks and encode/decode them separately; it shouldn't make a difference from an API perspective (ie, from your POV). :: # Initialization >>> from reedsolo import RSCodec >>> rsc = RSCodec(10) # 10 ecc symbols # Encoding >>> rsc.encode([1,2,3,4]) b',+=øhú˜M' >>> rsc.encode(bytearray([1,2,3,4])) bytearray(b',+=øhú˜M') >>> rsc.encode(b'hello world') b'hello worldí%TÄýý‰ó¨ª' # Note that chunking is supported transparently to encode any string length. # Decoding (repairing) >>> rsc.decode(b'hello worldí%TÄýý‰ó¨ª')[0] b'hello world' >>> rsc.decode(b'heXlo worXdí%TÄýX‰ó¨ª')[0] # 3 errors b'hello world' >>> rsc.decode(b'hXXXo worXdí%TÄýX‰ó¨ª')[0] # 5 errors b'hello world' >>> rsc.decode(b'hXXXo worXdí%TÄýXXó¨ª')[0] # 6 errors - fail Traceback (most recent call last): ... ReedSolomonError: Could not locate error >>> rsc = RSCodec(12) # using 2 more ecc symbols (to correct max 6 errors or 12 erasures) >>> rsc.encode(b'hello world') b'hello world?Ay²¼Üq¹ãâ=' >>> rsc.decode(b'hello worXXXXy²XXq¹ãâ=')[0] # 6 errors - ok b'hello world' >>> rsc.decode(b'helXXXXXXXXXXy²XXq¹ãâ=', erase_pos=[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16])[0] # 12 erasures - OK b'hello world' # Checking >> rsc.check(b'hello worXXXXy²XXq¹ãâ=') [False] >> rmes, rmesecc = rsc.decode(b'hello worXXXXy²XXq¹ãâ=') >> rsc.check(rmesecc) [True] # To use longer chunks or bigger values than 255 (may be very slow) >> rsc = RSCodec(12, nsize=4095) # always use a power of 2 minus 1 >> rsc = RSCodec(12, c_exp=12) # alternative way to set nsize=4095 >> mes = 'a' * (4095-12) >> mesecc = rsc.encode(mes) >> mesecc[2] = 1 >> mesecc[-1] = 1 >> rmes, rmesecc = rsc.decode(mesecc) >> rsc.check(mesecc) [False] >> rsc.check(rmesecc) [True] If you want full control, you can skip the API and directly use the library as-is. Here's how: First you need to init the precomputed tables: >> import reedsolo as rs >> rs.init_tables(0x11d) Pro tip: if you get the error: ValueError: byte must be in range(0, 256), please check that your prime polynomial is correct for your field. Pro tip2: by default, you can only encode messages of max length and max symbol value = 256. If you want to encode bigger messages, please use the following (where c_exp is the exponent of your Galois Field, eg, 12 = max length 2^12 = 4096): >> prim = rs.find_prime_polys(c_exp=12, fast_primes=True, single=True) >> rs.init_tables(c_exp=12, prim=prim) Let's define our RS message and ecc size: >> n = 255 # length of total message+ecc >> nsym = 12 # length of ecc >> mes = "a" * (n-nsym) # generate a sample message To optimize, you can precompute the generator polynomial: >> gen = rs.rs_generator_poly_all(n) Then to encode: >> mesecc = rs.rs_encode_msg(mes, nsym, gen=gen[nsym]) Let's tamper our message: >> mesecc[1] = 0 To decode: >> rmes, recc, errata_pos = rs.rs_correct_msg(mesecc, nsym, erase_pos=erase_pos) Note that both the message and the ecc are corrected (if possible of course). Pro tip: if you know a few erasures positions, you can specify them in a list `erase_pos` to double the repair power. But you can also just specify an empty list. If the decoding fails, it will normally automatically check and raise a ReedSolomonError exception that you can handle. However if you want to manually check if the repaired message is correct, you can do so: >> rs.rs_check(rmes + recc, nsym) Note: if you want to use multiple reedsolomon with different parameters, you need to backup the globals and restore them before calling reedsolo functions: >> rs.init_tables() >> global gf_log, gf_exp, field_charac >> bak_gf_log, bak_gf_exp, bak_field_charac = gf_log, gf_exp, field_charac Then at anytime, you can do: >> global gf_log, gf_exp, field_charac >> gf_log, gf_exp, field_charac = bak_gf_log, bak_gf_exp, bak_field_charac >> mesecc = rs.rs_encode_msg(mes, nsym) >> rmes, recc, errata_pos = rs.rs_correct_msg(mesecc, nsym) The globals backup is not necessary if you use RSCodec, it will be automatically managed. Read the sourcecode's comments for more info about how it works, and for the various parameters you can setup if you need to interface with other RS codecs. Narraylatin-1ct|tr d||D}nt|trdg|z}t d|S)zSimple bytearray replacementc,g|]}t|Sord).0chs O/var/www/menimich/repos/protonApp/venv/lib/python3.11/site-packages/reedsolo.py z_bytearray..s:::r3r77:::rB) isinstancestrencodeintr)objencodings r _bytearrayrsb c3   ::SZZ%9%9:::CC S ! ! #)CS#rceZdZdS)ReedSolomonErrorN)__name__ __module__ __qualname__rrr rrsDrric dgt|dz ztdt|dzdzdD]X}t|dz r>dgt|||zz dz d|zz dzzt||zdz d|<Ydgfdtdt|dz DzS) z Returns a list of primes < n Tg?rFNc0g|]}| d|zdzS)r!rr)r isieves r rzrwh_primes1..s*@@@AuQx@!A#a%@@@r)rxrange)nr$r%s @r rwh_primes1r(sFS1XX E Ac!S&kk!mA & &FF QqS? F&+WsAacE!Gac?13D/E/E%EE#qsAg,,// " 3@@@@#ac((!3!3@@@ @@rr!Fc  d}t||zdz  t||dzzdz }g}|rt|} fd|D}nt dz||}g}|D]w}t dz} d} d} t D]2} t | || dz} | ks | | dkrd} nd| | <3| s|||r|cSx|S)zgCompute the list of prime polynomials for the given generator and galois field characteristic exponent.r!rc g|] }|k| Srr)r x field_characs r rz$find_prime_polys..s#JJJ\9I9I19I9I9IrFT)rr(r&r gf_mult_noLUTappend) generatorc_exp fast_primessingle root_characfield_charac_nextprim_candidatescorrect_primesprimseenconflictr,r$r-s @r find_prime_polysr;sPK{E)A-..LK%'2Q677OQ%&788JJJJoJJJ a1BKPPN##,q.))  %%  AaD,q.AAA<47a<<Q #  ! !$ ' ' ' "d{{{ rc|dkrtan ddlmdfd atd|zdz attdzattdzad}ttD]0}|t |<|t |<t|||tdz}1tttdzD]}t |tz t |< t t tgS) a-Precompute the logarithm and anti-log tables for faster computation later, using the provided primitive polynomial. These tables are used for multiplication/division since addition/substraction are simple XOR operations inside GF of characteristic 2. The basic idea is quite simple: since b**(log_b(x), log_b(y)) == x * y given any number b (the base or generator of the logarithm), then we can use any number b to precompute logarithm and anti-log (exponentiation) tables to use for multiplying two numbers x and y. That's why when we use a different base/generator number, the log and anti-log tables are drastically different, but the resulting computations are the same given any such tables. For more infos, see https://en.wikipedia.org/wiki/Finite_field_arithmetic#Implementation_tricks r)rrrct|trb||}t|tr d|D}nht|tr d|D}nFtdft|t rdg|z}n!t|tr d|D}d|S)z;Fake bytearray replacement, supporting int values above 255c,g|]}t|Srr r chrs r rz_bytearray..3333s88333rc,g|]}t|Srrr@s r rz_bytearray..rBrzType of object not recognized!rc,g|]}t|SrrD)r bs r rz_bytearray..s+++!s1vv+++rr$)rrrbytes ValueErrorr)rrrs r rr s#s## ,jj**c3''H33s333CCU++H33s333CC$&FGGC%% ,cCiC'' ,++s+++5c?? "rr!rrr) bytearrayrrrr-gf_expgf_logr&r.)r8r0r1r,r$rs @r init_tablesrMs  zz  # # # # # #(q%x!|$$L  q( ) )F  Q ' 'F A L ! !>>q q !Yl1n = =L,"2 3 3--1|+,q FL ))rc ||z SNrr,ys r gf_addrR5 q5Lrc ||z SrOrrPs r gf_subrU8rSrc|SrOrr,s r gf_negrX;s HrcBttt|z SrO)rKr-rLrWs r gf_inverserZ>s ,* ++rcz|dks|dkrdStt|t|ztzSNrrKrLr-rPs r gf_mulr^As5Avvaq 6!9vay(L8 99rc|dkrt|dkrdStt|tzt|z tzSr\)ZeroDivisionErrorrKrLr-rPs r gf_divraFsGAvv!!!Avvq 6!9|+fQi7<G HHrcHtt||ztzSrOr])r,powers r gf_powrdMs 6!9u$ 4 55rc\d}ddfd }|||}|dkr |||}|S)zMultiplication in Galois Fields without using a precomputed look-up table (and thus it's slower) by using the standard carry-less multiplication + modular reduction using an irreducible prime polynomial.c\d}d}||z dkr|d|zzr|||zz}|dz }||z dk|S)z-Bitwise carry-less multiplication on integersrrr)r,rQzr$s r cl_multz#gf_mult_noLUT_slow..cl_multTsU  !tqjjAqDz QT  FA!tqjjrc(d}||z r |dz }||z |S)zbCompute the position of the most significant bit (1) of an integer. Equivalent to int.bit_length()rrr)r'bitss r bit_lengthz&gf_mult_noLUT_slow..bit_length^s'4i"a4i" rNc|}|}||kr|St||z ddD]}|d||zdz zzr|||zz}|S)zFBitwise carry-less long division on integers and returns the remainderrr&)dividenddivisordl1dl2r$rks r cl_divz"gf_mult_noLUT_slow..cl_divds}j""j!! 99OC2&& ) )A1#a<( )GqL(rrrOr)r,rQr8rhrsresultrks @r gf_mult_noLUT_slowruPso &WQq\\F axx%% MrTchd}|r-|dzr |r||z n||z}|dz }|dz}|dkr ||zr||z }|-|S)a7Galois Field integer multiplication using Russian Peasant Multiplication algorithm (faster than the standard multiplication + modular reduction). If prim is 0 and carryless=False, then the function produces the result for a standard integers multiplication (no carry-less arithmetics nor modular reduction).rrr)r,rQr8field_charac_full carrylessrs r r.r.~sn A < q53y3a!eea!e! F F !88--81t8q < HrcrtfdttDS)Nc<g|]}t|Sr)r^)r r$pr,s r rz!gf_poly_scale..s%???1vadA???r)rr&len)r|r,s``r gf_poly_scaler~s6 ?????s1vv??? @ @@rcttt|t|}||t|t|z t|<tt|D]8}||t|zt|z xx||zcc<9|SrO)rmaxr}r&)r|qryr$s r gf_poly_addrsCAA''))AAc!ffSVVmCFFCFF^^'' !c!ff*s1vv !A$& Hrcttt|zdz }fdttD}tt|D]o}||}|dkr_t|}ttD]5}|dkr'|||zxxt|||zzcc<6p|S)zzMultiply two polynomials, inside Galois Field (but the procedure is generic). Optimized function by precomputation of log.rc6g|]}t|SrrL)r r$r|s r rzgf_poly_mul..s! / / /1&1, / / /rr)rr}r&rLrK)r|rrylpjqjlqr$s` r gf_poly_mulrs 3q66CFF?Q&''A / / / /s1vv / / /B CFF^^33 qT 77BCFF^^ 3 3Q4199a!eHHHr!urz 22HHH Hrc :tt|t|zdz }tt|D]N}tt|D]/}|||zxxt||||zcc<0O|S)z-Multiply two polynomials, inside Galois Fieldr)rr}r&r^)r|rryrr$s r gf_poly_mul_simplers 3q66CFF?Q&''A CFF^^++A + +A a!eHHHqtQqT** *HHHH + Hrc|S)zReturns the polynomial with all coefficients negated. In GF(2^p), negation does not change the coefficient, so we return the polynomial as-is.r)polys r gf_poly_negrs Krc t|}tt|t|dz z D]c}||}|dkrStdt|D]5}||dkr'|||zxxt|||zcc<6dt|dz }|d|||dfS)zFast polynomial division by using Extended Synthetic Division and optimized for GF(2^p) computations (doesn't work with standard polynomials outside of this galois field).rrN)rr&r}r^)rorpmsg_outr$coefr separators r gf_poly_divrs""G CMMS\\!^4 5 5??qz 199As7||,, ? ?1:??AENNNfWQZ&>&>>NNNg,,q.!I :I:  3 33rcnt|}td|zdz }t|dz D]3}||}d|z}|dkrtdt|z||<4tdt||dz z|d|zdz <|ddkrd|dzdz |d<|S)aBLinear time implementation of polynomial squaring. For details, see paper: "A fast software implementation for arithmetic operations in GF (2n)". De Win, E., Bosselaers, A., Vandenberghe, S., De Gersem, P., & Vandewalle, J. (1996, January). In Advances in Cryptology - Asiacrypt'96 (pp. 65-76). Springer Berlin Heidelberg.r!rr)r}rr&rKrL)rlengthoutr$r|ks r gf_poly_squarers YYF QvX\ " "C F1H  )) G aC 66AfQiK(CFQvd6!8n556C& O 1v{{QtAwY]CF Jrc|d}tdt|D]}t||||z }|S)zqEvaluates a polynomial in GF(2^p) given the value for x. This is based on Horner's scheme for maximum efficiency.rr)r&r}r^)rr,rQr$s r gf_poly_evalrsG QA As4yy ! !## 1aLL47 " Hrc tdg}t|D]%}t|dt|||zg}&|S)z^Generate an irreducible generator polynomial (necessary to encode a message into Reed-Solomon)r)rr&rrd)nsymfcrr0gr$s r rs_generator_polyrsMA3A D\\:: Avi3778 9 9 Hrci}tdgx|d<|d<t|D]}t|||||<|S)zGenerate all irreducible generator polynomials up to max_nsym (usually you can use n, the length of the message+ecc). Very useful to reduce processing time if you want to encode using variable schemes and nsym rates.rr)rr&r)max_nsymrr0g_allrs r rs_generator_poly_allrsT E$aS//)E!HuQxx  >>'c9==d Lrc$t||ztkr)tdt||ztfz|t|||}t |t t|dz z|\}}||z}|S)zSimple Reed-Solomon encoding (mainly an example for you to understand how it works, because it's slower than the inlined function below)'Message is too long (%i when max is %i)Nr)r}r-rHrrr)msg_inrrr0gen_ remainderrs r rs_simple_encode_msgrs F dl***=fjmntjujuvzjz}IjJ>J3K3K-K {+D#yAACv 3s88A:(>(>>DDLAyy G Nrc t||ztkr)tdt||ztfzt|||t |}t |t tdz z}t fdt tD}t t|D]d}||}|dkrTt |} t dtD])} ||| zxxt| || zzcc<*e||dt|<|S)zReed-Solomon main encoding function, using polynomial division (Extended Synthetic Division, the fastest algorithm available to my knowledge), better explained at http://research.swtch.com/fieldrNrc6g|]}t|Srr)r rrs r rz!rs_encode_msg.. s!@@@!vc!f~@@@rr)r}r-rHrrr&rLrK) rrrr0rrlgenr$rlcoefrs ` r rs_encode_msgrso F dl***=fjmntjujuvzjz}IjJ>J3K3K-K {+D#yAAC   F  :c#hhqj#9#99G @@@@vc#hh/?/?@@@ A ADCKK ::qz 1994LEAs3xx(( : :A&a"99#GLS[[L NrcJdgfdt|DzS)zGiven the received codeword msg and the number of error correcting symbols (nsym), computes the syndromes polynomial. Mathematically, it's essentially equivalent to a Fourrier Transform (Chien search being the inverse). rc Rg|]#}tt|z$Sr)rrd)r r$rr0msgs r rz%rs_calc_syndromes..$s1TTT!,sF9ae$<$<==TTTrrnrrrr0s` ``r rs_calc_syndromesrs5 3TTTTTTvd||TTT TTrc t|fd|D}t||}t|ddd|t|dz ddd}g}t t|D]6} t || z } |t|| 7tt} t|} t|D]\} } t| }g}t | D]?}|| kr7|tdt|||@d}|D]}t||}|dkrtdt|ddd|}tt| d|z |}t||}|| || <t| S)zUForney algorithm, computes the values (error magnitude) to correct the input message.c:g|]}tdz |z Srr})r r|rs r rz%rs_correct_errata..+s(222QC1 q 222rNrmrrzuDecoding failed: Forney algorithm could not properly detect where the errors are located (errata locator prime is 0).)rrs_find_errata_locatorrs_find_error_evaluatorr}r&r-r/rd enumeraterZrUr^rrrar)rsynderr_posrr0coef_poserr_locerr_evalXr$lEXlengthXiXi_inverr_loc_prime_tmpr err_loc_primerrQ magnituders @r rs_correct_erratar&s V  C2222'222H$Xy99G&tDDbDz7CLLNKKDDbDQH A CMM " "** 8A; & &QB'')))) 3s88A!ffG1""2B L LAAvv!((&F61Q44H4H*I*IKKK % 8 8D"=$77MM A  "$[\\ \ $$B$ 0 0 6"ae$$a ( (1m,, !'!*  c1  C Jrc n|rt|}t|}n tdg}tdg}d}t||krt||z }t||z D]}|r ||z|z}n||z}||} tdt|D](} | t|| dz ||| z z} )|tdgz}| dkrmt|t|kr/t || } t |t | }| }t |t || }ttj d|}t|dz } | |z dz|z|krtd|S)zSFind error/errata locator and evaluator polynomials with Berlekamp-Massey algorithmrrc|dkSr\rrWs r z'rs_find_error_locator..s arr!zToo many errors to correct) rr}r&r^r~rZrlist itertools dropwhiler) rr erase_loc erase_countrold_loc synd_shiftr$Kdeltarnew_locerrss r rs_find_error_locatorr\s"Y''Y''aS//aS// J 4yy4c$ii$&6 D$ % %JJ  A j(AA* AQ3w<<(( : :A VGacFOT!a%[99 9EEJsOO+ A::7||c'll**(77'E1B1BCC! "'=%+H+HIIG9&'7'7AABBG w<}t|ttdgt||dg}?|S)aCompute the erasures/errors/errata locator polynomial from the erasures/errors/errata positions (the positions must be relative to the x coefficient, eg: "hello worldxxxxxxxxx" is tampered to "h_ll_ worldxxxxxxxxx" with xxxxxxxxx being the ecc of length n-k=9, here the string positions are [1, 4], but the coefficients are reversed since the ecc characters are placed as the first coefficients of the polynomial, thus the coefficients of the erased characters are n-1 - [1, 4] = [18, 15] = erasures_loc to be specified as an argument.rr)rrrrd)e_posr0e_locr$s r rrsUCE ^^UK A3&TUBVBVXYAZ$[$[]] Lrc^tt||dgdg|dzzz\}}|S)aCompute the error (or erasures if you supply sigma=erasures locator polynomial, or errata) evaluator polynomial Omega from the syndrome and the error/erasures/errata locator Sigma. Omega is already computed at the same time as Sigma inside the Berlekamp-Massey implemented above, but in case you modify Sigma, you can recompute Omega afterwards using this method, or just ensure that Omega computed by BM is correct given Sigma.rr)rr)rrrrrs r rrs: D' : :aSA3Q<=ORRLAy rct|dz }g}t|D]?}t|t||dkr||dz |z @t||krt d|S)zFind the roots (ie, where evaluation = zero) of error polynomial by bruteforce trial, this is a sort of Chien's search (but less efficient, Chien's search is a way to evaluate the polynomial such that each evaluation only takes constant time).rrzQToo many (or few) errors found by Chien Search for the errata locator polynomial!)r}r&rrdr/r)rnmessr0rrr$s r rs_find_errorsrs w<.s!111%'!)111rr)rr&r}rdr^) rposrr0erase_pos_reversedfsyndr$r,rs ` r rs_forney_syndromesrs1111S111 abbNNE CHH  :: 903 4 4E Q'' : :AeAh**U1q5\9E!HH : Lrc4t|tkr&tdt|tfzt|}|g}n |D]}d||<t||krt dt ||||}t |dkr|d| || d|fS|rg} nvt||t||} t| |t|} t| dddt||} | t dt|||| z||}t ||||}t |dkrt d|d| || d|| zfS) z#Reed-Solomon main decoding functionrNrToo many erasures to correct)rrmCould not locate errorCould not correct message) r}r-rHrrrrrrrr) rrrr0 erase_pos only_erasuresrrrrrrs r rs_correct_msgrs 6{{\!!Bc&kkS_E``aaa  G   EGENN 9~~$45S$T$TT WdC ; ;D 4yyA~~vv:: =$D)S\\9MM'tYPPP 2G iHH ?"#;<< < y7/BCSSG WdC ; ;D 4yy1}}:;;; 6TE6?GTEFFOY-@ @@rcZ t|tkr&tdt|tfzt| |g}n |D]}d |<t||krt dt |||}t |dkr d|  | dgfSd}d} |r.t|} fd|D} t| |}|r |ddd} nt|||| } | ddd} t| t |} | t d t || ||  t |||}t |dkrt d  d|  | d|| zfS) zPReed-Solomon main decoding function, without using the modified Forney syndromesrNrrc:g|]}tdz |z Srr)r erasrs r rz*rs_correct_msg_nofsynd..s(HHHdc'll1nT1HHHr)r0rm)rrrrr0r) r}r-rHrrrrrrrr)rrrr0rrrrrrrrrrs @r rs_correct_msg_nofsyndrs 6{{\!!Bc&kkS_E``aaa  G   EGENN 9~~$45S$T$TT WdC ; ;D 4yyA~~vv33IKT)nn HHHHiHHH*+=SSS  DDbD/(diU`aaa$$B$-Wc'llI>>G7888 wC9UUUG WdC ; ;D 4yy1}}:;;; 6TE6?GTEFFOY-@ @@rcHtt||||dkS)zReturns true if the message + ecc has no error of false otherwise (may not always catch a wrong decoding or a wrong message, particularly if there are too many errors -- above the Singleton bound --, but it usually does)r)rrrs r rs_checkr2s$ "3c9== > >! CErcBeZdZdZ dd Zd Zdd ZddZddZddZ d S)RSCodeca A Reed Solomon encoder/decoder. After initializing the object, use ``encode`` to encode a (byte)string to include the RS correction code, and pass such an encoded (byte)string to ``decode`` to extract the original message (if the number of errors allows for correct decoding). The ``nsym`` argument is the length of the correction code, and it determines the number of error bytes (if I understand this correctly, half of ``nsym`` is correctable) rrr<r!r)Tc |dkrg|dkrattjdtjtj|tjdz dzzd}|dkr4|dkr.t ||dd}|dkrtd|zdz }||krt d||_||_||_||_ ||_ ||_ t|||\|_ |_|_|r#i|_t#||| |j|<d St%||| |_d S) aInitialize the Reed-Solomon codec. Note that different parameters change the internal values (the ecc symbols, look-up table values, etc) but not the output result (whether your message can be repaired or not, there is no influence of the parameters). nsym : number of ecc symbols (you can repair nsym/2 errors and nsym erasures. nsize : maximum length of each chunk. If higher than 255, will use a higher Galois Field, but the algorithm's complexity and computational cost will raise quadratically... single_gen : if you want to use the same RSCodec for different nsym parameters (but nsize the same), then set single_gen = False. rr)r!rr<T)r0r1r2r3zOECC symbols must be strictly less than the total message length (nsym < nsize).rN)rmathlogfloorr;rHrnsizerr8r0r1rMrLrKr-rrr)selfrrrr8r0r1 single_gens r __init__zRSCodec.__init__KsO 3;;5A::tz$(5//DHQKK2O'P'PST'T!UWXYYZZE A::$%--#iuRV_cdddD||AuHqL)) 5==noo o   " 7B$ SX6Y6Y3 T[$"3  RDH.t RRRDHTNNN,UyQQQDHHHrc#nKtdt||D]}||||z}|VdS)z Split a long message into chunksrN)r&r})rdata chunksizer$chunks r rz RSCodec.chunknsN3t99i00  A1Y;'EKKKK  rNc v|j|j|jcaaa|s|j}t |t rt |}t }|||j|jz D]C}| t||j|j |j |j |D|S)zyEncode a message (ie, add the ecc symbols) using Reed-Solomon, whatever the length of the message because we use chunking)rr0r)rLrKr-rrrrrrextendrrr0r)rrrencrs r rzRSCodec.encodeus(,{DKAR$  9D dC  $d##DllZZdj49&<== t tE JJ}UDI48t~cgcklpcqrrr s s s s rFc .jjjcaaa|sj}t |t rt |}t }t }t }|jD]}g} |rfd|D} fd|D}t||j j | |\} } } | | | | | z| | |||fS)a)Repair a message, whatever its size is, by using chunking. May return a wrong result if number of errors > nsym. Note that it returns a couple of vars: the repaired messages, and the repaired messages+ecc (useful for checking). Usage: rmes, rmesecc = RSCodec.decode(data). c*g|]}|jk |Srrr r,rs r rz"RSCodec.decode..s @@@qTZrc:g|]}|jk |jz Srr r s r rz"RSCodec.decode..s&RRR!tz//Q^///r)rr0rr) rLrKr-rrrrrrrrr0r) rrrrrdecdec_fullerrata_pos_allrrrmesrecc errata_poss ` r decodezRSCodec.decodesF(,{DKAR$  9D dC  $d##Dll<<#ZZdj11 . .EE S@@@@I@@@RRRRYRRR %3E4TXY]YgsxIV&W&W&W "D$ JJt    OODI & & &  ! !* - - - -Hn,,rc |s|j}t|trt|}g}|||jD]2}|t|||j|j 3|S)zCheck if a message+ecc stream is not corrupted (or fully repaired). Note: may return a wrong result if number of errors > nsym.r) rrrrrrr/rrr0)rrrcheckrs r rz RSCodec.checks 9D dC  $d##DZZdj11 X XE LL%48t~VVV W W W W rc|j}t|dz }|}|J|dkrD||krtdt||z dz }|rtd||fz||fS|J|dkrD||krtdt||dzz }|rtd||fz||fS|rtd||fz||fS)aReturn the Singleton Bound for the current codec, which is the max number of errata (errors and erasures) that the codec can decode/correct. Beyond the Singleton Bound (too many errors/erasures), the algorithm will try to raise an exception, but it may also not detect any problem with the message and return 0 errors. Hence why you should use checksums if your goal is to detect errors (as opposed to correcting them), as checksums have no bounds on the number of errors, the only limitation being the probability of collisions. By default, return a tuple wth the maximum number of errors (2nd output) OR erasures (2nd output) that can be corrected. If errors or erasures (not both) is specified as argument, computes the remaining **simultaneous** correction capacity (eg, if errors specified, compute the number of erasures that can be simultaneously corrected). Set verbose to True to get print a report.r!NrzESpecified number of errors or erasures exceeding the Singleton Bound!zEThis codec can correct up to %i errors and %i erasures simultaneouslyzDThis codec can correct up to %i errors and %i erasures independently)rrrprint)rerrorserasuresverboser maxerrors maxerasuress r maxerratazRSCodec.maxerratas'yQKK   HMM+%%&'noooT(]A-..I w]ajlt`uuvvvh& &  &A++ !!&'nooodF1Ho..K w]agit`uuvvv;& &  u X\egr[ss t t t+%%r)rrrr<r!r)TrO)NNF) rrr__doc__rrrrrrrrr rr:s!R!R!R!RF - - - -D    !&!&!&!&!&!&rrrI)r!r)FF)r<r!r))r)rrT)rr!)rr!Nr\)r!)rr!NF)3rrrrJr NameErrorrr&range ExceptionrrKrLrr-r(r;rMrRrUrXrZr^rardrur.r~rrrrrrrrrrrrrrrrrrrrrobjectrrrr r#sIIZ  IJJ     FF FFF     y    QC#I   Cs8}} AAA4444l;*;*;*;*z   ,,,::: III666,,,,\     AAA         444$            >UUUU4444l;;;;z       (+A+A+A+AZ4A4A4A4AlFFFFY&Y&Y&Y&Y&fY&Y&Y&Y&Y&s##*44