Пример #1
0
func computeInverse8(input []int, output []int, shift uint) {
	oIdx := 0
	round := (1 << shift) >> 1

	for i := 0; i < 8; i++ {
		x0 := input[i]
		x1 := input[i+8]
		x2 := input[i+16]
		x3 := input[i+24]
		x4 := input[i+32]
		x5 := input[i+40]
		x6 := input[i+48]
		x7 := input[i+56]

		a0 := (W8_8 * x1) + (W8_24 * x3) + (W8_40 * x5) + (W8_56 * x7)
		a1 := (W8_9 * x1) + (W8_25 * x3) + (W8_41 * x5) + (W8_57 * x7)
		a2 := (W8_10 * x1) + (W8_26 * x3) + (W8_42 * x5) + (W8_58 * x7)
		a3 := (W8_11 * x1) + (W8_27 * x3) + (W8_43 * x5) + (W8_59 * x7)
		a4 := (W8_16 * x2) + (W8_48 * x6)
		a5 := (W8_17 * x2) + (W8_49 * x6)
		a6 := (W8_0 * x0) + (W8_32 * x4)
		a7 := (W8_1 * x0) + (W8_33 * x4)

		b0 := a6 + a4
		b1 := a7 + a5
		b2 := a6 - a4
		b3 := a7 - a5

		c0 := (b0 + a0 + round) >> shift
		c1 := (b1 + a1 + round) >> shift
		c2 := (b3 + a2 + round) >> shift
		c3 := (b2 + a3 + round) >> shift
		c4 := (b2 - a3 + round) >> shift
		c5 := (b3 - a2 + round) >> shift
		c6 := (b1 - a1 + round) >> shift
		c7 := (b0 - a0 + round) >> shift

		output[oIdx] = kanzi.Clamp(c0, MIN_VAL8, MAX_VAL8)
		output[oIdx+1] = kanzi.Clamp(c1, MIN_VAL8, MAX_VAL8)
		output[oIdx+2] = kanzi.Clamp(c2, MIN_VAL8, MAX_VAL8)
		output[oIdx+3] = kanzi.Clamp(c3, MIN_VAL8, MAX_VAL8)
		output[oIdx+4] = kanzi.Clamp(c4, MIN_VAL8, MAX_VAL8)
		output[oIdx+5] = kanzi.Clamp(c5, MIN_VAL8, MAX_VAL8)
		output[oIdx+6] = kanzi.Clamp(c6, MIN_VAL8, MAX_VAL8)
		output[oIdx+7] = kanzi.Clamp(c7, MIN_VAL8, MAX_VAL8)

		oIdx += 8
	}
}
Пример #2
0
func computeInverse4(input, output []int, shift uint) {
	round := (1 << shift) >> 1

	x0 := input[0]
	x1 := input[1]
	x2 := input[2]
	x3 := input[3]
	x4 := input[4]
	x5 := input[5]
	x6 := input[6]
	x7 := input[7]
	x8 := input[8]
	x9 := input[9]
	x10 := input[10]
	x11 := input[11]
	x12 := input[12]
	x13 := input[13]
	x14 := input[14]
	x15 := input[15]

	a0 := (W4_4 * x4) + (W4_12 * x12)
	a1 := (W4_5 * x4) + (W4_13 * x12)
	a2 := (W4_0 * x0) + (W4_8 * x8)
	a3 := (W4_1 * x0) + (W4_9 * x8)
	a4 := (W4_4 * x5) + (W4_12 * x13)
	a5 := (W4_5 * x5) + (W4_13 * x13)
	a6 := (W4_0 * x1) + (W4_8 * x9)
	a7 := (W4_1 * x1) + (W4_9 * x9)
	a8 := (W4_4 * x6) + (W4_12 * x14)
	a9 := (W4_5 * x6) + (W4_13 * x14)
	a10 := (W4_0 * x2) + (W4_8 * x10)
	a11 := (W4_1 * x2) + (W4_9 * x10)
	a12 := (W4_4 * x7) + (W4_12 * x15)
	a13 := (W4_5 * x7) + (W4_13 * x15)
	a14 := (W4_0 * x3) + (W4_8 * x11)
	a15 := (W4_1 * x3) + (W4_9 * x11)

	b0 := (a2 + a0 + round) >> shift
	b1 := (a3 + a1 + round) >> shift
	b2 := (a3 - a1 + round) >> shift
	b3 := (a2 - a0 + round) >> shift
	b4 := (a6 + a4 + round) >> shift
	b5 := (a7 + a5 + round) >> shift
	b6 := (a7 - a5 + round) >> shift
	b7 := (a6 - a4 + round) >> shift
	b8 := (a10 + a8 + round) >> shift
	b9 := (a11 + a9 + round) >> shift
	b10 := (a11 - a9 + round) >> shift
	b11 := (a10 - a8 + round) >> shift
	b12 := (a14 + a12 + round) >> shift
	b13 := (a15 + a13 + round) >> shift
	b14 := (a15 - a13 + round) >> shift
	b15 := (a14 - a12 + round) >> shift

	output[0] = kanzi.Clamp(b0, MIN_VAL4, MAX_VAL4)
	output[1] = kanzi.Clamp(b1, MIN_VAL4, MAX_VAL4)
	output[2] = kanzi.Clamp(b2, MIN_VAL4, MAX_VAL4)
	output[3] = kanzi.Clamp(b3, MIN_VAL4, MAX_VAL4)
	output[4] = kanzi.Clamp(b4, MIN_VAL4, MAX_VAL4)
	output[5] = kanzi.Clamp(b5, MIN_VAL4, MAX_VAL4)
	output[6] = kanzi.Clamp(b6, MIN_VAL4, MAX_VAL4)
	output[7] = kanzi.Clamp(b7, MIN_VAL4, MAX_VAL4)
	output[8] = kanzi.Clamp(b8, MIN_VAL4, MAX_VAL4)
	output[9] = kanzi.Clamp(b9, MIN_VAL4, MAX_VAL4)
	output[10] = kanzi.Clamp(b10, MIN_VAL4, MAX_VAL4)
	output[11] = kanzi.Clamp(b11, MIN_VAL4, MAX_VAL4)
	output[12] = kanzi.Clamp(b12, MIN_VAL4, MAX_VAL4)
	output[13] = kanzi.Clamp(b13, MIN_VAL4, MAX_VAL4)
	output[14] = kanzi.Clamp(b14, MIN_VAL4, MAX_VAL4)
	output[15] = kanzi.Clamp(b15, MIN_VAL4, MAX_VAL4)
}
Пример #3
0
func computeInverse16(input, output []int, shift uint) {
	oIdx := 0
	round := (1 << shift) >> 1

	for i := 0; i < 16; i++ {
		x0 := input[i]
		x1 := input[i+16]
		x2 := input[i+32]
		x3 := input[i+48]
		x4 := input[i+64]
		x5 := input[i+80]
		x6 := input[i+96]
		x7 := input[i+112]
		x8 := input[i+128]
		x9 := input[i+144]
		x10 := input[i+160]
		x11 := input[i+176]
		x12 := input[i+192]
		x13 := input[i+208]
		x14 := input[i+224]
		x15 := input[i+240]

		a0 := (W16_16 * x1) + (W16_48 * x3) + (W16_80 * x5) + (W16_112 * x7) +
			(W16_144 * x9) + (W16_176 * x11) + (W16_208 * x13) + (W16_240 * x15)
		a1 := (W16_17 * x1) + (W16_49 * x3) + (W16_81 * x5) + (W16_113 * x7) +
			(W16_145 * x9) + (W16_177 * x11) + (W16_209 * x13) + (W16_241 * x15)
		a2 := (W16_18 * x1) + (W16_50 * x3) + (W16_82 * x5) + (W16_114 * x7) +
			(W16_146 * x9) + (W16_178 * x11) + (W16_210 * x13) + (W16_242 * x15)
		a3 := (W16_19 * x1) + (W16_51 * x3) + (W16_83 * x5) + (W16_115 * x7) +
			(W16_147 * x9) + (W16_179 * x11) + (W16_211 * x13) + (W16_243 * x15)
		a4 := (W16_20 * x1) + (W16_52 * x3) + (W16_84 * x5) + (W16_116 * x7) +
			(W16_148 * x9) + (W16_180 * x11) + (W16_212 * x13) + (W16_244 * x15)
		a5 := (W16_21 * x1) + (W16_53 * x3) + (W16_85 * x5) + (W16_117 * x7) +
			(W16_149 * x9) + (W16_181 * x11) + (W16_213 * x13) + (W16_245 * x15)
		a6 := (W16_22 * x1) + (W16_54 * x3) + (W16_86 * x5) + (W16_118 * x7) +
			(W16_150 * x9) + (W16_182 * x11) + (W16_214 * x13) + (W16_246 * x15)
		a7 := (W16_23 * x1) + (W16_55 * x3) + (W16_87 * x5) + (W16_119 * x7) +
			(W16_151 * x9) + (W16_183 * x11) + (W16_215 * x13) + (W16_247 * x15)

		b0 := (W16_32 * x2) + (W16_96 * x6) + (W16_160 * x10) + (W16_224 * x14)
		b1 := (W16_33 * x2) + (W16_97 * x6) + (W16_161 * x10) + (W16_225 * x14)
		b2 := (W16_34 * x2) + (W16_98 * x6) + (W16_162 * x10) + (W16_226 * x14)
		b3 := (W16_35 * x2) + (W16_99 * x6) + (W16_163 * x10) + (W16_227 * x14)
		b4 := (W16_0 * x0) + (W16_128 * x8) + (W16_64 * x4) + (W16_192 * x12)
		b5 := (W16_0 * x0) + (W16_128 * x8) - (W16_64 * x4) - (W16_192 * x12)
		b6 := (W16_1 * x0) + (W16_129 * x8) + (W16_65 * x4) + (W16_193 * x12)
		b7 := (W16_1 * x0) + (W16_129 * x8) - (W16_65 * x4) - (W16_193 * x12)

		c0 := b4 + b0
		c1 := b6 + b1
		c2 := b7 + b2
		c3 := b5 + b3
		c4 := b5 - b3
		c5 := b7 - b2
		c6 := b6 - b1
		c7 := b4 - b0

		d0 := (c0 + a0 + round) >> shift
		d1 := (c1 + a1 + round) >> shift
		d2 := (c2 + a2 + round) >> shift
		d3 := (c3 + a3 + round) >> shift
		d4 := (c4 + a4 + round) >> shift
		d5 := (c5 + a5 + round) >> shift
		d6 := (c6 + a6 + round) >> shift
		d7 := (c7 + a7 + round) >> shift
		d8 := (c7 - a7 + round) >> shift
		d9 := (c6 - a6 + round) >> shift
		d10 := (c5 - a5 + round) >> shift
		d11 := (c4 - a4 + round) >> shift
		d12 := (c3 - a3 + round) >> shift
		d13 := (c2 - a2 + round) >> shift
		d14 := (c1 - a1 + round) >> shift
		d15 := (c0 - a0 + round) >> shift

		output[oIdx] = kanzi.Clamp(d0, MIN_VAL16, MAX_VAL16)
		output[oIdx+1] = kanzi.Clamp(d1, MIN_VAL16, MAX_VAL16)
		output[oIdx+2] = kanzi.Clamp(d2, MIN_VAL16, MAX_VAL16)
		output[oIdx+3] = kanzi.Clamp(d3, MIN_VAL16, MAX_VAL16)
		output[oIdx+4] = kanzi.Clamp(d4, MIN_VAL16, MAX_VAL16)
		output[oIdx+5] = kanzi.Clamp(d5, MIN_VAL16, MAX_VAL16)
		output[oIdx+6] = kanzi.Clamp(d6, MIN_VAL16, MAX_VAL16)
		output[oIdx+7] = kanzi.Clamp(d7, MIN_VAL16, MAX_VAL16)
		output[oIdx+8] = kanzi.Clamp(d8, MIN_VAL16, MAX_VAL16)
		output[oIdx+9] = kanzi.Clamp(d9, MIN_VAL16, MAX_VAL16)
		output[oIdx+10] = kanzi.Clamp(d10, MIN_VAL16, MAX_VAL16)
		output[oIdx+11] = kanzi.Clamp(d11, MIN_VAL16, MAX_VAL16)
		output[oIdx+12] = kanzi.Clamp(d12, MIN_VAL16, MAX_VAL16)
		output[oIdx+13] = kanzi.Clamp(d13, MIN_VAL16, MAX_VAL16)
		output[oIdx+14] = kanzi.Clamp(d14, MIN_VAL16, MAX_VAL16)
		output[oIdx+15] = kanzi.Clamp(d15, MIN_VAL16, MAX_VAL16)

		oIdx += 16
	}
}
Пример #4
0
func computeInverse32(input, output []int, shift uint) {
	oIdx := 0
	round := (1 << shift) >> 1

	for i := 0; i < 32; i++ {
		x0 := input[i]
		x1 := input[i+32]
		x2 := input[i+64]
		x3 := input[i+96]
		x4 := input[i+128]
		x5 := input[i+160]
		x6 := input[i+192]
		x7 := input[i+224]
		x8 := input[i+256]
		x9 := input[i+288]
		x10 := input[i+320]
		x11 := input[i+352]
		x12 := input[i+384]
		x13 := input[i+416]
		x14 := input[i+448]
		x15 := input[i+480]
		x16 := input[i+512]
		x17 := input[i+544]
		x18 := input[i+576]
		x19 := input[i+608]
		x20 := input[i+640]
		x21 := input[i+672]
		x22 := input[i+704]
		x23 := input[i+736]
		x24 := input[i+768]
		x25 := input[i+800]
		x26 := input[i+832]
		x27 := input[i+864]
		x28 := input[i+896]
		x29 := input[i+928]
		x30 := input[i+960]
		x31 := input[i+992]

		a0 := (w[32] * x1) + (w[96] * x3) + (w[160] * x5) + (w[224] * x7) +
			(w[288] * x9) + (w[352] * x11) + (w[416] * x13) + (w[480] * x15) +
			(w[544] * x17) + (w[608] * x19) + (w[672] * x21) + (w[736] * x23) +
			(w[800] * x25) + (w[864] * x27) + (w[928] * x29) + (w[992] * x31)
		a1 := (w[33] * x1) + (w[97] * x3) + (w[161] * x5) + (w[225] * x7) +
			(w[289] * x9) + (w[353] * x11) + (w[417] * x13) + (w[481] * x15) +
			(w[545] * x17) + (w[609] * x19) + (w[673] * x21) + (w[737] * x23) +
			(w[801] * x25) + (w[865] * x27) + (w[929] * x29) + (w[993] * x31)
		a2 := (w[34] * x1) + (w[98] * x3) + (w[162] * x5) + (w[226] * x7) +
			(w[290] * x9) + (w[354] * x11) + (w[418] * x13) + (w[482] * x15) +
			(w[546] * x17) + (w[610] * x19) + (w[674] * x21) + (w[738] * x23) +
			(w[802] * x25) + (w[866] * x27) + (w[930] * x29) + (w[994] * x31)
		a3 := (w[35] * x1) + (w[99] * x3) + (w[163] * x5) + (w[227] * x7) +
			(w[291] * x9) + (w[355] * x11) + (w[419] * x13) + (w[483] * x15) +
			(w[547] * x17) + (w[611] * x19) + (w[675] * x21) + (w[739] * x23) +
			(w[803] * x25) + (w[867] * x27) + (w[931] * x29) + (w[995] * x31)
		a4 := (w[36] * x1) + (w[100] * x3) + (w[164] * x5) + (w[228] * x7) +
			(w[292] * x9) + (w[356] * x11) + (w[420] * x13) + (w[484] * x15) +
			(w[548] * x17) + (w[612] * x19) + (w[676] * x21) + (w[740] * x23) +
			(w[804] * x25) + (w[868] * x27) + (w[932] * x29) + (w[996] * x31)
		a5 := (w[37] * x1) + (w[101] * x3) + (w[165] * x5) + (w[229] * x7) +
			(w[293] * x9) + (w[357] * x11) + (w[421] * x13) + (w[485] * x15) +
			(w[549] * x17) + (w[613] * x19) + (w[677] * x21) + (w[741] * x23) +
			(w[805] * x25) + (w[869] * x27) + (w[933] * x29) + (w[997] * x31)
		a6 := (w[38] * x1) + (w[102] * x3) + (w[166] * x5) + (w[230] * x7) +
			(w[294] * x9) + (w[358] * x11) + (w[422] * x13) + (w[486] * x15) +
			(w[550] * x17) + (w[614] * x19) + (w[678] * x21) + (w[742] * x23) +
			(w[806] * x25) + (w[870] * x27) + (w[934] * x29) + (w[998] * x31)
		a7 := (w[39] * x1) + (w[103] * x3) + (w[167] * x5) + (w[231] * x7) +
			(w[295] * x9) + (w[359] * x11) + (w[423] * x13) + (w[487] * x15) +
			(w[551] * x17) + (w[615] * x19) + (w[679] * x21) + (w[743] * x23) +
			(w[807] * x25) + (w[871] * x27) + (w[935] * x29) + (w[999] * x31)
		a8 := (w[40] * x1) + (w[104] * x3) + (w[168] * x5) + (w[232] * x7) +
			(w[296] * x9) + (w[360] * x11) + (w[424] * x13) + (w[488] * x15) +
			(w[552] * x17) + (w[616] * x19) + (w[680] * x21) + (w[744] * x23) +
			(w[808] * x25) + (w[872] * x27) + (w[936] * x29) + (w[1000] * x31)
		a9 := (w[41] * x1) + (w[105] * x3) + (w[169] * x5) + (w[233] * x7) +
			(w[297] * x9) + (w[361] * x11) + (w[425] * x13) + (w[489] * x15) +
			(w[553] * x17) + (w[617] * x19) + (w[681] * x21) + (w[745] * x23) +
			(w[809] * x25) + (w[873] * x27) + (w[937] * x29) + (w[1001] * x31)
		a10 := (w[42] * x1) + (w[106] * x3) + (w[170] * x5) + (w[234] * x7) +
			(w[298] * x9) + (w[362] * x11) + (w[426] * x13) + (w[490] * x15) +
			(w[554] * x17) + (w[618] * x19) + (w[682] * x21) + (w[746] * x23) +
			(w[810] * x25) + (w[874] * x27) + (w[938] * x29) + (w[1002] * x31)
		a11 := (w[43] * x1) + (w[107] * x3) + (w[171] * x5) + (w[235] * x7) +
			(w[299] * x9) + (w[363] * x11) + (w[427] * x13) + (w[491] * x15) +
			(w[555] * x17) + (w[619] * x19) + (w[683] * x21) + (w[747] * x23) +
			(w[811] * x25) + (w[875] * x27) + (w[939] * x29) + (w[1003] * x31)
		a12 := (w[44] * x1) + (w[108] * x3) + (w[172] * x5) + (w[236] * x7) +
			(w[300] * x9) + (w[364] * x11) + (w[428] * x13) + (w[492] * x15) +
			(w[556] * x17) + (w[620] * x19) + (w[684] * x21) + (w[748] * x23) +
			(w[812] * x25) + (w[876] * x27) + (w[940] * x29) + (w[1004] * x31)
		a13 := (w[45] * x1) + (w[109] * x3) + (w[173] * x5) + (w[237] * x7) +
			(w[301] * x9) + (w[365] * x11) + (w[429] * x13) + (w[493] * x15) +
			(w[557] * x17) + (w[621] * x19) + (w[685] * x21) + (w[749] * x23) +
			(w[813] * x25) + (w[877] * x27) + (w[941] * x29) + (w[1005] * x31)
		a14 := (w[46] * x1) + (w[110] * x3) + (w[174] * x5) + (w[238] * x7) +
			(w[302] * x9) + (w[366] * x11) + (w[430] * x13) + (w[494] * x15) +
			(w[558] * x17) + (w[622] * x19) + (w[686] * x21) + (w[750] * x23) +
			(w[814] * x25) + (w[878] * x27) + (w[942] * x29) + (w[1006] * x31)
		a15 := (w[47] * x1) + (w[111] * x3) + (w[175] * x5) + (w[239] * x7) +
			(w[303] * x9) + (w[367] * x11) + (w[431] * x13) + (w[495] * x15) +
			(w[559] * x17) + (w[623] * x19) + (w[687] * x21) + (w[751] * x23) +
			(w[815] * x25) + (w[879] * x27) + (w[943] * x29) + (w[1007] * x31)

		b0 := (w[64] * x2) + (w[192] * x6) + (w[320] * x10) + (w[448] * x14) +
			(w[576] * x18) + (w[704] * x22) + (w[832] * x26) + (w[960] * x30)
		b1 := (w[65] * x2) + (w[193] * x6) + (w[321] * x10) + (w[449] * x14) +
			(w[577] * x18) + (w[705] * x22) + (w[833] * x26) + (w[961] * x30)
		b2 := (w[66] * x2) + (w[194] * x6) + (w[322] * x10) + (w[450] * x14) +
			(w[578] * x18) + (w[706] * x22) + (w[834] * x26) + (w[962] * x30)
		b3 := (w[67] * x2) + (w[195] * x6) + (w[323] * x10) + (w[451] * x14) +
			(w[579] * x18) + (w[707] * x22) + (w[835] * x26) + (w[963] * x30)
		b4 := (w[68] * x2) + (w[196] * x6) + (w[324] * x10) + (w[452] * x14) +
			(w[580] * x18) + (w[708] * x22) + (w[836] * x26) + (w[964] * x30)
		b5 := (w[69] * x2) + (w[197] * x6) + (w[325] * x10) + (w[453] * x14) +
			(w[581] * x18) + (w[709] * x22) + (w[837] * x26) + (w[965] * x30)
		b6 := (w[70] * x2) + (w[198] * x6) + (w[326] * x10) + (w[454] * x14) +
			(w[582] * x18) + (w[710] * x22) + (w[838] * x26) + (w[966] * x30)
		b7 := (w[71] * x2) + (w[199] * x6) + (w[327] * x10) + (w[455] * x14) +
			(w[583] * x18) + (w[711] * x22) + (w[839] * x26) + (w[967] * x30)

		c0 := (w[128] * x4) + (w[384] * x12) + (w[640] * x20) + (w[896] * x28)
		c1 := (w[129] * x4) + (w[385] * x12) + (w[641] * x20) + (w[897] * x28)
		c2 := (w[130] * x4) + (w[386] * x12) + (w[642] * x20) + (w[898] * x28)
		c3 := (w[131] * x4) + (w[387] * x12) + (w[643] * x20) + (w[899] * x28)
		c4 := (w[256] * x8) + (w[768] * x24)
		c5 := (w[257] * x8) + (w[769] * x24)
		c6 := (w[0] * x0) + (w[512] * x16)
		c7 := (w[1] * x0) + (w[513] * x16)
		c8 := c6 + c4
		c9 := c7 + c5
		c10 := c7 - c5
		c11 := c6 - c4

		d0 := c8 + c0
		d1 := c9 + c1
		d2 := c10 + c2
		d3 := c11 + c3
		d4 := c11 - c3
		d5 := c10 - c2
		d6 := c9 - c1
		d7 := c8 - c0

		e0 := d0 + b0
		e1 := d1 + b1
		e2 := d2 + b2
		e3 := d3 + b3
		e4 := d4 + b4
		e5 := d5 + b5
		e6 := d6 + b6
		e7 := d7 + b7
		e8 := d7 - b7
		e9 := d6 - b6
		e10 := d5 - b5
		e11 := d4 - b4
		e12 := d3 - b3
		e13 := d2 - b2
		e14 := d1 - b1
		e15 := d0 - b0

		r0 := (e0 + a0 + round) >> shift
		r1 := (e1 + a1 + round) >> shift
		r2 := (e2 + a2 + round) >> shift
		r3 := (e3 + a3 + round) >> shift
		r4 := (e4 + a4 + round) >> shift
		r5 := (e5 + a5 + round) >> shift
		r6 := (e6 + a6 + round) >> shift
		r7 := (e7 + a7 + round) >> shift
		r8 := (e8 + a8 + round) >> shift
		r9 := (e9 + a9 + round) >> shift
		r10 := (e10 + a10 + round) >> shift
		r11 := (e11 + a11 + round) >> shift
		r12 := (e12 + a12 + round) >> shift
		r13 := (e13 + a13 + round) >> shift
		r14 := (e14 + a14 + round) >> shift
		r15 := (e15 + a15 + round) >> shift
		r16 := (e15 - a15 + round) >> shift
		r17 := (e14 - a14 + round) >> shift
		r18 := (e13 - a13 + round) >> shift
		r19 := (e12 - a12 + round) >> shift
		r20 := (e11 - a11 + round) >> shift
		r21 := (e10 - a10 + round) >> shift
		r22 := (e9 - a9 + round) >> shift
		r23 := (e8 - a8 + round) >> shift
		r24 := (e7 - a7 + round) >> shift
		r25 := (e6 - a6 + round) >> shift
		r26 := (e5 - a5 + round) >> shift
		r27 := (e4 - a4 + round) >> shift
		r28 := (e3 - a3 + round) >> shift
		r29 := (e2 - a2 + round) >> shift
		r30 := (e1 - a1 + round) >> shift
		r31 := (e0 - a0 + round) >> shift

		output[oIdx] = kanzi.Clamp(r0, MIN_VAL32, MAX_VAL32)
		output[oIdx+1] = kanzi.Clamp(r1, MIN_VAL32, MAX_VAL32)
		output[oIdx+2] = kanzi.Clamp(r2, MIN_VAL32, MAX_VAL32)
		output[oIdx+3] = kanzi.Clamp(r3, MIN_VAL32, MAX_VAL32)
		output[oIdx+4] = kanzi.Clamp(r4, MIN_VAL32, MAX_VAL32)
		output[oIdx+5] = kanzi.Clamp(r5, MIN_VAL32, MAX_VAL32)
		output[oIdx+6] = kanzi.Clamp(r6, MIN_VAL32, MAX_VAL32)
		output[oIdx+7] = kanzi.Clamp(r7, MIN_VAL32, MAX_VAL32)
		output[oIdx+8] = kanzi.Clamp(r8, MIN_VAL32, MAX_VAL32)
		output[oIdx+9] = kanzi.Clamp(r9, MIN_VAL32, MAX_VAL32)
		output[oIdx+10] = kanzi.Clamp(r10, MIN_VAL32, MAX_VAL32)
		output[oIdx+11] = kanzi.Clamp(r11, MIN_VAL32, MAX_VAL32)
		output[oIdx+12] = kanzi.Clamp(r12, MIN_VAL32, MAX_VAL32)
		output[oIdx+13] = kanzi.Clamp(r13, MIN_VAL32, MAX_VAL32)
		output[oIdx+14] = kanzi.Clamp(r14, MIN_VAL32, MAX_VAL32)
		output[oIdx+15] = kanzi.Clamp(r15, MIN_VAL32, MAX_VAL32)
		output[oIdx+16] = kanzi.Clamp(r16, MIN_VAL32, MAX_VAL32)
		output[oIdx+17] = kanzi.Clamp(r17, MIN_VAL32, MAX_VAL32)
		output[oIdx+18] = kanzi.Clamp(r18, MIN_VAL32, MAX_VAL32)
		output[oIdx+19] = kanzi.Clamp(r19, MIN_VAL32, MAX_VAL32)
		output[oIdx+20] = kanzi.Clamp(r20, MIN_VAL32, MAX_VAL32)
		output[oIdx+21] = kanzi.Clamp(r21, MIN_VAL32, MAX_VAL32)
		output[oIdx+22] = kanzi.Clamp(r22, MIN_VAL32, MAX_VAL32)
		output[oIdx+23] = kanzi.Clamp(r23, MIN_VAL32, MAX_VAL32)
		output[oIdx+24] = kanzi.Clamp(r24, MIN_VAL32, MAX_VAL32)
		output[oIdx+25] = kanzi.Clamp(r25, MIN_VAL32, MAX_VAL32)
		output[oIdx+26] = kanzi.Clamp(r26, MIN_VAL32, MAX_VAL32)
		output[oIdx+27] = kanzi.Clamp(r27, MIN_VAL32, MAX_VAL32)
		output[oIdx+28] = kanzi.Clamp(r28, MIN_VAL32, MAX_VAL32)
		output[oIdx+29] = kanzi.Clamp(r29, MIN_VAL32, MAX_VAL32)
		output[oIdx+30] = kanzi.Clamp(r30, MIN_VAL32, MAX_VAL32)
		output[oIdx+31] = kanzi.Clamp(r31, MIN_VAL32, MAX_VAL32)

		oIdx += 32
	}
}