1/* 2 * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * - Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 11 * - Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * - Neither the name of Oracle nor the names of its 16 * contributors may be used to endorse or promote products derived 17 * from this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32/* 33 * This source code is provided to illustrate the usage of a given feature 34 * or technique and has been deliberately simplified. Additional steps 35 * required for a production-quality application, such as security checks, 36 * input validation and proper error handling, might not be present in 37 * this sample code. 38 */ 39 40 41package j2dbench.tests.iio; 42 43import java.io.File; 44import java.io.IOException; 45import java.io.FileOutputStream; 46import java.io.OutputStream; 47import javax.imageio.ImageIO; 48import javax.imageio.stream.ImageInputStream; 49 50import j2dbench.Group; 51import j2dbench.Result; 52import j2dbench.TestEnvironment; 53 54abstract class InputStreamTests extends InputTests { 55 56 private static Group streamRoot; 57 private static Group streamTestRoot; 58 59 public static void init() { 60 streamRoot = new Group(inputRoot, "stream", 61 "Image Stream Benchmarks"); 62 streamTestRoot = new Group(streamRoot, "tests", 63 "ImageInputStream Tests"); 64 65 new IISConstruct(); 66 new IISRead(); 67 new IISReadByteArray(); 68 new IISReadFullyByteArray(); 69 new IISReadBit(); 70 new IISReadByte(); 71 new IISReadUnsignedByte(); 72 new IISReadShort(); 73 new IISReadUnsignedShort(); 74 new IISReadInt(); 75 new IISReadUnsignedInt(); 76 new IISReadFloat(); 77 new IISReadLong(); 78 new IISReadDouble(); 79 new IISSkipBytes(); 80 } 81 82 protected InputStreamTests(Group parent, 83 String nodeName, String description) 84 { 85 super(parent, nodeName, description); 86 addDependency(generalSourceRoot); 87 addDependencies(imageioGeneralOptRoot, true); 88 } 89 90 public void cleanupTest(TestEnvironment env, Object ctx) { 91 Context iioctx = (Context)ctx; 92 iioctx.cleanup(env); 93 } 94 95 private static class Context extends InputTests.Context { 96 ImageInputStream inputStream; 97 int scanlineStride; // width of a scanline (in bytes) 98 int length; // length of the entire stream (in bytes) 99 byte[] byteBuf; 100 101 Context(TestEnvironment env, Result result) { 102 super(env, result); 103 104 // 4 bytes per "pixel" 105 scanlineStride = size * 4; 106 107 // tack on an extra 4 bytes, so that in the 1x1 case we can 108 // call readLong() or readDouble() without hitting EOF 109 length = (scanlineStride * size) + 4; 110 111 // big enough for one scanline 112 byteBuf = new byte[scanlineStride]; 113 114 initInput(); 115 116 try { 117 inputStream = createImageInputStream(); 118 } catch (IOException e) { 119 System.err.println("Error creating ImageInputStream"); 120 } 121 } 122 123 void initContents(File f) throws IOException { 124 FileOutputStream fos = null; 125 try { 126 fos = new FileOutputStream(f); 127 initContents(fos); 128 } finally { 129 fos.close(); 130 } 131 } 132 133 void initContents(OutputStream out) throws IOException { 134 for (int i = 0; i < size; i++) { 135 out.write(byteBuf); 136 } 137 out.write(new byte[4]); // add the 4 byte pad 138 out.flush(); 139 } 140 141 void cleanup(TestEnvironment env) { 142 super.cleanup(env); 143 if (inputStream != null) { 144 try { 145 inputStream.close(); 146 } catch (IOException e) { 147 System.err.println("error closing stream"); 148 } 149 inputStream = null; 150 } 151 } 152 } 153 154 private static class IISConstruct extends InputStreamTests { 155 public IISConstruct() { 156 super(streamTestRoot, 157 "construct", 158 "Construct"); 159 } 160 161 public Object initTest(TestEnvironment env, Result result) { 162 Context ctx = new Context(env, result); 163 result.setUnits(1); 164 result.setUnitName("stream"); 165 return ctx; 166 } 167 168 public void runTest(Object ctx, int numReps) { 169 final Context ictx = (Context)ctx; 170 try { 171 do { 172 ImageInputStream iis = ictx.createImageInputStream(); 173 iis.close(); 174 ictx.closeOriginalStream(); 175 } while (--numReps >= 0); 176 } catch (IOException e) { 177 e.printStackTrace(); 178 } 179 } 180 } 181 182 private static class IISRead extends InputStreamTests { 183 public IISRead() { 184 super(streamTestRoot, 185 "read", 186 "read()"); 187 } 188 189 public Object initTest(TestEnvironment env, Result result) { 190 Context ctx = new Context(env, result); 191 result.setUnits(1); 192 result.setUnitName("byte"); 193 return ctx; 194 } 195 196 public void runTest(Object ctx, int numReps) { 197 final Context ictx = (Context)ctx; 198 final ImageInputStream iis = ictx.inputStream; 199 final int length = ictx.length; 200 int pos = 0; 201 try { 202 iis.mark(); 203 do { 204 if (pos >= length) { 205 iis.reset(); 206 iis.mark(); 207 pos = 0; 208 } 209 iis.read(); 210 pos++; 211 } while (--numReps >= 0); 212 } catch (IOException e) { 213 e.printStackTrace(); 214 } finally { 215 try { iis.reset(); } catch (IOException e) {} 216 } 217 } 218 } 219 220 private static class IISReadByteArray extends InputStreamTests { 221 public IISReadByteArray() { 222 super(streamTestRoot, 223 "readByteArray", 224 "read(byte[]) (one \"scanline\" at a time)"); 225 } 226 227 public Object initTest(TestEnvironment env, Result result) { 228 Context ctx = new Context(env, result); 229 result.setUnits(ctx.scanlineStride); 230 result.setUnitName("byte"); 231 return ctx; 232 } 233 234 public void runTest(Object ctx, int numReps) { 235 final Context ictx = (Context)ctx; 236 final ImageInputStream iis = ictx.inputStream; 237 final byte[] buf = ictx.byteBuf; 238 final int scanlineStride = ictx.scanlineStride; 239 final int length = ictx.length; 240 int pos = 0; 241 try { 242 iis.mark(); 243 do { 244 if (pos + scanlineStride > length) { 245 iis.reset(); 246 iis.mark(); 247 pos = 0; 248 } 249 iis.read(buf); 250 pos += scanlineStride; 251 } while (--numReps >= 0); 252 } catch (IOException e) { 253 e.printStackTrace(); 254 } finally { 255 try { iis.reset(); } catch (IOException e) {} 256 } 257 } 258 } 259 260 private static class IISReadFullyByteArray extends InputStreamTests { 261 public IISReadFullyByteArray() { 262 super(streamTestRoot, 263 "readFullyByteArray", 264 "readFully(byte[]) (one \"scanline\" at a time)"); 265 } 266 267 public Object initTest(TestEnvironment env, Result result) { 268 Context ctx = new Context(env, result); 269 result.setUnits(ctx.scanlineStride); 270 result.setUnitName("byte"); 271 return ctx; 272 } 273 274 public void runTest(Object ctx, int numReps) { 275 final Context ictx = (Context)ctx; 276 final ImageInputStream iis = ictx.inputStream; 277 final byte[] buf = ictx.byteBuf; 278 final int scanlineStride = ictx.scanlineStride; 279 final int length = ictx.length; 280 int pos = 0; 281 try { 282 iis.mark(); 283 do { 284 if (pos + scanlineStride > length) { 285 iis.reset(); 286 iis.mark(); 287 pos = 0; 288 } 289 iis.readFully(buf); 290 pos += scanlineStride; 291 } while (--numReps >= 0); 292 } catch (IOException e) { 293 e.printStackTrace(); 294 } finally { 295 try { iis.reset(); } catch (IOException e) {} 296 } 297 } 298 } 299 300 private static class IISReadBit extends InputStreamTests { 301 public IISReadBit() { 302 super(streamTestRoot, 303 "readBit", 304 "readBit()"); 305 } 306 307 public Object initTest(TestEnvironment env, Result result) { 308 Context ctx = new Context(env, result); 309 result.setUnits(1); 310 result.setUnitName("bit"); 311 return ctx; 312 } 313 314 public void runTest(Object ctx, int numReps) { 315 final Context ictx = (Context)ctx; 316 final ImageInputStream iis = ictx.inputStream; 317 final int length = ictx.length * 8; 318 int pos = 0; 319 try { 320 iis.mark(); 321 do { 322 if (pos >= length) { 323 iis.reset(); 324 iis.mark(); 325 pos = 0; 326 } 327 iis.readBit(); 328 pos++; 329 } while (--numReps >= 0); 330 } catch (IOException e) { 331 e.printStackTrace(); 332 } finally { 333 try { iis.reset(); } catch (IOException e) {} 334 } 335 } 336 } 337 338 private static class IISReadByte extends InputStreamTests { 339 public IISReadByte() { 340 super(streamTestRoot, 341 "readByte", 342 "readByte()"); 343 } 344 345 public Object initTest(TestEnvironment env, Result result) { 346 Context ctx = new Context(env, result); 347 result.setUnits(1); 348 result.setUnitName("byte"); 349 return ctx; 350 } 351 352 public void runTest(Object ctx, int numReps) { 353 final Context ictx = (Context)ctx; 354 final ImageInputStream iis = ictx.inputStream; 355 final int length = ictx.length; 356 int pos = 0; 357 try { 358 iis.mark(); 359 do { 360 if (pos >= length) { 361 iis.reset(); 362 iis.mark(); 363 pos = 0; 364 } 365 iis.readByte(); 366 pos++; 367 } while (--numReps >= 0); 368 } catch (IOException e) { 369 e.printStackTrace(); 370 } finally { 371 try { iis.reset(); } catch (IOException e) {} 372 } 373 } 374 } 375 376 private static class IISReadUnsignedByte extends InputStreamTests { 377 public IISReadUnsignedByte() { 378 super(streamTestRoot, 379 "readUnsignedByte", 380 "readUnsignedByte()"); 381 } 382 383 public Object initTest(TestEnvironment env, Result result) { 384 Context ctx = new Context(env, result); 385 result.setUnits(1); 386 result.setUnitName("byte"); 387 return ctx; 388 } 389 390 public void runTest(Object ctx, int numReps) { 391 final Context ictx = (Context)ctx; 392 final ImageInputStream iis = ictx.inputStream; 393 final int length = ictx.length; 394 int pos = 0; 395 try { 396 iis.mark(); 397 do { 398 if (pos >= length) { 399 iis.reset(); 400 iis.mark(); 401 pos = 0; 402 } 403 iis.readUnsignedByte(); 404 pos++; 405 } while (--numReps >= 0); 406 } catch (IOException e) { 407 e.printStackTrace(); 408 } finally { 409 try { iis.reset(); } catch (IOException e) {} 410 } 411 } 412 } 413 414 private static class IISReadShort extends InputStreamTests { 415 public IISReadShort() { 416 super(streamTestRoot, 417 "readShort", 418 "readShort()"); 419 } 420 421 public Object initTest(TestEnvironment env, Result result) { 422 Context ctx = new Context(env, result); 423 result.setUnits(2); 424 result.setUnitName("byte"); 425 return ctx; 426 } 427 428 public void runTest(Object ctx, int numReps) { 429 final Context ictx = (Context)ctx; 430 final ImageInputStream iis = ictx.inputStream; 431 final int length = ictx.length; 432 int pos = 0; 433 try { 434 iis.mark(); 435 do { 436 if (pos + 2 > length) { 437 iis.reset(); 438 iis.mark(); 439 pos = 0; 440 } 441 iis.readShort(); 442 pos += 2; 443 } while (--numReps >= 0); 444 } catch (IOException e) { 445 e.printStackTrace(); 446 } finally { 447 try { iis.reset(); } catch (IOException e) {} 448 } 449 } 450 } 451 452 private static class IISReadUnsignedShort extends InputStreamTests { 453 public IISReadUnsignedShort() { 454 super(streamTestRoot, 455 "readUnsignedShort", 456 "readUnsignedShort()"); 457 } 458 459 public Object initTest(TestEnvironment env, Result result) { 460 Context ctx = new Context(env, result); 461 result.setUnits(2); 462 result.setUnitName("byte"); 463 return ctx; 464 } 465 466 public void runTest(Object ctx, int numReps) { 467 final Context ictx = (Context)ctx; 468 final ImageInputStream iis = ictx.inputStream; 469 final int length = ictx.length; 470 int pos = 0; 471 try { 472 iis.mark(); 473 do { 474 if (pos + 2 > length) { 475 iis.reset(); 476 iis.mark(); 477 pos = 0; 478 } 479 iis.readUnsignedShort(); 480 pos += 2; 481 } while (--numReps >= 0); 482 } catch (IOException e) { 483 e.printStackTrace(); 484 } finally { 485 try { iis.reset(); } catch (IOException e) {} 486 } 487 } 488 } 489 490 private static class IISReadInt extends InputStreamTests { 491 public IISReadInt() { 492 super(streamTestRoot, 493 "readInt", 494 "readInt()"); 495 } 496 497 public Object initTest(TestEnvironment env, Result result) { 498 Context ctx = new Context(env, result); 499 result.setUnits(4); 500 result.setUnitName("byte"); 501 return ctx; 502 } 503 504 public void runTest(Object ctx, int numReps) { 505 final Context ictx = (Context)ctx; 506 final ImageInputStream iis = ictx.inputStream; 507 final int length = ictx.length; 508 int pos = 0; 509 try { 510 iis.mark(); 511 do { 512 if (pos + 4 > length) { 513 iis.reset(); 514 iis.mark(); 515 pos = 0; 516 } 517 iis.readInt(); 518 pos += 4; 519 } while (--numReps >= 0); 520 } catch (IOException e) { 521 e.printStackTrace(); 522 } finally { 523 try { iis.reset(); } catch (IOException e) {} 524 } 525 } 526 } 527 528 private static class IISReadUnsignedInt extends InputStreamTests { 529 public IISReadUnsignedInt() { 530 super(streamTestRoot, 531 "readUnsignedInt", 532 "readUnsignedInt()"); 533 } 534 535 public Object initTest(TestEnvironment env, Result result) { 536 Context ctx = new Context(env, result); 537 result.setUnits(4); 538 result.setUnitName("byte"); 539 return ctx; 540 } 541 542 public void runTest(Object ctx, int numReps) { 543 final Context ictx = (Context)ctx; 544 final ImageInputStream iis = ictx.inputStream; 545 final int length = ictx.length; 546 int pos = 0; 547 try { 548 iis.mark(); 549 do { 550 if (pos + 4 > length) { 551 iis.reset(); 552 iis.mark(); 553 pos = 0; 554 } 555 iis.readUnsignedInt(); 556 pos += 4; 557 } while (--numReps >= 0); 558 } catch (IOException e) { 559 e.printStackTrace(); 560 } finally { 561 try { iis.reset(); } catch (IOException e) {} 562 } 563 } 564 } 565 566 private static class IISReadFloat extends InputStreamTests { 567 public IISReadFloat() { 568 super(streamTestRoot, 569 "readFloat", 570 "readFloat()"); 571 } 572 573 public Object initTest(TestEnvironment env, Result result) { 574 Context ctx = new Context(env, result); 575 result.setUnits(4); 576 result.setUnitName("byte"); 577 return ctx; 578 } 579 580 public void runTest(Object ctx, int numReps) { 581 final Context ictx = (Context)ctx; 582 final ImageInputStream iis = ictx.inputStream; 583 final int length = ictx.length; 584 int pos = 0; 585 try { 586 iis.mark(); 587 do { 588 if (pos + 4 > length) { 589 iis.reset(); 590 iis.mark(); 591 pos = 0; 592 } 593 iis.readFloat(); 594 pos += 4; 595 } while (--numReps >= 0); 596 } catch (IOException e) { 597 e.printStackTrace(); 598 } finally { 599 try { iis.reset(); } catch (IOException e) {} 600 } 601 } 602 } 603 604 private static class IISReadLong extends InputStreamTests { 605 public IISReadLong() { 606 super(streamTestRoot, 607 "readLong", 608 "readLong()"); 609 } 610 611 public Object initTest(TestEnvironment env, Result result) { 612 Context ctx = new Context(env, result); 613 result.setUnits(8); 614 result.setUnitName("byte"); 615 return ctx; 616 } 617 618 public void runTest(Object ctx, int numReps) { 619 final Context ictx = (Context)ctx; 620 final ImageInputStream iis = ictx.inputStream; 621 final int length = ictx.length; 622 int pos = 0; 623 try { 624 iis.mark(); 625 do { 626 if (pos + 8 > length) { 627 iis.reset(); 628 iis.mark(); 629 pos = 0; 630 } 631 iis.readLong(); 632 pos += 8; 633 } while (--numReps >= 0); 634 } catch (IOException e) { 635 e.printStackTrace(); 636 } finally { 637 try { iis.reset(); } catch (IOException e) {} 638 } 639 } 640 } 641 642 private static class IISReadDouble extends InputStreamTests { 643 public IISReadDouble() { 644 super(streamTestRoot, 645 "readDouble", 646 "readDouble()"); 647 } 648 649 public Object initTest(TestEnvironment env, Result result) { 650 Context ctx = new Context(env, result); 651 result.setUnits(8); 652 result.setUnitName("byte"); 653 return ctx; 654 } 655 656 public void runTest(Object ctx, int numReps) { 657 final Context ictx = (Context)ctx; 658 final ImageInputStream iis = ictx.inputStream; 659 final int length = ictx.length; 660 int pos = 0; 661 try { 662 iis.mark(); 663 do { 664 if (pos + 8 > length) { 665 iis.reset(); 666 iis.mark(); 667 pos = 0; 668 } 669 iis.readDouble(); 670 pos += 8; 671 } while (--numReps >= 0); 672 } catch (IOException e) { 673 e.printStackTrace(); 674 } finally { 675 try { iis.reset(); } catch (IOException e) {} 676 } 677 } 678 } 679 680 private static class IISSkipBytes extends InputStreamTests { 681 public IISSkipBytes() { 682 super(streamTestRoot, 683 "skipBytes", 684 "skipBytes() (one \"scanline\" at a time)"); 685 } 686 687 public Object initTest(TestEnvironment env, Result result) { 688 Context ctx = new Context(env, result); 689 result.setUnits(ctx.scanlineStride); 690 result.setUnitName("byte"); 691 return ctx; 692 } 693 694 public void runTest(Object ctx, int numReps) { 695 final Context ictx = (Context)ctx; 696 final ImageInputStream iis = ictx.inputStream; 697 final int scanlineStride = ictx.scanlineStride; 698 final int length = ictx.length; 699 int pos = 0; 700 try { 701 iis.mark(); 702 do { 703 if (pos + scanlineStride > length) { 704 iis.reset(); 705 iis.mark(); 706 pos = 0; 707 } 708 iis.skipBytes(scanlineStride); 709 pos += scanlineStride; 710 } while (--numReps >= 0); 711 } catch (IOException e) { 712 e.printStackTrace(); 713 } finally { 714 try { iis.reset(); } catch (IOException e) {} 715 } 716 } 717 } 718} 719