aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
diff options
context:
space:
mode:
authorUbitUmarov2019-01-20 20:58:27 +0000
committerUbitUmarov2019-01-20 20:58:27 +0000
commit0c38d52538a5d713e034fcec8da8df434e3ca924 (patch)
treeb54bb1749bae275e77bbfcaafb98833fd436748b /OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
parentcosmetics (diff)
downloadopensim-SC-0c38d52538a5d713e034fcec8da8df434e3ca924.zip
opensim-SC-0c38d52538a5d713e034fcec8da8df434e3ca924.tar.gz
opensim-SC-0c38d52538a5d713e034fcec8da8df434e3ca924.tar.bz2
opensim-SC-0c38d52538a5d713e034fcec8da8df434e3ca924.tar.xz
cosmetics on terrain patchs
Diffstat (limited to 'OpenSim/Region/Framework/Scenes/TerrainCompressor.cs')
-rw-r--r--OpenSim/Region/Framework/Scenes/TerrainCompressor.cs948
1 files changed, 486 insertions, 462 deletions
diff --git a/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs b/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
index d3f2737..2070463 100644
--- a/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
+++ b/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
@@ -155,16 +155,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
155 return iout; 155 return iout;
156 } 156 }
157 157
158 static double tt;
158 // new using terrain data and patchs indexes 159 // new using terrain data and patchs indexes
159 public static List<LayerDataPacket> CreateLayerDataPackets(TerrainData terrData, int[] x, int[] y, byte landPacketType) 160 public static List<LayerDataPacket> CreateLayerDataPackets(TerrainData terrData, int[] map)
160 { 161 {
161 List<LayerDataPacket> ret = new List<LayerDataPacket>(); 162 List<LayerDataPacket> ret = new List<LayerDataPacket>();
162 163
163 byte[] data = new byte[x.Length * 256 * 2]; 164 int numberPatchs = map.Length / 2;
165 byte[] data = new byte[numberPatchs * 256 * 2];
164 166
165 //create packet and global header 167 //create packet and global header
166 LayerDataPacket layer = new LayerDataPacket(); 168 LayerDataPacket layer = new LayerDataPacket();
167 169
170 byte landPacketType;
171 if (terrData.SizeX > Constants.RegionSize || terrData.SizeY > Constants.RegionSize)
172 landPacketType = (byte)TerrainPatch.LayerType.LandExtended;
173 else
174 landPacketType = (byte)TerrainPatch.LayerType.Land;
175
168 layer.LayerID.Type = landPacketType; 176 layer.LayerID.Type = landPacketType;
169 177
170 BitPack bitpack = new BitPack(data, 0); 178 BitPack bitpack = new BitPack(data, 0);
@@ -172,11 +180,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
172 bitpack.PackBitsFromByte(16); 180 bitpack.PackBitsFromByte(16);
173 bitpack.PackBitsFromByte(landPacketType); 181 bitpack.PackBitsFromByte(landPacketType);
174 182
175 for (int i = 0; i < x.Length; i++) 183 tt = 0;
184
185 int s;
186 for (int i = 0; i < numberPatchs; i++)
176 { 187 {
177 CreatePatchFromTerrainData(bitpack, terrData, x[i], y[i]); 188 s = 2 * i;
189 tt -= Util.GetTimeStampMS();
190 CreatePatchFromTerrainData(bitpack, terrData, map[s], map[s + 1]);
191 tt += Util.GetTimeStampMS();
178 192
179 if (bitpack.BytePos > 980 && i != x.Length - 1) 193 if (bitpack.BytePos > 980 && i != numberPatchs - 1)
180 { 194 {
181 //finish this packet 195 //finish this packet
182 bitpack.PackBitsFromByte(END_OF_PATCHES); 196 bitpack.PackBitsFromByte(END_OF_PATCHES);
@@ -284,7 +298,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
284 output.PackBits(header.PatchIDs, 10); 298 output.PackBits(header.PatchIDs, 10);
285 } 299 }
286 300
287 private static void EncodePatch(BitPack output, int[] patch, int postquant, int wbits) 301 private unsafe static void EncodePatch(BitPack output, int[] _patch, int postquant, int wbits)
288 { 302 {
289 int maxwbitssize = (1 << wbits) - 1; 303 int maxwbitssize = (1 << wbits) - 1;
290 304
@@ -296,60 +310,63 @@ namespace OpenSim.Region.ClientStack.LindenUDP
296 310
297 int lastZeroindx = 256 - postquant; 311 int lastZeroindx = 256 - postquant;
298 312
299 if (lastZeroindx != 256) 313 fixed(int * patch = _patch)
300 patch[lastZeroindx] = 0;
301
302 int i = 0;
303 while(i < 256)
304 { 314 {
305 int temp = patch[i]; 315 if (lastZeroindx != 256)
316 patch[lastZeroindx] = 0;
306 317
307 if (temp == 0) 318 int i = 0;
319 while(i < 256)
308 { 320 {
309 int j = i + 1; 321 int temp = patch[i];
310 while(j < lastZeroindx)
311 {
312 if (patch[j] != 0)
313 break;
314 ++j;
315 }
316 322
317 if (j == lastZeroindx) 323 if (temp == 0)
318 { 324 {
319 output.PackBits(ZERO_EOB, 2); 325 int j = i + 1;
320 return; 326 while(j < lastZeroindx)
321 } 327 {
328 if (patch[j] != 0)
329 break;
330 ++j;
331 }
322 332
323 i = j - i; 333 if (j == lastZeroindx)
324 while(i > 8) 334 {
325 { 335 output.PackBits(ZERO_EOB, 2);
326 output.PackBitsFromByte(ZERO_CODE); 336 return;
327 i -= 8; 337 }
338
339 i = j - i;
340 while(i > 8)
341 {
342 output.PackBitsFromByte(ZERO_CODE);
343 i -= 8;
344 }
345 if( i > 0)
346 output.PackBitsFromByte(ZERO_CODE, i);
347 i = j;
348 continue;
328 } 349 }
329 if( i > 0)
330 output.PackBitsFromByte(ZERO_CODE, i);
331 i = j;
332 continue;
333 }
334 350
335 if (temp < 0) 351 if (temp < 0)
336 { 352 {
337 temp *= -1; 353 temp *= -1;
338 if (temp > maxwbitssize) 354 if (temp > maxwbitssize)
339 temp = maxwbitssize; 355 temp = maxwbitssize;
340 356
341 output.PackBits(NEGATIVE_VALUE, 3); 357 output.PackBits(NEGATIVE_VALUE, 3);
342 output.PackBits(temp, wbits); 358 output.PackBits(temp, wbits);
343 } 359 }
344 else 360 else
345 { 361 {
346 if (temp > maxwbitssize) 362 if (temp > maxwbitssize)
347 temp = maxwbitssize; 363 temp = maxwbitssize;
348 364
349 output.PackBits(POSITIVE_VALUE, 3); 365 output.PackBits(POSITIVE_VALUE, 3);
350 output.PackBits(temp, wbits); 366 output.PackBits(temp, wbits);
367 }
368 ++i;
351 } 369 }
352 ++i;
353 } 370 }
354 } 371 }
355 372
@@ -369,7 +386,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
369 header.QuantWBits = wordsize; 386 header.QuantWBits = wordsize;
370 header.QuantWBits |= wordsize << 4; 387 header.QuantWBits |= wordsize << 4;
371 388
372 terrData.GetPatchBlock(ref block, patchX, patchY, sub, premult); 389 terrData.GetPatchBlock(block, patchX, patchY, sub, premult);
373 390
374 wbits = (prequant >> 1); 391 wbits = (prequant >> 1);
375 392
@@ -391,20 +408,23 @@ namespace OpenSim.Region.ClientStack.LindenUDP
391 } 408 }
392 } 409 }
393 410
394 private static void BuildQuantizeTable16() 411 private unsafe static void BuildQuantizeTable16()
395 { 412 {
396 const float oosob = 2.0f / 16; 413 const float oosob = 2.0f / 16;
397 for (int j = 0; j < 16; j++) 414 fixed(float* fQuantizeTable16 = QuantizeTable16)
398 { 415 {
399 int c = j * 16; 416 for (int j = 0; j < 16; j++)
400 for (int i = 0; i < 16; i++)
401 { 417 {
402 QuantizeTable16[c + i] = oosob / (1.0f + 2.0f * (i + j)); 418 int c = j * 16;
419 for (int i = 0; i < 16; i++)
420 {
421 fQuantizeTable16[c + i] = oosob / (1.0f + 2.0f * (i + j));
422 }
403 } 423 }
404 } 424 }
405 } 425 }
406 426
407 private static void BuildCopyMatrix16() 427 private unsafe static void BuildCopyMatrix16()
408 { 428 {
409 bool diag = false; 429 bool diag = false;
410 bool right = true; 430 bool right = true;
@@ -412,42 +432,45 @@ namespace OpenSim.Region.ClientStack.LindenUDP
412 int j = 0; 432 int j = 0;
413 int count = 0; 433 int count = 0;
414 434
415 while (i < 16 && j < 16) 435 fixed (int* fCopyMatrix16 = CopyMatrix16)
416 { 436 {
417 CopyMatrix16[j * 16 + i] = count++; 437 while (i < 16 && j < 16)
418
419 if (!diag)
420 { 438 {
421 if (right) 439 fCopyMatrix16[j * 16 + i] = count++;
422 {
423 if (i < 15) i++;
424 else j++;
425 440
426 right = false; 441 if (!diag)
427 diag = true;
428 }
429 else
430 { 442 {
431 if (j < 15 ) j++; 443 if (right)
432 else i++; 444 {
445 if (i < 15) i++;
446 else j++;
433 447
434 right = true; 448 right = false;
435 diag = true; 449 diag = true;
436 } 450 }
437 } 451 else
438 else 452 {
439 { 453 if (j < 15 ) j++;
440 if (right) 454 else i++;
441 { 455
442 i++; 456 right = true;
443 j--; 457 diag = true;
444 if (i == 15 || j == 0) diag = false; 458 }
445 } 459 }
446 else 460 else
447 { 461 {
448 i--; 462 if (right)
449 j++; 463 {
450 if (j == 15 || i == 0) diag = false; 464 i++;
465 j--;
466 if (i == 15 || j == 0) diag = false;
467 }
468 else
469 {
470 i--;
471 j++;
472 if (j == 15 || i == 0) diag = false;
473 }
451 } 474 }
452 } 475 }
453 } 476 }
@@ -455,9 +478,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
455 478
456 #endregion Initialization 479 #endregion Initialization
457 480
458
459
460
461 #region DCT 481 #region DCT
462 482
463 /* DCT (Discrete Cosine Transform) 483 /* DCT (Discrete Cosine Transform)
@@ -506,9 +526,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
506 const float W16_8R = 0.70710678118654752440f; 526 const float W16_8R = 0.70710678118654752440f;
507 527
508 528
509 static void dct16x16(float[] a, int[] iout, ref int wbits) 529 unsafe static void dct16x16(float[] _a, int[] _iout, ref int wbits)
510 { 530 {
511 float[] tmp = new float[256]; 531 float[] _tmp = new float[256];
512 532
513 float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i; 533 float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
514 float x4r, x4i, x5r, x5i, x6r, x6i, x7r, x7i; 534 float x4r, x4i, x5r, x5i, x6r, x6i, x7r, x7i;
@@ -523,479 +543,483 @@ namespace OpenSim.Region.ClientStack.LindenUDP
523 int wbitsMaxValue = 1 << wbits; 543 int wbitsMaxValue = 1 << wbits;
524 bool dowbits = wbits < 17; 544 bool dowbits = wbits < 17;
525 545
526 for (j = 0, k = 0; j < 256; j += 16, k++) 546 fixed (float* a = _a, tmp = _tmp, fQuantizeTable16 = QuantizeTable16)
547 fixed (int* iout = _iout, fCopyMatrix16 = CopyMatrix16)
527 { 548 {
528 x4r = a[0 + j] - a[15 + j]; 549 for (j = 0, k = 0; j < 256; j += 16, k++)
529 xr = a[0 + j] + a[15 + j]; 550 {
530 x4i = a[8 + j] - a[7 + j]; 551 x4r = a[0 + j] - a[15 + j];
531 xi = a[8 + j] + a[7 + j]; 552 xr = a[0 + j] + a[15 + j];
532 x0r = xr + xi; 553 x4i = a[8 + j] - a[7 + j];
533 x0i = xr - xi; 554 xi = a[8 + j] + a[7 + j];
534 x5r = a[2 + j] - a[13 + j]; 555 x0r = xr + xi;
535 xr = a[2 + j] + a[13 + j]; 556 x0i = xr - xi;
536 x5i = a[10 + j] - a[5 + j]; 557 x5r = a[2 + j] - a[13 + j];
537 xi = a[10 + j] + a[5 + j]; 558 xr = a[2 + j] + a[13 + j];
538 x1r = xr + xi; 559 x5i = a[10 + j] - a[5 + j];
539 x1i = xr - xi; 560 xi = a[10 + j] + a[5 + j];
540 x6r = a[4 + j] - a[11 + j]; 561 x1r = xr + xi;
541 xr = a[4 + j] + a[11 + j]; 562 x1i = xr - xi;
542 x6i = a[12 + j] - a[3 + j]; 563 x6r = a[4 + j] - a[11 + j];
543 xi = a[12 + j] + a[3 + j]; 564 xr = a[4 + j] + a[11 + j];
544 x2r = xr + xi; 565 x6i = a[12 + j] - a[3 + j];
545 x2i = xr - xi; 566 xi = a[12 + j] + a[3 + j];
546 x7r = a[6 + j] - a[9 + j]; 567 x2r = xr + xi;
547 xr = a[6 + j] + a[9 + j]; 568 x2i = xr - xi;
548 x7i = a[14 + j] - a[1 + j]; 569 x7r = a[6 + j] - a[9 + j];
549 xi = a[14 + j] + a[1 + j]; 570 xr = a[6 + j] + a[9 + j];
550 x3r = xr + xi; 571 x7i = a[14 + j] - a[1 + j];
551 x3i = xr - xi; 572 xi = a[14 + j] + a[1 + j];
552 xr = x0r + x2r; 573 x3r = xr + xi;
553 xi = x1r + x3r; 574 x3i = xr - xi;
554 tmp[k] = C16_8R * (xr + xi); // 575 xr = x0r + x2r;
555 tmp[8 * 16 + k] = C16_8R * (xr - xi); // 576 xi = x1r + x3r;
556 xr = x0r - x2r; 577 tmp[k] = C16_8R * (xr + xi); //
557 xi = x1r - x3r; 578 tmp[8 * 16 + k] = C16_8R * (xr - xi); //
558 tmp[4 * 16 + k] = C16_4R * xr - C16_4I * xi; // 579 xr = x0r - x2r;
559 tmp[12 * 16 + k] = C16_4R * xi + C16_4I * xr; // 580 xi = x1r - x3r;
560 x0r = W16_8R * (x1i - x3i); 581 tmp[4 * 16 + k] = C16_4R * xr - C16_4I * xi; //
561 x2r = W16_8R * (x1i + x3i); 582 tmp[12 * 16 + k] = C16_4R * xi + C16_4I * xr; //
562 xr = x0i + x0r; 583 x0r = W16_8R * (x1i - x3i);
563 xi = x2r + x2i; 584 x2r = W16_8R * (x1i + x3i);
564 tmp[2 * 16 + k] = C16_2R * xr - C16_2I * xi; // 585 xr = x0i + x0r;
565 tmp[14 * 16 + k] = C16_2R * xi + C16_2I * xr; // 586 xi = x2r + x2i;
566 xr = x0i - x0r; 587 tmp[2 * 16 + k] = C16_2R * xr - C16_2I * xi; //
567 xi = x2r - x2i; 588 tmp[14 * 16 + k] = C16_2R * xi + C16_2I * xr; //
568 tmp[6 * 16 + k] = C16_6R * xr - C16_6I * xi; // 589 xr = x0i - x0r;
569 tmp[10 * 16 + k] = C16_6R * xi + C16_6I * xr; // 590 xi = x2r - x2i;
570 xr = W16_8R * (x6r - x6i); 591 tmp[6 * 16 + k] = C16_6R * xr - C16_6I * xi; //
571 xi = W16_8R * (x6i + x6r); 592 tmp[10 * 16 + k] = C16_6R * xi + C16_6I * xr; //
572 x6r = x4r - xr; 593 xr = W16_8R * (x6r - x6i);
573 x6i = x4i - xi; 594 xi = W16_8R * (x6i + x6r);
574 x4r += xr; 595 x6r = x4r - xr;
575 x4i += xi; 596 x6i = x4i - xi;
576 xr = W16_4I * x7r - W16_4R * x7i; 597 x4r += xr;
577 xi = W16_4I * x7i + W16_4R * x7r; 598 x4i += xi;
578 x7r = W16_4R * x5r - W16_4I * x5i; 599 xr = W16_4I * x7r - W16_4R * x7i;
579 x7i = W16_4R * x5i + W16_4I * x5r; 600 xi = W16_4I * x7i + W16_4R * x7r;
580 x5r = x7r + xr; 601 x7r = W16_4R * x5r - W16_4I * x5i;
581 x5i = x7i + xi; 602 x7i = W16_4R * x5i + W16_4I * x5r;
582 x7r -= xr; 603 x5r = x7r + xr;
583 x7i -= xi; 604 x5i = x7i + xi;
584 xr = x4r + x5r; 605 x7r -= xr;
585 xi = x5i + x4i; 606 x7i -= xi;
586 tmp[16 + k] = C16_1R * xr - C16_1I * xi; // 607 xr = x4r + x5r;
587 tmp[15 * 16 + k] = C16_1R * xi + C16_1I * xr; // 608 xi = x5i + x4i;
588 xr = x4r - x5r; 609 tmp[16 + k] = C16_1R * xr - C16_1I * xi; //
589 xi = x5i - x4i; 610 tmp[15 * 16 + k] = C16_1R * xi + C16_1I * xr; //
590 tmp[7 * 16 + k] = C16_7R * xr - C16_7I * xi; // 611 xr = x4r - x5r;
591 tmp[9 * 16 + k] = C16_7R * xi + C16_7I * xr; // 612 xi = x5i - x4i;
592 xr = x6r - x7i; 613 tmp[7 * 16 + k] = C16_7R * xr - C16_7I * xi; //
593 xi = x7r + x6i; 614 tmp[9 * 16 + k] = C16_7R * xi + C16_7I * xr; //
594 tmp[5 * 16 + k] = C16_5R * xr - C16_5I * xi; // 615 xr = x6r - x7i;
595 tmp[11 * 16 + k] = C16_5R * xi + C16_5I * xr; // 616 xi = x7r + x6i;
596 xr = x6r + x7i; 617 tmp[5 * 16 + k] = C16_5R * xr - C16_5I * xi; //
597 xi = x7r - x6i; 618 tmp[11 * 16 + k] = C16_5R * xi + C16_5I * xr; //
598 tmp[3 * 16 + k] = C16_3R * xr - C16_3I * xi; // 619 xr = x6r + x7i;
599 tmp[13 * 16 + k] = C16_3R * xi + C16_3I * xr; // 620 xi = x7r - x6i;
600 } 621 tmp[3 * 16 + k] = C16_3R * xr - C16_3I * xi; //
622 tmp[13 * 16 + k] = C16_3R * xi + C16_3I * xr; //
623 }
601 624
602 for (j = 0, k = 0; j < 256; j += 16, k++) 625 for (j = 0, k = 0; j < 256; j += 16, k++)
603 {
604 x4r = tmp[0 + j] - tmp[15 + j];
605 xr = tmp[0 + j] + tmp[15 + j];
606 x4i = tmp[8 + j] - tmp[7 + j];
607 xi = tmp[8 + j] + tmp[7 + j];
608 x0r = xr + xi;
609 x0i = xr - xi;
610 x5r = tmp[2 + j] - tmp[13 + j];
611 xr = tmp[2 + j] + tmp[13 + j];
612 x5i = tmp[10 + j] - tmp[5 + j];
613 xi = tmp[10 + j] + tmp[5 + j];
614 x1r = xr + xi;
615 x1i = xr - xi;
616 x6r = tmp[4 + j] - tmp[11 + j];
617 xr = tmp[4 + j] + tmp[11 + j];
618 x6i = tmp[12 + j] - tmp[3 + j];
619 xi = tmp[12 + j] + tmp[3 + j];
620 x2r = xr + xi;
621 x2i = xr - xi;
622 x7r = tmp[6 + j] - tmp[9 + j];
623 xr = tmp[6 + j] + tmp[9 + j];
624 x7i = tmp[14 + j] - tmp[1 + j];
625 xi = tmp[14 + j] + tmp[1 + j];
626 x3r = xr + xi;
627 x3i = xr - xi;
628 xr = x0r + x2r;
629 xi = x1r + x3r;
630
631 //tmp[0 + k] = C16_8R * (xr + xi); //
632 ftmp = C16_8R * (xr + xi);
633 itmp = (int)(ftmp * QuantizeTable16[k]);
634 iout[CopyMatrix16[k]] = itmp;
635
636 if (dowbits)
637 { 626 {
638 if (itmp < 0) itmp *= -1; 627 x4r = tmp[0 + j] - tmp[15 + j];
639 while (itmp > wbitsMaxValue) 628 xr = tmp[0 + j] + tmp[15 + j];
629 x4i = tmp[8 + j] - tmp[7 + j];
630 xi = tmp[8 + j] + tmp[7 + j];
631 x0r = xr + xi;
632 x0i = xr - xi;
633 x5r = tmp[2 + j] - tmp[13 + j];
634 xr = tmp[2 + j] + tmp[13 + j];
635 x5i = tmp[10 + j] - tmp[5 + j];
636 xi = tmp[10 + j] + tmp[5 + j];
637 x1r = xr + xi;
638 x1i = xr - xi;
639 x6r = tmp[4 + j] - tmp[11 + j];
640 xr = tmp[4 + j] + tmp[11 + j];
641 x6i = tmp[12 + j] - tmp[3 + j];
642 xi = tmp[12 + j] + tmp[3 + j];
643 x2r = xr + xi;
644 x2i = xr - xi;
645 x7r = tmp[6 + j] - tmp[9 + j];
646 xr = tmp[6 + j] + tmp[9 + j];
647 x7i = tmp[14 + j] - tmp[1 + j];
648 xi = tmp[14 + j] + tmp[1 + j];
649 x3r = xr + xi;
650 x3i = xr - xi;
651 xr = x0r + x2r;
652 xi = x1r + x3r;
653
654 //tmp[0 + k] = C16_8R * (xr + xi); //
655 ftmp = C16_8R * (xr + xi);
656 itmp = (int)(ftmp * fQuantizeTable16[k]);
657 iout[fCopyMatrix16[k]] = itmp;
658
659 if (dowbits)
640 { 660 {
641 wbits++; 661 if (itmp < 0) itmp *= -1;
642 wbitsMaxValue = 1 << wbits; 662 while (itmp > wbitsMaxValue)
643 if (wbits == maxwbits)
644 { 663 {
645 dowbits = false; 664 wbits++;
646 break; 665 wbitsMaxValue = 1 << wbits;
666 if (wbits == maxwbits)
667 {
668 dowbits = false;
669 break;
670 }
647 } 671 }
648 } 672 }
649 }
650 673
651 //tmp[8 * Constants.TerrainPatchSize + k] = C16_8R * (xr - xi); // 674 //tmp[8 * Constants.TerrainPatchSize + k] = C16_8R * (xr - xi); //
652 ftmp = C16_8R * (xr - xi); 675 ftmp = C16_8R * (xr - xi);
653 indx = 8 * 16 + k; 676 indx = 8 * 16 + k;
654 itmp = (int)(ftmp * QuantizeTable16[indx]); 677 itmp = (int)(ftmp * fQuantizeTable16[indx]);
655 iout[CopyMatrix16[indx]] = itmp; 678 iout[fCopyMatrix16[indx]] = itmp;
656 679
657 if (dowbits) 680 if (dowbits)
658 {
659 if (itmp < 0) itmp *= -1;
660 while (itmp > wbitsMaxValue)
661 { 681 {
662 wbits++; 682 if (itmp < 0) itmp *= -1;
663 wbitsMaxValue = 1 << wbits; 683 while (itmp > wbitsMaxValue)
664 if (wbits == maxwbits)
665 { 684 {
666 dowbits = false; 685 wbits++;
667 break; 686 wbitsMaxValue = 1 << wbits;
687 if (wbits == maxwbits)
688 {
689 dowbits = false;
690 break;
691 }
668 } 692 }
669 } 693 }
670 }
671 694
672 xr = x0r - x2r; 695 xr = x0r - x2r;
673 xi = x1r - x3r; 696 xi = x1r - x3r;
674 697
675 //tmp[4 * Constants.TerrainPatchSize + k] = C16_4R * xr - C16_4I * xi; // 698 //tmp[4 * Constants.TerrainPatchSize + k] = C16_4R * xr - C16_4I * xi; //
676 ftmp = C16_4R * xr - C16_4I * xi; 699 ftmp = C16_4R * xr - C16_4I * xi;
677 indx = 4 * 16 + k; 700 indx = 4 * 16 + k;
678 itmp = (int)(ftmp * QuantizeTable16[indx]); 701 itmp = (int)(ftmp * fQuantizeTable16[indx]);
679 iout[CopyMatrix16[indx]] = itmp; 702 iout[fCopyMatrix16[indx]] = itmp;
680 703
681 if (dowbits) 704 if (dowbits)
682 {
683 if (itmp < 0) itmp *= -1;
684 while (itmp > wbitsMaxValue)
685 { 705 {
686 wbits++; 706 if (itmp < 0) itmp *= -1;
687 wbitsMaxValue = 1 << wbits; 707 while (itmp > wbitsMaxValue)
688 if (wbits == maxwbits)
689 { 708 {
690 dowbits = false; 709 wbits++;
691 break; 710 wbitsMaxValue = 1 << wbits;
711 if (wbits == maxwbits)
712 {
713 dowbits = false;
714 break;
715 }
692 } 716 }
693 } 717 }
694 }
695 718
696 //tmp[12 * Constants.TerrainPatchSize + k] = C16_4R * xi + C16_4I * xr; // 719 //tmp[12 * Constants.TerrainPatchSize + k] = C16_4R * xi + C16_4I * xr; //
697 ftmp = C16_4R * xi + C16_4I * xr; 720 ftmp = C16_4R * xi + C16_4I * xr;
698 indx = 12 * 16 + k; 721 indx = 12 * 16 + k;
699 itmp = (int)(ftmp * QuantizeTable16[indx]); 722 itmp = (int)(ftmp * fQuantizeTable16[indx]);
700 iout[CopyMatrix16[indx]] = itmp; 723 iout[fCopyMatrix16[indx]] = itmp;
701 724
702 if (dowbits) 725 if (dowbits)
703 {
704 if (itmp < 0) itmp *= -1;
705 while (itmp > wbitsMaxValue)
706 { 726 {
707 wbits++; 727 if (itmp < 0) itmp *= -1;
708 wbitsMaxValue = 1 << wbits; 728 while (itmp > wbitsMaxValue)
709 if (wbits == maxwbits)
710 { 729 {
711 dowbits = false; 730 wbits++;
712 break; 731 wbitsMaxValue = 1 << wbits;
732 if (wbits == maxwbits)
733 {
734 dowbits = false;
735 break;
736 }
713 } 737 }
714 } 738 }
715 }
716 739
717 x0r = W16_8R * (x1i - x3i); 740 x0r = W16_8R * (x1i - x3i);
718 x2r = W16_8R * (x1i + x3i); 741 x2r = W16_8R * (x1i + x3i);
719 xr = x0i + x0r; 742 xr = x0i + x0r;
720 xi = x2r + x2i; 743 xi = x2r + x2i;
721 744
722 //tmp[2 * Constants.TerrainPatchSize + k] = C16_2R * xr - C16_2I * xi; // 745 //tmp[2 * Constants.TerrainPatchSize + k] = C16_2R * xr - C16_2I * xi; //
723 ftmp = C16_2R * xr - C16_2I * xi; 746 ftmp = C16_2R * xr - C16_2I * xi;
724 indx = 2 * 16 + k; 747 indx = 2 * 16 + k;
725 itmp = (int)(ftmp * QuantizeTable16[indx]); 748 itmp = (int)(ftmp * fQuantizeTable16[indx]);
726 iout[CopyMatrix16[indx]] = itmp; 749 iout[fCopyMatrix16[indx]] = itmp;
727 750
728 if (dowbits) 751 if (dowbits)
729 {
730 if (itmp < 0) itmp *= -1;
731 while (itmp > wbitsMaxValue)
732 { 752 {
733 wbits++; 753 if (itmp < 0) itmp *= -1;
734 wbitsMaxValue = 1 << wbits; 754 while (itmp > wbitsMaxValue)
735 if (wbits == maxwbits)
736 { 755 {
737 dowbits = false; 756 wbits++;
738 break; 757 wbitsMaxValue = 1 << wbits;
758 if (wbits == maxwbits)
759 {
760 dowbits = false;
761 break;
762 }
739 } 763 }
740 } 764 }
741 }
742 765
743 //tmp[14 * Constants.TerrainPatchSize + k] = C16_2R * xi + C16_2I * xr; // 766 //tmp[14 * Constants.TerrainPatchSize + k] = C16_2R * xi + C16_2I * xr; //
744 ftmp = C16_2R * xi + C16_2I * xr; 767 ftmp = C16_2R * xi + C16_2I * xr;
745 indx = 14 * 16 + k; 768 indx = 14 * 16 + k;
746 itmp = (int)(ftmp * QuantizeTable16[indx]); 769 itmp = (int)(ftmp * fQuantizeTable16[indx]);
747 iout[CopyMatrix16[indx]] = itmp; 770 iout[fCopyMatrix16[indx]] = itmp;
748 771
749 if (dowbits) 772 if (dowbits)
750 {
751 if (itmp < 0) itmp *= -1;
752 while (itmp > wbitsMaxValue)
753 { 773 {
754 wbits++; 774 if (itmp < 0) itmp *= -1;
755 wbitsMaxValue = 1 << wbits; 775 while (itmp > wbitsMaxValue)
756 if (wbits == maxwbits)
757 { 776 {
758 dowbits = false; 777 wbits++;
759 break; 778 wbitsMaxValue = 1 << wbits;
779 if (wbits == maxwbits)
780 {
781 dowbits = false;
782 break;
783 }
760 } 784 }
761 } 785 }
762 }
763 786
764 xr = x0i - x0r; 787 xr = x0i - x0r;
765 xi = x2r - x2i; 788 xi = x2r - x2i;
766 789
767 //tmp[6 * Constants.TerrainPatchSize + k] = C16_6R * xr - C16_6I * xi; // 790 //tmp[6 * Constants.TerrainPatchSize + k] = C16_6R * xr - C16_6I * xi; //
768 ftmp = C16_6R * xr - C16_6I * xi; 791 ftmp = C16_6R * xr - C16_6I * xi;
769 indx = 6 * 16 + k; 792 indx = 6 * 16 + k;
770 itmp = (int)(ftmp * QuantizeTable16[indx]); 793 itmp = (int)(ftmp * fQuantizeTable16[indx]);
771 iout[CopyMatrix16[indx]] = itmp; 794 iout[fCopyMatrix16[indx]] = itmp;
772 795
773 if (dowbits) 796 if (dowbits)
774 {
775 if (itmp < 0) itmp *= -1;
776 while (itmp > wbitsMaxValue)
777 { 797 {
778 wbits++; 798 if (itmp < 0) itmp *= -1;
779 wbitsMaxValue = 1 << wbits; 799 while (itmp > wbitsMaxValue)
780 if (wbits == maxwbits)
781 { 800 {
782 dowbits = false; 801 wbits++;
783 break; 802 wbitsMaxValue = 1 << wbits;
803 if (wbits == maxwbits)
804 {
805 dowbits = false;
806 break;
807 }
784 } 808 }
785 } 809 }
786 }
787 810
788 //tmp[10 * Constants.TerrainPatchSize + k] = C16_6R * xi + C16_6I * xr; // 811 //tmp[10 * Constants.TerrainPatchSize + k] = C16_6R * xi + C16_6I * xr; //
789 ftmp = C16_6R * xi + C16_6I * xr; 812 ftmp = C16_6R * xi + C16_6I * xr;
790 indx = 10 * 16 + k; 813 indx = 10 * 16 + k;
791 itmp = (int)(ftmp * QuantizeTable16[indx]); 814 itmp = (int)(ftmp * fQuantizeTable16[indx]);
792 iout[CopyMatrix16[indx]] = itmp; 815 iout[fCopyMatrix16[indx]] = itmp;
793 816
794 if (dowbits) 817 if (dowbits)
795 {
796 if (itmp < 0) itmp *= -1;
797 while (itmp > wbitsMaxValue)
798 { 818 {
799 wbits++; 819 if (itmp < 0) itmp *= -1;
800 wbitsMaxValue = 1 << wbits; 820 while (itmp > wbitsMaxValue)
801 if (wbits == maxwbits)
802 { 821 {
803 dowbits = false; 822 wbits++;
804 break; 823 wbitsMaxValue = 1 << wbits;
824 if (wbits == maxwbits)
825 {
826 dowbits = false;
827 break;
828 }
805 } 829 }
806 } 830 }
807 }
808 831
809 xr = W16_8R * (x6r - x6i); 832 xr = W16_8R * (x6r - x6i);
810 xi = W16_8R * (x6i + x6r); 833 xi = W16_8R * (x6i + x6r);
811 x6r = x4r - xr; 834 x6r = x4r - xr;
812 x6i = x4i - xi; 835 x6i = x4i - xi;
813 x4r += xr; 836 x4r += xr;
814 x4i += xi; 837 x4i += xi;
815 xr = W16_4I * x7r - W16_4R * x7i; 838 xr = W16_4I * x7r - W16_4R * x7i;
816 xi = W16_4I * x7i + W16_4R * x7r; 839 xi = W16_4I * x7i + W16_4R * x7r;
817 x7r = W16_4R * x5r - W16_4I * x5i; 840 x7r = W16_4R * x5r - W16_4I * x5i;
818 x7i = W16_4R * x5i + W16_4I * x5r; 841 x7i = W16_4R * x5i + W16_4I * x5r;
819 x5r = x7r + xr; 842 x5r = x7r + xr;
820 x5i = x7i + xi; 843 x5i = x7i + xi;
821 x7r -= xr; 844 x7r -= xr;
822 x7i -= xi; 845 x7i -= xi;
823 xr = x4r + x5r; 846 xr = x4r + x5r;
824 xi = x5i + x4i; 847 xi = x5i + x4i;
825 848
826 //tmp[1 * Constants.TerrainPatchSize + k] = C16_1R * xr - C16_1I * xi; // 849 //tmp[1 * Constants.TerrainPatchSize + k] = C16_1R * xr - C16_1I * xi; //
827 ftmp = C16_1R * xr - C16_1I * xi; 850 ftmp = C16_1R * xr - C16_1I * xi;
828 indx = 16 + k; 851 indx = 16 + k;
829 itmp = (int)(ftmp * QuantizeTable16[indx]); 852 itmp = (int)(ftmp * fQuantizeTable16[indx]);
830 iout[CopyMatrix16[indx]] = itmp; 853 iout[fCopyMatrix16[indx]] = itmp;
831 854
832 if (dowbits) 855 if (dowbits)
833 {
834 if (itmp < 0) itmp *= -1;
835 while (itmp > wbitsMaxValue)
836 { 856 {
837 wbits++; 857 if (itmp < 0) itmp *= -1;
838 wbitsMaxValue = 1 << wbits; 858 while (itmp > wbitsMaxValue)
839 if (wbits == maxwbits)
840 { 859 {
841 dowbits = false; 860 wbits++;
842 break; 861 wbitsMaxValue = 1 << wbits;
862 if (wbits == maxwbits)
863 {
864 dowbits = false;
865 break;
866 }
843 } 867 }
844 } 868 }
845 }
846 869
847 //tmp[15 * Constants.TerrainPatchSize + k] = C16_1R * xi + C16_1I * xr; // 870 //tmp[15 * Constants.TerrainPatchSize + k] = C16_1R * xi + C16_1I * xr; //
848 ftmp = C16_1R * xi + C16_1I * xr; 871 ftmp = C16_1R * xi + C16_1I * xr;
849 indx = 15 * 16 + k; 872 indx = 15 * 16 + k;
850 itmp = (int)(ftmp * QuantizeTable16[indx]); 873 itmp = (int)(ftmp * fQuantizeTable16[indx]);
851 iout[CopyMatrix16[indx]] = itmp; 874 iout[fCopyMatrix16[indx]] = itmp;
852 875
853 if (dowbits) 876 if (dowbits)
854 {
855 if (itmp < 0) itmp *= -1;
856 while (itmp > wbitsMaxValue)
857 { 877 {
858 wbits++; 878 if (itmp < 0) itmp *= -1;
859 wbitsMaxValue = 1 << wbits; 879 while (itmp > wbitsMaxValue)
860 if (wbits == maxwbits)
861 { 880 {
862 dowbits = false; 881 wbits++;
863 break; 882 wbitsMaxValue = 1 << wbits;
883 if (wbits == maxwbits)
884 {
885 dowbits = false;
886 break;
887 }
864 } 888 }
865 } 889 }
866 }
867 890
868 xr = x4r - x5r; 891 xr = x4r - x5r;
869 xi = x5i - x4i; 892 xi = x5i - x4i;
870 893
871 //tmp[7 * Constants.TerrainPatchSize + k] = C16_7R * xr - C16_7I * xi; // 894 //tmp[7 * Constants.TerrainPatchSize + k] = C16_7R * xr - C16_7I * xi; //
872 ftmp = C16_7R * xr - C16_7I * xi; 895 ftmp = C16_7R * xr - C16_7I * xi;
873 indx = 7 * 16 + k; 896 indx = 7 * 16 + k;
874 itmp = (int)(ftmp * QuantizeTable16[indx]); 897 itmp = (int)(ftmp * fQuantizeTable16[indx]);
875 iout[CopyMatrix16[indx]] = itmp; 898 iout[fCopyMatrix16[indx]] = itmp;
876 899
877 if (dowbits) 900 if (dowbits)
878 {
879 if (itmp < 0) itmp *= -1;
880 while (itmp > wbitsMaxValue)
881 { 901 {
882 wbits++; 902 if (itmp < 0) itmp *= -1;
883 wbitsMaxValue = 1 << wbits; 903 while (itmp > wbitsMaxValue)
884 if (wbits == maxwbits)
885 { 904 {
886 dowbits = false; 905 wbits++;
887 break; 906 wbitsMaxValue = 1 << wbits;
907 if (wbits == maxwbits)
908 {
909 dowbits = false;
910 break;
911 }
888 } 912 }
889 } 913 }
890 }
891 914
892 //tmp[9 * Constants.TerrainPatchSize + k] = C16_7R * xi + C16_7I * xr; // 915 //tmp[9 * Constants.TerrainPatchSize + k] = C16_7R * xi + C16_7I * xr; //
893 ftmp = C16_7R * xi + C16_7I * xr; 916 ftmp = C16_7R * xi + C16_7I * xr;
894 indx = 9 * 16 + k; 917 indx = 9 * 16 + k;
895 itmp = (int)(ftmp * QuantizeTable16[indx]); 918 itmp = (int)(ftmp * fQuantizeTable16[indx]);
896 iout[CopyMatrix16[indx]] = itmp; 919 iout[fCopyMatrix16[indx]] = itmp;
897 920
898 if (dowbits) 921 if (dowbits)
899 {
900 if (itmp < 0) itmp *= -1;
901 while (itmp > wbitsMaxValue)
902 { 922 {
903 wbits++; 923 if (itmp < 0) itmp *= -1;
904 wbitsMaxValue = 1 << wbits; 924 while (itmp > wbitsMaxValue)
905 if (wbits == maxwbits)
906 { 925 {
907 dowbits = false; 926 wbits++;
908 break; 927 wbitsMaxValue = 1 << wbits;
928 if (wbits == maxwbits)
929 {
930 dowbits = false;
931 break;
932 }
909 } 933 }
910 } 934 }
911 }
912 935
913 xr = x6r - x7i; 936 xr = x6r - x7i;
914 xi = x7r + x6i; 937 xi = x7r + x6i;
915 938
916 //tmp[5 * Constants.TerrainPatchSize + k] = C16_5R * xr - C16_5I * xi; // 939 //tmp[5 * Constants.TerrainPatchSize + k] = C16_5R * xr - C16_5I * xi; //
917 ftmp = C16_5R * xr - C16_5I * xi; 940 ftmp = C16_5R * xr - C16_5I * xi;
918 indx = 5 * 16 + k; 941 indx = 5 * 16 + k;
919 itmp = (int)(ftmp * QuantizeTable16[indx]); 942 itmp = (int)(ftmp * fQuantizeTable16[indx]);
920 iout[CopyMatrix16[indx]] = itmp; 943 iout[fCopyMatrix16[indx]] = itmp;
921 944
922 if (dowbits) 945 if (dowbits)
923 {
924 if (itmp < 0) itmp *= -1;
925 while (itmp > wbitsMaxValue)
926 { 946 {
927 wbits++; 947 if (itmp < 0) itmp *= -1;
928 wbitsMaxValue = 1 << wbits; 948 while (itmp > wbitsMaxValue)
929 if (wbits == maxwbits)
930 { 949 {
931 dowbits = false; 950 wbits++;
932 break; 951 wbitsMaxValue = 1 << wbits;
952 if (wbits == maxwbits)
953 {
954 dowbits = false;
955 break;
956 }
933 } 957 }
934 } 958 }
935 }
936 959
937 //tmp[11 * Constants.TerrainPatchSize + k] = C16_5R * xi + C16_5I * xr; // 960 //tmp[11 * Constants.TerrainPatchSize + k] = C16_5R * xi + C16_5I * xr; //
938 ftmp = C16_5R * xi + C16_5I * xr; 961 ftmp = C16_5R * xi + C16_5I * xr;
939 indx = 11 * 16 + k; 962 indx = 11 * 16 + k;
940 itmp = (int)(ftmp * QuantizeTable16[indx]); 963 itmp = (int)(ftmp * fQuantizeTable16[indx]);
941 iout[CopyMatrix16[indx]] = itmp; 964 iout[fCopyMatrix16[indx]] = itmp;
942 965
943 if (dowbits) 966 if (dowbits)
944 {
945 if (itmp < 0) itmp *= -1;
946 while (itmp > wbitsMaxValue)
947 { 967 {
948 wbits++; 968 if (itmp < 0) itmp *= -1;
949 wbitsMaxValue = 1 << wbits; 969 while (itmp > wbitsMaxValue)
950 if (wbits == maxwbits)
951 { 970 {
952 dowbits = false; 971 wbits++;
953 break; 972 wbitsMaxValue = 1 << wbits;
973 if (wbits == maxwbits)
974 {
975 dowbits = false;
976 break;
977 }
954 } 978 }
955 } 979 }
956 }
957 980
958 xr = x6r + x7i; 981 xr = x6r + x7i;
959 xi = x7r - x6i; 982 xi = x7r - x6i;
960 983
961 //tmp[3 * Constants.TerrainPatchSize + k] = C16_3R * xr - C16_3I * xi; // 984 //tmp[3 * Constants.TerrainPatchSize + k] = C16_3R * xr - C16_3I * xi; //
962 ftmp = C16_3R * xr - C16_3I * xi; 985 ftmp = C16_3R * xr - C16_3I * xi;
963 indx = 3 * 16 + k; 986 indx = 3 * 16 + k;
964 itmp = (int)(ftmp * QuantizeTable16[indx]); 987 itmp = (int)(ftmp * fQuantizeTable16[indx]);
965 iout[CopyMatrix16[indx]] = itmp; 988 iout[fCopyMatrix16[indx]] = itmp;
966 989
967 if (dowbits) 990 if (dowbits)
968 {
969 if (itmp < 0) itmp *= -1;
970 while (itmp > wbitsMaxValue)
971 { 991 {
972 wbits++; 992 if (itmp < 0) itmp *= -1;
973 wbitsMaxValue = 1 << wbits; 993 while (itmp > wbitsMaxValue)
974 if (wbits == maxwbits)
975 { 994 {
976 dowbits = false; 995 wbits++;
977 break; 996 wbitsMaxValue = 1 << wbits;
997 if (wbits == maxwbits)
998 {
999 dowbits = false;
1000 break;
1001 }
978 } 1002 }
979 } 1003 }
980 }
981 1004
982 //tmp[13 * Constants.TerrainPatchSize + k] = C16_3R * xi + C16_3I * xr; // 1005 //tmp[13 * Constants.TerrainPatchSize + k] = C16_3R * xi + C16_3I * xr; //
983 ftmp = C16_3R * xi + C16_3I * xr; 1006 ftmp = C16_3R * xi + C16_3I * xr;
984 indx = 13 * 16 + k; 1007 indx = 13 * 16 + k;
985 itmp = (int)(ftmp * QuantizeTable16[indx]); 1008 itmp = (int)(ftmp * fQuantizeTable16[indx]);
986 iout[CopyMatrix16[indx]] = itmp; 1009 iout[fCopyMatrix16[indx]] = itmp;
987 1010
988 if (dowbits) 1011 if (dowbits)
989 {
990 if (itmp < 0) itmp *= -1;
991 while (itmp > wbitsMaxValue)
992 { 1012 {
993 wbits++; 1013 if (itmp < 0) itmp *= -1;
994 wbitsMaxValue = 1 << wbits; 1014 while (itmp > wbitsMaxValue)
995 if (wbits == maxwbits)
996 { 1015 {
997 dowbits = false; 1016 wbits++;
998 break; 1017 wbitsMaxValue = 1 << wbits;
1018 if (wbits == maxwbits)
1019 {
1020 dowbits = false;
1021 break;
1022 }
999 } 1023 }
1000 } 1024 }
1001 } 1025 }
generated by cgit v1.1 at 2025-02-27 16:07:42 +0000